------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                               S P R I N T                                --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2019, Free Software Foundation, Inc.         --
--                                                                          --
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT 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  distributed with GNAT; see file COPYING3.  If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license.          --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------

with Aspects;  use Aspects;
with Atree;    use Atree;
with Casing;   use Casing;
with Csets;    use Csets;
with Debug;    use Debug;
with Einfo;    use Einfo;
with Lib;      use Lib;
with Namet;    use Namet;
with Nlists;   use Nlists;
with Opt;      use Opt;
with Output;   use Output;
with Rtsfind;  use Rtsfind;
with Sem_Eval; use Sem_Eval;
with Sem_Util; use Sem_Util;
with Sinfo;    use Sinfo;
with Sinput;   use Sinput;
with Sinput.D; use Sinput.D;
with Snames;   use Snames;
with Stand;    use Stand;
with Stringt;  use Stringt;
with Uintp;    use Uintp;
with Uname;    use Uname;
with Urealp;   use Urealp;

package body Sprint is
   Current_Source_File : Source_File_Index;
   --  Index of source file whose generated code is being dumped

   Dump_Node : Node_Id := Empty;
   --  This is set to the current node, used for printing line numbers. In
   --  Debug_Generated_Code mode, Dump_Node is set to the current node
   --  requiring Sloc fixup, until Set_Debug_Sloc is called to set the proper
   --  value. The call clears it back to Empty.

   First_Debug_Sloc : Source_Ptr;
   --  Sloc of first byte of the current output file if we are generating a
   --  source debug file.

   Debug_Sloc : Source_Ptr;
   --  Sloc of first byte of line currently being written if we are
   --  generating a source debug file.

   Dump_Original_Only : Boolean;
   --  Set True if the -gnatdo (dump original tree) flag is set

   Dump_Generated_Only : Boolean;
   --  Set True if the -gnatdG (dump generated tree) debug flag is set
   --  or for Print_Generated_Code (-gnatG) or Dump_Generated_Code (-gnatD).

   Dump_Freeze_Null : Boolean;
   --  Set True if empty freeze nodes and non-source null statements output.
   --  Note that freeze nodes containing freeze actions are always output,
   --  as are freeze nodes for itypes, which in general have the effect of
   --  causing elaboration of the itype.

   Freeze_Indent : Int := 0;
   --  Keep track of freeze indent level (controls output of blank lines before
   --  procedures within expression freeze actions). Relevant only if we are
   --  not in Dump_Source_Text mode, since in Dump_Source_Text mode we don't
   --  output these blank lines in any case.

   Indent : Int := 0;
   --  Number of columns for current line output indentation

   Indent_Annull_Flag : Boolean := False;
   --  Set True if subsequent Write_Indent call to be ignored, gets reset
   --  by this call, so it is only active to suppress a single indent call.

   Last_Line_Printed : Physical_Line_Number;
   --  This keeps track of the physical line number of the last source line
   --  that has been output. The value is only valid in Dump_Source_Text mode.

   -------------------------------
   -- Operator Precedence Table --
   -------------------------------

   --  This table is used to decide whether a subexpression needs to be
   --  parenthesized. The rule is that if an operand of an operator (which
   --  for this purpose includes AND THEN and OR ELSE) is itself an operator
   --  with a lower precedence than the operator (or equal precedence if
   --  appearing as the right operand), then parentheses are required.

   Op_Prec : constant array (N_Subexpr) of Short_Short_Integer :=
               (N_Op_And          => 1,
                N_Op_Or           => 1,
                N_Op_Xor          => 1,
                N_And_Then        => 1,
                N_Or_Else         => 1,

                N_In              => 2,
                N_Not_In          => 2,
                N_Op_Eq           => 2,
                N_Op_Ge           => 2,
                N_Op_Gt           => 2,
                N_Op_Le           => 2,
                N_Op_Lt           => 2,
                N_Op_Ne           => 2,

                N_Op_Add          => 3,
                N_Op_Concat       => 3,
                N_Op_Subtract     => 3,
                N_Op_Plus         => 3,
                N_Op_Minus        => 3,

                N_Op_Divide       => 4,
                N_Op_Mod          => 4,
                N_Op_Rem          => 4,
                N_Op_Multiply     => 4,

                N_Op_Expon        => 5,
                N_Op_Abs          => 5,
                N_Op_Not          => 5,

                others            => 6);

   procedure Sprint_Left_Opnd (N : Node_Id);
   --  Print left operand of operator, parenthesizing if necessary

   procedure Sprint_Right_Opnd (N : Node_Id);
   --  Print right operand of operator, parenthesizing if necessary

   -----------------------
   -- Local Subprograms --
   -----------------------

   procedure Col_Check (N : Nat);
   --  Check that at least N characters remain on current line, and if not,
   --  then start an extra line with two characters extra indentation for
   --  continuing text on the next line.

   procedure Extra_Blank_Line;
   --  In some situations we write extra blank lines to separate the generated
   --  code to make it more readable. However, these extra blank lines are not
   --  generated in Dump_Source_Text mode, since there the source text lines
   --  output with preceding blank lines are quite sufficient as separators.
   --  This procedure writes a blank line if Dump_Source_Text is False.

   procedure Indent_Annull;
   --  Causes following call to Write_Indent to be ignored. This is used when
   --  a higher level node wants to stop a lower level node from starting a
   --  new line, when it would otherwise be inclined to do so (e.g. the case
   --  of an accept statement called from an accept alternative with a guard)

   procedure Indent_Begin;
   --  Increase indentation level

   procedure Indent_End;
   --  Decrease indentation level

   procedure Print_Debug_Line (S : String);
   --  Used to print output lines in Debug_Generated_Code mode (this is used
   --  as the argument for a call to Set_Special_Output in package Output).

   procedure Process_TFAI_RR_Flags (Nod : Node_Id);
   --  Given a divide, multiplication or division node, check the flags
   --  Treat_Fixed_As_Integer and Rounded_Flags, and if set, output the
   --  appropriate special syntax characters (# and @).

   procedure Set_Debug_Sloc;
   --  If Dump_Node is non-empty, this routine sets the appropriate value
   --  in its Sloc field, from the current location in the debug source file
   --  that is currently being written.

   procedure Sprint_And_List (List : List_Id);
   --  Print the given list with items separated by vertical "and"

   procedure Sprint_Aspect_Specifications
     (Node      : Node_Id;
      Semicolon : Boolean);
   --  Node is a declaration node that has aspect specifications (Has_Aspects
   --  flag set True). It outputs the aspect specifications. For the case
   --  of Semicolon = True, it is called after outputting the terminating
   --  semicolon for the related node. The effect is to remove the semicolon
   --  and print the aspect specifications followed by a terminating semicolon.
   --  For the case of Semicolon False, no semicolon is removed or output, and
   --  all the aspects are printed on a single line.

   procedure Sprint_Bar_List (List : List_Id);
   --  Print the given list with items separated by vertical bars

   procedure Sprint_End_Label
     (Node    : Node_Id;
      Default : Node_Id);
   --  Print the end label for a Handled_Sequence_Of_Statements in a body.
   --  If there is no end label, use the defining identifier of the enclosing
   --  construct. If the end label is present, treat it as a reference to the
   --  defining entity of the construct: this guarantees that it carries the
   --  proper sloc information for debugging purposes.

   procedure Sprint_Node_Actual (Node : Node_Id);
   --  This routine prints its node argument. It is a lower level routine than
   --  Sprint_Node, in that it does not bother about rewritten trees.

   procedure Sprint_Node_Sloc (Node : Node_Id);
   --  Like Sprint_Node, but in addition, in Debug_Generated_Code mode,
   --  sets the Sloc of the current debug node to be a copy of the Sloc
   --  of the sprinted node Node. Note that this is done after printing
   --  Node, so that the Sloc is the proper updated value for the debug file.

   procedure Update_Itype (Node : Node_Id);
   --  Update the Sloc of an itype that is not attached to the tree, when
   --  debugging expanded code. This routine is called from nodes whose
   --  type can be an Itype, such as defining_identifiers that may be of
   --  an anonymous access type, or ranges in slices.

   procedure Write_Char_Sloc (C : Character);
   --  Like Write_Char, except that if C is non-blank, Set_Debug_Sloc is
   --  called to ensure that the current node has a proper Sloc set.

   procedure Write_Condition_And_Reason (Node : Node_Id);
   --  Write Condition and Reason codes of Raise_xxx_Error node

   procedure Write_Corresponding_Source (S : String);
   --  If S is a string with a single keyword (possibly followed by a space),
   --  and if the next non-comment non-blank source line matches this keyword,
   --  then output all source lines up to this matching line.

   procedure Write_Discr_Specs (N : Node_Id);
   --  Output discriminant specification for node, which is any of the type
   --  declarations that can have discriminants.

   procedure Write_Ekind (E : Entity_Id);
   --  Write the String corresponding to the Ekind without "E_"

   procedure Write_Id (N : Node_Id);
   --  N is a node with a Chars field. This procedure writes the name that
   --  will be used in the generated code associated with the name. For a
   --  node with no associated entity, this is simply the Chars field. For
   --  the case where there is an entity associated with the node, we print
   --  the name associated with the entity (since it may have been encoded).
   --  One other special case is that an entity has an active external name
   --  (i.e. an external name present with no address clause), then this
   --  external name is output. This procedure also deals with outputting
   --  declarations of referenced itypes, if not output earlier.

   function Write_Identifiers (Node : Node_Id) return Boolean;
   --  Handle node where the grammar has a list of defining identifiers, but
   --  the tree has a separate declaration for each identifier. Handles the
   --  printing of the defining identifier, and returns True if the type and
   --  initialization information is to be printed, False if it is to be
   --  skipped (the latter case happens when printing defining identifiers
   --  other than the first in the original tree output case).

   procedure Write_Implicit_Def (E : Entity_Id);
   pragma Warnings (Off, Write_Implicit_Def);
   --  Write the definition of the implicit type E according to its Ekind
   --  For now a debugging procedure, but might be used in the future.

   procedure Write_Indent;
   --  Start a new line and write indentation spacing

   function Write_Indent_Identifiers (Node : Node_Id) return Boolean;
   --  Like Write_Identifiers except that each new printed declaration
   --  is at the start of a new line.

   function Write_Indent_Identifiers_Sloc (Node : Node_Id) return Boolean;
   --  Like Write_Indent_Identifiers except that in Debug_Generated_Code
   --  mode, the Sloc of the current debug node is set to point to the
   --  first output identifier.

   procedure Write_Indent_Str (S : String);
   --  Start a new line and write indent spacing followed by given string

   procedure Write_Indent_Str_Sloc (S : String);
   --  Like Write_Indent_Str, but in addition, in Debug_Generated_Code mode,
   --  the Sloc of the current node is set to the first non-blank character
   --  in the string S.

   procedure Write_Itype (Typ : Entity_Id);
   --  If Typ is an Itype that has not been written yet, write it. If Typ is
   --  any other kind of entity or tree node, the call is ignored.

   procedure Write_Name_With_Col_Check (N : Name_Id);
   --  Write name (using Write_Name) with initial column check, and possible
   --  initial Write_Indent (to get new line) if current line is too full.

   procedure Write_Name_With_Col_Check_Sloc (N : Name_Id);
   --  Like Write_Name_With_Col_Check but in addition, in Debug_Generated_Code
   --  mode, sets Sloc of current debug node to first character of name.

   procedure Write_Operator (N : Node_Id; S : String);
   --  Like Write_Str_Sloc, used for operators, encloses the string in
   --  characters {} if the Do_Overflow flag is set on the node N.

   procedure Write_Param_Specs (N : Node_Id);
   --  Output parameter specifications for node N (which is a subprogram, or
   --  entry or entry family or access-subprogram-definition, all of which
   --  have a Parameter_Specificatioons field).

   procedure Write_Rewrite_Str (S : String);
   --  Writes out a string (typically containing <<< or >>>}) for a node
   --  created by rewriting the tree. Suppressed if we are outputting the
   --  generated code only, since in this case we don't specially mark nodes
   --  created by rewriting).

   procedure Write_Source_Line (L : Physical_Line_Number);
   --  If writing of interspersed source lines is enabled, then write the given
   --  line from the source file, preceded by Eol, then an extra blank line if
   --  the line has at least one blank, is not a comment and is not line one,
   --  then "--" and the line number followed by period followed by text of the
   --  source line (without terminating Eol). If interspersed source line
   --  output not enabled, then the call has no effect.

   procedure Write_Source_Lines (L : Physical_Line_Number);
   --  If writing of interspersed source lines is enabled, then writes source
   --  lines Last_Line_Printed + 1 .. L, and updates Last_Line_Printed. If
   --  interspersed source line output not enabled, then call has no effect.

   procedure Write_Str_Sloc (S : String);
   --  Like Write_Str, but sets debug Sloc of current debug node to first
   --  non-blank character if a current debug node is active.

   procedure Write_Str_With_Col_Check (S : String);
   --  Write string (using Write_Str) with initial column check, and possible
   --  initial Write_Indent (to get new line) if current line is too full.

   procedure Write_Str_With_Col_Check_Sloc (S : String);
   --  Like Write_Str_With_Col_Check, but sets debug Sloc of current debug
   --  node to first non-blank character if a current debug node is active.

   procedure Write_Subprogram_Name (N : Node_Id);
   --  N is the Name field of a function call or procedure statement call.
   --  The effect of the call is to output the name, preceded by a $ if the
   --  call is identified as an implicit call to a run time routine.

   procedure Write_Uint_With_Col_Check (U : Uint; Format : UI_Format);
   --  Write Uint (using UI_Write) with initial column check, and possible
   --  initial Write_Indent (to get new line) if current line is too full.
   --  The format parameter determines the output format (see UI_Write).

   procedure Write_Uint_With_Col_Check_Sloc (U : Uint; Format : UI_Format);
   --  Write Uint (using UI_Write) with initial column check, and possible
   --  initial Write_Indent (to get new line) if current line is too full.
   --  The format parameter determines the output format (see UI_Write).
   --  In addition, in Debug_Generated_Code mode, sets the current node
   --  Sloc to the first character of the output value.

   procedure Write_Ureal_With_Col_Check_Sloc (U : Ureal);
   --  Write Ureal (using same output format as UR_Write) with column checks
   --  and a possible initial Write_Indent (to get new line) if current line
   --  is too full. In addition, in Debug_Generated_Code mode, sets the
   --  current node Sloc to the first character of the output value.

   ---------------
   -- Col_Check --
   ---------------

   procedure Col_Check (N : Nat) is
   begin
      if N + Column > Sprint_Line_Limit then
         Write_Indent_Str ("  ");
      end if;
   end Col_Check;

   ----------------------
   -- Extra_Blank_Line --
   ----------------------

   procedure Extra_Blank_Line is
   begin
      if not Dump_Source_Text then
         Write_Indent;
      end if;
   end Extra_Blank_Line;

   -------------------
   -- Indent_Annull --
   -------------------

   procedure Indent_Annull is
   begin
      Indent_Annull_Flag := True;
   end Indent_Annull;

   ------------------
   -- Indent_Begin --
   ------------------

   procedure Indent_Begin is
   begin
      Indent := Indent + 3;
   end Indent_Begin;

   ----------------
   -- Indent_End --
   ----------------

   procedure Indent_End is
   begin
      Indent := Indent - 3;
   end Indent_End;

   --------
   -- pg --
   --------

   procedure pg (Arg : Union_Id) is
   begin
      Dump_Generated_Only := True;
      Dump_Original_Only  := False;
      Dump_Freeze_Null    := True;
      Current_Source_File := No_Source_File;

      if Arg in List_Range then
         Sprint_Node_List (List_Id (Arg), New_Lines => True);

      elsif Arg in Node_Range then
         Sprint_Node (Node_Id (Arg));

      else
         null;
      end if;

      Write_Eol;
   end pg;

   --------
   -- po --
   --------

   procedure po (Arg : Union_Id) is
   begin
      Dump_Generated_Only := False;
      Dump_Original_Only := True;
      Current_Source_File := No_Source_File;

      if Arg in List_Range then
         Sprint_Node_List (List_Id (Arg), New_Lines => True);

      elsif Arg in Node_Range then
         Sprint_Node (Node_Id (Arg));

      else
         null;
      end if;

      Write_Eol;
   end po;

   ----------------------
   -- Print_Debug_Line --
   ----------------------

   procedure Print_Debug_Line (S : String) is
   begin
      Write_Debug_Line (S, Debug_Sloc);
   end Print_Debug_Line;

   ---------------------------
   -- Process_TFAI_RR_Flags --
   ---------------------------

   procedure Process_TFAI_RR_Flags (Nod : Node_Id) is
   begin
      if Treat_Fixed_As_Integer (Nod) then
         Write_Char ('#');
      end if;

      if Rounded_Result (Nod) then
         Write_Char ('@');
      end if;
   end Process_TFAI_RR_Flags;

   --------
   -- ps --
   --------

   procedure ps (Arg : Union_Id) is
   begin
      Dump_Generated_Only := False;
      Dump_Original_Only := False;
      Current_Source_File := No_Source_File;

      if Arg in List_Range then
         Sprint_Node_List (List_Id (Arg), New_Lines => True);

      elsif Arg in Node_Range then
         Sprint_Node (Node_Id (Arg));

      else
         null;
      end if;

      Write_Eol;
   end ps;

   --------------------
   -- Set_Debug_Sloc --
   --------------------

   procedure Set_Debug_Sloc is
   begin
      if Debug_Generated_Code and then Present (Dump_Node) then
         declare
            Loc : constant Source_Ptr := Sloc (Dump_Node);

         begin
            --  Do not change the location of nodes defined in package Standard
            --  and nodes of pragmas scanned by Targparm.

            if Loc <= Standard_Location then
               null;

            --  Update the location of a node which is part of the current .dg
            --  output. This situation occurs in comma separated parameter
            --  declarations since each parameter references the same parameter
            --  type node (ie. obj1, obj2 : <param-type>).

            --  Note: This case is needed here since we cannot use the routine
            --  In_Extended_Main_Code_Unit with nodes whose location is a .dg
            --  file.

            elsif Loc >= First_Debug_Sloc then
               Set_Sloc (Dump_Node, Debug_Sloc + Source_Ptr (Column - 1));

            --  Do not change the location of nodes which are not part of the
            --  generated code

            elsif not In_Extended_Main_Code_Unit (Loc) then
               null;

            else
               Set_Sloc (Dump_Node, Debug_Sloc + Source_Ptr (Column - 1));
            end if;
         end;

         --  We do not know the actual end location in the generated code and
         --  it could be much closer than in the source code, so play safe.

         if Nkind_In (Dump_Node, N_Case_Statement, N_If_Statement) then
            Set_End_Location (Dump_Node, Debug_Sloc + Source_Ptr (Column - 1));
         end if;

         Dump_Node := Empty;
      end if;
   end Set_Debug_Sloc;

   -----------------
   -- Source_Dump --
   -----------------

   procedure Source_Dump is

      procedure Underline;
      --  Put underline under string we just printed

      ---------------
      -- Underline --
      ---------------

      procedure Underline is
         Col : constant Int := Column;

      begin
         Write_Eol;

         while Col > Column loop
            Write_Char ('-');
         end loop;

         Write_Eol;
      end Underline;

   --  Start of processing for Source_Dump

   begin
      Dump_Generated_Only := Debug_Flag_G or
                             Print_Generated_Code or
                             Debug_Generated_Code;
      Dump_Original_Only  := Debug_Flag_O;
      Dump_Freeze_Null    := Debug_Flag_S or Debug_Flag_G;

      --  Note that we turn off the tree dump flags immediately, before
      --  starting the dump. This avoids generating two copies of the dump
      --  if an abort occurs after printing the dump, and more importantly,
      --  avoids an infinite loop if an abort occurs during the dump.

      if Debug_Flag_Z then
         Current_Source_File := No_Source_File;
         Debug_Flag_Z := False;
         Write_Eol;
         Write_Eol;
         Write_Str ("Source recreated from tree of Standard (spec)");
         Underline;
         Sprint_Node (Standard_Package_Node);
         Write_Eol;
         Write_Eol;
      end if;

      if Debug_Flag_S or Dump_Generated_Only or Dump_Original_Only then
         Debug_Flag_G := False;
         Debug_Flag_O := False;
         Debug_Flag_S := False;
         First_Debug_Sloc := No_Location;

         --  Dump requested units

         for U in Main_Unit .. Last_Unit loop
            Current_Source_File := Source_Index (U);

            --  Dump all units if -gnatdf set, otherwise dump only the source
            --  files that are in the extended main source. Note that, if we
            --  are generating debug files, generating that of the main unit
            --  has an effect on the outcome of In_Extended_Main_Source_Unit
            --  because slocs are rewritten, so we also test for equality of
            --  Cunit_Entity to work around this effect.

            if Debug_Flag_F
              or else In_Extended_Main_Source_Unit (Cunit_Entity (U))
              or else Cunit_Entity (U) = Cunit_Entity (Main_Unit)
            then
               --  If we are generating debug files, setup to write them

               if Debug_Generated_Code then
                  Set_Special_Output (Print_Debug_Line'Access);
                  Create_Debug_Source (Source_Index (U), Debug_Sloc);
                  First_Debug_Sloc := Debug_Sloc;
                  Write_Source_Line (1);
                  Last_Line_Printed := 1;

                  --  If this unit has the same entity as the main unit, for
                  --  example is the spec of a stand-alone instantiation of
                  --  a package and the main unit is the body, its debug file
                  --  will also be the same. Therefore, we need to print again
                  --  the main unit to have both units in the debug file.

                  if U /= Main_Unit
                    and then Cunit_Entity (U) = Cunit_Entity (Main_Unit)
                  then
                     Sprint_Node (Cunit (Main_Unit));
                     Write_Eol;
                  end if;

                  Sprint_Node (Cunit (U));
                  Write_Source_Lines (Last_Source_Line (Current_Source_File));
                  Write_Eol;
                  Close_Debug_Source;
                  Cancel_Special_Output;

               --  Normal output to standard output file

               else
                  Write_Str ("Source recreated from tree for ");
                  Write_Unit_Name (Unit_Name (U));
                  Underline;
                  Write_Source_Line (1);
                  Last_Line_Printed := 1;
                  Sprint_Node (Cunit (U));
                  Write_Source_Lines (Last_Source_Line (Current_Source_File));
                  Write_Eol;
                  Write_Eol;
               end if;
            end if;
         end loop;
      end if;
   end Source_Dump;

   ---------------------
   -- Sprint_And_List --
   ---------------------

   procedure Sprint_And_List (List : List_Id) is
      Node : Node_Id;
   begin
      if Is_Non_Empty_List (List) then
         Node := First (List);
         loop
            Sprint_Node (Node);
            Next (Node);
            exit when Node = Empty;
            Write_Str (" and ");
         end loop;
      end if;
   end Sprint_And_List;

   ----------------------------------
   -- Sprint_Aspect_Specifications --
   ----------------------------------

   procedure Sprint_Aspect_Specifications
     (Node      : Node_Id;
      Semicolon : Boolean)
   is
      AS : constant List_Id := Aspect_Specifications (Node);
      A  : Node_Id;

   begin
      if Semicolon then
         Write_Erase_Char (';');
         Indent := Indent + 2;
         Write_Indent;
         Write_Str ("with ");
         Indent := Indent + 5;

      else
         Write_Str (" with ");
      end if;

      A := First (AS);
      loop
         Sprint_Node (Identifier (A));

         if Class_Present (A) then
            Write_Str ("'Class");
         end if;

         if Present (Expression (A)) then
            Write_Str (" => ");
            Sprint_Node (Expression (A));
         end if;

         Next (A);

         exit when No (A);
         Write_Char (',');

         if Semicolon then
            Write_Indent;
         end if;
      end loop;

      if Semicolon then
         Indent := Indent - 7;
         Write_Char (';');
      end if;
   end Sprint_Aspect_Specifications;

   ---------------------
   -- Sprint_Bar_List --
   ---------------------

   procedure Sprint_Bar_List (List : List_Id) is
      Node : Node_Id;
   begin
      if Is_Non_Empty_List (List) then
         Node := First (List);
         loop
            Sprint_Node (Node);
            Next (Node);
            exit when Node = Empty;
            Write_Str (" | ");
         end loop;
      end if;
   end Sprint_Bar_List;

   ----------------------
   -- Sprint_End_Label --
   ----------------------

   procedure Sprint_End_Label
     (Node    : Node_Id;
      Default : Node_Id)
   is
   begin
      if Present (Node)
        and then Present (End_Label (Node))
        and then Is_Entity_Name (End_Label (Node))
      then
         Set_Entity (End_Label (Node), Default);

         --  For a function whose name is an operator, use the qualified name
         --  created for the defining entity.

         if Nkind (End_Label (Node)) = N_Operator_Symbol then
            Set_Chars (End_Label (Node), Chars (Default));
         end if;

         Sprint_Node (End_Label (Node));
      else
         Sprint_Node (Default);
      end if;
   end Sprint_End_Label;

   -----------------------
   -- Sprint_Comma_List --
   -----------------------

   procedure Sprint_Comma_List (List : List_Id) is
      Node : Node_Id;

   begin
      if Is_Non_Empty_List (List) then
         Node := First (List);
         loop
            Sprint_Node (Node);
            Next (Node);
            exit when Node = Empty;

            if not Is_Rewrite_Insertion (Node)
              or else not Dump_Original_Only
            then
               Write_Str (", ");
            end if;
         end loop;
      end if;
   end Sprint_Comma_List;

   --------------------------
   -- Sprint_Indented_List --
   --------------------------

   procedure Sprint_Indented_List (List : List_Id) is
   begin
      Indent_Begin;
      Sprint_Node_List (List);
      Indent_End;
   end Sprint_Indented_List;

   ---------------------
   -- Sprint_Left_Opnd --
   ---------------------

   procedure Sprint_Left_Opnd (N : Node_Id) is
      Opnd : constant Node_Id := Left_Opnd (N);

   begin
      if Paren_Count (Opnd) /= 0
        or else Op_Prec (Nkind (Opnd)) >= Op_Prec (Nkind (N))
      then
         Sprint_Node (Opnd);

      else
         Write_Char ('(');
         Sprint_Node (Opnd);
         Write_Char (')');
      end if;
   end Sprint_Left_Opnd;

   -----------------
   -- Sprint_Node --
   -----------------

   procedure Sprint_Node (Node : Node_Id) is
   begin
      if Is_Rewrite_Insertion (Node) then
         if not Dump_Original_Only then

            --  For special cases of nodes that always output <<< >>>
            --  do not duplicate the output at this point.

            if Nkind (Node) = N_Freeze_Entity
              or else Nkind (Node) = N_Freeze_Generic_Entity
              or else Nkind (Node) = N_Implicit_Label_Declaration
            then
               Sprint_Node_Actual (Node);

            --  Normal case where <<< >>> may be required

            else
               Write_Rewrite_Str ("<<<");
               Sprint_Node_Actual (Node);
               Write_Rewrite_Str (">>>");
            end if;
         end if;

      elsif Is_Rewrite_Substitution (Node) then

         --  Case of dump generated only

         if Dump_Generated_Only then
            Sprint_Node_Actual (Node);

         --  Case of dump original only

         elsif Dump_Original_Only then
            Sprint_Node_Actual (Original_Node (Node));

         --  Case of both being dumped

         else
            Sprint_Node_Actual (Original_Node (Node));
            Write_Rewrite_Str ("<<<");
            Sprint_Node_Actual (Node);
            Write_Rewrite_Str (">>>");
         end if;

      else
         Sprint_Node_Actual (Node);
      end if;
   end Sprint_Node;

   ------------------------
   -- Sprint_Node_Actual --
   ------------------------

   procedure Sprint_Node_Actual (Node : Node_Id) is
      Save_Dump_Node : constant Node_Id := Dump_Node;

   begin
      if Node = Empty then
         return;
      end if;

      for J in 1 .. Paren_Count (Node) loop
         Write_Str_With_Col_Check ("(");
      end loop;

      --  Setup current dump node

      Dump_Node := Node;

      if Nkind (Node) in N_Subexpr
        and then Do_Range_Check (Node)
      then
         Write_Str_With_Col_Check ("{");
      end if;

      --  Select print circuit based on node kind

      case Nkind (Node) is
         when N_Abort_Statement =>
            Write_Indent_Str_Sloc ("abort ");
            Sprint_Comma_List (Names (Node));
            Write_Char (';');

         when N_Abortable_Part =>
            Set_Debug_Sloc;
            Write_Str_Sloc ("abort ");
            Sprint_Indented_List (Statements (Node));

         when N_Abstract_Subprogram_Declaration =>
            Write_Indent;
            Sprint_Node (Specification (Node));
            Write_Str_With_Col_Check (" is ");
            Write_Str_Sloc ("abstract;");

         when N_Accept_Alternative =>
            Sprint_Node_List (Pragmas_Before (Node));

            if Present (Condition (Node)) then
               Write_Indent_Str ("when ");
               Sprint_Node (Condition (Node));
               Write_Str (" => ");
               Indent_Annull;
            end if;

            Sprint_Node_Sloc (Accept_Statement (Node));
            Sprint_Node_List (Statements (Node));

         when N_Accept_Statement =>
            Write_Indent_Str_Sloc ("accept ");
            Write_Id (Entry_Direct_Name (Node));

            if Present (Entry_Index (Node)) then
               Write_Str_With_Col_Check (" (");
               Sprint_Node (Entry_Index (Node));
               Write_Char (')');
            end if;

            Write_Param_Specs (Node);

            if Present (Handled_Statement_Sequence (Node)) then
               Write_Str_With_Col_Check (" do");
               Sprint_Node (Handled_Statement_Sequence (Node));
               Write_Indent_Str ("end ");
               Write_Id (Entry_Direct_Name (Node));
            end if;

            Write_Char (';');

         when N_Access_Definition =>

            --  Ada 2005 (AI-254)

            if Present (Access_To_Subprogram_Definition (Node)) then
               Sprint_Node (Access_To_Subprogram_Definition (Node));
            else
               --  Ada 2005 (AI-231)

               if Null_Exclusion_Present (Node) then
                  Write_Str ("not null ");
               end if;

               Write_Str_With_Col_Check_Sloc ("access ");

               if All_Present (Node) then
                  Write_Str ("all ");
               elsif Constant_Present (Node) then
                  Write_Str ("constant ");
               end if;

               Sprint_Node (Subtype_Mark (Node));
            end if;

         when N_Access_Function_Definition =>

            --  Ada 2005 (AI-231)

            if Null_Exclusion_Present (Node) then
               Write_Str ("not null ");
            end if;

            Write_Str_With_Col_Check_Sloc ("access ");

            if Protected_Present (Node) then
               Write_Str_With_Col_Check ("protected ");
            end if;

            Write_Str_With_Col_Check ("function");
            Write_Param_Specs (Node);
            Write_Str_With_Col_Check (" return ");
            Sprint_Node (Result_Definition (Node));

         when N_Access_Procedure_Definition =>

            --  Ada 2005 (AI-231)

            if Null_Exclusion_Present (Node) then
               Write_Str ("not null ");
            end if;

            Write_Str_With_Col_Check_Sloc ("access ");

            if Protected_Present (Node) then
               Write_Str_With_Col_Check ("protected ");
            end if;

            Write_Str_With_Col_Check ("procedure");
            Write_Param_Specs (Node);

         when N_Access_To_Object_Definition =>
            Write_Str_With_Col_Check_Sloc ("access ");

            if All_Present (Node) then
               Write_Str_With_Col_Check ("all ");
            elsif Constant_Present (Node) then
               Write_Str_With_Col_Check ("constant ");
            end if;

            --  Ada 2005 (AI-231)

            if Null_Exclusion_Present (Node) then
               Write_Str ("not null ");
            end if;

            Sprint_Node (Subtype_Indication (Node));

         when N_Aggregate =>
            if Null_Record_Present (Node) then
               Write_Str_With_Col_Check_Sloc ("(null record)");

            else
               Write_Str_With_Col_Check_Sloc ("(");

               if Present (Expressions (Node)) then
                  Sprint_Comma_List (Expressions (Node));

                  if Present (Component_Associations (Node))
                    and then not Is_Empty_List (Component_Associations (Node))
                  then
                     Write_Str (", ");
                  end if;
               end if;

               if Present (Component_Associations (Node))
                 and then not Is_Empty_List (Component_Associations (Node))
               then
                  Indent_Begin;

                  declare
                     Nd : Node_Id;

                  begin
                     Nd := First (Component_Associations (Node));

                     loop
                        Write_Indent;
                        Sprint_Node (Nd);
                        Next (Nd);
                        exit when No (Nd);

                        if not Is_Rewrite_Insertion (Nd)
                          or else not Dump_Original_Only
                        then
                           Write_Str (", ");
                        end if;
                     end loop;
                  end;

                  Indent_End;
               end if;

               Write_Char (')');
            end if;

         when N_Allocator =>
            Write_Str_With_Col_Check_Sloc ("new ");

            --  Ada 2005 (AI-231)

            if Null_Exclusion_Present (Node) then
               Write_Str ("not null ");
            end if;

            Sprint_Node (Expression (Node));

            if Present (Storage_Pool (Node)) then
               Write_Str_With_Col_Check ("[storage_pool = ");
               Sprint_Node (Storage_Pool (Node));
               Write_Char (']');
            end if;

         when N_And_Then =>
            Sprint_Left_Opnd (Node);
            Write_Str_Sloc (" and then ");
            Sprint_Right_Opnd (Node);

         --  Note: the following code for N_Aspect_Specification is not
         --  normally used, since we deal with aspects as part of a
         --  declaration, but it is here in case we deliberately try
         --  to print an N_Aspect_Speficiation node (e.g. from GDB).

         when N_Aspect_Specification =>
            Sprint_Node (Identifier (Node));
            Write_Str (" => ");
            Sprint_Node (Expression (Node));

         when N_Assignment_Statement =>
            Write_Indent;
            Sprint_Node (Name (Node));
            Write_Str_Sloc (" := ");
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Asynchronous_Select =>
            Write_Indent_Str_Sloc ("select");
            Indent_Begin;
            Sprint_Node (Triggering_Alternative (Node));
            Indent_End;

            --  Note: let the printing of Abortable_Part handle outputting
            --  the ABORT keyword, so that the Sloc can be set correctly.

            Write_Indent_Str ("then ");
            Sprint_Node (Abortable_Part (Node));
            Write_Indent_Str ("end select;");

         when N_At_Clause =>
            Write_Indent_Str_Sloc ("for ");
            Write_Id (Identifier (Node));
            Write_Str_With_Col_Check (" use at ");
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Attribute_Definition_Clause =>
            Write_Indent_Str_Sloc ("for ");
            Sprint_Node (Name (Node));
            Write_Char (''');
            Write_Name_With_Col_Check (Chars (Node));
            Write_Str_With_Col_Check (" use ");
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Attribute_Reference =>
            if Is_Procedure_Attribute_Name (Attribute_Name (Node)) then
               Write_Indent;
            end if;

            Sprint_Node (Prefix (Node));
            Write_Char_Sloc (''');
            Write_Name_With_Col_Check (Attribute_Name (Node));
            Sprint_Paren_Comma_List (Expressions (Node));

            if Is_Procedure_Attribute_Name (Attribute_Name (Node)) then
               Write_Char (';');
            end if;

         when N_Block_Statement =>
            Write_Indent;

            if Present (Identifier (Node))
              and then (not Has_Created_Identifier (Node)
                         or else not Dump_Original_Only)
            then
               Write_Rewrite_Str ("<<<");
               Write_Id (Identifier (Node));
               Write_Str (" : ");
               Write_Rewrite_Str (">>>");
            end if;

            if Present (Declarations (Node)) then
               Write_Str_With_Col_Check_Sloc ("declare");
               Sprint_Indented_List (Declarations (Node));
               Write_Indent;
            end if;

            Write_Str_With_Col_Check_Sloc ("begin");
            Sprint_Node (Handled_Statement_Sequence (Node));
            Write_Indent_Str ("end");

            if Present (Identifier (Node))
              and then (not Has_Created_Identifier (Node)
                          or else not Dump_Original_Only)
            then
               Write_Rewrite_Str ("<<<");
               Write_Char (' ');
               Write_Id (Identifier (Node));
               Write_Rewrite_Str (">>>");
            end if;

            Write_Char (';');

         when N_Call_Marker =>
            null;

            --  Enable the following code for debugging purposes only

            --  Write_Indent_Str ("#");
            --  Write_Id (Target (Node));
            --  Write_Char ('#');

         when N_Case_Expression =>
            declare
               Has_Parens : constant Boolean := Paren_Count (Node) > 0;
               Alt        : Node_Id;

            begin
               --  The syntax for case_expression does not include parentheses,
               --  but sometimes parentheses are required, so unconditionally
               --  generate them here unless already present.

               if not Has_Parens then
                  Write_Char ('(');
               end if;

               Write_Str_With_Col_Check_Sloc ("case ");
               Sprint_Node (Expression (Node));
               Write_Str_With_Col_Check (" is");

               Alt := First (Alternatives (Node));
               loop
                  Sprint_Node (Alt);
                  Next (Alt);
                  exit when No (Alt);
                  Write_Char (',');
               end loop;

               if not Has_Parens then
                  Write_Char (')');
               end if;
            end;

         when N_Case_Expression_Alternative =>
            Write_Str_With_Col_Check (" when ");
            Sprint_Bar_List (Discrete_Choices (Node));
            Write_Str (" => ");
            Sprint_Node (Expression (Node));

         when N_Case_Statement =>
            Write_Indent_Str_Sloc ("case ");
            Sprint_Node (Expression (Node));
            Write_Str (" is");
            Sprint_Indented_List (Alternatives (Node));
            Write_Indent_Str ("end case;");

         when N_Case_Statement_Alternative =>
            Write_Indent_Str_Sloc ("when ");
            Sprint_Bar_List (Discrete_Choices (Node));
            Write_Str (" => ");
            Sprint_Indented_List (Statements (Node));

         when N_Character_Literal =>
            if Column > Sprint_Line_Limit - 2 then
               Write_Indent_Str ("  ");
            end if;

            Write_Char_Sloc (''');
            Write_Char_Code (UI_To_CC (Char_Literal_Value (Node)));
            Write_Char (''');

         when N_Code_Statement =>
            Write_Indent;
            Set_Debug_Sloc;
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Compilation_Unit =>
            Sprint_Node_List (Context_Items (Node));
            Sprint_Opt_Node_List (Declarations (Aux_Decls_Node (Node)));

            if Private_Present (Node) then
               Write_Indent_Str ("private ");
               Indent_Annull;
            end if;

            Sprint_Node_Sloc (Unit (Node));

            if Present (Actions (Aux_Decls_Node (Node)))
                 or else
               Present (Pragmas_After (Aux_Decls_Node (Node)))
            then
               Write_Indent;
            end if;

            Sprint_Opt_Node_List (Actions (Aux_Decls_Node (Node)));
            Sprint_Opt_Node_List (Pragmas_After (Aux_Decls_Node (Node)));

         when N_Compilation_Unit_Aux =>
            null; -- nothing to do, never used, see above

         when N_Component_Association =>
            Set_Debug_Sloc;
            Sprint_Bar_List (Choices (Node));
            Write_Str (" => ");

            --  Ada 2005 (AI-287): Print the box if present

            if Box_Present (Node) then
               Write_Str_With_Col_Check ("<>");
            else
               Sprint_Node (Expression (Node));
            end if;

         when N_Iterated_Component_Association =>
            Set_Debug_Sloc;
            Write_Str (" for ");
            Write_Id (Defining_Identifier (Node));
            Write_Str (" in ");
            Sprint_Bar_List (Discrete_Choices (Node));
            Write_Str (" => ");
            Sprint_Node (Expression (Node));

         when N_Component_Clause =>
            Write_Indent;
            Sprint_Node (Component_Name (Node));
            Write_Str_Sloc (" at ");
            Sprint_Node (Position (Node));
            Write_Char (' ');
            Write_Str_With_Col_Check ("range ");
            Sprint_Node (First_Bit (Node));
            Write_Str (" .. ");
            Sprint_Node (Last_Bit (Node));
            Write_Char (';');

         when N_Component_Definition =>
            Set_Debug_Sloc;

            --  Ada 2005 (AI-230): Access definition components

            if Present (Access_Definition (Node)) then
               Sprint_Node (Access_Definition (Node));

            elsif Present (Subtype_Indication (Node)) then
               if Aliased_Present (Node) then
                  Write_Str_With_Col_Check ("aliased ");
               end if;

               --  Ada 2005 (AI-231)

               if Null_Exclusion_Present (Node) then
                  Write_Str (" not null ");
               end if;

               Sprint_Node (Subtype_Indication (Node));

            else
               Write_Str (" ??? ");
            end if;

         when N_Component_Declaration =>
            if Write_Indent_Identifiers_Sloc (Node) then
               Write_Str (" : ");
               Sprint_Node (Component_Definition (Node));

               if Present (Expression (Node)) then
                  Write_Str (" := ");
                  Sprint_Node (Expression (Node));
               end if;

               Write_Char (';');
            end if;

         when N_Component_List =>
            if Null_Present (Node) then
               Indent_Begin;
               Write_Indent_Str_Sloc ("null");
               Write_Char (';');
               Indent_End;

            else
               Set_Debug_Sloc;
               Sprint_Indented_List (Component_Items (Node));
               Sprint_Node (Variant_Part (Node));
            end if;

         when N_Compound_Statement =>
            Write_Indent_Str ("do");
            Indent_Begin;
            Sprint_Node_List (Actions (Node));
            Indent_End;
            Write_Indent_Str ("end;");

         when N_Conditional_Entry_Call =>
            Write_Indent_Str_Sloc ("select");
            Indent_Begin;
            Sprint_Node (Entry_Call_Alternative (Node));
            Indent_End;
            Write_Indent_Str ("else");
            Sprint_Indented_List (Else_Statements (Node));
            Write_Indent_Str ("end select;");

         when N_Constrained_Array_Definition =>
            Write_Str_With_Col_Check_Sloc ("array ");
            Sprint_Paren_Comma_List (Discrete_Subtype_Definitions (Node));
            Write_Str (" of ");

            Sprint_Node (Component_Definition (Node));

         --  A contract node should not appear in the tree. It is a semantic
         --  node attached to entry and [generic] subprogram entities. But we
         --  still provide meaningful output, in case called from the debugger.

         when N_Contract =>
            declare
               P : Node_Id;

            begin
               Indent_Begin;
               Write_Str ("N_Contract node");
               Write_Eol;

               Write_Indent_Str ("Pre_Post_Conditions");
               Indent_Begin;

               P := Pre_Post_Conditions (Node);
               while Present (P) loop
                  Sprint_Node (P);
                  P := Next_Pragma (P);
               end loop;

               Write_Eol;
               Indent_End;

               Write_Indent_Str ("Contract_Test_Cases");
               Indent_Begin;

               P := Contract_Test_Cases (Node);
               while Present (P) loop
                  Sprint_Node (P);
                  P := Next_Pragma (P);
               end loop;

               Write_Eol;
               Indent_End;

               Write_Indent_Str ("Classifications");
               Indent_Begin;

               P := Classifications (Node);
               while Present (P) loop
                  Sprint_Node (P);
                  P := Next_Pragma (P);
               end loop;

               Write_Eol;
               Indent_End;
               Indent_End;
            end;

         when N_Decimal_Fixed_Point_Definition =>
            Write_Str_With_Col_Check_Sloc (" delta ");
            Sprint_Node (Delta_Expression (Node));
            Write_Str_With_Col_Check ("digits ");
            Sprint_Node (Digits_Expression (Node));
            Sprint_Opt_Node (Real_Range_Specification (Node));

         when N_Defining_Character_Literal =>
            Write_Name_With_Col_Check_Sloc (Chars (Node));

         when N_Defining_Identifier =>
            Set_Debug_Sloc;
            Write_Id (Node);

         when N_Defining_Operator_Symbol =>
            Write_Name_With_Col_Check_Sloc (Chars (Node));

         when N_Defining_Program_Unit_Name =>
            Set_Debug_Sloc;
            Sprint_Node (Name (Node));
            Write_Char ('.');
            Write_Id (Defining_Identifier (Node));

         when N_Delay_Alternative =>
            Sprint_Node_List (Pragmas_Before (Node));

            if Present (Condition (Node)) then
               Write_Indent;
               Write_Str_With_Col_Check ("when ");
               Sprint_Node (Condition (Node));
               Write_Str (" => ");
               Indent_Annull;
            end if;

            Sprint_Node_Sloc (Delay_Statement (Node));
            Sprint_Node_List (Statements (Node));

         when N_Delay_Relative_Statement =>
            Write_Indent_Str_Sloc ("delay ");
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Delay_Until_Statement =>
            Write_Indent_Str_Sloc ("delay until ");
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Delta_Constraint =>
            Write_Str_With_Col_Check_Sloc ("delta ");
            Sprint_Node (Delta_Expression (Node));
            Sprint_Opt_Node (Range_Constraint (Node));

         when N_Derived_Type_Definition =>
            if Abstract_Present (Node) then
               Write_Str_With_Col_Check ("abstract ");
            end if;

            Write_Str_With_Col_Check ("new ");

            --  Ada 2005 (AI-231)

            if Null_Exclusion_Present (Node) then
               Write_Str_With_Col_Check ("not null ");
            end if;

            Sprint_Node (Subtype_Indication (Node));

            if Present (Interface_List (Node)) then
               Write_Str_With_Col_Check (" and ");
               Sprint_And_List (Interface_List (Node));
               Write_Str_With_Col_Check (" with ");
            end if;

            if Present (Record_Extension_Part (Node)) then
               if No (Interface_List (Node)) then
                  Write_Str_With_Col_Check (" with ");
               end if;

               Sprint_Node (Record_Extension_Part (Node));
            end if;

         when N_Designator =>
            Sprint_Node (Name (Node));
            Write_Char_Sloc ('.');
            Write_Id (Identifier (Node));

         when N_Digits_Constraint =>
            Write_Str_With_Col_Check_Sloc ("digits ");
            Sprint_Node (Digits_Expression (Node));
            Sprint_Opt_Node (Range_Constraint (Node));

         when N_Discriminant_Association =>
            Set_Debug_Sloc;

            if Present (Selector_Names (Node)) then
               Sprint_Bar_List (Selector_Names (Node));
               Write_Str (" => ");
            end if;

            Set_Debug_Sloc;
            Sprint_Node (Expression (Node));

         when N_Discriminant_Specification =>
            Set_Debug_Sloc;

            if Write_Identifiers (Node) then
               Write_Str (" : ");

               if Null_Exclusion_Present (Node) then
                  Write_Str ("not null ");
               end if;

               Sprint_Node (Discriminant_Type (Node));

               if Present (Expression (Node)) then
                  Write_Str (" := ");
                  Sprint_Node (Expression (Node));
               end if;
            else
               Write_Str (", ");
            end if;

         when N_Elsif_Part =>
            Write_Indent_Str_Sloc ("elsif ");
            Sprint_Node (Condition (Node));
            Write_Str_With_Col_Check (" then");
            Sprint_Indented_List (Then_Statements (Node));

         when N_Empty =>
            null;

         when N_Entry_Body =>
            Write_Indent_Str_Sloc ("entry ");
            Write_Id (Defining_Identifier (Node));
            Sprint_Node (Entry_Body_Formal_Part (Node));
            Write_Str_With_Col_Check (" is");
            Sprint_Indented_List (Declarations (Node));
            Write_Indent_Str ("begin");
            Sprint_Node (Handled_Statement_Sequence (Node));
            Write_Indent_Str ("end ");
            Write_Id (Defining_Identifier (Node));
            Write_Char (';');

         when N_Entry_Body_Formal_Part =>
            if Present (Entry_Index_Specification (Node)) then
               Write_Str_With_Col_Check_Sloc (" (");
               Sprint_Node (Entry_Index_Specification (Node));
               Write_Char (')');
            end if;

            Write_Param_Specs (Node);
            Write_Str_With_Col_Check_Sloc (" when ");
            Sprint_Node (Condition (Node));

         when N_Entry_Call_Alternative =>
            Sprint_Node_List (Pragmas_Before (Node));
            Sprint_Node_Sloc (Entry_Call_Statement (Node));
            Sprint_Node_List (Statements (Node));

         when N_Entry_Call_Statement =>
            Write_Indent;
            Sprint_Node_Sloc (Name (Node));
            Sprint_Opt_Paren_Comma_List (Parameter_Associations (Node));
            Write_Char (';');

         when N_Entry_Declaration =>
            Write_Indent_Str_Sloc ("entry ");
            Write_Id (Defining_Identifier (Node));

            if Present (Discrete_Subtype_Definition (Node)) then
               Write_Str_With_Col_Check (" (");
               Sprint_Node (Discrete_Subtype_Definition (Node));
               Write_Char (')');
            end if;

            Write_Param_Specs (Node);
            Write_Char (';');

         when N_Entry_Index_Specification =>
            Write_Str_With_Col_Check_Sloc ("for ");
            Write_Id (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" in ");
            Sprint_Node (Discrete_Subtype_Definition (Node));

         when N_Enumeration_Representation_Clause =>
            Write_Indent_Str_Sloc ("for ");
            Write_Id (Identifier (Node));
            Write_Str_With_Col_Check (" use ");
            Sprint_Node (Array_Aggregate (Node));
            Write_Char (';');

         when N_Enumeration_Type_Definition =>
            Set_Debug_Sloc;

            --  Skip attempt to print Literals field if it's not there and
            --  we are in package Standard (case of Character, which is
            --  handled specially (without an explicit literals list).

            if Sloc (Node) > Standard_Location
              or else Present (Literals (Node))
            then
               Sprint_Paren_Comma_List (Literals (Node));
            end if;

         when N_Error =>
            Write_Str_With_Col_Check_Sloc ("<error>");

         when N_Exception_Declaration =>
            if Write_Indent_Identifiers (Node) then
               Write_Str_With_Col_Check (" : ");

               if Is_Statically_Allocated (Defining_Identifier (Node)) then
                  Write_Str_With_Col_Check ("static ");
               end if;

               Write_Str_Sloc ("exception");

               if Present (Expression (Node)) then
                  Write_Str (" := ");
                  Sprint_Node (Expression (Node));
               end if;

               Write_Char (';');
            end if;

         when N_Exception_Handler =>
            Write_Indent_Str_Sloc ("when ");

            if Present (Choice_Parameter (Node)) then
               Sprint_Node (Choice_Parameter (Node));
               Write_Str (" : ");
            end if;

            Sprint_Bar_List (Exception_Choices (Node));
            Write_Str (" => ");
            Sprint_Indented_List (Statements (Node));

         when N_Exception_Renaming_Declaration =>
            Write_Indent;
            Set_Debug_Sloc;
            Sprint_Node (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" : exception renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Exit_Statement =>
            Write_Indent_Str_Sloc ("exit");
            Sprint_Opt_Node (Name (Node));

            if Present (Condition (Node)) then
               Write_Str_With_Col_Check (" when ");
               Sprint_Node (Condition (Node));
            end if;

            Write_Char (';');

         when N_Expanded_Name =>
            Sprint_Node (Prefix (Node));
            Write_Char_Sloc ('.');
            Sprint_Node (Selector_Name (Node));

         when N_Explicit_Dereference =>
            Sprint_Node (Prefix (Node));
            Write_Char_Sloc ('.');
            Write_Str_Sloc ("all");

         when N_Expression_With_Actions =>
            Indent_Begin;
            Write_Indent_Str_Sloc ("do ");
            Indent_Begin;
            Sprint_Node_List (Actions (Node));
            Indent_End;
            Write_Indent;
            Write_Str_With_Col_Check_Sloc ("in ");
            Sprint_Node (Expression (Node));
            Write_Str_With_Col_Check (" end");
            Indent_End;
            Write_Indent;

         when N_Expression_Function =>
            Write_Indent;
            Sprint_Node_Sloc (Specification (Node));
            Write_Str (" is");
            Indent_Begin;
            Write_Indent;
            Sprint_Node (Expression (Node));
            Write_Char (';');
            Indent_End;

         when N_Extended_Return_Statement =>
            Write_Indent_Str_Sloc ("return ");
            Sprint_Node_List (Return_Object_Declarations (Node));

            if Present (Handled_Statement_Sequence (Node)) then
               Write_Str_With_Col_Check (" do");
               Sprint_Node (Handled_Statement_Sequence (Node));
               Write_Indent_Str ("end return;");
            else
               Write_Indent_Str (";");
            end if;

         when N_Delta_Aggregate =>
            Write_Str_With_Col_Check_Sloc ("(");
            Sprint_Node (Expression (Node));
            Write_Str_With_Col_Check (" with delta ");
            Sprint_Comma_List (Component_Associations (Node));
            Write_Char (')');

         when N_Extension_Aggregate =>
            Write_Str_With_Col_Check_Sloc ("(");
            Sprint_Node (Ancestor_Part (Node));
            Write_Str_With_Col_Check (" with ");

            if Null_Record_Present (Node) then
               Write_Str_With_Col_Check ("null record");
            else
               if Present (Expressions (Node)) then
                  Sprint_Comma_List (Expressions (Node));

                  if Present (Component_Associations (Node)) then
                     Write_Str (", ");
                  end if;
               end if;

               if Present (Component_Associations (Node)) then
                  Sprint_Comma_List (Component_Associations (Node));
               end if;
            end if;

            Write_Char (')');

         when N_Floating_Point_Definition =>
            Write_Str_With_Col_Check_Sloc ("digits ");
            Sprint_Node (Digits_Expression (Node));
            Sprint_Opt_Node (Real_Range_Specification (Node));

         when N_Formal_Decimal_Fixed_Point_Definition =>
            Write_Str_With_Col_Check_Sloc ("delta <> digits <>");

         when N_Formal_Derived_Type_Definition =>
            Write_Str_With_Col_Check_Sloc ("new ");
            Sprint_Node (Subtype_Mark (Node));

            if Present (Interface_List (Node)) then
               Write_Str_With_Col_Check (" and ");
               Sprint_And_List (Interface_List (Node));
            end if;

            if Private_Present (Node) then
               Write_Str_With_Col_Check (" with private");
            end if;

         when N_Formal_Abstract_Subprogram_Declaration =>
            Write_Indent_Str_Sloc ("with ");
            Sprint_Node (Specification (Node));

            Write_Str_With_Col_Check (" is abstract");

            if Box_Present (Node) then
               Write_Str_With_Col_Check (" <>");
            elsif Present (Default_Name (Node)) then
               Write_Str_With_Col_Check (" ");
               Sprint_Node (Default_Name (Node));
            end if;

            Write_Char (';');

         when N_Formal_Concrete_Subprogram_Declaration =>
            Write_Indent_Str_Sloc ("with ");
            Sprint_Node (Specification (Node));

            if Box_Present (Node) then
               Write_Str_With_Col_Check (" is <>");
            elsif Present (Default_Name (Node)) then
               Write_Str_With_Col_Check (" is ");
               Sprint_Node (Default_Name (Node));
            end if;

            Write_Char (';');

         when N_Formal_Discrete_Type_Definition =>
            Write_Str_With_Col_Check_Sloc ("<>");

         when N_Formal_Floating_Point_Definition =>
            Write_Str_With_Col_Check_Sloc ("digits <>");

         when N_Formal_Modular_Type_Definition =>
            Write_Str_With_Col_Check_Sloc ("mod <>");

         when N_Formal_Object_Declaration =>
            Set_Debug_Sloc;

            if Write_Indent_Identifiers (Node) then
               Write_Str (" : ");

               if In_Present (Node) then
                  Write_Str_With_Col_Check ("in ");
               end if;

               if Out_Present (Node) then
                  Write_Str_With_Col_Check ("out ");
               end if;

               if Present (Subtype_Mark (Node)) then

                  --  Ada 2005 (AI-423): Formal object with null exclusion

                  if Null_Exclusion_Present (Node) then
                     Write_Str ("not null ");
                  end if;

                  Sprint_Node (Subtype_Mark (Node));

               --  Ada 2005 (AI-423): Formal object with access definition

               else
                  pragma Assert (Present (Access_Definition (Node)));

                  Sprint_Node (Access_Definition (Node));
               end if;

               if Present (Default_Expression (Node)) then
                  Write_Str (" := ");
                  Sprint_Node (Default_Expression (Node));
               end if;

               Write_Char (';');
            end if;

         when N_Formal_Ordinary_Fixed_Point_Definition =>
            Write_Str_With_Col_Check_Sloc ("delta <>");

         when N_Formal_Package_Declaration =>
            Write_Indent_Str_Sloc ("with package ");
            Write_Id (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" is new ");
            Sprint_Node (Name (Node));
            Write_Str_With_Col_Check (" (<>);");

         when N_Formal_Private_Type_Definition =>
            if Abstract_Present (Node) then
               Write_Str_With_Col_Check ("abstract ");
            end if;

            if Tagged_Present (Node) then
               Write_Str_With_Col_Check ("tagged ");
            end if;

            if Limited_Present (Node) then
               Write_Str_With_Col_Check ("limited ");
            end if;

            Write_Str_With_Col_Check_Sloc ("private");

         when N_Formal_Incomplete_Type_Definition =>
            if Tagged_Present (Node) then
               Write_Str_With_Col_Check ("is tagged ");
            end if;

         when N_Formal_Signed_Integer_Type_Definition =>
            Write_Str_With_Col_Check_Sloc ("range <>");

         when N_Formal_Type_Declaration =>
            Write_Indent_Str_Sloc ("type ");
            Write_Id (Defining_Identifier (Node));

            if Present (Discriminant_Specifications (Node)) then
               Write_Discr_Specs (Node);
            elsif Unknown_Discriminants_Present (Node) then
               Write_Str_With_Col_Check ("(<>)");
            end if;

            if Nkind (Formal_Type_Definition (Node)) /=
                N_Formal_Incomplete_Type_Definition
            then
               Write_Str_With_Col_Check (" is ");
            end if;

            Sprint_Node (Formal_Type_Definition (Node));
            Write_Char (';');

         when N_Free_Statement =>
            Write_Indent_Str_Sloc ("free ");
            Sprint_Node (Expression (Node));
            Write_Char (';');

         when N_Freeze_Entity =>
            if Dump_Original_Only then
               null;

            --  A freeze node is output if it has some effect (i.e. non-empty
            --  actions, or freeze node for an itype, which causes elaboration
            --  of the itype), and is also always output if Dump_Freeze_Null
            --  is set True.

            elsif Present (Actions (Node))
              or else Is_Itype (Entity (Node))
              or else Dump_Freeze_Null
            then
               Write_Indent;
               Write_Rewrite_Str ("<<<");
               Write_Str_With_Col_Check_Sloc ("freeze ");
               Write_Id (Entity (Node));
               Write_Str (" [");

               if No (Actions (Node)) then
                  Write_Char (']');

               else
                  --  Output freeze actions. We increment Freeze_Indent during
                  --  this output to avoid generating extra blank lines before
                  --  any procedures included in the freeze actions.

                  Freeze_Indent := Freeze_Indent + 1;
                  Sprint_Indented_List (Actions (Node));
                  Freeze_Indent := Freeze_Indent - 1;
                  Write_Indent_Str ("]");
               end if;

               Write_Rewrite_Str (">>>");
            end if;

         when N_Freeze_Generic_Entity =>
            if Dump_Original_Only then
               null;

            else
               Write_Indent;
               Write_Str_With_Col_Check_Sloc ("freeze_generic ");
               Write_Id (Entity (Node));
            end if;

         when N_Full_Type_Declaration =>
            Write_Indent_Str_Sloc ("type ");
            Sprint_Node (Defining_Identifier (Node));
            Write_Discr_Specs (Node);
            Write_Str_With_Col_Check (" is ");
            Sprint_Node (Type_Definition (Node));
            Write_Char (';');

         when N_Function_Call =>
            Set_Debug_Sloc;
            Write_Subprogram_Name (Name (Node));
            Sprint_Opt_Paren_Comma_List (Parameter_Associations (Node));

         when N_Function_Instantiation =>
            Write_Indent_Str_Sloc ("function ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str_With_Col_Check (" is new ");
            Sprint_Node (Name (Node));
            Sprint_Opt_Paren_Comma_List (Generic_Associations (Node));
            Write_Char (';');

         when N_Function_Specification =>
            Write_Str_With_Col_Check_Sloc ("function ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Param_Specs (Node);
            Write_Str_With_Col_Check (" return ");

            --  Ada 2005 (AI-231)

            if Nkind (Result_Definition (Node)) /= N_Access_Definition
              and then Null_Exclusion_Present (Node)
            then
               Write_Str (" not null ");
            end if;

            Sprint_Node (Result_Definition (Node));

         when N_Generic_Association =>
            Set_Debug_Sloc;

            if Present (Selector_Name (Node)) then
               Sprint_Node (Selector_Name (Node));
               Write_Str (" => ");
            end if;

            Sprint_Node (Explicit_Generic_Actual_Parameter (Node));

         when N_Generic_Function_Renaming_Declaration =>
            Write_Indent_Str_Sloc ("generic function ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str_With_Col_Check (" renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Generic_Package_Declaration =>
            Extra_Blank_Line;
            Write_Indent_Str_Sloc ("generic ");
            Sprint_Indented_List (Generic_Formal_Declarations (Node));
            Write_Indent;
            Sprint_Node (Specification (Node));
            Write_Char (';');

         when N_Generic_Package_Renaming_Declaration =>
            Write_Indent_Str_Sloc ("generic package ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str_With_Col_Check (" renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Generic_Procedure_Renaming_Declaration =>
            Write_Indent_Str_Sloc ("generic procedure ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str_With_Col_Check (" renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Generic_Subprogram_Declaration =>
            Extra_Blank_Line;
            Write_Indent_Str_Sloc ("generic ");
            Sprint_Indented_List (Generic_Formal_Declarations (Node));
            Write_Indent;
            Sprint_Node (Specification (Node));
            Write_Char (';');

         when N_Goto_Statement =>
            Write_Indent_Str_Sloc ("goto ");
            Sprint_Node (Name (Node));
            Write_Char (';');

            if Nkind (Next (Node)) = N_Label then
               Write_Indent;
            end if;

         when N_Handled_Sequence_Of_Statements =>
            Set_Debug_Sloc;
            Sprint_Indented_List (Statements (Node));

            if Present (Exception_Handlers (Node)) then
               Write_Indent_Str ("exception");
               Indent_Begin;
               Sprint_Node_List (Exception_Handlers (Node));
               Indent_End;
            end if;

            if Present (At_End_Proc (Node)) then
               Write_Indent_Str ("at end");
               Indent_Begin;
               Write_Indent;
               Sprint_Node (At_End_Proc (Node));
               Write_Char (';');
               Indent_End;
            end if;

         when N_Identifier =>
            Set_Debug_Sloc;
            Write_Id (Node);

         when N_If_Expression =>
            declare
               Has_Parens : constant Boolean := Paren_Count (Node) > 0;
               Condition  : constant Node_Id := First (Expressions (Node));
               Then_Expr  : constant Node_Id := Next (Condition);

            begin
               --  The syntax for if_expression does not include parentheses,
               --  but sometimes parentheses are required, so unconditionally
               --  generate them here unless already present.

               if not Has_Parens then
                  Write_Char ('(');
               end if;

               Write_Str_With_Col_Check_Sloc ("if ");
               Sprint_Node (Condition);
               Write_Str_With_Col_Check (" then ");

               --  Defense against junk here

               if Present (Then_Expr) then
                  Sprint_Node (Then_Expr);

                  if Present (Next (Then_Expr)) then
                     Write_Str_With_Col_Check (" else ");
                     Sprint_Node (Next (Then_Expr));
                  end if;
               end if;

               if not Has_Parens then
                  Write_Char (')');
               end if;
            end;

         when N_If_Statement =>
            Write_Indent_Str_Sloc ("if ");
            Sprint_Node (Condition (Node));
            Write_Str_With_Col_Check (" then");
            Sprint_Indented_List (Then_Statements (Node));
            Sprint_Opt_Node_List (Elsif_Parts (Node));

            if Present (Else_Statements (Node)) then
               Write_Indent_Str ("else");
               Sprint_Indented_List (Else_Statements (Node));
            end if;

            Write_Indent_Str ("end if;");

         when N_Implicit_Label_Declaration =>
            if not Dump_Original_Only then
               Write_Indent;
               Write_Rewrite_Str ("<<<");
               Set_Debug_Sloc;
               Write_Id (Defining_Identifier (Node));
               Write_Str (" : ");
               Write_Str_With_Col_Check ("label");
               Write_Rewrite_Str (">>>");
            end if;

         when N_In =>
            Sprint_Left_Opnd (Node);
            Write_Str_Sloc (" in ");

            if Present (Right_Opnd (Node)) then
               Sprint_Right_Opnd (Node);
            else
               Sprint_Bar_List (Alternatives (Node));
            end if;

         when N_Incomplete_Type_Declaration =>
            Write_Indent_Str_Sloc ("type ");
            Write_Id (Defining_Identifier (Node));

            if Present (Discriminant_Specifications (Node)) then
               Write_Discr_Specs (Node);
            elsif Unknown_Discriminants_Present (Node) then
               Write_Str_With_Col_Check ("(<>)");
            end if;

            Write_Char (';');

         when N_Index_Or_Discriminant_Constraint =>
            Set_Debug_Sloc;
            Sprint_Paren_Comma_List (Constraints (Node));

         when N_Indexed_Component =>
            Sprint_Node_Sloc (Prefix (Node));
            Sprint_Opt_Paren_Comma_List (Expressions (Node));

         when N_Integer_Literal =>
            if Print_In_Hex (Node) then
               Write_Uint_With_Col_Check_Sloc (Intval (Node), Hex);
            else
               Write_Uint_With_Col_Check_Sloc (Intval (Node), Auto);
            end if;

         when N_Iteration_Scheme =>
            if Present (Condition (Node)) then
               Write_Str_With_Col_Check_Sloc ("while ");
               Sprint_Node (Condition (Node));
            else
               Write_Str_With_Col_Check_Sloc ("for ");

               if Present (Iterator_Specification (Node)) then
                  Sprint_Node (Iterator_Specification (Node));
               else
                  Sprint_Node (Loop_Parameter_Specification (Node));
               end if;
            end if;

            Write_Char (' ');

         when N_Iterator_Specification =>
            Set_Debug_Sloc;
            Write_Id (Defining_Identifier (Node));

            if Present (Subtype_Indication (Node)) then
               Write_Str_With_Col_Check (" : ");
               Sprint_Node (Subtype_Indication (Node));
            end if;

            if Of_Present (Node) then
               Write_Str_With_Col_Check (" of ");
            else
               Write_Str_With_Col_Check (" in ");
            end if;

            if Reverse_Present (Node) then
               Write_Str_With_Col_Check ("reverse ");
            end if;

            Sprint_Node (Name (Node));

         when N_Itype_Reference =>
            Write_Indent_Str_Sloc ("reference ");
            Write_Id (Itype (Node));

         when N_Label =>
            Write_Indent_Str_Sloc ("<<");
            Write_Id (Identifier (Node));
            Write_Str (">>");

         when N_Loop_Parameter_Specification =>
            Set_Debug_Sloc;
            Write_Id (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" in ");

            if Reverse_Present (Node) then
               Write_Str_With_Col_Check ("reverse ");
            end if;

            Sprint_Node (Discrete_Subtype_Definition (Node));

         when N_Loop_Statement =>
            Write_Indent;

            if Present (Identifier (Node))
              and then (not Has_Created_Identifier (Node)
                          or else not Dump_Original_Only)
            then
               Write_Rewrite_Str ("<<<");
               Write_Id (Identifier (Node));
               Write_Str (" : ");
               Write_Rewrite_Str (">>>");
               Sprint_Node (Iteration_Scheme (Node));
               Write_Str_With_Col_Check_Sloc ("loop");
               Sprint_Indented_List (Statements (Node));
               Write_Indent_Str ("end loop ");
               Write_Rewrite_Str ("<<<");
               Write_Id (Identifier (Node));
               Write_Rewrite_Str (">>>");
               Write_Char (';');

            else
               Sprint_Node (Iteration_Scheme (Node));
               Write_Str_With_Col_Check_Sloc ("loop");
               Sprint_Indented_List (Statements (Node));
               Write_Indent_Str ("end loop;");
            end if;

         when N_Mod_Clause =>
            Sprint_Node_List (Pragmas_Before (Node));
            Write_Str_With_Col_Check_Sloc ("at mod ");
            Sprint_Node (Expression (Node));

         when N_Modular_Type_Definition =>
            Write_Str_With_Col_Check_Sloc ("mod ");
            Sprint_Node (Expression (Node));

         when N_Not_In =>
            Sprint_Left_Opnd (Node);
            Write_Str_Sloc (" not in ");

            if Present (Right_Opnd (Node)) then
               Sprint_Right_Opnd (Node);
            else
               Sprint_Bar_List (Alternatives (Node));
            end if;

         when N_Null =>
            Write_Str_With_Col_Check_Sloc ("null");

         when N_Null_Statement =>
            if Comes_From_Source (Node)
              or else Dump_Freeze_Null
              or else not Is_List_Member (Node)
              or else (No (Prev (Node)) and then No (Next (Node)))
            then
               Write_Indent_Str_Sloc ("null;");
            end if;

         when N_Number_Declaration =>
            Set_Debug_Sloc;

            if Write_Indent_Identifiers (Node) then
               Write_Str_With_Col_Check (" : constant ");
               Write_Str (" := ");
               Sprint_Node (Expression (Node));
               Write_Char (';');
            end if;

         when N_Object_Declaration =>
            Set_Debug_Sloc;

            if Write_Indent_Identifiers (Node) then
               declare
                  Def_Id : constant Entity_Id := Defining_Identifier (Node);

               begin
                  Write_Str_With_Col_Check (" : ");

                  if Is_Statically_Allocated (Def_Id) then
                     Write_Str_With_Col_Check ("static ");
                  end if;

                  if Aliased_Present (Node) then
                     Write_Str_With_Col_Check ("aliased ");
                  end if;

                  if Constant_Present (Node) then
                     Write_Str_With_Col_Check ("constant ");
                  end if;

                  --  Ada 2005 (AI-231)

                  if Null_Exclusion_Present (Node) then
                     Write_Str_With_Col_Check ("not null ");
                  end if;

                  --  Print type. We used to print the Object_Definition from
                  --  the node, but it is much more useful to print the Etype
                  --  of the defining identifier for the case where the nominal
                  --  type is an unconstrained array type. For example, this
                  --  will be a clear reference to the Itype with the bounds
                  --  in the case of a type like String. The object after
                  --  all is constrained, even if its nominal subtype is
                  --  unconstrained.

                  declare
                     Odef : constant Node_Id := Object_Definition (Node);

                  begin
                     if Nkind (Odef) = N_Identifier
                       and then Present (Etype (Odef))
                       and then Is_Array_Type (Etype (Odef))
                       and then not Is_Constrained (Etype (Odef))
                       and then Present (Etype (Def_Id))
                     then
                        Sprint_Node (Etype (Def_Id));

                     --  In other cases, the nominal type is fine to print

                     else
                        Sprint_Node (Odef);
                     end if;
                  end;

                  if Present (Expression (Node))
                    and then Expression (Node) /= Error
                  then
                     Write_Str (" := ");
                     Sprint_Node (Expression (Node));
                  end if;

                  Write_Char (';');

                  --  Handle implicit importation and implicit exportation of
                  --  object declarations:
                  --    $pragma import (Convention_Id, Def_Id, "...");
                  --    $pragma export (Convention_Id, Def_Id, "...");

                  if Is_Internal (Def_Id)
                    and then Present (Interface_Name (Def_Id))
                  then
                     Write_Indent_Str_Sloc ("$pragma ");

                     if Is_Imported (Def_Id) then
                        Write_Str ("import (");

                     else pragma Assert (Is_Exported (Def_Id));
                        Write_Str ("export (");
                     end if;

                     declare
                        Prefix : constant String  := "Convention_";
                        S      : constant String  := Convention (Def_Id)'Img;

                     begin
                        Name_Len := S'Last - Prefix'Last;
                        Name_Buffer (1 .. Name_Len) :=
                          S (Prefix'Last + 1 .. S'Last);
                        Set_Casing (All_Lower_Case);
                        Write_Str (Name_Buffer (1 .. Name_Len));
                     end;

                     Write_Str (", ");
                     Write_Id  (Def_Id);
                     Write_Str (", ");
                     Write_String_Table_Entry
                       (Strval (Interface_Name (Def_Id)));
                     Write_Str (");");
                  end if;
               end;
            end if;

         when N_Object_Renaming_Declaration =>
            Write_Indent;
            Set_Debug_Sloc;
            Sprint_Node (Defining_Identifier (Node));
            Write_Str (" : ");

            --  Ada 2005 (AI-230): Access renamings

            if Present (Access_Definition (Node)) then
               Sprint_Node (Access_Definition (Node));

            elsif Present (Subtype_Mark (Node)) then

               --  Ada 2005 (AI-423): Object renaming with a null exclusion

               if Null_Exclusion_Present (Node) then
                  Write_Str ("not null ");
               end if;

               Sprint_Node (Subtype_Mark (Node));

            else
               Write_Str (" ??? ");
            end if;

            Write_Str_With_Col_Check (" renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Op_Abs =>
            Write_Operator (Node, "abs ");
            Sprint_Right_Opnd (Node);

         when N_Op_Add =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " + ");
            Sprint_Right_Opnd (Node);

         when N_Op_And =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " and ");
            Sprint_Right_Opnd (Node);

         when N_Op_Concat =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " & ");
            Sprint_Right_Opnd (Node);

         when N_Op_Divide =>
            Sprint_Left_Opnd (Node);
            Write_Char (' ');
            Process_TFAI_RR_Flags (Node);
            Write_Operator (Node, "/ ");
            Sprint_Right_Opnd (Node);

         when N_Op_Eq =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " = ");
            Sprint_Right_Opnd (Node);

         when N_Op_Expon =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " ** ");
            Sprint_Right_Opnd (Node);

         when N_Op_Ge =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " >= ");
            Sprint_Right_Opnd (Node);

         when N_Op_Gt =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " > ");
            Sprint_Right_Opnd (Node);

         when N_Op_Le =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " <= ");
            Sprint_Right_Opnd (Node);

         when N_Op_Lt =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " < ");
            Sprint_Right_Opnd (Node);

         when N_Op_Minus =>
            Write_Operator (Node, "-");
            Sprint_Right_Opnd (Node);

         when N_Op_Mod =>
            Sprint_Left_Opnd (Node);

            if Treat_Fixed_As_Integer (Node) then
               Write_Str (" #");
            end if;

            Write_Operator (Node, " mod ");
            Sprint_Right_Opnd (Node);

         when N_Op_Multiply =>
            Sprint_Left_Opnd (Node);
            Write_Char (' ');
            Process_TFAI_RR_Flags (Node);
            Write_Operator (Node, "* ");
            Sprint_Right_Opnd (Node);

         when N_Op_Ne =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " /= ");
            Sprint_Right_Opnd (Node);

         when N_Op_Not =>
            Write_Operator (Node, "not ");
            Sprint_Right_Opnd (Node);

         when N_Op_Or =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " or ");
            Sprint_Right_Opnd (Node);

         when N_Op_Plus =>
            Write_Operator (Node, "+");
            Sprint_Right_Opnd (Node);

         when N_Op_Rem =>
            Sprint_Left_Opnd (Node);

            if Treat_Fixed_As_Integer (Node) then
               Write_Str (" #");
            end if;

            Write_Operator (Node, " rem ");
            Sprint_Right_Opnd (Node);

         when N_Op_Shift =>
            Set_Debug_Sloc;
            Write_Id (Node);
            Write_Char ('!');
            Write_Str_With_Col_Check ("(");
            Sprint_Node (Left_Opnd (Node));
            Write_Str (", ");
            Sprint_Node (Right_Opnd (Node));
            Write_Char (')');

         when N_Op_Subtract =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " - ");
            Sprint_Right_Opnd (Node);

         when N_Op_Xor =>
            Sprint_Left_Opnd (Node);
            Write_Operator (Node, " xor ");
            Sprint_Right_Opnd (Node);

         when N_Operator_Symbol =>
            Write_Name_With_Col_Check_Sloc (Chars (Node));

         when N_Ordinary_Fixed_Point_Definition =>
            Write_Str_With_Col_Check_Sloc ("delta ");
            Sprint_Node (Delta_Expression (Node));
            Sprint_Opt_Node (Real_Range_Specification (Node));

         when N_Or_Else =>
            Sprint_Left_Opnd (Node);
            Write_Str_Sloc (" or else ");
            Sprint_Right_Opnd (Node);

         when N_Others_Choice =>
            if All_Others (Node) then
               Write_Str_With_Col_Check ("all ");
            end if;

            Write_Str_With_Col_Check_Sloc ("others");

         when N_Package_Body =>
            Extra_Blank_Line;
            Write_Indent_Str_Sloc ("package body ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str (" is");
            Sprint_Indented_List (Declarations (Node));

            if Present (Handled_Statement_Sequence (Node)) then
               Write_Indent_Str ("begin");
               Sprint_Node (Handled_Statement_Sequence (Node));
            end if;

            Write_Indent_Str ("end ");
            Sprint_End_Label
              (Handled_Statement_Sequence (Node), Defining_Unit_Name (Node));
            Write_Char (';');

         when N_Package_Body_Stub =>
            Write_Indent_Str_Sloc ("package body ");
            Sprint_Node (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" is separate;");

         when N_Package_Declaration =>
            Extra_Blank_Line;
            Write_Indent;
            Sprint_Node_Sloc (Specification (Node));
            Write_Char (';');

            --  If this is an instantiation, get the aspects from the original
            --  instantiation node.

            if Is_Generic_Instance (Defining_Entity (Node))
              and then Has_Aspects
                         (Package_Instantiation (Defining_Entity (Node)))
            then
               Sprint_Aspect_Specifications
                 (Package_Instantiation (Defining_Entity (Node)),
                   Semicolon => True);
            end if;

         when N_Package_Instantiation =>
            Extra_Blank_Line;
            Write_Indent_Str_Sloc ("package ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str (" is new ");
            Sprint_Node (Name (Node));
            Sprint_Opt_Paren_Comma_List (Generic_Associations (Node));
            Write_Char (';');

         when N_Package_Renaming_Declaration =>
            Write_Indent_Str_Sloc ("package ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str_With_Col_Check (" renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Package_Specification =>
            Write_Str_With_Col_Check_Sloc ("package ");
            Sprint_Node (Defining_Unit_Name (Node));

            if Nkind (Parent (Node)) = N_Generic_Package_Declaration
              and then Has_Aspects (Parent (Node))
            then
               Sprint_Aspect_Specifications
                 (Parent (Node), Semicolon => False);

            --  An instantiation is rewritten as a package declaration, but
            --  the aspects belong to the instantiation node.

            elsif Nkind (Parent (Node)) = N_Package_Declaration then
               declare
                  Pack : constant Entity_Id := Defining_Entity (Node);

               begin
                  if not Is_Generic_Instance (Pack) then
                     if Has_Aspects (Parent (Node)) then
                        Sprint_Aspect_Specifications
                          (Parent (Node), Semicolon => False);
                     end if;
                  end if;
               end;
            end if;

            Write_Str (" is");
            Sprint_Indented_List (Visible_Declarations (Node));

            if Present (Private_Declarations (Node)) then
               Write_Indent_Str ("private");
               Sprint_Indented_List (Private_Declarations (Node));
            end if;

            Write_Indent_Str ("end ");
            Sprint_Node (Defining_Unit_Name (Node));

         when N_Parameter_Association =>
            Sprint_Node_Sloc (Selector_Name (Node));
            Write_Str (" => ");
            Sprint_Node (Explicit_Actual_Parameter (Node));

         when N_Parameter_Specification =>
            Set_Debug_Sloc;

            if Write_Identifiers (Node) then
               Write_Str (" : ");

               if In_Present (Node) then
                  Write_Str_With_Col_Check ("in ");
               end if;

               if Out_Present (Node) then
                  Write_Str_With_Col_Check ("out ");
               end if;

               --  Ada 2005 (AI-231): Parameter specification may carry null
               --  exclusion. Do not print it now if this is an access formal,
               --  it is emitted when the access definition is displayed.

               if Null_Exclusion_Present (Node)
                 and then Nkind (Parameter_Type (Node)) /= N_Access_Definition
               then
                  Write_Str ("not null ");
               end if;

               if Aliased_Present (Node) then
                  Write_Str ("aliased ");
               end if;

               Sprint_Node (Parameter_Type (Node));

               if Present (Expression (Node)) then
                  Write_Str (" := ");
                  Sprint_Node (Expression (Node));
               end if;
            else
               Write_Str (", ");
            end if;

         when N_Pop_Constraint_Error_Label =>
            Write_Indent_Str ("%pop_constraint_error_label");

         when N_Pop_Program_Error_Label =>
            Write_Indent_Str ("%pop_program_error_label");

         when N_Pop_Storage_Error_Label =>
            Write_Indent_Str ("%pop_storage_error_label");

         when N_Private_Extension_Declaration =>
            Write_Indent_Str_Sloc ("type ");
            Write_Id (Defining_Identifier (Node));

            if Present (Discriminant_Specifications (Node)) then
               Write_Discr_Specs (Node);
            elsif Unknown_Discriminants_Present (Node) then
               Write_Str_With_Col_Check ("(<>)");
            end if;

            Write_Str_With_Col_Check (" is new ");
            Sprint_Node (Subtype_Indication (Node));

            if Present (Interface_List (Node)) then
               Write_Str_With_Col_Check (" and ");
               Sprint_And_List (Interface_List (Node));
            end if;

            Write_Str_With_Col_Check (" with private;");

         when N_Private_Type_Declaration =>
            Write_Indent_Str_Sloc ("type ");
            Write_Id (Defining_Identifier (Node));

            if Present (Discriminant_Specifications (Node)) then
               Write_Discr_Specs (Node);
            elsif Unknown_Discriminants_Present (Node) then
               Write_Str_With_Col_Check ("(<>)");
            end if;

            Write_Str (" is ");

            if Tagged_Present (Node) then
               Write_Str_With_Col_Check ("tagged ");
            end if;

            if Limited_Present (Node) then
               Write_Str_With_Col_Check ("limited ");
            end if;

            Write_Str_With_Col_Check ("private;");

         when N_Push_Constraint_Error_Label =>
            Write_Indent_Str ("%push_constraint_error_label (");

            if Present (Exception_Label (Node)) then
               Write_Name_With_Col_Check (Chars (Exception_Label (Node)));
            end if;

            Write_Str (")");

         when N_Push_Program_Error_Label =>
            Write_Indent_Str ("%push_program_error_label (");

            if Present (Exception_Label (Node)) then
               Write_Name_With_Col_Check (Chars (Exception_Label (Node)));
            end if;

            Write_Str (")");

         when N_Push_Storage_Error_Label =>
            Write_Indent_Str ("%push_storage_error_label (");

            if Present (Exception_Label (Node)) then
               Write_Name_With_Col_Check (Chars (Exception_Label (Node)));
            end if;

            Write_Str (")");

         when N_Pragma =>
            Write_Indent_Str_Sloc ("pragma ");
            Write_Name_With_Col_Check (Pragma_Name_Unmapped (Node));

            if Present (Pragma_Argument_Associations (Node)) then
               Sprint_Opt_Paren_Comma_List
                 (Pragma_Argument_Associations (Node));
            end if;

            Write_Char (';');

         when N_Pragma_Argument_Association =>
            Set_Debug_Sloc;

            if Chars (Node) /= No_Name then
               Write_Name_With_Col_Check (Chars (Node));
               Write_Str (" => ");
            end if;

            Sprint_Node (Expression (Node));

         when N_Procedure_Call_Statement =>
            Write_Indent;
            Set_Debug_Sloc;
            Write_Subprogram_Name (Name (Node));
            Sprint_Opt_Paren_Comma_List (Parameter_Associations (Node));
            Write_Char (';');

         when N_Procedure_Instantiation =>
            Write_Indent_Str_Sloc ("procedure ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Str_With_Col_Check (" is new ");
            Sprint_Node (Name (Node));
            Sprint_Opt_Paren_Comma_List (Generic_Associations (Node));
            Write_Char (';');

         when N_Procedure_Specification =>
            Write_Str_With_Col_Check_Sloc ("procedure ");
            Sprint_Node (Defining_Unit_Name (Node));
            Write_Param_Specs (Node);

         when N_Protected_Body =>
            Write_Indent_Str_Sloc ("protected body ");
            Write_Id (Defining_Identifier (Node));
            Write_Str (" is");
            Sprint_Indented_List (Declarations (Node));
            Write_Indent_Str ("end ");
            Write_Id (Defining_Identifier (Node));
            Write_Char (';');

         when N_Protected_Body_Stub =>
            Write_Indent_Str_Sloc ("protected body ");
            Write_Id (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" is separate;");

         when N_Protected_Definition =>
            Set_Debug_Sloc;
            Sprint_Indented_List (Visible_Declarations (Node));

            if Present (Private_Declarations (Node)) then
               Write_Indent_Str ("private");
               Sprint_Indented_List (Private_Declarations (Node));
            end if;

            Write_Indent_Str ("end ");

         when N_Protected_Type_Declaration =>
            Write_Indent_Str_Sloc ("protected type ");
            Sprint_Node (Defining_Identifier (Node));
            Write_Discr_Specs (Node);

            if Present (Interface_List (Node)) then
               Write_Str (" is new ");
               Sprint_And_List (Interface_List (Node));
               Write_Str (" with ");
            else
               Write_Str (" is");
            end if;

            Sprint_Node (Protected_Definition (Node));
            Write_Id (Defining_Identifier (Node));
            Write_Char (';');

         when N_Qualified_Expression =>
            Sprint_Node (Subtype_Mark (Node));
            Write_Char_Sloc (''');

            --  Print expression, make sure we have at least one level of
            --  parentheses around the expression. For cases of qualified
            --  expressions in the source, this is always the case, but
            --  for generated qualifications, there may be no explicit
            --  parentheses present.

            if Paren_Count (Expression (Node)) /= 0 then
               Sprint_Node (Expression (Node));

            else
               Write_Char ('(');
               Sprint_Node (Expression (Node));

               --  Odd case, for the qualified expressions used in machine
               --  code the argument may be a procedure call, resulting in
               --  a junk semicolon before the right parent, get rid of it.

               Write_Erase_Char (';');

               --  Now we can add the terminating right paren

               Write_Char (')');
            end if;

         when N_Quantified_Expression =>
            Write_Str (" for");

            if All_Present (Node) then
               Write_Str (" all ");
            else
               Write_Str (" some ");
            end if;

            if Present (Iterator_Specification (Node)) then
               Sprint_Node (Iterator_Specification (Node));
            else
               Sprint_Node (Loop_Parameter_Specification (Node));
            end if;

            Write_Str (" => ");
            Sprint_Node (Condition (Node));

         when N_Raise_Expression =>
            declare
               Has_Parens : constant Boolean := Paren_Count (Node) > 0;

            begin
               --  The syntax for raise_expression does not include parentheses
               --  but sometimes parentheses are required, so unconditionally
               --  generate them here unless already present.

               if not Has_Parens then
                  Write_Char ('(');
               end if;

               Write_Str_With_Col_Check_Sloc ("raise ");
               Sprint_Node (Name (Node));

               if Present (Expression (Node)) then
                  Write_Str_With_Col_Check (" with ");
                  Sprint_Node (Expression (Node));
               end if;

               if not Has_Parens then
                  Write_Char (')');
               end if;
            end;

         when N_Raise_Constraint_Error =>

            --  This node can be used either as a subexpression or as a
            --  statement form. The following test is a reasonably reliable
            --  way to distinguish the two cases.

            if Is_List_Member (Node)
              and then Nkind (Parent (Node)) not in N_Subexpr
            then
               Write_Indent;
            end if;

            Write_Str_With_Col_Check_Sloc ("[constraint_error");
            Write_Condition_And_Reason (Node);

         when N_Raise_Program_Error =>

            --  This node can be used either as a subexpression or as a
            --  statement form. The following test is a reasonably reliable
            --  way to distinguish the two cases.

            if Is_List_Member (Node)
              and then Nkind (Parent (Node)) not in N_Subexpr
            then
               Write_Indent;
            end if;

            Write_Str_With_Col_Check_Sloc ("[program_error");
            Write_Condition_And_Reason (Node);

         when N_Raise_Storage_Error =>

            --  This node can be used either as a subexpression or as a
            --  statement form. The following test is a reasonably reliable
            --  way to distinguish the two cases.

            if Is_List_Member (Node)
              and then Nkind (Parent (Node)) not in N_Subexpr
            then
               Write_Indent;
            end if;

            Write_Str_With_Col_Check_Sloc ("[storage_error");
            Write_Condition_And_Reason (Node);

         when N_Raise_Statement =>
            Write_Indent_Str_Sloc ("raise ");
            Sprint_Node (Name (Node));

            if Present (Expression (Node)) then
               Write_Str_With_Col_Check_Sloc (" with ");
               Sprint_Node (Expression (Node));
            end if;

            Write_Char (';');

         when N_Range =>
            Sprint_Node (Low_Bound (Node));
            Write_Str_Sloc (" .. ");
            Sprint_Node (High_Bound (Node));
            Update_Itype (Node);

         when N_Range_Constraint =>
            Write_Str_With_Col_Check_Sloc ("range ");
            Sprint_Node (Range_Expression (Node));

         when N_Real_Literal =>
            Write_Ureal_With_Col_Check_Sloc (Realval (Node));

         when N_Real_Range_Specification =>
            Write_Str_With_Col_Check_Sloc ("range ");
            Sprint_Node (Low_Bound (Node));
            Write_Str (" .. ");
            Sprint_Node (High_Bound (Node));

         when N_Record_Definition =>
            if Abstract_Present (Node) then
               Write_Str_With_Col_Check ("abstract ");
            end if;

            if Tagged_Present (Node) then
               Write_Str_With_Col_Check ("tagged ");
            end if;

            if Limited_Present (Node) then
               Write_Str_With_Col_Check ("limited ");
            end if;

            if Null_Present (Node) then
               Write_Str_With_Col_Check_Sloc ("null record");

            else
               Write_Str_With_Col_Check_Sloc ("record");
               Sprint_Node (Component_List (Node));
               Write_Indent_Str ("end record");
            end if;

         when N_Record_Representation_Clause =>
            Write_Indent_Str_Sloc ("for ");
            Sprint_Node (Identifier (Node));
            Write_Str_With_Col_Check (" use record ");

            if Present (Mod_Clause (Node)) then
               Sprint_Node (Mod_Clause (Node));
            end if;

            Sprint_Indented_List (Component_Clauses (Node));
            Write_Indent_Str ("end record;");

         when N_Reference =>
            Sprint_Node (Prefix (Node));
            Write_Str_With_Col_Check_Sloc ("'reference");

         when N_Requeue_Statement =>
            Write_Indent_Str_Sloc ("requeue ");
            Sprint_Node (Name (Node));

            if Abort_Present (Node) then
               Write_Str_With_Col_Check (" with abort");
            end if;

            Write_Char (';');

         --  Don't we want to print more detail???

         --  Doc of this extended syntax belongs in sinfo.ads and/or
         --  sprint.ads ???

         when N_SCIL_Dispatch_Table_Tag_Init =>
            Write_Indent_Str ("[N_SCIL_Dispatch_Table_Tag_Init]");

         when N_SCIL_Dispatching_Call =>
            Write_Indent_Str ("[N_SCIL_Dispatching_Node]");

         when N_SCIL_Membership_Test =>
            Write_Indent_Str ("[N_SCIL_Membership_Test]");

         when N_Simple_Return_Statement =>
            if Present (Expression (Node)) then
               Write_Indent_Str_Sloc ("return ");
               Sprint_Node (Expression (Node));
               Write_Char (';');
            else
               Write_Indent_Str_Sloc ("return;");
            end if;

         when N_Selective_Accept =>
            Write_Indent_Str_Sloc ("select");

            declare
               Alt_Node : Node_Id;
            begin
               Alt_Node := First (Select_Alternatives (Node));
               loop
                  Indent_Begin;
                  Sprint_Node (Alt_Node);
                  Indent_End;
                  Next (Alt_Node);
                  exit when No (Alt_Node);
                  Write_Indent_Str ("or");
               end loop;
            end;

            if Present (Else_Statements (Node)) then
               Write_Indent_Str ("else");
               Sprint_Indented_List (Else_Statements (Node));
            end if;

            Write_Indent_Str ("end select;");

         when N_Signed_Integer_Type_Definition =>
            Write_Str_With_Col_Check_Sloc ("range ");
            Sprint_Node (Low_Bound (Node));
            Write_Str (" .. ");
            Sprint_Node (High_Bound (Node));

         when N_Single_Protected_Declaration =>
            Write_Indent_Str_Sloc ("protected ");
            Write_Id (Defining_Identifier (Node));
            Write_Str (" is");
            Sprint_Node (Protected_Definition (Node));
            Write_Id (Defining_Identifier (Node));
            Write_Char (';');

         when N_Single_Task_Declaration =>
            Write_Indent_Str_Sloc ("task ");
            Sprint_Node (Defining_Identifier (Node));

            if Present (Task_Definition (Node)) then
               Write_Str (" is");
               Sprint_Node (Task_Definition (Node));
            end if;

            Write_Char (';');

         when N_Selected_Component =>
            Sprint_Node (Prefix (Node));
            Write_Char_Sloc ('.');
            Sprint_Node (Selector_Name (Node));

         when N_Slice =>
            Set_Debug_Sloc;
            Sprint_Node (Prefix (Node));
            Write_Str_With_Col_Check (" (");
            Sprint_Node (Discrete_Range (Node));
            Write_Char (')');

         when N_String_Literal =>
            if String_Length (Strval (Node)) + Column > Sprint_Line_Limit then
               Write_Indent_Str ("  ");
            end if;

            Set_Debug_Sloc;
            Write_String_Table_Entry (Strval (Node));

         when N_Subprogram_Body =>

            --  Output extra blank line unless we are in freeze actions

            if Freeze_Indent = 0 then
               Extra_Blank_Line;
            end if;

            Write_Indent;

            if Present (Corresponding_Spec (Node)) then
               Sprint_Node_Sloc (Parent (Corresponding_Spec (Node)));
            else
               Sprint_Node_Sloc (Specification (Node));
            end if;

            Write_Str (" is");

            Sprint_Indented_List (Declarations (Node));
            Write_Indent_Str ("begin");
            Sprint_Node (Handled_Statement_Sequence (Node));

            Write_Indent_Str ("end ");

            Sprint_End_Label
              (Handled_Statement_Sequence (Node),
                 Defining_Unit_Name (Specification (Node)));
            Write_Char (';');

            if Is_List_Member (Node)
              and then Present (Next (Node))
              and then Nkind (Next (Node)) /= N_Subprogram_Body
            then
               Write_Indent;
            end if;

         when N_Subprogram_Body_Stub =>
            Write_Indent;
            Sprint_Node_Sloc (Specification (Node));
            Write_Str_With_Col_Check (" is separate;");

         when N_Subprogram_Declaration =>
            Write_Indent;
            Sprint_Node_Sloc (Specification (Node));

            if Nkind (Specification (Node)) = N_Procedure_Specification
              and then Null_Present (Specification (Node))
            then
               Write_Str_With_Col_Check (" is null");
            end if;

            Write_Char (';');

         when N_Subprogram_Renaming_Declaration =>
            Write_Indent;
            Sprint_Node (Specification (Node));
            Write_Str_With_Col_Check_Sloc (" renames ");
            Sprint_Node (Name (Node));
            Write_Char (';');

         when N_Subtype_Declaration =>
            Write_Indent_Str_Sloc ("subtype ");
            Sprint_Node (Defining_Identifier (Node));
            Write_Str (" is ");

            --  Ada 2005 (AI-231)

            if Null_Exclusion_Present (Node) then
               Write_Str ("not null ");
            end if;

            Sprint_Node (Subtype_Indication (Node));
            Write_Char (';');

         when N_Subtype_Indication =>
            Sprint_Node_Sloc (Subtype_Mark (Node));
            Write_Char (' ');
            Sprint_Node (Constraint (Node));

         when N_Subunit =>
            Write_Indent_Str_Sloc ("separate (");
            Sprint_Node (Name (Node));
            Write_Char (')');
            Extra_Blank_Line;
            Sprint_Node (Proper_Body (Node));

         when N_Target_Name =>
            Write_Char ('@');

         when N_Task_Body =>
            Write_Indent_Str_Sloc ("task body ");
            Write_Id (Defining_Identifier (Node));
            Write_Str (" is");
            Sprint_Indented_List (Declarations (Node));
            Write_Indent_Str ("begin");
            Sprint_Node (Handled_Statement_Sequence (Node));
            Write_Indent_Str ("end ");
            Sprint_End_Label
              (Handled_Statement_Sequence (Node), Defining_Identifier (Node));
            Write_Char (';');

         when N_Task_Body_Stub =>
            Write_Indent_Str_Sloc ("task body ");
            Write_Id (Defining_Identifier (Node));
            Write_Str_With_Col_Check (" is separate;");

         when N_Task_Definition =>
            Set_Debug_Sloc;
            Sprint_Indented_List (Visible_Declarations (Node));

            if Present (Private_Declarations (Node)) then
               Write_Indent_Str ("private");
               Sprint_Indented_List (Private_Declarations (Node));
            end if;

            Write_Indent_Str ("end ");
            Sprint_End_Label (Node, Defining_Identifier (Parent (Node)));

         when N_Task_Type_Declaration =>
            Write_Indent_Str_Sloc ("task type ");
            Sprint_Node (Defining_Identifier (Node));
            Write_Discr_Specs (Node);

            if Present (Interface_List (Node)) then
               Write_Str (" is new ");
               Sprint_And_List (Interface_List (Node));
            end if;

            if Present (Task_Definition (Node)) then
               if No (Interface_List (Node)) then
                  Write_Str (" is");
               else
                  Write_Str (" with ");
               end if;

               Sprint_Node (Task_Definition (Node));
            end if;

            Write_Char (';');

         when N_Terminate_Alternative =>
            Sprint_Node_List (Pragmas_Before (Node));
            Write_Indent;

            if Present (Condition (Node)) then
               Write_Str_With_Col_Check ("when ");
               Sprint_Node (Condition (Node));
               Write_Str (" => ");
            end if;

            Write_Str_With_Col_Check_Sloc ("terminate;");
            Sprint_Node_List (Pragmas_After (Node));

         when N_Timed_Entry_Call =>
            Write_Indent_Str_Sloc ("select");
            Indent_Begin;
            Sprint_Node (Entry_Call_Alternative (Node));
            Indent_End;
            Write_Indent_Str ("or");
            Indent_Begin;
            Sprint_Node (Delay_Alternative (Node));
            Indent_End;
            Write_Indent_Str ("end select;");

         when N_Triggering_Alternative =>
            Sprint_Node_List (Pragmas_Before (Node));
            Sprint_Node_Sloc (Triggering_Statement (Node));
            Sprint_Node_List (Statements (Node));

         when N_Type_Conversion =>
            Set_Debug_Sloc;
            Sprint_Node (Subtype_Mark (Node));
            Col_Check (4);

            if Conversion_OK (Node) then
               Write_Char ('?');
            end if;

            if Float_Truncate (Node) then
               Write_Char ('^');
            end if;

            if Rounded_Result (Node) then
               Write_Char ('@');
            end if;

            Write_Char ('(');
            Sprint_Node (Expression (Node));
            Write_Char (')');

         when N_Unchecked_Expression =>
            Col_Check (10);
            Write_Str ("`(");
            Sprint_Node_Sloc (Expression (Node));
            Write_Char (')');

         when N_Unchecked_Type_Conversion =>
            Sprint_Node (Subtype_Mark (Node));
            Write_Char ('!');
            Write_Str_With_Col_Check ("(");
            Sprint_Node_Sloc (Expression (Node));
            Write_Char (')');

         when N_Unconstrained_Array_Definition =>
            Write_Str_With_Col_Check_Sloc ("array (");

            declare
               Node1 : Node_Id;
            begin
               Node1 := First (Subtype_Marks (Node));
               loop
                  Sprint_Node (Node1);
                  Write_Str_With_Col_Check (" range <>");
                  Next (Node1);
                  exit when Node1 = Empty;
                  Write_Str (", ");
               end loop;
            end;

            Write_Str (") of ");
            Sprint_Node (Component_Definition (Node));

         when N_Unused_At_Start | N_Unused_At_End =>
            Write_Indent_Str ("***** Error, unused node encountered *****");
            Write_Eol;

         when N_Use_Package_Clause =>
            Write_Indent_Str_Sloc ("use ");
            Sprint_Node_Sloc (Name (Node));
            Write_Char (';');

         when N_Use_Type_Clause =>
            Write_Indent_Str_Sloc ("use type ");
            Sprint_Node_Sloc (Subtype_Mark (Node));
            Write_Char (';');

         when N_Validate_Unchecked_Conversion =>
            Write_Indent_Str_Sloc ("validate unchecked_conversion (");
            Sprint_Node (Source_Type (Node));
            Write_Str (", ");
            Sprint_Node (Target_Type (Node));
            Write_Str (");");

         when N_Variable_Reference_Marker =>
            null;

            --  Enable the following code for debugging purposes only

            --  if Is_Read (Node) and then Is_Write (Node) then
            --     Write_Indent_Str ("rw#");

            --  elsif Is_Read (Node) then
            --     Write_Indent_Str ("r#");

            --  else
            --     pragma Assert (Is_Write (Node));
            --     Write_Indent_Str ("w#");
            --  end if;

            --  Write_Id (Target (Node));
            --  Write_Char ('#');

         when N_Variant =>
            Write_Indent_Str_Sloc ("when ");
            Sprint_Bar_List (Discrete_Choices (Node));
            Write_Str (" => ");
            Sprint_Node (Component_List (Node));

         when N_Variant_Part =>
            Indent_Begin;
            Write_Indent_Str_Sloc ("case ");
            Sprint_Node (Name (Node));
            Write_Str (" is ");
            Sprint_Indented_List (Variants (Node));
            Write_Indent_Str ("end case");
            Indent_End;

         when N_With_Clause =>

            --  Special test, if we are dumping the original tree only,
            --  then we want to eliminate the bogus with clauses that
            --  correspond to the non-existent children of Text_IO.

            if Dump_Original_Only
              and then Is_Text_IO_Special_Unit (Name (Node))
            then
               null;

            --  Normal case, output the with clause

            else
               if First_Name (Node) or else not Dump_Original_Only then

                  --  Ada 2005 (AI-50217): Print limited with_clauses

                  if Private_Present (Node) and Limited_Present (Node) then
                     Write_Indent_Str ("limited private with ");

                  elsif Private_Present (Node) then
                     Write_Indent_Str ("private with ");

                  elsif Limited_Present (Node) then
                     Write_Indent_Str ("limited with ");

                  else
                     Write_Indent_Str ("with ");
                  end if;

               else
                  Write_Str (", ");
               end if;

               Sprint_Node_Sloc (Name (Node));

               if Last_Name (Node) or else not Dump_Original_Only then
                  Write_Char (';');
               end if;
            end if;
      end case;

      --  Print aspects, except for special case of package declaration,
      --  where the aspects are printed inside the package specification.

      if Has_Aspects (Node)
        and then not Nkind_In (Node, N_Generic_Package_Declaration,
                                     N_Package_Declaration)
        and then not Is_Empty_List (Aspect_Specifications (Node))
      then
         Sprint_Aspect_Specifications (Node, Semicolon => True);
      end if;

      if Nkind (Node) in N_Subexpr and then Do_Range_Check (Node) then
         Write_Str ("}");
      end if;

      for J in 1 .. Paren_Count (Node) loop
         Write_Char (')');
      end loop;

      Dump_Node := Save_Dump_Node;
   end Sprint_Node_Actual;

   ----------------------
   -- Sprint_Node_List --
   ----------------------

   procedure Sprint_Node_List (List : List_Id; New_Lines : Boolean := False) is
      Node : Node_Id;

   begin
      if Is_Non_Empty_List (List) then
         Node := First (List);

         loop
            Sprint_Node (Node);
            Next (Node);
            exit when Node = Empty;
         end loop;
      end if;

      if New_Lines and then Column /= 1 then
         Write_Eol;
      end if;
   end Sprint_Node_List;

   ----------------------
   -- Sprint_Node_Sloc --
   ----------------------

   procedure Sprint_Node_Sloc (Node : Node_Id) is
   begin
      Sprint_Node (Node);

      if Debug_Generated_Code and then Present (Dump_Node) then
         Set_Sloc (Dump_Node, Sloc (Node));
         Dump_Node := Empty;
      end if;
   end Sprint_Node_Sloc;

   ---------------------
   -- Sprint_Opt_Node --
   ---------------------

   procedure Sprint_Opt_Node (Node : Node_Id) is
   begin
      if Present (Node) then
         Write_Char (' ');
         Sprint_Node (Node);
      end if;
   end Sprint_Opt_Node;

   --------------------------
   -- Sprint_Opt_Node_List --
   --------------------------

   procedure Sprint_Opt_Node_List (List : List_Id) is
   begin
      if Present (List) then
         Sprint_Node_List (List);
      end if;
   end Sprint_Opt_Node_List;

   ---------------------------------
   -- Sprint_Opt_Paren_Comma_List --
   ---------------------------------

   procedure Sprint_Opt_Paren_Comma_List (List : List_Id) is
   begin
      if Is_Non_Empty_List (List) then
         Write_Char (' ');
         Sprint_Paren_Comma_List (List);
      end if;
   end Sprint_Opt_Paren_Comma_List;

   -----------------------------
   -- Sprint_Paren_Comma_List --
   -----------------------------

   procedure Sprint_Paren_Comma_List (List : List_Id) is
      N           : Node_Id;
      Node_Exists : Boolean := False;

   begin

      if Is_Non_Empty_List (List) then

         if Dump_Original_Only then
            N := First (List);
            while Present (N) loop
               if not Is_Rewrite_Insertion (N) then
                  Node_Exists := True;
                  exit;
               end if;

               Next (N);
            end loop;

            if not Node_Exists then
               return;
            end if;
         end if;

         Write_Str_With_Col_Check ("(");
         Sprint_Comma_List (List);
         Write_Char (')');
      end if;
   end Sprint_Paren_Comma_List;

   ----------------------
   -- Sprint_Right_Opnd --
   ----------------------

   procedure Sprint_Right_Opnd (N : Node_Id) is
      Opnd : constant Node_Id := Right_Opnd (N);

   begin
      if Paren_Count (Opnd) /= 0
        or else Op_Prec (Nkind (Opnd)) > Op_Prec (Nkind (N))
      then
         Sprint_Node (Opnd);

      else
         Write_Char ('(');
         Sprint_Node (Opnd);
         Write_Char (')');
      end if;
   end Sprint_Right_Opnd;

   ------------------
   -- Update_Itype --
   ------------------

   procedure Update_Itype (Node : Node_Id) is
   begin
      if Present (Etype (Node))
        and then Is_Itype (Etype (Node))
        and then Debug_Generated_Code
      then
         Set_Sloc (Etype (Node), Sloc (Node));
      end if;
   end Update_Itype;

   ---------------------
   -- Write_Char_Sloc --
   ---------------------

   procedure Write_Char_Sloc (C : Character) is
   begin
      if Debug_Generated_Code and then C /= ' ' then
         Set_Debug_Sloc;
      end if;

      Write_Char (C);
   end Write_Char_Sloc;

   --------------------------------
   -- Write_Condition_And_Reason --
   --------------------------------

   procedure Write_Condition_And_Reason (Node : Node_Id) is
      Cond  : constant Node_Id := Condition (Node);
      Image : constant String  := RT_Exception_Code'Image
                                    (RT_Exception_Code'Val
                                       (UI_To_Int (Reason (Node))));

   begin
      if Present (Cond) then

         --  If condition is a single entity, or NOT with a single entity,
         --  output all on one line, since it will likely fit just fine.

         if Is_Entity_Name (Cond)
           or else (Nkind (Cond) = N_Op_Not
                     and then Is_Entity_Name (Right_Opnd (Cond)))
         then
            Write_Str_With_Col_Check (" when ");
            Sprint_Node (Cond);
            Write_Char (' ');

            --  Otherwise for more complex condition, multiple lines

         else
            Write_Str_With_Col_Check (" when");
            Indent := Indent + 2;
            Write_Indent;
            Sprint_Node (Cond);
            Write_Indent;
            Indent := Indent - 2;
         end if;

      --  If no condition, just need a space (all on one line)

      else
         Write_Char (' ');
      end if;

      --  Write the reason

      Write_Char ('"');

      for J in 4 .. Image'Last loop
         if Image (J) = '_' then
            Write_Char (' ');
         else
            Write_Char (Fold_Lower (Image (J)));
         end if;
      end loop;

      Write_Str ("""]");
   end Write_Condition_And_Reason;

   --------------------------------
   -- Write_Corresponding_Source --
   --------------------------------

   procedure Write_Corresponding_Source (S : String) is
      Loc : Source_Ptr;
      Src : Source_Buffer_Ptr;

   begin
      --  Ignore if there is no current source file, or we're not in dump
      --  source text mode, or if in freeze actions.

      if Current_Source_File > No_Source_File
        and then Dump_Source_Text
        and then Freeze_Indent = 0
      then

         --  Ignore null string

         if S = "" then
            return;
         end if;

         --  Ignore space or semicolon at end of given string

         if S (S'Last) = ' ' or else S (S'Last) = ';' then
            Write_Corresponding_Source (S (S'First .. S'Last - 1));
            return;
         end if;

         --  Loop to look at next lines not yet printed in source file

         for L in
           Last_Line_Printed + 1 .. Last_Source_Line (Current_Source_File)
         loop
            Src := Source_Text (Current_Source_File);
            Loc := Line_Start (L, Current_Source_File);

            --  If comment, keep looking

            if Src (Loc .. Loc + 1) = "--" then
               null;

            --  Search to first non-blank

            else
               while Src (Loc) not in Line_Terminator loop

                  --  Non-blank found

                  if Src (Loc) /= ' ' and then Src (Loc) /= ASCII.HT then

                     --  Loop through characters in string to see if we match

                     for J in S'Range loop

                        --  If mismatch, then not the case we are looking for

                        if Src (Loc) /= S (J) then
                           return;
                        end if;

                        Loc := Loc + 1;
                     end loop;

                     --  If we fall through, string matched, if white space or
                     --  semicolon after the matched string, this is the case
                     --  we are looking for.

                     if Src (Loc) in Line_Terminator
                       or else Src (Loc) = ' '
                       or else Src (Loc) = ASCII.HT
                       or else Src (Loc) = ';'
                     then
                        --  So output source lines up to and including this one

                        Write_Source_Lines (L);
                        return;
                     end if;
                  end if;

                  Loc := Loc + 1;
               end loop;
            end if;

         --  Line was all blanks, or a comment line, keep looking

         end loop;
      end if;
   end Write_Corresponding_Source;

   -----------------------
   -- Write_Discr_Specs --
   -----------------------

   procedure Write_Discr_Specs (N : Node_Id) is
      Specs : List_Id;
      Spec  : Node_Id;

   begin
      Specs := Discriminant_Specifications (N);

      if Present (Specs) then
         Write_Str_With_Col_Check (" (");
         Spec := First (Specs);

         loop
            Sprint_Node (Spec);
            Next (Spec);
            exit when Spec = Empty;

            --  Add semicolon, unless we are printing original tree and the
            --  next specification is part of a list (but not the first
            --  element of that list)

            if not Dump_Original_Only or else not Prev_Ids (Spec) then
               Write_Str ("; ");
            end if;
         end loop;

         Write_Char (')');
      end if;
   end Write_Discr_Specs;

   -----------------
   -- Write_Ekind --
   -----------------

   procedure Write_Ekind (E : Entity_Id) is
      S : constant String := Entity_Kind'Image (Ekind (E));

   begin
      Name_Len := S'Length;
      Name_Buffer (1 .. Name_Len) := S;
      Set_Casing (Mixed_Case);
      Write_Str_With_Col_Check (Name_Buffer (1 .. Name_Len));
   end Write_Ekind;

   --------------
   -- Write_Id --
   --------------

   procedure Write_Id (N : Node_Id) is
   begin
      --  Deal with outputting Itype

      --  Note: if we are printing the full tree with -gnatds, then we may
      --  end up picking up the Associated_Node link from a generic template
      --  here which overlaps the Entity field, but as documented, Write_Itype
      --  is defended against junk calls.

      if Nkind (N) in N_Entity then
         Write_Itype (N);
      elsif Nkind (N) in N_Has_Entity then
         Write_Itype (Entity (N));
      end if;

      --  Case of a defining identifier

      if Nkind (N) = N_Defining_Identifier then

         --  If defining identifier has an interface name (and no
         --  address clause), then we output the interface name.

         if (Is_Imported (N) or else Is_Exported (N))
           and then Present (Interface_Name (N))
           and then No (Address_Clause (N))
         then
            String_To_Name_Buffer (Strval (Interface_Name (N)));
            Write_Str_With_Col_Check (Name_Buffer (1 .. Name_Len));

         --  If no interface name (or inactive because there was
         --  an address clause), then just output the Chars name.

         else
            Write_Name_With_Col_Check (Chars (N));
         end if;

      --  Case of selector of an expanded name where the expanded name
      --  has an associated entity, output this entity. Check that the
      --  entity or associated node is of the right kind, see above.

      elsif Nkind (Parent (N)) = N_Expanded_Name
        and then Selector_Name (Parent (N)) = N
        and then Present (Entity_Or_Associated_Node (Parent (N)))
        and then Nkind (Entity (Parent (N))) in N_Entity
      then
         Write_Id (Entity (Parent (N)));

      --  For any other node with an associated entity, output it

      elsif Nkind (N) in N_Has_Entity
        and then Present (Entity_Or_Associated_Node (N))
        and then Nkind (Entity_Or_Associated_Node (N)) in N_Entity
      then
         Write_Id (Entity (N));

      --  All other cases, we just print the Chars field

      else
         Write_Name_With_Col_Check (Chars (N));
      end if;
   end Write_Id;

   -----------------------
   -- Write_Identifiers --
   -----------------------

   function Write_Identifiers (Node : Node_Id) return Boolean is
   begin
      Sprint_Node (Defining_Identifier (Node));
      Update_Itype (Defining_Identifier (Node));

      --  The remainder of the declaration must be printed unless we are
      --  printing the original tree and this is not the last identifier

      return
         not Dump_Original_Only or else not More_Ids (Node);

   end Write_Identifiers;

   ------------------------
   -- Write_Implicit_Def --
   ------------------------

   procedure Write_Implicit_Def (E : Entity_Id) is
      Ind : Node_Id;

   begin
      case Ekind (E) is
         when E_Array_Subtype =>
            Write_Str_With_Col_Check ("subtype ");
            Write_Id (E);
            Write_Str_With_Col_Check (" is ");
            Write_Id (Base_Type (E));
            Write_Str_With_Col_Check (" (");

            Ind := First_Index (E);
            while Present (Ind) loop
               Sprint_Node (Ind);
               Next_Index (Ind);

               if Present (Ind) then
                  Write_Str (", ");
               end if;
            end loop;

            Write_Str (");");

         when E_Enumeration_Subtype
            | E_Signed_Integer_Subtype
         =>
            Write_Str_With_Col_Check ("subtype ");
            Write_Id (E);
            Write_Str (" is ");
            Write_Id (Etype (E));
            Write_Str_With_Col_Check (" range ");
            Sprint_Node (Scalar_Range (E));
            Write_Str (";");

         when others =>
            Write_Str_With_Col_Check ("type ");
            Write_Id (E);
            Write_Str_With_Col_Check (" is <");
            Write_Ekind (E);
            Write_Str (">;");
      end case;
   end Write_Implicit_Def;

   ------------------
   -- Write_Indent --
   ------------------

   procedure Write_Indent is
      Loc : constant Source_Ptr := Sloc (Dump_Node);

   begin
      if Indent_Annull_Flag then
         Indent_Annull_Flag := False;
      else
         --  Deal with Dump_Source_Text output. Note that we ignore implicit
         --  label declarations, since they typically have the sloc of the
         --  corresponding label, which really messes up the -gnatL output.

         if Dump_Source_Text
           and then Loc > No_Location
           and then Nkind (Dump_Node) /= N_Implicit_Label_Declaration
         then
            if Get_Source_File_Index (Loc) = Current_Source_File then
               Write_Source_Lines
                 (Get_Physical_Line_Number (Sloc (Dump_Node)));
            end if;
         end if;

         Write_Eol;

         for J in 1 .. Indent loop
            Write_Char (' ');
         end loop;
      end if;
   end Write_Indent;

   ------------------------------
   -- Write_Indent_Identifiers --
   ------------------------------

   function Write_Indent_Identifiers (Node : Node_Id) return Boolean is
   begin
      --  We need to start a new line for every node, except in the case
      --  where we are printing the original tree and this is not the first
      --  defining identifier in the list.

      if not Dump_Original_Only or else not Prev_Ids (Node) then
         Write_Indent;

      --  If printing original tree and this is not the first defining
      --  identifier in the list, then the previous call to this procedure
      --  printed only the name, and we add a comma to separate the names.

      else
         Write_Str (", ");
      end if;

      Sprint_Node (Defining_Identifier (Node));

      --  The remainder of the declaration must be printed unless we are
      --  printing the original tree and this is not the last identifier

      return
         not Dump_Original_Only or else not More_Ids (Node);
   end Write_Indent_Identifiers;

   -----------------------------------
   -- Write_Indent_Identifiers_Sloc --
   -----------------------------------

   function Write_Indent_Identifiers_Sloc (Node : Node_Id) return Boolean is
   begin
      --  We need to start a new line for every node, except in the case
      --  where we are printing the original tree and this is not the first
      --  defining identifier in the list.

      if not Dump_Original_Only or else not Prev_Ids (Node) then
         Write_Indent;

      --  If printing original tree and this is not the first defining
      --  identifier in the list, then the previous call to this procedure
      --  printed only the name, and we add a comma to separate the names.

      else
         Write_Str (", ");
      end if;

      Set_Debug_Sloc;
      Sprint_Node (Defining_Identifier (Node));

      --  The remainder of the declaration must be printed unless we are
      --  printing the original tree and this is not the last identifier

      return not Dump_Original_Only or else not More_Ids (Node);
   end Write_Indent_Identifiers_Sloc;

   ----------------------
   -- Write_Indent_Str --
   ----------------------

   procedure Write_Indent_Str (S : String) is
   begin
      Write_Corresponding_Source (S);
      Write_Indent;
      Write_Str (S);
   end Write_Indent_Str;

   ---------------------------
   -- Write_Indent_Str_Sloc --
   ---------------------------

   procedure Write_Indent_Str_Sloc (S : String) is
   begin
      Write_Corresponding_Source (S);
      Write_Indent;
      Write_Str_Sloc (S);
   end Write_Indent_Str_Sloc;

   -----------------
   -- Write_Itype --
   -----------------

   procedure Write_Itype (Typ : Entity_Id) is

      procedure Write_Header (T : Boolean := True);
      --  Write type if T is True, subtype if T is false

      ------------------
      -- Write_Header --
      ------------------

      procedure Write_Header (T : Boolean := True) is
      begin
         if T then
            Write_Str ("[type ");
         else
            Write_Str ("[subtype ");
         end if;

         Write_Name_With_Col_Check (Chars (Typ));
         Write_Str (" is ");
      end Write_Header;

   --  Start of processing for Write_Itype

   begin
      if Nkind (Typ) in N_Entity
        and then Is_Itype (Typ)
        and then not Itype_Printed (Typ)
      then
         --  Itype to be printed

         declare
            B : constant Node_Id := Etype (Typ);
            X : Node_Id;
            P : constant Node_Id := Parent (Typ);

            S : constant Saved_Output_Buffer := Save_Output_Buffer;
            --  Save current output buffer

            Old_Sloc : Source_Ptr;
            --  Save sloc of related node, so it is not modified when
            --  printing with -gnatD.

         begin
            --  Write indentation at start of line

            for J in 1 .. Indent loop
               Write_Char (' ');
            end loop;

            --  If we have a constructed declaration for the itype, print it

            if Present (P)
              and then Nkind (P) in N_Declaration
              and then Defining_Entity (P) = Typ
            then
               --  We must set Itype_Printed true before the recursive call to
               --  print the node, otherwise we get an infinite recursion.

               Set_Itype_Printed (Typ, True);

               --  Write the declaration enclosed in [], avoiding new line
               --  at start of declaration, and semicolon at end.

               --  Note: The itype may be imported from another unit, in which
               --  case we do not want to modify the Sloc of the declaration.
               --  Otherwise the itype may appear to be in the current unit,
               --  and the back-end will reject a reference out of scope.

               Write_Char ('[');
               Indent_Annull_Flag := True;
               Old_Sloc := Sloc (P);
               Sprint_Node (P);
               Set_Sloc (P, Old_Sloc);
               Write_Erase_Char (';');

            --  If no constructed declaration, then we have to concoct the
            --  source corresponding to the type entity that we have at hand.

            else
               case Ekind (Typ) is

                  --  Access types and subtypes

                  when Access_Kind =>
                     Write_Header (Ekind (Typ) = E_Access_Type);

                     if Can_Never_Be_Null (Typ) then
                        Write_Str ("not null ");
                     end if;

                     Write_Str ("access ");

                     if Is_Access_Constant (Typ) then
                        Write_Str ("constant ");
                     end if;

                     Write_Id (Directly_Designated_Type (Typ));

                  --  Array types

                  when E_Array_Type =>
                     Write_Header;
                     Write_Str ("array (");

                     X := First_Index (Typ);
                     loop
                        Sprint_Node (X);

                        if not Is_Constrained (Typ) then
                           Write_Str (" range <>");
                        end if;

                        Next_Index (X);
                        exit when No (X);
                        Write_Str (", ");
                     end loop;

                     Write_Str (") of ");
                     X := Component_Type (Typ);

                     --  Preserve sloc of component type, which is defined
                     --  elsewhere than the itype (see comment above).

                     Old_Sloc := Sloc (X);
                     Sprint_Node (X);
                     Set_Sloc (X, Old_Sloc);

                     --  Array subtypes

                     --  Preserve Sloc of index subtypes, as above

                  when E_Array_Subtype =>
                     Write_Header (False);
                     Write_Id (Etype (Typ));
                     Write_Str (" (");

                     X := First_Index (Typ);
                     loop
                        Old_Sloc := Sloc (X);
                        Sprint_Node (X);
                        Set_Sloc (X, Old_Sloc);
                        Next_Index (X);
                        exit when No (X);
                        Write_Str (", ");
                     end loop;

                     Write_Char (')');

                  --  Signed integer types, and modular integer subtypes,
                  --  and also enumeration subtypes.

                  when E_Enumeration_Subtype
                     | E_Modular_Integer_Subtype
                     | E_Signed_Integer_Subtype
                     | E_Signed_Integer_Type
                  =>
                     Write_Header (Ekind (Typ) = E_Signed_Integer_Type);

                     if Ekind (Typ) = E_Signed_Integer_Type then
                        Write_Str ("new ");
                     end if;

                     Write_Id (B);

                     --  Print bounds if different from base type

                     declare
                        L  : constant Node_Id := Type_Low_Bound (Typ);
                        H  : constant Node_Id := Type_High_Bound (Typ);
                        LE : Node_Id;
                        HE : Node_Id;

                     begin
                        --  B can either be a scalar type, in which case the
                        --  declaration of Typ may constrain it with different
                        --  bounds, or a private type, in which case we know
                        --  that the declaration of Typ cannot have a scalar
                        --  constraint.

                        if Is_Scalar_Type (B) then
                           LE := Type_Low_Bound (B);
                           HE := Type_High_Bound (B);
                        else
                           LE := Empty;
                           HE := Empty;
                        end if;

                        if No (LE)
                          or else (True
                            and then Nkind (L) = N_Integer_Literal
                            and then Nkind (H) = N_Integer_Literal
                            and then Nkind (LE) = N_Integer_Literal
                            and then Nkind (HE) = N_Integer_Literal
                            and then UI_Eq (Intval (L), Intval (LE))
                            and then UI_Eq (Intval (H), Intval (HE)))
                        then
                           null;

                        else
                           Write_Str (" range ");
                           Sprint_Node (Type_Low_Bound (Typ));
                           Write_Str (" .. ");
                           Sprint_Node (Type_High_Bound (Typ));
                        end if;
                     end;

                  --  Modular integer types

                  when E_Modular_Integer_Type =>
                     Write_Header;
                     Write_Str ("mod ");
                     Write_Uint_With_Col_Check (Modulus (Typ), Auto);

                  --  Floating point types and subtypes

                  when E_Floating_Point_Subtype
                     | E_Floating_Point_Type
                  =>
                     Write_Header (Ekind (Typ) = E_Floating_Point_Type);

                     if Ekind (Typ) = E_Floating_Point_Type then
                        Write_Str ("new ");
                     end if;

                     Write_Id (Etype (Typ));

                     if Digits_Value (Typ) /= Digits_Value (Etype (Typ)) then
                        Write_Str (" digits ");
                        Write_Uint_With_Col_Check
                          (Digits_Value (Typ), Decimal);
                     end if;

                     --  Print bounds if not different from base type

                     declare
                        L  : constant Node_Id := Type_Low_Bound (Typ);
                        H  : constant Node_Id := Type_High_Bound (Typ);
                        LE : constant Node_Id := Type_Low_Bound (B);
                        HE : constant Node_Id := Type_High_Bound (B);

                     begin
                        if Nkind (L) = N_Real_Literal
                          and then Nkind (H) = N_Real_Literal
                          and then Nkind (LE) = N_Real_Literal
                          and then Nkind (HE) = N_Real_Literal
                          and then UR_Eq (Realval (L), Realval (LE))
                          and then UR_Eq (Realval (H), Realval (HE))
                        then
                           null;

                        else
                           Write_Str (" range ");
                           Sprint_Node (Type_Low_Bound (Typ));
                           Write_Str (" .. ");
                           Sprint_Node (Type_High_Bound (Typ));
                        end if;
                     end;

                  --  Record subtypes

                  when E_Record_Subtype
                     | E_Record_Subtype_With_Private
                  =>
                     Write_Header (False);
                     Write_Str ("record");
                     Indent_Begin;

                     declare
                        C : Entity_Id;
                     begin
                        C := First_Entity (Typ);
                        while Present (C) loop
                           Write_Indent;
                           Write_Id (C);
                           Write_Str (" : ");
                           Write_Id (Etype (C));
                           Next_Entity (C);
                        end loop;
                     end;

                     Indent_End;
                     Write_Indent_Str (" end record");

                  --  Class-Wide types

                  when E_Class_Wide_Subtype
                     | E_Class_Wide_Type
                  =>
                     Write_Header (Ekind (Typ) = E_Class_Wide_Type);
                     Write_Name_With_Col_Check (Chars (Etype (Typ)));
                     Write_Str ("'Class");

                  --  Subprogram types

                  when E_Subprogram_Type =>
                     Write_Header;

                     if Etype (Typ) = Standard_Void_Type then
                        Write_Str ("procedure");
                     else
                        Write_Str ("function");
                     end if;

                     if Present (First_Entity (Typ)) then
                        Write_Str (" (");

                        declare
                           Param : Entity_Id;

                        begin
                           Param := First_Entity (Typ);
                           loop
                              Write_Id (Param);
                              Write_Str (" : ");

                              if Ekind (Param) = E_In_Out_Parameter then
                                 Write_Str ("in out ");
                              elsif Ekind (Param) = E_Out_Parameter then
                                 Write_Str ("out ");
                              end if;

                              Write_Id (Etype (Param));
                              Next_Entity (Param);
                              exit when No (Param);
                              Write_Str (", ");
                           end loop;

                           Write_Char (')');
                        end;
                     end if;

                     if Etype (Typ) /= Standard_Void_Type then
                        Write_Str (" return ");
                        Write_Id (Etype (Typ));
                     end if;

                  when E_String_Literal_Subtype =>
                     declare
                        LB  : constant Uint :=
                                Expr_Value (String_Literal_Low_Bound (Typ));
                        Len : constant Uint :=
                                String_Literal_Length (Typ);
                     begin
                        Write_Header (False);
                        Write_Str ("String (");
                        Write_Int (UI_To_Int (LB));
                        Write_Str (" .. ");
                        Write_Int (UI_To_Int (LB + Len) - 1);
                        Write_Str (");");
                     end;

                  --  For all other Itypes, print ??? (fill in later)

                  when others =>
                     Write_Header (True);
                     Write_Str ("???");
               end case;
            end if;

            --  Add terminating bracket and restore output buffer

            Write_Char (']');
            Write_Eol;
            Restore_Output_Buffer (S);
         end;

         Set_Itype_Printed (Typ);
      end if;
   end Write_Itype;

   -------------------------------
   -- Write_Name_With_Col_Check --
   -------------------------------

   procedure Write_Name_With_Col_Check (N : Name_Id) is
      J : Natural;
      K : Natural;
      L : Natural;

   begin
      --  Avoid crashing on invalid Name_Ids

      if not Is_Valid_Name (N) then
         Write_Str ("<invalid name ");
         Write_Int (Int (N));
         Write_Str (">");
         return;
      end if;

      Get_Name_String (N);

      --  Deal with -gnatdI which replaces any sequence Cnnnb where C is an
      --  upper case letter, nnn is one or more digits and b is a lower case
      --  letter by C...b, so that listings do not depend on serial numbers.

      if Debug_Flag_II then
         J := 1;
         while J < Name_Len - 1 loop
            if Name_Buffer (J) in 'A' .. 'Z'
              and then Name_Buffer (J + 1) in '0' .. '9'
            then
               K := J + 1;
               while K < Name_Len loop
                  exit when Name_Buffer (K) not in '0' .. '9';
                  K := K + 1;
               end loop;

               if Name_Buffer (K) in 'a' .. 'z' then
                  L := Name_Len - K + 1;

                  Name_Buffer (J + 4 .. J + L + 3) :=
                    Name_Buffer (K .. Name_Len);
                  Name_Buffer (J + 1 .. J + 3) := "...";
                  Name_Len := J + L + 3;
                  J := J + 5;

               else
                  J := K;
               end if;

            else
               J := J + 1;
            end if;
         end loop;
      end if;

      --  Fall through for normal case

      Write_Str_With_Col_Check (Name_Buffer (1 .. Name_Len));
   end Write_Name_With_Col_Check;

   ------------------------------------
   -- Write_Name_With_Col_Check_Sloc --
   ------------------------------------

   procedure Write_Name_With_Col_Check_Sloc (N : Name_Id) is
   begin
      --  Avoid crashing on invalid Name_Ids

      if not Is_Valid_Name (N) then
         Write_Str ("<invalid name ");
         Write_Int (Int (N));
         Write_Str (">");
         return;
      end if;

      Get_Name_String (N);
      Write_Str_With_Col_Check_Sloc (Name_Buffer (1 .. Name_Len));
   end Write_Name_With_Col_Check_Sloc;

   --------------------
   -- Write_Operator --
   --------------------

   procedure Write_Operator (N : Node_Id; S : String) is
      F : Natural := S'First;
      T : Natural := S'Last;

   begin
      --  If no overflow check, just write string out, and we are done

      if not Do_Overflow_Check (N) then
         Write_Str_Sloc (S);

      --  If overflow check, we want to surround the operator with curly
      --  brackets, but not include spaces within the brackets.

      else
         if S (F) = ' ' then
            Write_Char (' ');
            F := F + 1;
         end if;

         if S (T) = ' ' then
            T := T - 1;
         end if;

         Write_Char ('{');
         Write_Str_Sloc (S (F .. T));
         Write_Char ('}');

         if S (S'Last) = ' ' then
            Write_Char (' ');
         end if;
      end if;
   end Write_Operator;

   -----------------------
   -- Write_Param_Specs --
   -----------------------

   procedure Write_Param_Specs (N : Node_Id) is
      Specs         : constant List_Id := Parameter_Specifications (N);
      Specs_Present : constant Boolean := Is_Non_Empty_List (Specs);

      Ent    : Entity_Id;
      Extras : Node_Id;
      Spec   : Node_Id;
      Formal : Node_Id;

      Output : Boolean := False;
      --  Set true if we output at least one parameter

   begin
      --  Write out explicit specs from Parameter_Speficiations list

      if Specs_Present then
         Write_Str_With_Col_Check (" (");
         Output := True;

         Spec := First (Specs);
         loop
            Sprint_Node (Spec);
            Formal := Defining_Identifier (Spec);
            Next (Spec);
            exit when Spec = Empty;

            --  Add semicolon, unless we are printing original tree and the
            --  next specification is part of a list (but not the first element
            --  of that list).

            if not Dump_Original_Only or else not Prev_Ids (Spec) then
               Write_Str ("; ");
            end if;
         end loop;
      end if;

      --  See if we have extra formals

      if Nkind_In (N, N_Function_Specification,
                      N_Procedure_Specification)
      then
         Ent := Defining_Entity (N);

         --  Loop to write extra formals (if any)

         if Present (Ent) and then Is_Subprogram (Ent) then
            Extras := Extra_Formals (Ent);

            if Present (Extras) then
               if not Specs_Present then
                  Write_Str_With_Col_Check (" (");
                  Output := True;
               end if;

               Formal := Extras;
               while Present (Formal) loop
                  if Specs_Present or else Formal /= Extras then
                     Write_Str ("; ");
                  end if;

                  Write_Name_With_Col_Check (Chars (Formal));
                  Write_Str (" : ");
                  Write_Name_With_Col_Check (Chars (Etype (Formal)));
                  Formal := Extra_Formal (Formal);
               end loop;
            end if;
         end if;
      end if;

      if Output then
         Write_Char (')');
      end if;
   end Write_Param_Specs;

   -----------------------
   -- Write_Rewrite_Str --
   -----------------------

   procedure Write_Rewrite_Str (S : String) is
   begin
      if not Dump_Generated_Only then
         if S'Length = 3 and then S = ">>>" then
            Write_Str (">>>");
         else
            Write_Str_With_Col_Check (S);
         end if;
      end if;
   end Write_Rewrite_Str;

   -----------------------
   -- Write_Source_Line --
   -----------------------

   procedure Write_Source_Line (L : Physical_Line_Number) is
      Loc : Source_Ptr;
      Src : Source_Buffer_Ptr;
      Scn : Source_Ptr;

   begin
      if Dump_Source_Text then
         Src := Source_Text (Current_Source_File);
         Loc := Line_Start (L, Current_Source_File);
         Write_Eol;

         --  See if line is a comment line, if not, and if not line one,
         --  precede with blank line.

         Scn := Loc;
         while Src (Scn) = ' ' or else Src (Scn) = ASCII.HT loop
            Scn := Scn + 1;
         end loop;

         if (Src (Scn) in Line_Terminator
              or else Src (Scn .. Scn + 1) /= "--")
           and then L /= 1
         then
            Write_Eol;
         end if;

         --  Now write the source text of the line

         Write_Str ("-- ");
         Write_Int (Int (L));
         Write_Str (": ");

         while Src (Loc) not in Line_Terminator loop
            Write_Char (Src (Loc));
            Loc := Loc + 1;
         end loop;
      end if;
   end Write_Source_Line;

   ------------------------
   -- Write_Source_Lines --
   ------------------------

   procedure Write_Source_Lines (L : Physical_Line_Number) is
   begin
      while Last_Line_Printed < L loop
         Last_Line_Printed := Last_Line_Printed + 1;
         Write_Source_Line (Last_Line_Printed);
      end loop;
   end Write_Source_Lines;

   --------------------
   -- Write_Str_Sloc --
   --------------------

   procedure Write_Str_Sloc (S : String) is
   begin
      for J in S'Range loop
         Write_Char_Sloc (S (J));
      end loop;
   end Write_Str_Sloc;

   ------------------------------
   -- Write_Str_With_Col_Check --
   ------------------------------

   procedure Write_Str_With_Col_Check (S : String) is
   begin
      if Int (S'Last) + Column > Sprint_Line_Limit then
         Write_Indent_Str ("  ");

         if S (S'First) = ' ' then
            Write_Str (S (S'First + 1 .. S'Last));
         else
            Write_Str (S);
         end if;

      else
         Write_Str (S);
      end if;
   end Write_Str_With_Col_Check;

   -----------------------------------
   -- Write_Str_With_Col_Check_Sloc --
   -----------------------------------

   procedure Write_Str_With_Col_Check_Sloc (S : String) is
   begin
      if Int (S'Last) + Column > Sprint_Line_Limit then
         Write_Indent_Str ("  ");

         if S (S'First) = ' ' then
            Write_Str_Sloc (S (S'First + 1 .. S'Last));
         else
            Write_Str_Sloc (S);
         end if;

      else
         Write_Str_Sloc (S);
      end if;
   end Write_Str_With_Col_Check_Sloc;

   ---------------------------
   -- Write_Subprogram_Name --
   ---------------------------

   procedure Write_Subprogram_Name (N : Node_Id) is
   begin
      if not Comes_From_Source (N)
        and then Is_Entity_Name (N)
      then
         declare
            Ent : constant Entity_Id := Entity (N);
         begin
            if not In_Extended_Main_Source_Unit (Ent)
              and then In_Predefined_Unit (Ent)
            then
               --  Run-time routine name, output name with a preceding dollar
               --  making sure that we do not get a line split between them.

               Col_Check (Length_Of_Name (Chars (Ent)) + 1);
               Write_Char ('$');
               Write_Name (Chars (Ent));
               return;
            end if;
         end;
      end if;

      --  Normal case, not a run-time routine name

      Sprint_Node (N);
   end Write_Subprogram_Name;

   -------------------------------
   -- Write_Uint_With_Col_Check --
   -------------------------------

   procedure Write_Uint_With_Col_Check (U : Uint; Format : UI_Format) is
   begin
      Col_Check (UI_Decimal_Digits_Hi (U));
      UI_Write (U, Format);
   end Write_Uint_With_Col_Check;

   ------------------------------------
   -- Write_Uint_With_Col_Check_Sloc --
   ------------------------------------

   procedure Write_Uint_With_Col_Check_Sloc (U : Uint; Format : UI_Format) is
   begin
      Col_Check (UI_Decimal_Digits_Hi (U));
      Set_Debug_Sloc;
      UI_Write (U, Format);
   end Write_Uint_With_Col_Check_Sloc;

   -------------------------------------
   -- Write_Ureal_With_Col_Check_Sloc --
   -------------------------------------

   procedure Write_Ureal_With_Col_Check_Sloc (U : Ureal) is
      D : constant Uint := Denominator (U);
      N : constant Uint := Numerator (U);
   begin
      Col_Check (UI_Decimal_Digits_Hi (D) + UI_Decimal_Digits_Hi (N) + 4);
      Set_Debug_Sloc;
      UR_Write (U, Brackets => True);
   end Write_Ureal_With_Col_Check_Sloc;

end Sprint;