Subversion Repositories openrisc

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                               S P R I N T                                --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2009, 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 Atree;    use Atree;

with Casing;   use Casing;

with Csets;    use Csets;

with Debug;    use Debug;

with Einfo;    use Einfo;

with Fname;    use Fname;

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.

   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 -gnatG (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 freeze nodes and non-source null statements output

   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_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 not 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 (which is either a function

   --  or procedure specification with a Parameter_Specifications 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;

      Current_Source_File := No_Source_File;

      if Arg in List_Range then

         Sprint_Node_List (List_Id (Arg));

      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));

      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));

      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

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

         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;

         --  Dump requested units

         for U in Main_Unit .. Last_Unit loop

            Current_Source_File := Source_Index (U);

            --  Dump all units if -gnatdf set, otherwise we dump only

            --  the source files that are in the extended main source.

            if Debug_Flag_F

              or else In_Extended_Main_Source_Unit (Cunit_Entity (U))

            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);

                  Write_Source_Line (1);

                  Last_Line_Printed := 1;

                  Sprint_Node (Cunit (U));

                  Write_Source_Lines (Last_Source_Line (Current_Source_File));

                  Write_Eol;

                  Close_Debug_Source;

                  Set_Special_Output (null);

               --  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_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_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)