Subversion Repositories scarts

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

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                              B I N D G E N                               --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2005, 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 2,  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 COPYING.  If not, write --

-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --

-- Boston, MA 02110-1301, USA.                                              --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

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

with ALI;         use ALI;

with Binde;       use Binde;

with Casing;      use Casing;

with Fname;       use Fname;

with GNAT.OS_Lib; use GNAT.OS_Lib;

with Gnatvsn;     use Gnatvsn;

with Hostparm;

with Namet;       use Namet;

with Opt;         use Opt;

with Osint;       use Osint;

with Osint.B;     use Osint.B;

with Output;      use Output;

with Rident;      use Rident;

with Table;       use Table;

with Targparm;    use Targparm;

with Types;       use Types;

with GNAT.Heap_Sort_A;     use GNAT.Heap_Sort_A;

package body Bindgen is

   Statement_Buffer : String (1 .. 1000);

   --  Buffer used for constructing output statements

   Last : Natural := 0;

   --  Last location in Statement_Buffer currently set

   With_DECGNAT : Boolean := False;

   --  Flag which indicates whether the program uses the DECGNAT library

   --  (presence of the unit DEC).

   With_GNARL : Boolean := False;

   --  Flag which indicates whether the program uses the GNARL library

   --  (presence of the unit System.OS_Interface)

   Num_Elab_Calls : Nat := 0;

   --  Number of generated calls to elaboration routines

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

   -- Interface_State Pragma Table --

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

   --  This table assembles the interface state pragma information from

   --  all the units in the partition. Note that Bcheck has already checked

   --  that the information is consistent across partitions. The entries

   --  in this table are n/u/r/s for not set/user/runtime/system.

   package IS_Pragma_Settings is new Table.Table (

     Table_Component_Type => Character,

     Table_Index_Type     => Int,

     Table_Low_Bound      => 0,

     Table_Initial        => 100,

     Table_Increment      => 200,

     Table_Name           => "IS_Pragma_Settings");

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

   -- Run-Time Globals --

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

   --  This section documents the global variables that are passed to the

   --  run time from the generated binder file. The call that is made is

   --  to the routine Set_Globals, which has the following spec:

   --   procedure Set_Globals

   --     (Main_Priority            : Integer;

   --      Time_Slice_Value         : Integer;

   --      WC_Encoding              : Character;

   --      Locking_Policy           : Character;

   --      Queuing_Policy           : Character;

   --      Task_Dispatching_Policy  : Character;

   --      Restrictions             : System.Address;

   --      Interrupt_States         : System.Address;

   --      Num_Interrupt_States     : Integer;

   --      Unreserve_All_Interrupts : Integer;

   --      Exception_Tracebacks     : Integer;

   --      Zero_Cost_Exceptions     : Integer;

   --      Detect_Blocking          : Integer);

   --  Main_Priority is the priority value set by pragma Priority in the

   --  main program. If no such pragma is present, the value is -1.

   --  Time_Slice_Value is the time slice value set by pragma Time_Slice

   --  in the main program, or by the use of a -Tnnn parameter for the

   --  binder (if both are present, the binder value overrides). The

   --  value is in milliseconds. A value of zero indicates that time

   --  slicing should be suppressed. If no pragma is present, and no

   --  -T switch was used, the value is -1.

   --  WC_Encoding shows the wide character encoding method used for

   --  the main program. This is one of the encoding letters defined

   --  in System.WCh_Con.WC_Encoding_Letters.

   --  Locking_Policy is a space if no locking policy was specified

   --  for the partition. If a locking policy was specified, the value

   --  is the upper case first character of the locking policy name,

   --  for example, 'C' for Ceiling_Locking.

   --  Queuing_Policy is a space if no queuing policy was specified

   --  for the partition. If a queuing policy was specified, the value

   --  is the upper case first character of the queuing policy name

   --  for example, 'F' for FIFO_Queuing.

   --  Task_Dispatching_Policy is a space if no task dispatching policy

   --  was specified for the partition. If a task dispatching policy

   --  was specified, the value is the upper case first character of

   --  the policy name, e.g. 'F' for FIFO_Within_Priorities.

   --  Restrictions is the address of a null-terminated string specifying the

   --  restrictions information for the partition. The format is identical to

   --  that of the parameter string found on R lines in ali files (see Lib.Writ

   --  spec in lib-writ.ads for full details). The difference is that in this

   --  context the values are the cumulative ones for the entire partition.

   --  Interrupt_States is the address of a string used to specify the

   --  cumulative results of Interrupt_State pragmas used in the partition.

   --  The length of this string is determined by the last interrupt for which

   --  such a pragma is given (the string will be a null string if no pragmas

   --  were used). If pragma were present the entries apply to the interrupts

   --  in sequence from the first interrupt, and are set to one of four

   --  possible settings: 'n' for not specified, 'u' for user, 'r' for

   --  run time, 's' for system, see description of Interrupt_State pragma

   --  for further details.

   --  Num_Interrupt_States is the length of the Interrupt_States string.

   --  It will be set to zero if no Interrupt_State pragmas are present.

   --  Unreserve_All_Interrupts is set to one if at least one unit in the

   --  partition had a pragma Unreserve_All_Interrupts, and zero otherwise.

   --  Exception_Tracebacks is set to one if the -E parameter was present

   --  in the bind and to zero otherwise. Note that on some targets exception

   --  tracebacks are provided by default, so a value of zero for this

   --  parameter does not necessarily mean no trace backs are available.

   --  Zero_Cost_Exceptions is set to one if zero cost exceptions are used for

   --  this partition, and to zero if longjmp/setjmp exceptions are used.

   --  the use of zero

   --  Detect_Blocking indicates whether pragma Detect_Blocking is

   --  active or not. A value of zero indicates that the pragma is not

   --  present, while a value of 1 signals its presence in the

   --  partition.

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

   -- Local Subprograms --

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

   procedure WBI (Info : String) renames Osint.B.Write_Binder_Info;

   --  Convenient shorthand used throughout

   procedure Gen_Adainit_Ada;

   --  Generates the Adainit procedure (Ada code case)

   procedure Gen_Adainit_C;

   --  Generates the Adainit procedure (C code case)

   procedure Gen_Adafinal_Ada;

   --  Generate the Adafinal procedure (Ada code case)

   procedure Gen_Adafinal_C;

   --  Generate the Adafinal procedure (C code case)

   procedure Gen_Elab_Calls_Ada;

   --  Generate sequence of elaboration calls (Ada code case)

   procedure Gen_Elab_Calls_C;

   --  Generate sequence of elaboration calls (C code case)

   procedure Gen_Elab_Order_Ada;

   --  Generate comments showing elaboration order chosen (Ada case)

   procedure Gen_Elab_Order_C;

   --  Generate comments showing elaboration order chosen (C case)

   procedure Gen_Elab_Defs_C;

   --  Generate sequence of definitions for elaboration routines (C code case)

   procedure Gen_Main_Ada;

   --  Generate procedure main (Ada code case)

   procedure Gen_Main_C;

   --  Generate main() procedure (C code case)

   procedure Gen_Object_Files_Options;

   --  Output comments containing a list of the full names of the object

   --  files to be linked and the list of linker options supplied by

   --  Linker_Options pragmas in the source. (C and Ada code case)

   procedure Gen_Output_File_Ada (Filename : String);

   --  Generate output file (Ada code case)

   procedure Gen_Output_File_C (Filename : String);

   --  Generate output file (C code case)

   procedure Gen_Restrictions_String_1;

   --  Generate first restrictions string, which consists of the parameters

   --  the first R line, as described in lib-writ.ads, with the restrictions

   --  being those for the entire partition (from Cumulative_Restrictions).

   procedure Gen_Restrictions_String_2;

   --  Generate first restrictions string, which consists of the parameters

   --  the second R line, as described in lib-writ.ads, with the restrictions

   --  being those for the entire partition (from Cumulative_Restrictions).

   procedure Gen_Versions_Ada;

   --  Output series of definitions for unit versions (Ada code case)

   procedure Gen_Versions_C;

   --  Output series of definitions for unit versions (C code case)

   function Get_Ada_Main_Name return String;

   --  This function is used in the Ada main output case to compute a usable

   --  name for the generated main program. The normal main program name is

   --  Ada_Main, but this won't work if the user has a unit with this name.

   --  This function tries Ada_Main first, and if there is such a clash, then

   --  it tries Ada_Name_01, Ada_Name_02 ... Ada_Name_99 in sequence.

   function Get_Main_Name return String;

   --  This function is used in the Ada main output case to compute the

   --  correct external main program. It is "main" by default, unless the

   --  flag Use_Ada_Main_Program_Name_On_Target is set, in which case it

   --  is the name of the Ada main name without the "_ada". This default

   --  can be overridden explicitly using the -Mname binder switch.

   function Lt_Linker_Option (Op1, Op2 : Natural) return Boolean;

   --  Compare linker options, when sorting, first according to

   --  Is_Internal_File (internal files come later) and then by

   --  elaboration order position (latest to earliest).

   procedure Move_Linker_Option (From : Natural; To : Natural);

   --  Move routine for sorting linker options

   procedure Public_Version_Warning;

   --  Emit a warning concerning the use of the Public version under

   --  certain circumstances. See details in body.

   procedure Resolve_Binder_Options;

   --  Set the value of With_GNARL and With_DECGNAT. The latter only on VMS

   --  since it tests for a package named "dec" which might cause a conflict

   --  on non-VMS systems.

   procedure Set_Char (C : Character);

   --  Set given character in Statement_Buffer at the Last + 1 position

   --  and increment Last by one to reflect the stored character.

   procedure Set_Int (N : Int);

   --  Set given value in decimal in Statement_Buffer with no spaces

   --  starting at the Last + 1 position, and updating Last past the value.

   --  A minus sign is output for a negative value.

   procedure Set_IS_Pragma_Table;

   --  Initializes contents of IS_Pragma_Settings table from ALI table

   procedure Set_Main_Program_Name;

   --  Given the main program name in Name_Buffer (length in Name_Len)

   --  generate the name of the routine to be used in the call. The name

   --  is generated starting at Last + 1, and Last is updated past it.

   procedure Set_Name_Buffer;

   --  Set the value stored in positions 1 .. Name_Len of the Name_Buffer

   procedure Set_String (S : String);

   --  Sets characters of given string in Statement_Buffer, starting at the

   --  Last + 1 position, and updating last past the string value.

   procedure Set_Unit_Name;

   --  Given a unit name in the Name_Buffer, copies it to Statement_Buffer,

   --  starting at the Last + 1 position, and updating last past the value.

   --  changing periods to double underscores, and updating Last appropriately.

   procedure Set_Unit_Number (U : Unit_Id);

   --  Sets unit number (first unit is 1, leading zeroes output to line

   --  up all output unit numbers nicely as required by the value, and

   --  by the total number of units.

   procedure Tab_To (N : Natural);

   --  If Last is greater than or equal to N, no effect, otherwise store

   --  blanks in Statement_Buffer bumping Last, until Last = N.

   procedure Write_Info_Ada_C (Ada : String; C : String; Common : String);

   --  For C code case, write C & Common, for Ada case write Ada & Common

   --  to current binder output file using Write_Binder_Info.

   procedure Write_Statement_Buffer;

   --  Write out contents of statement buffer up to Last, and reset Last to 0

   procedure Write_Statement_Buffer (S : String);

   --  First writes its argument (using Set_String (S)), then writes out the

   --  contents of statement buffer up to Last, and reset Last to 0

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

   -- Gen_Adafinal_Ada --

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

   procedure Gen_Adafinal_Ada is

   begin

      WBI ("");

      WBI ("   procedure " & Ada_Final_Name.all & " is");

      WBI ("   begin");

      --  If compiling for the JVM, we directly call Adafinal because

      --  we don't import it via Do_Finalize (see Gen_Output_File_Ada).

      if Hostparm.Java_VM then

         WBI ("      System.Standard_Library.Adafinal;");

      --  If there is no finalization, there is nothing to do

      elsif Cumulative_Restrictions.Set (No_Finalization) then

         WBI ("      null;");

      else

         WBI ("      Do_Finalize;");

      end if;

      WBI ("   end " & Ada_Final_Name.all & ";");

   end Gen_Adafinal_Ada;

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

   -- Gen_Adafinal_C --

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

   procedure Gen_Adafinal_C is

   begin

      WBI ("void " & Ada_Final_Name.all & " () {");

      WBI ("   system__standard_library__adafinal ();");

      WBI ("}");

      WBI ("");

   end Gen_Adafinal_C;

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

   -- Gen_Adainit_Ada --

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

   procedure Gen_Adainit_Ada is

      Main_Priority : Int renames ALIs.Table (ALIs.First).Main_Priority;

   begin

      WBI ("   procedure " & Ada_Init_Name.all & " is");

      --  Generate externals for elaboration entities

      for E in Elab_Order.First .. Elab_Order.Last loop

         declare

            Unum : constant Unit_Id := Elab_Order.Table (E);

            U    : Unit_Record renames Units.Table (Unum);

         begin

            --  Check for Elab_Entity to be set for this unit

            if U.Set_Elab_Entity

            --  Don't generate reference for stand alone library

              and then not U.SAL_Interface

            --  Don't generate reference for predefined file in No_Run_Time

            --  mode, since we don't include the object files in this case

              and then not

                (No_Run_Time_Mode

                   and then Is_Predefined_File_Name (U.Sfile))

            then

               Set_String ("      ");

               Set_String ("E");

               Set_Unit_Number (Unum);

               Set_String (" : Boolean; pragma Import (Ada, ");

               Set_String ("E");

               Set_Unit_Number (Unum);

               Set_String (", """);

               Get_Name_String (U.Uname);

               --  In the case of JGNAT we need to emit an Import name

               --  that includes the class name (using '$' separators

               --  in the case of a child unit name).

               if Hostparm.Java_VM then

                  for J in 1 .. Name_Len - 2 loop

                     if Name_Buffer (J) /= '.' then

                        Set_Char (Name_Buffer (J));

                     else

                        Set_String ("$");

                     end if;

                  end loop;

                  Set_String (".");

                  --  If the unit name is very long, then split the

                  --  Import link name across lines using "&" (occurs

                  --  in some C2 tests).

                  if 2 * Name_Len + 60 > Hostparm.Max_Line_Length then

                     Set_String (""" &");

                     Write_Statement_Buffer;

                     Set_String ("         """);

                  end if;

               end if;

               Set_Unit_Name;

               Set_String ("_E"");");

               Write_Statement_Buffer;

            end if;

         end;

      end loop;

      Write_Statement_Buffer;

      --  If the standard library is suppressed, then the only global variable

      --  that might be needed (by the Ravenscar profile) is the priority of

      --  the environment. Also no exception tables are needed.

      if Suppress_Standard_Library_On_Target then

         if Main_Priority /= No_Main_Priority then

            WBI ("      Main_Priority : Integer;");

            WBI ("      pragma Import (C, Main_Priority," &

                 " ""__gl_main_priority"");");

            WBI ("");

         end if;

         WBI ("   begin");

         if Main_Priority /= No_Main_Priority then

            Set_String ("      Main_Priority := ");

            Set_Int    (Main_Priority);

            Set_Char   (';');

            Write_Statement_Buffer;

         else

            WBI ("      null;");

         end if;

      --  Normal case (standard library not suppressed). Global values are

      --  assigned using the runtime routine Set_Globals (we have to use

      --  the routine call, rather than define the globals in the binder

      --  file to deal with cross-library calls in some systems.

      else

         --  Generate restrictions string

         Set_String ("      Restrictions : constant String :=");

         Write_Statement_Buffer;

         Set_String ("        """);

         Gen_Restrictions_String_1;

         Set_String (""" &");

         Write_Statement_Buffer;

         Set_String ("        """);

         Gen_Restrictions_String_2;

         Set_String (""" & ASCII.Nul;");

         Write_Statement_Buffer;

         WBI ("");

         --  Generate Interrupt_State pragma string

         Set_String ("      Interrupt_States : constant String :=");

         Write_Statement_Buffer;

         declare

            Col : Natural;

         begin

            Set_String ("        """);

            Col := 9;

            for J in 0 .. IS_Pragma_Settings.Last loop

               if Col > 72 then

                  Set_String (""" &");

                  Write_Statement_Buffer;

                  Set_String ("        """);

                  Col := 9;

               else

                  Col := Col + 1;

               end if;

               Set_Char (IS_Pragma_Settings.Table (J));

            end loop;

         end;

         Set_String (""";");

         Write_Statement_Buffer;

         WBI ("");

         --  Generate spec for Set_Globals procedure

         WBI ("      procedure Set_Globals");

         WBI ("        (Main_Priority            : Integer;");

         WBI ("         Time_Slice_Value         : Integer;");

         WBI ("         WC_Encoding              : Character;");

         WBI ("         Locking_Policy           : Character;");

         WBI ("         Queuing_Policy           : Character;");

         WBI ("         Task_Dispatching_Policy  : Character;");

         WBI ("         Restrictions             : System.Address;");

         WBI ("         Interrupt_States         : System.Address;");

         WBI ("         Num_Interrupt_States     : Integer;");

         WBI ("         Unreserve_All_Interrupts : Integer;");

         WBI ("         Exception_Tracebacks     : Integer;");

         WBI ("         Zero_Cost_Exceptions     : Integer;");

         WBI ("         Detect_Blocking          : Integer);");

         WBI ("      pragma Import (C, Set_Globals, ""__gnat_set_globals"");");

         --  Import entry point for elaboration time signal handler

         --  installation, and indication of if it's been called previously.

         WBI ("");

         WBI ("      procedure Install_Handler;");

         WBI ("      pragma Import (C, Install_Handler, " &

              """__gnat_install_handler"");");

         WBI ("");

         WBI ("      Handler_Installed : Integer;");

         WBI ("      pragma Import (C, Handler_Installed, " &

              """__gnat_handler_installed"");");

         WBI ("   begin");

         --  Generate the call to Set_Globals

         WBI ("      Set_Globals");

         Set_String ("        (Main_Priority            => ");

         Set_Int    (Main_Priority);

         Set_Char   (',');

         Write_Statement_Buffer;

         Set_String ("         Time_Slice_Value         => ");

         if Task_Dispatching_Policy_Specified = 'F'

           and then ALIs.Table (ALIs.First).Time_Slice_Value = -1

         then

            Set_Int (0);

         else

            Set_Int (ALIs.Table (ALIs.First).Time_Slice_Value);

         end if;

         Set_Char   (',');

         Write_Statement_Buffer;

         Set_String ("         WC_Encoding              => '");

         Set_Char   (ALIs.Table (ALIs.First).WC_Encoding);

         Set_String ("',");

         Write_Statement_Buffer;

         Set_String ("         Locking_Policy           => '");

         Set_Char   (Locking_Policy_Specified);

         Set_String ("',");

         Write_Statement_Buffer;

         Set_String ("         Queuing_Policy           => '");

         Set_Char   (Queuing_Policy_Specified);

         Set_String ("',");

         Write_Statement_Buffer;

         Set_String ("         Task_Dispatching_Policy  => '");

         Set_Char   (Task_Dispatching_Policy_Specified);

         Set_String ("',");

         Write_Statement_Buffer;

         WBI ("         Restrictions             => Restrictions'Address,");

         WBI ("         Interrupt_States         => " &

                                                 "Interrupt_States'Address,");

         Set_String ("         Num_Interrupt_States     => ");

         Set_Int (IS_Pragma_Settings.Last + 1);

         Set_Char (',');

         Write_Statement_Buffer;

         Set_String ("         Unreserve_All_Interrupts => ");

         if Unreserve_All_Interrupts_Specified then

            Set_String ("1");

         else

            Set_String ("0");

         end if;

         Set_Char (',');

         Write_Statement_Buffer;

         Set_String ("         Exception_Tracebacks     => ");

         if Exception_Tracebacks then

            Set_String ("1");

         else

            Set_String ("0");

         end if;

         Set_String (",");

         Write_Statement_Buffer;

         Set_String ("         Zero_Cost_Exceptions     => ");

         if Zero_Cost_Exceptions_Specified then

            Set_String ("1");

         else

            Set_String ("0");

         end if;

         Set_String (",");

         Write_Statement_Buffer;

         Set_String ("         Detect_Blocking          => ");

         if Detect_Blocking then

            Set_Int (1);

         else

            Set_Int (0);

         end if;

         Set_String (");");

         Write_Statement_Buffer;

         --  Generate call to Install_Handler

         WBI ("");

         WBI ("      if Handler_Installed = 0 then");

         WBI ("         Install_Handler;");

         WBI ("      end if;");

      end if;

      --  Generate call to set Initialize_Scalar values if active

      if Initialize_Scalars_Used then

         WBI ("");

         Set_String ("      System.Scalar_Values.Initialize ('");

         Set_Char (Initialize_Scalars_Mode1);

         Set_String ("', '");

         Set_Char (Initialize_Scalars_Mode2);

         Set_String ("');");

         Write_Statement_Buffer;

      end if;

      --  Generate assignment of default secondary stack size if set

      if Sec_Stack_Used and then Default_Sec_Stack_Size /= -1 then

         WBI ("");

         Set_String ("      System.Secondary_Stack.");

         Set_String ("Default_Secondary_Stack_Size := ");

         Set_Int (Opt.Default_Sec_Stack_Size);

         Set_Char (';');

         Write_Statement_Buffer;

      end if;

      --  Generate elaboration calls

      WBI ("");

      Gen_Elab_Calls_Ada;

      WBI ("   end " & Ada_Init_Name.all & ";");

   end Gen_Adainit_Ada;

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

   -- Gen_Adainit_C --

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

   procedure Gen_Adainit_C is

      Main_Priority : Int renames ALIs.Table (ALIs.First).Main_Priority;

   begin

      WBI ("void " & Ada_Init_Name.all & " (void)");

      WBI ("{");

      --  Generate externals for elaboration entities

      for E in Elab_Order.First .. Elab_Order.Last loop

         declare

            Unum : constant Unit_Id := Elab_Order.Table (E);

            U    : Unit_Record renames Units.Table (Unum);

         begin

            --  Check for Elab entity to be set for this unit

            if U.Set_Elab_Entity

            --  Don't generate reference for stand alone library

              and then not U.SAL_Interface

            --  Don't generate reference for predefined file in No_Run_Time

            --  mode, since we don't include the object files in this case

              and then not

                (No_Run_Time_Mode

                   and then Is_Predefined_File_Name (U.Sfile))

            then

               Set_String ("   extern char ");

               Get_Name_String (U.Uname);

               Set_Unit_Name;

               Set_String ("_E;");

               Write_Statement_Buffer;

            end if;

         end;

      end loop;

      Write_Statement_Buffer;

      --  Standard library suppressed

      if Suppress_Standard_Library_On_Target then

         --  Case of High_Integrity_Mode mode. Set __gl_main_priority if needed

         --  for the Ravenscar profile.

         if Main_Priority /= No_Main_Priority then

            Set_String ("   extern int __gl_main_priority = ");

            Set_Int    (Main_Priority);

            Set_Char   (';');

            Write_Statement_Buffer;

         end if;

      --  Normal case (standard library not suppressed)

      else

         --  Generate definition for restrictions string

         Set_String ("   const char *restrictions = """);

         Gen_Restrictions_String_1;

         Gen_Restrictions_String_2;

         Set_String (""";");

         Write_Statement_Buffer;

         --  Generate definition for interrupt states string

         Set_String ("   const char *interrupt_states = """);

         for J in 0 .. IS_Pragma_Settings.Last loop

            Set_Char (IS_Pragma_Settings.Table (J));

         end loop;

         Set_String (""";");

         Write_Statement_Buffer;

         --  Generate declaration for secondary stack default if needed

         if Sec_Stack_Used and then Default_Sec_Stack_Size /= -1 then

            WBI ("   extern int system__secondary_stack__" &

                 "default_secondary_stack_size;");

         end if;

         WBI ("");

         --  Code for normal case (standard library not suppressed)

         --  Generate call to set the runtime global variables defined in

         --  init.c. We define the varables in init.c, rather than in

         --  the binder generated file itself to avoid undefined externals

         --  when the runtime is linked as a shareable image library.

         --  We call the routine from inside adainit() because this works for

         --  both programs with and without binder generated "main" functions.

         WBI ("   __gnat_set_globals (");

         Set_String ("      ");

         Set_Int (Main_Priority);

         Set_Char (',');

         Tab_To (24);

         Set_String ("/* Main_Priority              */");