with ALI; use ALI;
with Binde; use Binde;
with Butil; use Butil;
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 Types; use Types;
with Sdefault; use Sdefault;
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;
procedure WBI (Info : String) renames Osint.B.Write_Binder_Info;
procedure Resolve_Binder_Options;
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_Scalar_Values;
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 Set_Char (C : Character);
procedure Set_Int (N : Int);
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;");
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 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 No_Run_Time_Specified 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 (" """);
for J in Restrictions'Range loop
Set_Char (Restrictions (J));
end loop;
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 (" Unreserve_All_Interrupts : Integer;");
WBI (" Exception_Tracebacks : Integer;");
WBI (" Zero_Cost_Exceptions : 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,");
Set_String (" Unreserve_All_Interrupts => ");
if Unreserve_All_Interrupts_Specified then
Set_String ("1");
else
Set_String ("0");
end if;
Set_String (",");
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;
WBI ("");
WBI (" if Handler_Installed = 0 then");
WBI (" Install_Handler;");
WBI (" end if;");
end if;
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 & " ()");
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 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 No_Run_Time_Specified 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 = """);
for J in Restrictions'Range loop
Set_Char (Restrictions (J));
end loop;
Set_String (""";");
Write_Statement_Buffer;
Gen_Exception_Table_C;
WBI (" __gnat_set_globals (");
Set_String (" ");
Set_Int (Main_Priority);
Set_Char (',');
Tab_To (15);
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 (20);
Set_String ("/* Time_Slice_Value */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (ALIs.Table (ALIs.First).WC_Encoding);
Set_String ("',");
Tab_To (20);
Set_String ("/* WC_Encoding */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (Locking_Policy_Specified);
Set_String ("',");
Tab_To (20);
Set_String ("/* Locking_Policy */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (Queuing_Policy_Specified);
Set_String ("',");
Tab_To (20);
Set_String ("/* Queuing_Policy */");
Write_Statement_Buffer;
Set_String (" '");
Set_Char (Task_Dispatching_Policy_Specified);
Set_String ("',");
Tab_To (20);
Set_String ("/* Tasking_Dispatching_Policy */");
Write_Statement_Buffer;
Set_String (" ");
Set_String ("restrictions");
Set_String (",");
Tab_To (20);
Set_String ("/* Restrictions */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (Boolean'Pos (Unreserve_All_Interrupts_Specified));
Set_String (",");
Tab_To (20);
Set_String ("/* Unreserve_All_Interrupts */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (Boolean'Pos (Exception_Tracebacks));
Set_String (",");
Tab_To (20);
Set_String ("/* Exception_Tracebacks */");
Write_Statement_Buffer;
Set_String (" ");
Set_Int (Boolean'Pos (Zero_Cost_Exceptions_Specified));
Set_String (");");
Tab_To (20);
Set_String ("/* Zero_Cost_Exceptions */");
Write_Statement_Buffer;
WBI (" if (__gnat_handler_installed == 0)");
WBI (" {");
WBI (" __gnat_install_handler ();");
WBI (" }");
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 U.No_Elab then
if 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;
else
Set_String (" if not E");
Set_Unit_Number (Unum_Spec);
Set_String (" then");
Write_Statement_Buffer;
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
Set_String (" E");
Set_Unit_Number (Unum_Spec);
Set_String (" := True;");
Write_Statement_Buffer;
end if;
WBI (" 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 U.No_Elab then
if 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;
else
Set_String (" if (");
Get_Name_String (U.Uname);
Set_Unit_Name;
Set_String ("_E == 0) {");
Write_Statement_Buffer;
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
Set_String (" ");
Set_Unit_Name;
Set_String ("_E++;");
Write_Statement_Buffer;
end if;
WBI (" }");
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 (" PARAMS ((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_Unit_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_Unit_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 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 => A1);");
Write_Statement_Buffer;
else
Write_Statement_Buffer;
for A in ALIs.First .. ALIs.Last loop
if 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);
Set_String (" ");
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;
end if;
WBI (" ");
Set_String (" EA : aliased constant array (1 .. ");
Set_Int (Num_Elab_Calls + 2);
Set_String (") of System.Address := (");
Write_Statement_Buffer;
WBI (" " & Ada_Init_Name.all & "'Code_Address,");
if Hostparm.Java_VM then
Set_String (" System.Standard_Library.Adafinal'Code_Address");
else
Set_String (" Do_Finalize'Code_Address");
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_Int (Num_Elab_Calls + 2);
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 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 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_Int (Num_Elab_Calls + 2);
Set_String ("]) () = {");
Write_Statement_Buffer;
WBI (" " & Ada_Init_Name.all & ",");
Set_String (" system__standard_library__adafinal");
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_Int (Num_Elab_Calls + 2);
Set_String (");");
Write_Statement_Buffer;
end Gen_Exception_Table_C;
procedure Gen_Main_Ada is
Target : constant String_Ptr := Target_Name;
VxWorks_Target : constant Boolean :=
Target (Target'Last - 7 .. Target'Last) = "vxworks/"
or else Target (Target'Last - 9 .. Target'Last) = "vxworksae/";
begin
WBI ("");
Set_String (" function ");
Set_String (Get_Main_Name);
if VxWorks_Target then
Set_String (" return Integer is");
Write_Statement_Buffer;
else
Write_Statement_Buffer;
WBI (" (argc : Integer;");
WBI (" argv : System.Address;");
WBI (" envp : System.Address)");
WBI (" return Integer");
WBI (" is");
end if;
if not No_Run_Time_Specified then
WBI (" procedure initialize;");
WBI (" pragma Import (C, initialize, ""__gnat_initialize"");");
WBI ("");
WBI (" procedure finalize;");
WBI (" pragma Import (C, finalize, ""__gnat_finalize"");");
WBI ("");
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 ("");
end if;
if Bind_Main_Program then
WBI
(" Ensure_Reference : System.Address := " &
"Ada_Main_Program_Name'Address;");
WBI ("");
end if;
WBI (" begin");
if VxWorks_Target then
WBI (" gnat_argc := 0;");
WBI (" gnat_argv := System.Null_Address;");
WBI (" gnat_envp := System.Null_Address;");
else
WBI (" gnat_argc := argc;");
WBI (" gnat_argv := argv;");
WBI (" gnat_envp := envp;");
WBI ("");
end if;
if not No_Run_Time_Specified then
WBI (" Initialize;");
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 No_Run_Time_Specified then
if Hostparm.Java_VM then
WBI (" System.Standard_Library.Adafinal;");
else
WBI (" Do_Finalize;");
end if;
end if;
if not No_Run_Time_Specified then
WBI (" Finalize;");
end if;
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;
WBI (" end;");
end Gen_Main_Ada;
procedure Gen_Main_C is
Target : constant String_Ptr := Target_Name;
VxWorks_Target : constant Boolean :=
Target (Target'Last - 7 .. Target'Last) = "vxworks/"
or else Target (Target'Last - 9 .. Target'Last) = "vxworksae/";
begin
Set_String ("int ");
Set_String (Get_Main_Name);
if VxWorks_Target then
Set_String (" ()");
else
Set_String (" (argc, argv, envp)");
end if;
Write_Statement_Buffer;
if VxWorks_Target then
WBI ("{");
WBI (" int result;");
WBI (" gnat_argc = 0;");
WBI (" gnat_argv = 0;");
WBI (" gnat_envp = 0;");
else
WBI (" int argc;");
WBI (" char **argv;");
WBI (" char **envp;");
WBI ("{");
if Bind_Main_Program then
WBI (" char *ensure_reference = __gnat_ada_main_program_name;");
WBI ("");
end if;
if ALIs.Table (ALIs.First).Main_Program = Func then
WBI (" int result;");
end if;
WBI (" gnat_argc = argc;");
WBI (" gnat_argv = argv;");
WBI (" gnat_envp = envp;");
WBI (" ");
end if;
if not No_Run_Time_Specified then
WBI
(" __gnat_initialize ();");
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 No_Run_Time_Specified then
WBI (" ");
WBI (" system__standard_library__adafinal ();");
end if;
if not No_Run_Time_Specified then
WBI (" __gnat_finalize ();");
end if;
if ALIs.Table (ALIs.First).Main_Program = Func then
if Hostparm.OpenVMS then
WBI (" __posix_exit (result);");
else
WBI (" exit (result);");
end if;
else
if Hostparm.OpenVMS then
WBI (" __posix_exit (gnat_exit_status);");
else
WBI (" exit (gnat_exit_status);");
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 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
Opt.Shared_Libgnat := False;
end if;
end if;
end if;
end loop;
if not No_Run_Time_Specified then
for J in 1 .. Nb_Dir_In_Obj_Search_Path loop
declare
Dir : 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;
end if;
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 (No_Run_Time_Specified or else 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;
Add_Str_To_Name_Buffer ("-lgnarl");
Write_Linker_Option;
end if;
Name_Len := 0;
Add_Str_To_Name_Buffer ("-lgnat");
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
begin
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 Ada_Bind_File then
Gen_Output_File_Ada (Filename);
else
Gen_Output_File_C (Filename);
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;
Target : constant String_Ptr := Target_Name;
VxWorks_Target : constant Boolean :=
Target (Target'Last - 7 .. Target'Last) = "vxworks/"
or else Target (Target'Last - 9 .. Target'Last) = "vxworksae/";
begin
Create_Binder_Output (Filename, 's', Bfiles);
if No_Run_Time_Specified then
WBI ("pragma No_Run_Time;");
end if;
WBI ("with System;");
if Initialize_Scalars_Used then
WBI ("with System.Scalar_Values;");
end if;
Resolve_Binder_Options;
if not No_Run_Time_Specified then
if Hostparm.Java_VM then
WBI ("with System.Standard_Library;");
end if;
end if;
WBI ("package " & Ada_Main & " is");
if Bind_Main_Program then
WBI ("");
WBI (" gnat_argc : Integer;");
WBI (" gnat_argv : System.Address;");
WBI (" gnat_envp : System.Address;");
if not No_Run_Time_Specified then
WBI ("");
WBI (" pragma Import (C, gnat_argc);");
WBI (" pragma Import (C, gnat_argv);");
WBI (" pragma Import (C, gnat_envp);");
end if;
WBI ("");
if No_Run_Time_Specified then
WBI (" gnat_exit_status : Integer := 0;");
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;
if not No_Run_Time_Specified then
WBI ("");
WBI (" procedure " & Ada_Final_Name.all & ";");
WBI (" pragma Export (C, " & Ada_Final_Name.all & ", """ &
Ada_Final_Name.all & """);");
end if;
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 No_Run_Time_Specified then
WBI (" pragma Export (C, Break_Start, ""__gnat_break_start"");");
else
WBI (" pragma Import (C, Break_Start, ""__gnat_break_start"");");
end if;
WBI ("");
WBI (" function " & Get_Main_Name);
if not VxWorks_Target then
WBI (" (argc : Integer;");
WBI (" argv : System.Address;");
WBI (" envp : System.Address)");
end if;
WBI (" return Integer;");
WBI (" pragma Export (C, " & Get_Main_Name & ", """ &
Get_Main_Name & """);");
end if;
if Initialize_Scalars_Used then
Gen_Scalar_Values;
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");
if not No_Run_Time_Specified 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;
if not No_Run_Time_Specified then
Gen_Adafinal_Ada;
end if;
if Bind_Main_Program then
if No_Run_Time_Specified 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 ("#ifdef __STDC__");
WBI ("#define PARAMS(paramlist) paramlist");
WBI ("#else");
WBI ("#define PARAMS(paramlist) ()");
WBI ("#endif");
WBI ("");
WBI ("extern void __gnat_set_globals ");
WBI (" PARAMS ((int, int, int, int, int, int, const char *,");
WBI (" int, int, int));");
WBI ("extern void " & Ada_Final_Name.all & " PARAMS ((void));");
WBI ("extern void " & Ada_Init_Name.all & " PARAMS ((void));");
WBI ("extern void system__standard_library__adafinal PARAMS ((void));");
if not No_Main_Subprogram then
WBI ("extern int main PARAMS ((int, char **, char **));");
if Hostparm.OpenVMS then
WBI ("extern void __posix_exit PARAMS ((int));");
else
WBI ("extern void exit PARAMS ((int));");
end if;
WBI ("extern void __gnat_break_start PARAMS ((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 (" PARAMS ((void));");
Write_Statement_Buffer;
end if;
if not No_Run_Time_Specified then
WBI ("extern void __gnat_initialize PARAMS ((void));");
WBI ("extern void __gnat_finalize PARAMS ((void));");
WBI ("extern void __gnat_install_handler PARAMS ((void));");
end if;
WBI ("");
Gen_Elab_Defs_C;
if not No_Run_Time_Specified then
WBI ("extern int __gnat_handler_installed;");
WBI ("");
end if;
if Bind_Main_Program then
if not No_Run_Time_Specified then
WBI ("extern int gnat_argc;");
WBI ("extern char **gnat_argv;");
WBI ("extern char **gnat_envp;");
WBI ("extern int gnat_exit_status;");
else
WBI ("int gnat_argc;");
WBI ("char **gnat_argv;");
WBI ("char **gnat_envp;");
WBI ("int gnat_exit_status = 0;");
end if;
WBI ("");
end if;
if No_Run_Time_Specified 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 No_Run_Time_Specified then
Gen_Adafinal_C;
end if;
Gen_Adainit_C;
if Bind_Main_Program then
Gen_Main_C;
end if;
if Initialize_Scalars_Used then
Gen_Scalar_Values;
end if;
Gen_Versions_C;
Gen_Elab_Order_C;
Gen_Object_Files_Options;
Close_Binder_Output;
end Gen_Output_File_C;
procedure Gen_Scalar_Values is
IS_Is1 : String (1 .. 2);
IS_Is2 : String (1 .. 4);
IS_Is4 : String (1 .. 8);
IS_Is8 : String (1 .. 16);
IS_Iu1 : String (1 .. 2);
IS_Iu2 : String (1 .. 4);
IS_Iu4 : String (1 .. 8);
IS_Iu8 : String (1 .. 16);
IS_Isf : String (1 .. 8);
IS_Ifl : String (1 .. 8);
IS_Ilf : String (1 .. 16);
IS_Ill : String (1 .. 24);
begin
if Opt.Initialize_Scalars_Mode = 'I' then
IS_Is1 := "80";
IS_Is2 := "8000";
IS_Is4 := "80000000";
IS_Is8 := "8000000000000000";
IS_Iu1 := "FF";
IS_Iu2 := "FFFF";
IS_Iu4 := "FFFFFFFF";
IS_Iu8 := "FFFFFFFFFFFFFFFF";
IS_Isf := IS_Iu4;
IS_Ifl := IS_Iu4;
IS_Ilf := IS_Iu8;
IS_Ill := "00000000000000C0FFFF0000";
elsif Opt.Initialize_Scalars_Mode = 'L' then
IS_Is1 := "80";
IS_Is2 := "8000";
IS_Is4 := "80000000";
IS_Is8 := "8000000000000000";
IS_Iu1 := "00";
IS_Iu2 := "0000";
IS_Iu4 := "00000000";
IS_Iu8 := "0000000000000000";
IS_Isf := "FF800000";
IS_Ifl := IS_Isf;
IS_Ilf := "FFF0000000000000";
IS_Ill := "0000000000000080FFFF0000";
elsif Opt.Initialize_Scalars_Mode = 'H' then
IS_Is1 := "7F";
IS_Is2 := "7FFF";
IS_Is4 := "7FFFFFFF";
IS_Is8 := "7FFFFFFFFFFFFFFF";
IS_Iu1 := "FF";
IS_Iu2 := "FFFF";
IS_Iu4 := "FFFFFFFF";
IS_Iu8 := "FFFFFFFFFFFFFFFF";
IS_Isf := "7F800000";
IS_Ifl := IS_Isf;
IS_Ilf := "7FF0000000000000";
IS_Ill := "0000000000000080FF7F0000";
else pragma Assert (Opt.Initialize_Scalars_Mode = 'X');
IS_Is1 (1 .. 2) := Opt.Initialize_Scalars_Val;
IS_Is2 (1 .. 2) := Opt.Initialize_Scalars_Val;
IS_Is2 (3 .. 4) := Opt.Initialize_Scalars_Val;
for J in 1 .. 4 loop
IS_Is4 (2 * J - 1 .. 2 * J) := Opt.Initialize_Scalars_Val;
end loop;
for J in 1 .. 8 loop
IS_Is8 (2 * J - 1 .. 2 * J) := Opt.Initialize_Scalars_Val;
end loop;
IS_Iu1 := IS_Is1;
IS_Iu2 := IS_Is2;
IS_Iu4 := IS_Is4;
IS_Iu8 := IS_Is8;
IS_Isf := IS_Is4;
IS_Ifl := IS_Is4;
IS_Ilf := IS_Is8;
for J in 1 .. 12 loop
IS_Ill (2 * J - 1 .. 2 * J) := Opt.Initialize_Scalars_Val;
end loop;
end if;
if Ada_Bind_File then
WBI ("");
Set_String (" IS_Is1 : constant System.Scalar_Values.Byte1 := 16#");
Set_String (IS_Is1);
Write_Statement_Buffer ("#;");
Set_String (" IS_Is2 : constant System.Scalar_Values.Byte2 := 16#");
Set_String (IS_Is2);
Write_Statement_Buffer ("#;");
Set_String (" IS_Is4 : constant System.Scalar_Values.Byte4 := 16#");
Set_String (IS_Is4);
Write_Statement_Buffer ("#;");
Set_String (" IS_Is8 : constant System.Scalar_Values.Byte8 := 16#");
Set_String (IS_Is8);
Write_Statement_Buffer ("#;");
Set_String (" IS_Iu1 : constant System.Scalar_Values.Byte1 := 16#");
Set_String (IS_Iu1);
Write_Statement_Buffer ("#;");
Set_String (" IS_Iu2 : constant System.Scalar_Values.Byte2 := 16#");
Set_String (IS_Iu2);
Write_Statement_Buffer ("#;");
Set_String (" IS_Iu4 : constant System.Scalar_Values.Byte4 := 16#");
Set_String (IS_Iu4);
Write_Statement_Buffer ("#;");
Set_String (" IS_Iu8 : constant System.Scalar_Values.Byte8 := 16#");
Set_String (IS_Iu8);
Write_Statement_Buffer ("#;");
Set_String (" IS_Isf : constant System.Scalar_Values.Byte4 := 16#");
Set_String (IS_Isf);
Write_Statement_Buffer ("#;");
Set_String (" IS_Ifl : constant System.Scalar_Values.Byte4 := 16#");
Set_String (IS_Ifl);
Write_Statement_Buffer ("#;");
Set_String (" IS_Ilf : constant System.Scalar_Values.Byte8 := 16#");
Set_String (IS_Ilf);
Write_Statement_Buffer ("#;");
WBI (" IS_Ill : constant array (1 .. 12) of");
WBI (" System.Scalar_Values.Byte1 := (");
Set_String (" ");
for J in 1 .. 6 loop
Set_String (" 16#");
Set_Char (IS_Ill (2 * J - 1));
Set_Char (IS_Ill (2 * J));
Set_String ("#,");
end loop;
Write_Statement_Buffer;
Set_String (" ");
for J in 7 .. 12 loop
Set_String (" 16#");
Set_Char (IS_Ill (2 * J - 1));
Set_Char (IS_Ill (2 * J));
if J = 12 then
Set_String ("#);");
else
Set_String ("#,");
end if;
end loop;
Write_Statement_Buffer;
WBI ("");
WBI (" pragma Export (Ada, IS_Is1, ""__gnat_Is1"");");
WBI (" pragma Export (Ada, IS_Is2, ""__gnat_Is2"");");
WBI (" pragma Export (Ada, IS_Is4, ""__gnat_Is4"");");
WBI (" pragma Export (Ada, IS_Is8, ""__gnat_Is8"");");
WBI (" pragma Export (Ada, IS_Iu1, ""__gnat_Iu1"");");
WBI (" pragma Export (Ada, IS_Iu2, ""__gnat_Iu2"");");
WBI (" pragma Export (Ada, IS_Iu4, ""__gnat_Iu4"");");
WBI (" pragma Export (Ada, IS_Iu8, ""__gnat_Iu8"");");
WBI (" pragma Export (Ada, IS_Isf, ""__gnat_Isf"");");
WBI (" pragma Export (Ada, IS_Ifl, ""__gnat_Ifl"");");
WBI (" pragma Export (Ada, IS_Ilf, ""__gnat_Ilf"");");
WBI (" pragma Export (Ada, IS_Ill, ""__gnat_Ill"");");
else
WBI ("");
Set_String ("unsigned char __gnat_Is1 = 0x");
Set_String (IS_Is1);
Write_Statement_Buffer (";");
Set_String ("unsigned short __gnat_Is2 = 0x");
Set_String (IS_Is2);
Write_Statement_Buffer (";");
Set_String ("unsigned __gnat_Is4 = 0x");
Set_String (IS_Is4);
Write_Statement_Buffer (";");
Set_String ("long long unsigned __gnat_Is8 = 0x");
Set_String (IS_Is8);
Write_Statement_Buffer ("LL;");
Set_String ("unsigned char __gnat_Iu1 = 0x");
Set_String (IS_Is1);
Write_Statement_Buffer (";");
Set_String ("unsigned short __gnat_Iu2 = 0x");
Set_String (IS_Is2);
Write_Statement_Buffer (";");
Set_String ("unsigned __gnat_Iu4 = 0x");
Set_String (IS_Is4);
Write_Statement_Buffer (";");
Set_String ("long long unsigned __gnat_Iu8 = 0x");
Set_String (IS_Is8);
Write_Statement_Buffer ("LL;");
Set_String ("unsigned __gnat_Isf = 0x");
Set_String (IS_Isf);
Write_Statement_Buffer (";");
Set_String ("unsigned __gnat_Ifl = 0x");
Set_String (IS_Ifl);
Write_Statement_Buffer (";");
Set_String ("long long unsigned __gnat_Ilf = 0x");
Set_String (IS_Ilf);
Write_Statement_Buffer ("LL;");
Set_String ("unsigned char __gnat_Ill[12] = {");
for J in 1 .. 6 loop
Set_String ("0x");
Set_Char (IS_Ill (2 * J - 1));
Set_Char (IS_Ill (2 * J));
Set_String (", ");
end loop;
Write_Statement_Buffer;
Set_String (" ");
for J in 7 .. 12 loop
Set_String ("0x");
Set_Char (IS_Ill (2 * J - 1));
Set_Char (IS_Ill (2 * J));
if J = 12 then
Set_String ("};");
else
Set_String (", ");
end if;
end loop;
Write_Statement_Buffer;
end if;
end Gen_Scalar_Values;
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
Target : constant String_Ptr := Target_Name;
VxWorks_Target : constant Boolean :=
Target (Target'Last - 7 .. Target'Last) = "vxworks/"
or else Target (Target'Last - 9 .. Target'Last) = "vxworksae/";
begin
if Bind_Alternate_Main_Name then
return Alternate_Main_Name.all;
elsif VxWorks_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 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 .. 3) = "dec" 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_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_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.Table'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;