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);
Last : Natural := 0;
With_DECGNAT : Boolean := False;
With_GNARL : Boolean := False;
Num_Elab_Calls : Nat := 0;
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");
procedure WBI (Info : String) renames Osint.B.Write_Binder_Info;
procedure Gen_Adainit_Ada;
procedure Gen_Adainit_C;
procedure Gen_Adafinal_Ada;
procedure Gen_Adafinal_C;
procedure Gen_Elab_Calls_Ada;
procedure Gen_Elab_Calls_C;
procedure Gen_Elab_Order_Ada;
procedure Gen_Elab_Order_C;
procedure Gen_Elab_Defs_C;
procedure Gen_Exception_Table_Ada;
procedure Gen_Exception_Table_C;
procedure Gen_Main_Ada;
procedure Gen_Main_C;
procedure Gen_Object_Files_Options;
procedure Gen_Output_File_Ada (Filename : String);
procedure Gen_Output_File_C (Filename : String);
procedure Gen_Restrictions_String_1;
procedure Gen_Restrictions_String_2;
procedure Gen_Versions_Ada;
procedure Gen_Versions_C;
function Get_Ada_Main_Name return String;
function Get_Main_Name return String;
function Lt_Linker_Option (Op1, Op2 : Natural) return Boolean;
procedure Move_Linker_Option (From : Natural; To : Natural);
procedure Public_Version_Warning;
procedure Resolve_Binder_Options;
procedure Set_Char (C : Character);
procedure Set_EA_Last;
procedure Set_Int (N : Int);
procedure Set_IS_Pragma_Table;
procedure Set_Main_Program_Name;
procedure Set_Name_Buffer;
procedure Set_String (S : String);
procedure Set_Unit_Name;
procedure Set_Unit_Number (U : Unit_Id);
procedure Tab_To (N : Natural);
procedure Write_Info_Ada_C (Ada : String; C : String; Common : String);
procedure Write_Statement_Buffer;
procedure Write_Statement_Buffer (S : String);
procedure Gen_Adafinal_Ada is
begin
WBI ("");
WBI (" procedure " & Ada_Final_Name.all & " is");
WBI (" begin");
if Hostparm.Java_VM then
WBI (" System.Standard_Library.Adafinal;");
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;
procedure Gen_Adafinal_C is
begin
WBI ("void " & Ada_Final_Name.all & " () {");
WBI (" system__standard_library__adafinal ();");
WBI ("}");
WBI ("");
end Gen_Adafinal_C;
procedure Gen_Adainit_Ada is
Main_Priority : Int renames ALIs.Table (ALIs.First).Main_Priority;
begin
WBI (" procedure " & Ada_Init_Name.all & " is");
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
if U.Set_Elab_Entity
and then not U.SAL_Interface
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);
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 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 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;
else
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 ("");
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 ("");
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"");");
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"");");
Gen_Exception_Table_Ada;
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;
WBI ("");
WBI (" if Handler_Installed = 0 then");
WBI (" Install_Handler;");
WBI (" end if;");
end if;
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;
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;
WBI ("");
Gen_Elab_Calls_Ada;
WBI (" end " & Ada_Init_Name.all & ";");
end Gen_Adainit_Ada;
procedure Gen_Adainit_C is
Main_Priority : Int renames ALIs.Table (ALIs.First).Main_Priority;
begin
WBI ("void " & Ada_Init_Name.all & " (void)");
WBI ("{");
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
if U.Set_Elab_Entity
and then not U.SAL_Interface
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;
if Suppress_Standard_Library_On_Target then
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;
else
Set_String (" const char *restrictions = """);
Gen_Restrictions_String_1;
Gen_Restrictions_String_2;
Set_String (""";");
Write_Statement_Buffer;
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;
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 ("");
Gen_Exception_Table_C;
WBI (" __gnat_set_globals (");
Set_String (" ");
Set_Int (Main_Priority);
Set_Char (',');
Tab_To (24);
Set_String ("/* Main_Priority */");
Write_Statement_Buffer;
Set_String (" ");
if Task_Dispatching_Policy = '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 (',');
Tab_To (24);
Set_String ("/* Time_Slice_Value */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (ALIs.Table (ALIs.First).WC_Encoding);
Set_String ("',");
Tab_To (24);
Set_String ("/* WC_Encoding */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (Locking_Policy_Specified);
Set_String ("',");
Tab_To (24);
Set_String ("/* Locking_Policy */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (Queuing_Policy_Specified);
Set_String ("',");
Tab_To (24);
Set_String ("/* Queuing_Policy */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (Task_Dispatching_Policy_Specified);
Set_String ("',");
Tab_To (24);
Set_String ("/* Tasking_Dispatching_Policy */");
Write_Statement_Buffer;
Set_String (" ");
Set_String ("restrictions");
Set_String (",");
Tab_To (24);
Set_String ("/* Restrictions */");
Write_Statement_Buffer;
Set_String (" ");
Set_String ("interrupt_states");
Set_String (",");
Tab_To (24);
Set_String ("/* Interrupt_States */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (IS_Pragma_Settings.Last + 1);
Set_String (",");
Tab_To (24);
Set_String ("/* Num_Interrupt_States */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (Boolean'Pos (Unreserve_All_Interrupts_Specified));
Set_String (",");
Tab_To (24);
Set_String ("/* Unreserve_All_Interrupts */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (Boolean'Pos (Exception_Tracebacks));
Set_String (",");
Tab_To (24);
Set_String ("/* Exception_Tracebacks */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (Boolean'Pos (Zero_Cost_Exceptions_Specified));
Set_String (",");
Tab_To (24);
Set_String ("/* Zero_Cost_Exceptions */");
Write_Statement_Buffer;
Set_String (" ");
if Detect_Blocking then
Set_Int (1);
else
Set_Int (0);
end if;
Set_String (");");
Tab_To (24);
Set_String ("/* Detect_Blocking */");
Write_Statement_Buffer;
WBI ("");
WBI (" if (__gnat_handler_installed == 0)");
WBI (" {");
WBI (" __gnat_install_handler ();");
WBI (" }");
end if;
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;
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;
WBI ("");
Gen_Elab_Calls_C;
WBI ("}");
end Gen_Adainit_C;
procedure Gen_Elab_Calls_Ada is
begin
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);
Unum_Spec : Unit_Id;
begin
if U.Utype = Is_Body then
Unum_Spec := Unum + 1;
else
Unum_Spec := Unum;
end if;
if No_Run_Time_Mode and then Is_Predefined_File_Name (U.Sfile) then
null;
elsif U.No_Elab then
if not U.SAL_Interface and then U.Utype = Is_Body
and then Units.Table (Unum_Spec).Set_Elab_Entity
then
Set_String (" E");
Set_Unit_Number (Unum_Spec);
Set_String (" := True;");
Write_Statement_Buffer;
end if;
elsif not U.SAL_Interface then
if Force_Checking_Of_Elaboration_Flags or
Interface_Library_Unit or
(not Bind_Main_Program)
then
Set_String (" if not E");
Set_Unit_Number (Unum_Spec);
Set_String (" then");
Write_Statement_Buffer;
Set_String (" ");
end if;
Set_String (" ");
Get_Decoded_Name_String_With_Brackets (U.Uname);
if Name_Buffer (Name_Len) = 's' then
Name_Buffer (Name_Len - 1 .. Name_Len + 8) := "'elab_spec";
else
Name_Buffer (Name_Len - 1 .. Name_Len + 8) := "'elab_body";
end if;
Name_Len := Name_Len + 8;
Set_Casing (U.Icasing);
Set_Name_Buffer;
Set_Char (';');
Write_Statement_Buffer;
if U.Utype /= Is_Spec then
if Force_Checking_Of_Elaboration_Flags or
Interface_Library_Unit or
(not Bind_Main_Program)
then
Set_String (" ");
end if;
Set_String (" E");
Set_Unit_Number (Unum_Spec);
Set_String (" := True;");
Write_Statement_Buffer;
end if;
if Force_Checking_Of_Elaboration_Flags or
Interface_Library_Unit or
(not Bind_Main_Program)
then
WBI (" end if;");
end if;
end if;
end;
end loop;
end Gen_Elab_Calls_Ada;
procedure Gen_Elab_Calls_C is
begin
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);
Unum_Spec : Unit_Id;
begin
if U.Utype = Is_Body then
Unum_Spec := Unum + 1;
else
Unum_Spec := Unum;
end if;
if No_Run_Time_Mode and then Is_Predefined_File_Name (U.Sfile) then
null;
elsif U.No_Elab then
if not U.SAL_Interface and then U.Utype = Is_Body
and then Units.Table (Unum_Spec).Set_Elab_Entity
then
Set_String (" ");
Get_Name_String (U.Uname);
Set_Unit_Name;
Set_String ("_E = 1;");
Write_Statement_Buffer;
end if;
elsif not U.SAL_Interface then
Get_Name_String (U.Uname);
if Force_Checking_Of_Elaboration_Flags or
Interface_Library_Unit or
(not Bind_Main_Program)
then
Set_String (" if (");
Set_Unit_Name;
Set_String ("_E == 0) {");
Write_Statement_Buffer;
Set_String (" ");
end if;
Set_String (" ");
Set_Unit_Name;
Set_String ("___elab");
Set_Char (Name_Buffer (Name_Len)); Set_String (" ();");
Write_Statement_Buffer;
if U.Utype /= Is_Spec then
if Force_Checking_Of_Elaboration_Flags or
Interface_Library_Unit or
(not Bind_Main_Program)
then
Set_String (" ");
end if;
Set_String (" ");
Set_Unit_Name;
Set_String ("_E++;");
Write_Statement_Buffer;
end if;
if Force_Checking_Of_Elaboration_Flags or
Interface_Library_Unit or
(not Bind_Main_Program)
then
WBI (" }");
end if;
end if;
end;
end loop;
end Gen_Elab_Calls_C;
procedure Gen_Elab_Defs_C is
begin
for E in Elab_Order.First .. Elab_Order.Last loop
if not Units.Table (Elab_Order.Table (E)).No_Elab then
Get_Name_String (Units.Table (Elab_Order.Table (E)).Uname);
Set_String ("extern void ");
Set_Unit_Name;
Set_String ("___elab");
Set_Char (Name_Buffer (Name_Len)); Set_String (" (void);");
Write_Statement_Buffer;
end if;
end loop;
WBI ("");
end Gen_Elab_Defs_C;
procedure Gen_Elab_Order_Ada is
begin
WBI ("");
WBI (" -- BEGIN ELABORATION ORDER");
for J in Elab_Order.First .. Elab_Order.Last loop
Set_String (" -- ");
Get_Name_String (Units.Table (Elab_Order.Table (J)).Uname);
Set_Name_Buffer;
Write_Statement_Buffer;
end loop;
WBI (" -- END ELABORATION ORDER");
end Gen_Elab_Order_Ada;
procedure Gen_Elab_Order_C is
begin
WBI ("");
WBI ("/* BEGIN ELABORATION ORDER");
for J in Elab_Order.First .. Elab_Order.Last loop
Get_Name_String (Units.Table (Elab_Order.Table (J)).Uname);
Set_Name_Buffer;
Write_Statement_Buffer;
end loop;
WBI (" END ELABORATION ORDER */");
end Gen_Elab_Order_C;
procedure Gen_Exception_Table_Ada is
Num : Nat;
Last : ALI_Id := No_ALI_Id;
begin
if not Zero_Cost_Exceptions_Specified then
WBI (" begin");
return;
end if;
Num := 0;
for A in ALIs.First .. ALIs.Last loop
if not ALIs.Table (A).SAL_Interface
and then ALIs.Table (A).Unit_Exception_Table
then
Num := Num + 1;
Last := A;
end if;
end loop;
if Num = 0 then
WBI (" ");
WBI (" begin");
return;
end if;
WBI (" procedure SDP_Table_Build");
WBI (" (SDP_Addresses : System.Address;");
WBI (" SDP_Count : Natural;");
WBI (" Elab_Addresses : System.Address;");
WBI (" Elab_Addr_Count : Natural);");
WBI (" " &
"pragma Import (C, SDP_Table_Build, ""__gnat_SDP_Table_Build"");");
WBI (" ");
Set_String (" ST : aliased constant array (1 .. ");
Set_Int (Num);
Set_String (") of System.Address := (");
if Num = 1 then
Set_String ("1 => ");
else
Write_Statement_Buffer;
end if;
for A in ALIs.First .. ALIs.Last loop
if not ALIs.Table (A).SAL_Interface
and then ALIs.Table (A).Unit_Exception_Table
then
Get_Decoded_Name_String_With_Brackets
(Units.Table (ALIs.Table (A).First_Unit).Uname);
Set_Casing (Mixed_Case);
if Num /= 1 then
Set_String (" ");
end if;
Set_String (Name_Buffer (1 .. Name_Len - 2));
Set_String ("'UET_Address");
if A = Last then
Set_String (");");
else
Set_Char (',');
end if;
Write_Statement_Buffer;
end if;
end loop;
WBI (" ");
Set_String (" EA : aliased constant array (1 .. ");
Set_EA_Last;
Set_String (") of System.Address := (");
Write_Statement_Buffer;
Set_String (" " & Ada_Init_Name.all & "'Code_Address");
if not Cumulative_Restrictions.Set (No_Finalization) then
Set_Char (',');
Write_Statement_Buffer;
if Hostparm.Java_VM then
Set_String
(" System.Standard_Library.Adafinal'Code_Address");
else
Set_String
(" Do_Finalize'Code_Address");
end if;
end if;
for E in Elab_Order.First .. Elab_Order.Last loop
Get_Decoded_Name_String_With_Brackets
(Units.Table (Elab_Order.Table (E)).Uname);
if Units.Table (Elab_Order.Table (E)).No_Elab then
null;
else
Set_Char (',');
Write_Statement_Buffer;
Set_String (" ");
if Name_Buffer (Name_Len) = 's' then
Name_Buffer (Name_Len - 1 .. Name_Len + 21) :=
"'elab_spec'code_address";
else
Name_Buffer (Name_Len - 1 .. Name_Len + 21) :=
"'elab_body'code_address";
end if;
Name_Len := Name_Len + 21;
Set_Casing (Units.Table (Elab_Order.Table (E)).Icasing);
Set_Name_Buffer;
end if;
end loop;
Set_String (");");
Write_Statement_Buffer;
WBI (" ");
WBI (" begin");
Set_String (" SDP_Table_Build (ST'Address, ");
Set_Int (Num);
Set_String (", EA'Address, ");
Set_EA_Last;
Set_String (");");
Write_Statement_Buffer;
end Gen_Exception_Table_Ada;
procedure Gen_Exception_Table_C is
Num : Nat;
Num2 : Nat;
begin
if not Zero_Cost_Exceptions_Specified then
return;
end if;
Num := 0;
for A in ALIs.First .. ALIs.Last loop
if not ALIs.Table (A).SAL_Interface
and then ALIs.Table (A).Unit_Exception_Table
then
Num := Num + 1;
Set_String (" extern void *__gnat_");
Get_Name_String (Units.Table (ALIs.Table (A).First_Unit).Uname);
Set_Unit_Name;
Set_String ("__SDP");
Set_Char (';');
Write_Statement_Buffer;
end if;
end loop;
if Num = 0 then
return;
end if;
WBI (" ");
Set_String (" void **st[");
Set_Int (Num);
Set_String ("] = {");
Write_Statement_Buffer;
Num2 := 0;
for A in ALIs.First .. ALIs.Last loop
if not ALIs.Table (A).SAL_Interface
and then ALIs.Table (A).Unit_Exception_Table
then
Num2 := Num2 + 1;
Set_String (" &__gnat_");
Get_Name_String (Units.Table (ALIs.Table (A).First_Unit).Uname);
Set_Unit_Name;
Set_String ("__SDP");
if Num = Num2 then
Set_String ("};");
else
Set_Char (',');
end if;
Write_Statement_Buffer;
end if;
end loop;
WBI ("");
for E in Elab_Order.First .. Elab_Order.Last loop
Get_Name_String (Units.Table (Elab_Order.Table (E)).Uname);
if Units.Table (Elab_Order.Table (E)).No_Elab then
null;
else
Set_String (" extern void ");
Set_Unit_Name;
Set_String ("___elab");
Set_Char (Name_Buffer (Name_Len)); Set_String (" ();");
Write_Statement_Buffer;
end if;
end loop;
WBI ("");
Set_String (" void (*ea[");
Set_EA_Last;
Set_String ("]) () = {");
Write_Statement_Buffer;
Set_String (" " & Ada_Init_Name.all);
if not Cumulative_Restrictions.Set (No_Finalization) then
Set_Char (',');
Write_Statement_Buffer;
Set_String (" system__standard_library__adafinal");
end if;
for E in Elab_Order.First .. Elab_Order.Last loop
Get_Name_String (Units.Table (Elab_Order.Table (E)).Uname);
if Units.Table (Elab_Order.Table (E)).No_Elab then
null;
else
Set_Char (',');
Write_Statement_Buffer;
Set_String (" ");
Set_Unit_Name;
Set_String ("___elab");
Set_Char (Name_Buffer (Name_Len)); end if;
end loop;
Set_String ("};");
Write_Statement_Buffer;
WBI (" ");
Set_String (" __gnat_SDP_Table_Build (&st, ");
Set_Int (Num);
Set_String (", ea, ");
Set_EA_Last;
Set_String (");");
Write_Statement_Buffer;
end Gen_Exception_Table_C;
procedure Gen_Main_Ada is
begin
WBI ("");
if Exit_Status_Supported_On_Target then
Set_String (" function ");
else
Set_String (" procedure ");
end if;
Set_String (Get_Main_Name);
if Command_Line_Args_On_Target then
Write_Statement_Buffer;
WBI (" (argc : Integer;");
WBI (" argv : System.Address;");
WBI (" envp : System.Address)");
if Exit_Status_Supported_On_Target then
WBI (" return Integer");
end if;
WBI (" is");
else
if Exit_Status_Supported_On_Target then
Set_String (" return Integer is");
else
Set_String (" is");
end if;
Write_Statement_Buffer;
end if;
if Opt.Default_Exit_Status /= 0
and then Bind_Main_Program
and then not Configurable_Run_Time_Mode
then
WBI (" procedure Set_Exit_Status (Status : Integer);");
WBI (" pragma Import (C, Set_Exit_Status, " &
"""__gnat_set_exit_status"");");
WBI ("");
end if;
if not Cumulative_Restrictions.Set (No_Finalization) then
WBI (" procedure initialize (Addr : System.Address);");
WBI (" pragma Import (C, initialize, ""__gnat_initialize"");");
WBI ("");
WBI (" procedure finalize;");
WBI (" pragma Import (C, finalize, ""__gnat_finalize"");");
end if;
if not No_Main_Subprogram then
WBI ("");
if ALIs.Table (ALIs.First).Main_Program = Func then
WBI (" Result : Integer;");
WBI ("");
WBI (" function Ada_Main_Program return Integer;");
else
WBI (" procedure Ada_Main_Program;");
end if;
Set_String (" pragma Import (Ada, Ada_Main_Program, """);
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
Set_Main_Program_Name;
Set_String (""");");
Write_Statement_Buffer;
WBI ("");
if Bind_Main_Program
and then not Suppress_Standard_Library_On_Target
then
WBI (" SEH : aliased array (1 .. 2) of Integer;");
WBI ("");
end if;
end if;
if Bind_Main_Program then
WBI
(" Ensure_Reference : System.Address := " &
"Ada_Main_Program_Name'Address;");
WBI ("");
end if;
WBI (" begin");
if Command_Line_Args_On_Target then
WBI (" gnat_argc := argc;");
WBI (" gnat_argv := argv;");
WBI (" gnat_envp := envp;");
WBI ("");
elsif Configurable_Run_Time_On_Target then
null;
else
WBI (" gnat_argc := 0;");
WBI (" gnat_argv := System.Null_Address;");
WBI (" gnat_envp := System.Null_Address;");
end if;
if Opt.Default_Exit_Status /= 0
and then Bind_Main_Program
and then not Configurable_Run_Time_Mode
then
Set_String (" Set_Exit_Status (");
Set_Int (Opt.Default_Exit_Status);
Set_String (");");
Write_Statement_Buffer;
end if;
if not Cumulative_Restrictions.Set (No_Finalization) then
if not No_Main_Subprogram
and then Bind_Main_Program
and then not Suppress_Standard_Library_On_Target
then
WBI (" Initialize (SEH'Address);");
else
WBI (" Initialize (System.Null_Address);");
end if;
end if;
WBI (" " & Ada_Init_Name.all & ";");
if not No_Main_Subprogram then
WBI (" Break_Start;");
if ALIs.Table (ALIs.First).Main_Program = Proc then
WBI (" Ada_Main_Program;");
else
WBI (" Result := Ada_Main_Program;");
end if;
end if;
if not Cumulative_Restrictions.Set (No_Finalization) then
if Hostparm.Java_VM then
WBI (" System.Standard_Library.Adafinal;");
else
WBI (" Do_Finalize;");
end if;
end if;
if not Cumulative_Restrictions.Set (No_Finalization) then
WBI (" Finalize;");
end if;
if Exit_Status_Supported_On_Target then
if No_Main_Subprogram
or else ALIs.Table (ALIs.First).Main_Program = Proc
then
WBI (" return (gnat_exit_status);");
else
WBI (" return (Result);");
end if;
end if;
WBI (" end;");
end Gen_Main_Ada;
procedure Gen_Main_C is
begin
if Exit_Status_Supported_On_Target then
Set_String ("int ");
else
Set_String ("void ");
end if;
Set_String (Get_Main_Name);
if Command_Line_Args_On_Target then
Write_Statement_Buffer (" (int argc, char **argv, char **envp)");
else
Write_Statement_Buffer (" ()");
end if;
WBI ("{");
if Bind_Main_Program then
WBI (" char *ensure_reference __attribute__ ((__unused__)) = " &
"__gnat_ada_main_program_name;");
WBI ("");
if not Suppress_Standard_Library_On_Target
and then not No_Main_Subprogram
then
WBI (" int SEH [2];");
WBI ("");
end if;
end if;
if ALIs.Table (ALIs.First).Main_Program = Func then
WBI (" int result;");
end if;
if Command_Line_Args_On_Target then
WBI (" gnat_argc = argc;");
WBI (" gnat_argv = argv;");
WBI (" gnat_envp = envp;");
WBI (" ");
elsif Configurable_Run_Time_On_Target then
null;
else
WBI (" int result;");
WBI (" gnat_argc = 0;");
WBI (" gnat_argv = 0;");
WBI (" gnat_envp = 0;");
end if;
if Opt.Default_Exit_Status /= 0
and then Bind_Main_Program
and then not Configurable_Run_Time_Mode
then
Set_String (" __gnat_set_exit_status (");
Set_Int (Opt.Default_Exit_Status);
Set_String (");");
Write_Statement_Buffer;
end if;
if not Suppress_Standard_Library_On_Target then
if not No_Main_Subprogram and then Bind_Main_Program then
WBI (" __gnat_initialize ((void *)SEH);");
else
WBI (" __gnat_initialize ((void *)0);");
end if;
end if;
WBI (" " & Ada_Init_Name.all & " ();");
if not No_Main_Subprogram then
WBI (" __gnat_break_start ();");
WBI (" ");
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
if ALIs.Table (ALIs.First).Main_Program = Proc then
Set_String (" ");
Set_Main_Program_Name;
Set_String (" ();");
Write_Statement_Buffer;
else Set_String (" result = ");
Set_Main_Program_Name;
Set_String (" ();");
Write_Statement_Buffer;
end if;
end if;
if not Cumulative_Restrictions.Set (No_Finalization) then
WBI (" ");
WBI (" system__standard_library__adafinal ();");
end if;
if not Suppress_Standard_Library_On_Target then
WBI (" __gnat_finalize ();");
end if;
if ALIs.Table (ALIs.First).Main_Program = Func then
if Exit_Status_Supported_On_Target then
if OpenVMS_On_Target then
WBI (" __posix_exit (result);");
else
WBI (" exit (result);");
end if;
end if;
else
if Exit_Status_Supported_On_Target then
if OpenVMS_On_Target then
WBI (" __posix_exit (gnat_exit_status);");
else
WBI (" exit (gnat_exit_status);");
end if;
end if;
end if;
WBI ("}");
end Gen_Main_C;
procedure Gen_Object_Files_Options is
Lgnat : Natural;
procedure Write_Linker_Option;
procedure Write_Linker_Option is
Start : Natural;
Stop : Natural;
begin
Start := 1;
while Start < Name_Len loop
Stop := Start + 1;
while Name_Buffer (Stop) /= ASCII.NUL
and then Stop <= Name_Len loop
Stop := Stop + 1;
end loop;
if Stop > Start then
if Output_Linker_Option_List then
Write_Str (Name_Buffer (Start .. Stop - 1));
Write_Eol;
end if;
Write_Info_Ada_C
(" -- ", "", Name_Buffer (Start .. Stop - 1));
end if;
Start := Stop + 1;
end loop;
end Write_Linker_Option;
begin
WBI ("");
Write_Info_Ada_C ("-- ", "/* ", " BEGIN Object file/option list");
for E in Elab_Order.First .. Elab_Order.Last loop
if (not Units.Table (Elab_Order.Table (E)).SAL_Interface)
and then Units.Table (Elab_Order.Table (E)).Utype /= Is_Spec
then
Get_Name_String
(ALIs.Table
(Units.Table (Elab_Order.Table (E)).My_ALI).Ofile_Full_Name);
if not Hostparm.Exclude_Missing_Objects
or else GNAT.OS_Lib.Is_Regular_File (Name_Buffer (1 .. Name_Len))
then
Write_Info_Ada_C (" -- ", "", Name_Buffer (1 .. Name_Len));
if Output_Object_List then
Write_Str (Name_Buffer (1 .. Name_Len));
Write_Eol;
end if;
if Hostparm.OpenVMS
and then Is_Internal_File_Name
(ALIs.Table
(Units.Table (Elab_Order.Table (E)).My_ALI).Sfile)
then
Get_Name_String (ALIs.Table
(Units.Table (Elab_Order.Table (E)).My_ALI).Sfile);
if Name_Buffer (1 .. 8) /= "g-trasym" then
Opt.Shared_Libgnat := False;
end if;
end if;
end if;
end if;
end loop;
for J in 1 .. Nb_Dir_In_Obj_Search_Path loop
declare
Dir : constant String_Ptr := Dir_In_Obj_Search_Path (J);
begin
Name_Len := 0;
Add_Str_To_Name_Buffer ("-L");
Add_Str_To_Name_Buffer (Dir.all);
Write_Linker_Option;
end;
end loop;
Sort
(Linker_Options.Last,
Move_Linker_Option'Access,
Lt_Linker_Option'Access);
Lgnat := Linker_Options.Last + 1;
for J in 1 .. Linker_Options.Last loop
if not Linker_Options.Table (J).Internal_File then
Get_Name_String (Linker_Options.Table (J).Name);
Write_Linker_Option;
else
Lgnat := J;
exit;
end if;
end loop;
if not Opt.No_Stdlib then
Name_Len := 0;
if Opt.Shared_Libgnat then
Add_Str_To_Name_Buffer ("-shared");
else
Add_Str_To_Name_Buffer ("-static");
end if;
Write_Info_Ada_C (" -- ", "", Name_Buffer (1 .. Name_Len));
if With_DECGNAT then
Name_Len := 0;
Add_Str_To_Name_Buffer ("-ldecgnat");
Write_Linker_Option;
end if;
if With_GNARL then
Name_Len := 0;
if Opt.Shared_Libgnat then
Add_Str_To_Name_Buffer (Shared_Lib ("gnarl"));
else
Add_Str_To_Name_Buffer ("-lgnarl");
end if;
Write_Linker_Option;
end if;
Name_Len := 0;
if Opt.Shared_Libgnat then
Add_Str_To_Name_Buffer (Shared_Lib ("gnat"));
else
Add_Str_To_Name_Buffer ("-lgnat");
end if;
Write_Linker_Option;
end if;
for J in Lgnat .. Linker_Options.Last loop
Get_Name_String (Linker_Options.Table (J).Name);
Write_Linker_Option;
end loop;
if Ada_Bind_File then
WBI ("-- END Object file/option list ");
else
WBI (" END Object file/option list */");
end if;
end Gen_Object_Files_Options;
procedure Gen_Output_File (Filename : String) is
Is_Public_Version : constant Boolean := Get_Gnat_Build_Type = Public;
Is_GAP_Version : constant Boolean := Get_Gnat_Build_Type = GAP;
begin
Set_IS_Pragma_Table;
if Hostparm.Java_VM then
Ada_Bind_File := True;
Bind_Main_Program := False;
end if;
if Time_Slice_Set then
ALIs.Table (ALIs.First).Time_Slice_Value := Opt.Time_Slice_Value;
end if;
for E in Elab_Order.First .. Elab_Order.Last loop
if Units.Table (Elab_Order.Table (E)).No_Elab then
null;
else
Num_Elab_Calls := Num_Elab_Calls + 1;
end if;
end loop;
if Is_Public_Version or Is_GAP_Version then
Record_Time_From_Last_Bind;
end if;
if Ada_Bind_File then
Gen_Output_File_Ada (Filename);
else
Gen_Output_File_C (Filename);
end if;
if Is_Public_Version then
Public_Version_Warning;
end if;
end Gen_Output_File;
procedure Gen_Output_File_Ada (Filename : String) is
Bfiles : Name_Id;
Bfileb : Name_Id;
Ada_Main : constant String := Get_Ada_Main_Name;
begin
Create_Binder_Output (Filename, 's', Bfiles);
if Cumulative_Restrictions.Set (No_Exception_Handlers) then
WBI ("pragma Restrictions (No_Exception_Handlers);");
end if;
WBI ("with System;");
if Initialize_Scalars_Used then
WBI ("with System.Scalar_Values;");
end if;
if Sec_Stack_Used and then Default_Sec_Stack_Size /= -1 then
WBI ("with System.Secondary_Stack;");
end if;
Resolve_Binder_Options;
if not Suppress_Standard_Library_On_Target then
if Hostparm.Java_VM then
WBI ("with System.Standard_Library;");
end if;
end if;
WBI ("package " & Ada_Main & " is");
WBI (" pragma Warnings (Off);");
if Bind_Main_Program then
if Command_Line_Args_On_Target
or not Configurable_Run_Time_On_Target
then
WBI ("");
WBI (" gnat_argc : Integer;");
WBI (" gnat_argv : System.Address;");
WBI (" gnat_envp : System.Address;");
if not Suppress_Standard_Library_On_Target then
WBI ("");
WBI (" pragma Import (C, gnat_argc);");
WBI (" pragma Import (C, gnat_argv);");
WBI (" pragma Import (C, gnat_envp);");
end if;
end if;
WBI ("");
if Configurable_Run_Time_Mode then
if Exit_Status_Supported_On_Target then
WBI (" gnat_exit_status : Integer := 0;");
end if;
else
WBI (" gnat_exit_status : Integer;");
WBI (" pragma Import (C, gnat_exit_status);");
end if;
end if;
if Bind_Main_Program then
WBI ("");
WBI (" GNAT_Version : constant String :=");
WBI (" ""GNAT Version: " &
Gnat_Version_String & """;");
WBI (" pragma Export (C, GNAT_Version, ""__gnat_version"");");
WBI ("");
Set_String (" Ada_Main_Program_Name : constant String := """);
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
Set_Main_Program_Name;
Set_String (""" & Ascii.NUL;");
Write_Statement_Buffer;
WBI
(" pragma Export (C, Ada_Main_Program_Name, " &
"""__gnat_ada_main_program_name"");");
end if;
WBI ("");
WBI (" procedure " & Ada_Final_Name.all & ";");
WBI (" pragma Export (C, " & Ada_Final_Name.all & ", """ &
Ada_Final_Name.all & """);");
WBI ("");
WBI (" procedure " & Ada_Init_Name.all & ";");
WBI (" pragma Export (C, " & Ada_Init_Name.all & ", """ &
Ada_Init_Name.all & """);");
if Bind_Main_Program then
WBI ("");
WBI (" procedure Break_Start;");
if Suppress_Standard_Library_On_Target then
WBI (" pragma Export (C, Break_Start, ""__gnat_break_start"");");
else
WBI (" pragma Import (C, Break_Start, ""__gnat_break_start"");");
end if;
WBI ("");
if Exit_Status_Supported_On_Target then
Set_String (" function ");
else
Set_String (" procedure ");
end if;
Set_String (Get_Main_Name);
if Command_Line_Args_On_Target then
Write_Statement_Buffer;
WBI (" (argc : Integer;");
WBI (" argv : System.Address;");
Set_String
(" envp : System.Address)");
if Exit_Status_Supported_On_Target then
Write_Statement_Buffer;
WBI (" return Integer;");
else
Write_Statement_Buffer (";");
end if;
else
if Exit_Status_Supported_On_Target then
Write_Statement_Buffer (" return Integer;");
else
Write_Statement_Buffer (";");
end if;
end if;
WBI (" pragma Export (C, " & Get_Main_Name & ", """ &
Get_Main_Name & """);");
end if;
Gen_Versions_Ada;
Gen_Elab_Order_Ada;
WBI ("");
WBI ("end " & Ada_Main & ";");
Close_Binder_Output;
Create_Binder_Output (Filename, 'b', Bfileb);
Get_Name_String (Bfiles);
Name_Buffer (Name_Len + 1 .. Name_Len + 3) := """);";
WBI ("pragma Source_File_Name (" &
Ada_Main &
", Spec_File_Name => """ &
Name_Buffer (1 .. Name_Len + 3));
Get_Name_String (Bfileb);
Name_Buffer (Name_Len + 1 .. Name_Len + 3) := """);";
WBI ("pragma Source_File_Name (" &
Ada_Main &
", Body_File_Name => """ &
Name_Buffer (1 .. Name_Len + 3));
WBI ("");
WBI ("package body " & Ada_Main & " is");
WBI (" pragma Warnings (Off);");
if not Cumulative_Restrictions.Set (No_Finalization) then
if not Hostparm.Java_VM then
WBI ("");
WBI (" procedure Do_Finalize;");
WBI
(" pragma Import (C, Do_Finalize, " &
"""system__standard_library__adafinal"");");
WBI ("");
end if;
end if;
Gen_Adainit_Ada;
Gen_Adafinal_Ada;
if Bind_Main_Program then
if Suppress_Standard_Library_On_Target then
WBI ("");
WBI (" procedure Break_Start is");
WBI (" begin");
WBI (" null;");
WBI (" end;");
end if;
Gen_Main_Ada;
end if;
Gen_Object_Files_Options;
WBI ("");
WBI ("end " & Ada_Main & ";");
Close_Binder_Output;
end Gen_Output_File_Ada;
procedure Gen_Output_File_C (Filename : String) is
Bfile : Name_Id;
begin
Create_Binder_Output (Filename, 'c', Bfile);
Resolve_Binder_Options;
WBI ("extern void __gnat_set_globals");
WBI (" (int, int, char, char, char, char,");
WBI (" const char *, const char *,");
WBI (" int, int, int, int, int);");
WBI ("extern void " & Ada_Final_Name.all & " (void);");
WBI ("extern void " & Ada_Init_Name.all & " (void);");
WBI ("extern void system__standard_library__adafinal (void);");
if not No_Main_Subprogram then
Set_String ("extern ");
if Exit_Status_Supported_On_Target then
Set_String ("int");
else
Set_String ("void");
end if;
Set_String (" main ");
if Command_Line_Args_On_Target then
Write_Statement_Buffer ("(int, char **, char **);");
else
Write_Statement_Buffer ("(void);");
end if;
if OpenVMS_On_Target then
WBI ("extern void __posix_exit (int);");
else
WBI ("extern void exit (int);");
end if;
WBI ("extern void __gnat_break_start (void);");
Set_String ("extern ");
if ALIs.Table (ALIs.First).Main_Program = Proc then
Set_String ("void ");
else
Set_String ("int ");
end if;
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
Set_Main_Program_Name;
Set_String (" (void);");
Write_Statement_Buffer;
end if;
if not Suppress_Standard_Library_On_Target then
WBI ("extern void __gnat_initialize (void *);");
WBI ("extern void __gnat_finalize (void);");
WBI ("extern void __gnat_install_handler (void);");
end if;
WBI ("");
Gen_Elab_Defs_C;
if not Suppress_Standard_Library_On_Target then
WBI ("extern int __gnat_handler_installed;");
WBI ("");
end if;
if Bind_Main_Program then
if not Configurable_Run_Time_On_Target then
WBI ("extern int gnat_argc;");
WBI ("extern char **gnat_argv;");
WBI ("extern char **gnat_envp;");
elsif not Command_Line_Args_On_Target then
null;
else
WBI ("int gnat_argc;");
WBI ("char **gnat_argv;");
WBI ("char **gnat_envp;");
end if;
if not Configurable_Run_Time_On_Target then
WBI ("extern int gnat_exit_status;");
elsif not Exit_Status_Supported_On_Target then
null;
else
WBI ("int gnat_exit_status = 0;");
end if;
WBI ("");
end if;
if Suppress_Standard_Library_On_Target then
WBI ("");
WBI ("void __gnat_break_start () {}");
end if;
if Bind_Main_Program then
WBI ("");
WBI ("char __gnat_version[] = ""GNAT Version: " &
Gnat_Version_String & """;");
Set_String ("char __gnat_ada_main_program_name[] = """);
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
Set_Main_Program_Name;
Set_String (""";");
Write_Statement_Buffer;
end if;
if not Cumulative_Restrictions.Set (No_Finalization) then
Gen_Adafinal_C;
end if;
Gen_Adainit_C;
if Bind_Main_Program then
Gen_Main_C;
end if;
Gen_Versions_C;
Gen_Elab_Order_C;
Gen_Object_Files_Options;
Close_Binder_Output;
end Gen_Output_File_C;
procedure Gen_Restrictions_String_1 is
begin
for R in All_Boolean_Restrictions loop
if Cumulative_Restrictions.Set (R) then
Set_Char ('r');
elsif Cumulative_Restrictions.Violated (R) then
Set_Char ('v');
else
Set_Char ('n');
end if;
end loop;
end Gen_Restrictions_String_1;
procedure Gen_Restrictions_String_2 is
begin
for RP in All_Parameter_Restrictions loop
if Cumulative_Restrictions.Set (RP) then
Set_Char ('r');
Set_Int (Int (Cumulative_Restrictions.Value (RP)));
else
Set_Char ('n');
end if;
if not Cumulative_Restrictions.Violated (RP)
or else RP not in Checked_Parameter_Restrictions
then
Set_Char ('n');
else
Set_Char ('v');
Set_Int (Int (Cumulative_Restrictions.Count (RP)));
if Cumulative_Restrictions.Unknown (RP) then
Set_Char ('+');
end if;
end if;
end loop;
end Gen_Restrictions_String_2;
procedure Gen_Versions_Ada is
Ubuf : String (1 .. 6) := "u00000";
procedure Increment_Ubuf;
procedure Increment_Ubuf is
begin
for J in reverse Ubuf'Range loop
Ubuf (J) := Character'Succ (Ubuf (J));
exit when Ubuf (J) <= '9';
Ubuf (J) := '0';
end loop;
end Increment_Ubuf;
begin
if Bind_For_Library then
return;
end if;
WBI ("");
WBI (" type Version_32 is mod 2 ** 32;");
for U in Units.First .. Units.Last loop
Increment_Ubuf;
WBI (" " & Ubuf & " : constant Version_32 := 16#" &
Units.Table (U).Version & "#;");
end loop;
WBI ("");
Ubuf := "u00000";
for U in Units.First .. Units.Last loop
Increment_Ubuf;
Set_String (" pragma Export (C, ");
Set_String (Ubuf);
Set_String (", """);
Get_Name_String (Units.Table (U).Uname);
for K in 1 .. Name_Len loop
if Name_Buffer (K) = '.' then
Set_Char ('_');
Set_Char ('_');
elsif Name_Buffer (K) = '%' then
exit;
else
Set_Char (Name_Buffer (K));
end if;
end loop;
if Name_Buffer (Name_Len) = 's' then
Set_Char ('S');
else
Set_Char ('B');
end if;
Set_String (""");");
Write_Statement_Buffer;
end loop;
end Gen_Versions_Ada;
procedure Gen_Versions_C is
begin
if Bind_For_Library then
return;
end if;
for U in Units.First .. Units.Last loop
Set_String ("unsigned ");
Get_Name_String (Units.Table (U).Uname);
for K in 1 .. Name_Len loop
if Name_Buffer (K) = '.' then
Set_String ("__");
elsif Name_Buffer (K) = '%' then
exit;
else
Set_Char (Name_Buffer (K));
end if;
end loop;
if Name_Buffer (Name_Len) = 's' then
Set_Char ('S');
else
Set_Char ('B');
end if;
Set_String (" = 0x");
Set_String (Units.Table (U).Version);
Set_Char (';');
Write_Statement_Buffer;
end loop;
end Gen_Versions_C;
function Get_Ada_Main_Name return String is
Suffix : constant String := "_00";
Name : String (1 .. Opt.Ada_Main_Name.all'Length + Suffix'Length) :=
Opt.Ada_Main_Name.all & Suffix;
Nlen : Natural;
begin
if Hostparm.Java_VM then
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
return "ada_" & Name_Buffer (1 .. Name_Len - 2);
end if;
for J in 0 .. 99 loop
if J = 0 then
Nlen := Name'Length - Suffix'Length;
else
Nlen := Name'Length;
Name (Name'Last) := Character'Val (J mod 10 + Character'Pos ('0'));
Name (Name'Last - 1) :=
Character'Val (J / 10 + Character'Pos ('0'));
end if;
for K in ALIs.First .. ALIs.Last loop
for L in ALIs.Table (K).First_Unit .. ALIs.Table (K).Last_Unit loop
Get_Name_String (Units.Table (L).Uname);
Name_Len := Name_Len - 2;
if Name_Buffer (1 .. Name_Len) = Name (1 .. Nlen) then
goto Continue;
end if;
end loop;
end loop;
return Name (1 .. Nlen);
<<Continue>>
null;
end loop;
return ("Qwertyuiop");
end Get_Ada_Main_Name;
function Get_Main_Name return String is
begin
if Bind_Alternate_Main_Name then
return Alternate_Main_Name.all;
elsif Use_Ada_Main_Program_Name_On_Target then
Get_Name_String (Units.Table (First_Unit_Entry).Uname);
for J in reverse 1 .. Name_Len - 2 loop
if J = 1 or else Name_Buffer (J - 1) = '.' then
return Name_Buffer (J .. Name_Len - 2);
end if;
end loop;
raise Program_Error;
else
return "main";
end if;
end Get_Main_Name;
function Lt_Linker_Option (Op1, Op2 : Natural) return Boolean is
begin
if Linker_Options.Table (Op1).Internal_File
/=
Linker_Options.Table (Op2).Internal_File
then
return Linker_Options.Table (Op1).Internal_File
<
Linker_Options.Table (Op2).Internal_File;
else
return Units.Table (Linker_Options.Table (Op1).Unit).Elab_Position
>
Units.Table (Linker_Options.Table (Op2).Unit).Elab_Position;
end if;
end Lt_Linker_Option;
procedure Move_Linker_Option (From : Natural; To : Natural) is
begin
Linker_Options.Table (To) := Linker_Options.Table (From);
end Move_Linker_Option;
procedure Public_Version_Warning is
Time : constant Int := Time_From_Last_Bind;
Hour : constant := 60;
Day : constant := 24 * Hour;
Never : constant := Integer'Last;
Large : constant := 20;
Period_Large : constant := Day;
Period_Small : constant := Never;
Nb_Unit : Int;
begin
Nb_Unit := 0;
for A in ALIs.First .. ALIs.Last loop
if not Is_Internal_File_Name (ALIs.Table (A).Sfile) then
Nb_Unit := Nb_Unit + 1;
end if;
end loop;
pragma Warnings (Off);
if Nb_Unit < Large and then Time <= Period_Small then
return;
elsif Time <= Period_Large then
return;
end if;
pragma Warnings (On);
Write_Eol;
Write_Str ("IMPORTANT NOTICE:");
Write_Eol;
Write_Str (" This version of GNAT is unsupported"
& " and comes with absolutely no warranty.");
Write_Eol;
Write_Str (" If you intend to evaluate or use GNAT for building "
& "commercial applications,");
Write_Eol;
Write_Str (" please consult http://www.gnat.com/ for information");
Write_Eol;
Write_Str (" on the GNAT Professional product line.");
Write_Eol;
Write_Eol;
end Public_Version_Warning;
procedure Resolve_Binder_Options is
begin
for E in Elab_Order.First .. Elab_Order.Last loop
Get_Name_String (Units.Table (Elab_Order.Table (E)).Uname);
if Name_Buffer (1 .. 19) = "system.os_interface" then
With_GNARL := True;
end if;
if Hostparm.OpenVMS and then Name_Buffer (1 .. 5) = "dec%s" then
With_DECGNAT := True;
end if;
end loop;
end Resolve_Binder_Options;
procedure Set_Char (C : Character) is
begin
Last := Last + 1;
Statement_Buffer (Last) := C;
end Set_Char;
procedure Set_EA_Last is
begin
if Cumulative_Restrictions.Set (No_Finalization) then
Set_Int (Num_Elab_Calls + 1);
else
Set_Int (Num_Elab_Calls + 2);
end if;
end Set_EA_Last;
procedure Set_Int (N : Int) is
begin
if N < 0 then
Set_String ("-");
Set_Int (-N);
else
if N > 9 then
Set_Int (N / 10);
end if;
Last := Last + 1;
Statement_Buffer (Last) :=
Character'Val (N mod 10 + Character'Pos ('0'));
end if;
end Set_Int;
procedure Set_IS_Pragma_Table is
begin
for F in ALIs.First .. ALIs.Last loop
for K in ALIs.Table (F).First_Interrupt_State ..
ALIs.Table (F).Last_Interrupt_State
loop
declare
Inum : constant Int :=
Interrupt_States.Table (K).Interrupt_Id;
Stat : constant Character :=
Interrupt_States.Table (K).Interrupt_State;
begin
while IS_Pragma_Settings.Last < Inum loop
IS_Pragma_Settings.Append ('n');
end loop;
IS_Pragma_Settings.Table (Inum) := Stat;
end;
end loop;
end loop;
end Set_IS_Pragma_Table;
procedure Set_Main_Program_Name is
begin
Set_String ("_ada_");
for J in 1 .. Name_Len - 2 loop
if Name_Buffer (J) = '.' then
Set_String ("__");
else
Set_Char (Name_Buffer (J));
end if;
end loop;
end Set_Main_Program_Name;
procedure Set_Name_Buffer is
begin
for J in 1 .. Name_Len loop
Set_Char (Name_Buffer (J));
end loop;
end Set_Name_Buffer;
procedure Set_String (S : String) is
begin
Statement_Buffer (Last + 1 .. Last + S'Length) := S;
Last := Last + S'Length;
end Set_String;
procedure Set_Unit_Name is
begin
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;
end Set_Unit_Name;
procedure Set_Unit_Number (U : Unit_Id) is
Num_Units : constant Nat := Nat (Units.Last) - Nat (Unit_Id'First);
Unum : constant Nat := Nat (U) - Nat (Unit_Id'First);
begin
if Num_Units >= 10 and then Unum < 10 then
Set_Char ('0');
end if;
if Num_Units >= 100 and then Unum < 100 then
Set_Char ('0');
end if;
Set_Int (Unum);
end Set_Unit_Number;
procedure Tab_To (N : Natural) is
begin
while Last < N loop
Set_Char (' ');
end loop;
end Tab_To;
procedure Write_Info_Ada_C (Ada : String; C : String; Common : String) is
begin
if Ada_Bind_File then
declare
S : String (1 .. Ada'Length + Common'Length);
begin
S (1 .. Ada'Length) := Ada;
S (Ada'Length + 1 .. S'Length) := Common;
WBI (S);
end;
else
declare
S : String (1 .. C'Length + Common'Length);
begin
S (1 .. C'Length) := C;
S (C'Length + 1 .. S'Length) := Common;
WBI (S);
end;
end if;
end Write_Info_Ada_C;
procedure Write_Statement_Buffer is
begin
WBI (Statement_Buffer (1 .. Last));
Last := 0;
end Write_Statement_Buffer;
procedure Write_Statement_Buffer (S : String) is
begin
Set_String (S);
Write_Statement_Buffer;
end Write_Statement_Buffer;
end Bindgen;