⟦0fe625e2c⟧

TextFile

with Compilation_Interface;
with Debug_Tools;
with Directory;
with Extensions_Support;
with Io;
with Import_Interface;
with Library_Interface;
with Log;
with Object_Subclass;
with Profile;
with Rci_Switch_Implementation;
with Remote_Command_Interface;
with String_Utilities;

package body Library_Extensions is
    package Ci renames Compilation_Interface;
    package Es renames Extensions_Support;
    package Naming renames Directory.Naming;  
    package Rsi renames Rci_Switch_Implementation;


    Default_Host_List_File : constant String := "alib_list";
    Default_Target_List_File : constant String := "alib.list";
    Default_Program_Library : constant String := "working";

    function Program_Library_Name
                (Stripped_Program_Library : String) return String is
    begin
        if Stripped_Program_Library'Length = 0 then
            return Default_Program_Library;
        else
            return Stripped_Program_Library;
        end if;
    end Program_Library_Name;

    procedure Set_Status (Status : in out Simple_Status.Condition;
                          Error_Type : String := "Remote_Operation_Error";
                          Message : String;
                          Severity : Simple_Status.Condition_Class :=
                             Simple_Status.Problem) is
    begin
        Simple_Status.Create_Condition (Status => Status,
                                        Error_Type => Error_Type,
                                        Message => Message,
                                        Severity => Severity);
    end Set_Status;

    procedure Unhandled_Exception
                 (Status : in out Simple_Status.Condition; Routine : String) is
    begin
        Set_Status (Status => Status,  
                    Error_Type => "Unhandled Exception",
                    Message => Debug_Tools.Get_Exception_Name &
                                  " caught in " & Routine & ".");
    end Unhandled_Exception;

    procedure Set_Context (Old_Context : in out Naming.Context;
                           View : String;
                           Status : in out Simple_Status.Condition) is
        Error_Status : Directory.Error_Status;
        New_Context : Naming.Context;
        Dir_Object : Directory.Object;  
        Name_Status : Naming.Name_Status;
    begin  
        Naming.Resolve (Name => View,
                        The_Object => Dir_Object,
                        Status => Name_Status);

        if not Naming."=" (Name_Status, Naming.Successful) then
            Set_Status (Status => Status,
                        Message => "Unable to resolve" & View &
                                      ".  " & "Name Status = " &
                                      Naming.Name_Status'Image (Name_Status));
            return;

        end if;

        -- Get the current naming context for Promote_Unit.
        Naming.Get_Context (The_Context => New_Context,
                            The_Unit => Dir_Object,
                            Status => Error_Status);

        if not Directory."=" (Error_Status, Directory.Successful) then
            Set_Status (Status => Status,
                        Message => "Unable to get default context for " &
                                      View & ".  Error Status = " &
                                      Directory.Error_Status'Image
                                         (Error_Status));
            return;

        end if;

        -- Get the job's default naming context.
        Old_Context := Naming.Default_Context;
        -- We must restore this context (after any errors) before we return.

        -- Change the job's default context to the unit's current context.
        Naming.Set_Default_Context (The_Context => New_Context,  
                                    Status => Error_Status);

        if not Directory."=" (Error_Status, Directory.Successful) then
            Set_Status (Status => Status,
                        Message => "Unable to default context to " &
                                      View & ".  Error Status = " &
                                      Directory.Error_Status'Image
                                         (Error_Status));
            return;

        end if;

    end Set_Context;

    procedure Reset_Context (Old_Context : Directory.Naming.Context) is
        Error_Status : Directory.Error_Status;
    begin
        -- Restore the job's original naming context.
        Naming.Set_Default_Context (The_Context => Old_Context,  
                                    Status => Error_Status);
    end Reset_Context;


    procedure Download_File (Host_File_Name : String;
                             Target_File_Name : String;
                             Remote_Directory : String;
                             Remote_Machine : String;
                             Status : in out Simple_Status.Condition) is
        Remote_Connection : Remote_Command_Interface.Context;
        Local_Status : Simple_Status.Condition;
        Fully_Qualified_Target_Name : constant String :=
           Remote_Directory & "/" & Target_File_Name;
        View_Obj : Directory.Object := Es.Get_View (Host_File_Name);
        Trace_On : constant Boolean := Rsi.Trace_On (View_Obj);
    begin
        Log.Put_Line (Message => "Transferring " & Host_File_Name & " to " &
                                    Fully_Qualified_Target_Name & ".",
                      Kind => Profile.Debug_Msg);

        Remote_Command_Interface.Acquire
           (Remote_Connection => Remote_Connection,
            Target_Key => "Rs6000_Aix_Ibm",
            Remote_Machine => Remote_Machine,
            Trace_Command => Trace_On,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to acquire connection to " &
                                      Remote_Machine);

            return;
        end if;

        Remote_Command_Interface.Put
           (Host_File_Name => Host_File_Name,
            Target_File_Name => Fully_Qualified_Target_Name,
            Remote_Connection => Remote_Connection,
            Status => Status,
            Trace_Command => False);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to transfer " & Host_File_Name &
                                      " to " & Target_File_Name &
                                      " on " & Remote_Machine);

        end if;

        -- Remote_Command_Interface.Release
        -- (Remote_Connection => Remote_Connection, Status => Local_Status);

    end Download_File;

    procedure Upload_File (Host_File_Name : String;
                           Target_File_Name : String;
                           Remote_Directory : String;
                           Remote_Machine : String;
                           Status : in out Simple_Status.Condition) is
        Remote_Connection : Remote_Command_Interface.Context;
        Local_Status : Simple_Status.Condition;
        Fully_Qualified_Target_Name : constant String :=
           Remote_Directory & "/" & Target_File_Name;
        View_Obj : Directory.Object := Es.Get_View (Host_File_Name);
        Trace_On : constant Boolean := Rsi.Trace_On (View_Obj);
    begin
        Log.Put_Line (Message => "Uploading " & Host_File_Name & " from " &
                                    Fully_Qualified_Target_Name & ".",
                      Kind => Profile.Debug_Msg);

        Remote_Command_Interface.Acquire
           (Remote_Connection => Remote_Connection,
            Target_Key => "Rs6000_Aix_Ibm",
            Remote_Machine => Remote_Machine,
            Trace_Command => Trace_On,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to acquire connection to " &
                                      Remote_Machine);

            return;
        end if;


        Remote_Command_Interface.Get
           (Host_File_Name => Host_File_Name,
            Target_File_Name => Fully_Qualified_Target_Name,
            Remote_Connection => Remote_Connection,
            Status => Status,
            Trace_Command => False);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to upload " & Host_File_Name &
                                      " to " & Target_File_Name &
                                      " from " & Remote_Machine);

        end if;

        -- Remote_Command_Interface.Release
        -- (Remote_Connection => Remote_Connection, Status => Local_Status);

    end Upload_File;


    procedure Build_List_File (Host_View : String;
                               Remote_Machine : String;
                               Remote_Directory : String;
                               Remote_Program_Library : String;
                               List_File_Name : String;
                               Status : in out Simple_Status.Condition) is
        Dir_Object : Directory.Object;  
        Name_Status : Naming.Name_Status;
        Local_Status : Simple_Status.Condition;
        List_File : Io.File_Type;

    begin
        Log.Put_Line (Message =>
                         "Building list file for Host_View = " &
                            Host_View & ", and target library = " &
                            Remote_Directory & "/" & Remote_Program_Library,
                      Kind => Profile.Debug_Msg);

        if Host_View = "" then
            Set_Status
               (Status => Status,
                Message => "A null Host_View was supplied to " &
                              "Remote_Library_Integration.Build_List_File");
            return;
        end if;

        Naming.Resolve (Name => List_File_Name,
                        The_Object => Dir_Object,
                        Status => Name_Status);

        case Name_Status is
            when Naming.Successful =>
                Io.Open (File => List_File, Name => List_File_Name);
            when Naming.Undefined =>
                Io.Create (File => List_File, Name => List_File_Name);
                -- do I need to open it here
            when others =>
                Set_Status (Status => Status,
                            Message => "Unable to resolve " &
                                          List_File_Name & ". Status =" &
                                          Naming.Name_Status'Image
                                             (Name_Status));
                return;
        end case;

        Io.Put_Line (File => List_File, Item => "-- Host_View => " & Host_View);
        if Remote_Program_Library = "" then  
            Io.Put_Line (File => List_File, Item => Default_Program_Library);
        else
            Io.Put_Line (File => List_File, Item => Remote_Program_Library);
        end if;
        -- Add Imports Later !
        Io.Put_Line (List_File, "/usr/lpp/ada/lib/libada");
        Io.Close (List_File);

    exception
        when others =>
            Unhandled_Exception (Status, "Build_List_File");
            begin
                Io.Close (List_File);
            exception
                when others =>
                    null;
            end;

    end Build_List_File;


    procedure Create_Remote_Directory
                 (Remote_Directory : String;
                  Remote_Machine : String;
                  Trace_On : Boolean;
                  Status : in out Simple_Status.Condition) is
        Remote_Connection : Remote_Command_Interface.Context;

        Local_Status : Simple_Status.Condition;  
        Create_Dir_Command : constant String := "mkdir " & Remote_Directory;

    begin
        Log.Put_Line (Message =>
                         "Creating remote directory = " & Remote_Directory,
                      Kind => Profile.Debug_Msg);

        Remote_Command_Interface.Acquire
           (Remote_Connection => Remote_Connection,
            Target_Key => "Rs6000_Aix_Ibm",
            Remote_Machine => Remote_Machine,
            Trace_Command => Trace_On,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to acquire connection to " &
                                      Remote_Machine);

            return;
        end if;

        Remote_Command_Interface.Execute_Command
           (Command_Line => Create_Dir_Command,
            Remote_Connection => Remote_Connection,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to create the remote directory, " &
                                      Remote_Directory & ".");

        end if;

        -- Remote_Command_Interface.Release
        --   (Remote_Connection => Remote_Connection, Status => Local_Status);
    exception
        when others =>
            Unhandled_Exception (Status, "Create_Remote_Directory");
            -- begin
            --     Remote_Command_Interface.Release
            --        (Remote_Connection => Remote_Connection,
            --         Status => Local_Status);
            -- exception
            --     when others =>
            --         null;
            -- end;
    end Create_Remote_Directory;

    procedure Create_Program_Library
                 (Host_View : String;
                  Remote_Directory : String;
                  Remote_Program_Library : String;
                  Remote_Machine : String;  
                  Status : in out Simple_Status.Condition) is

        Remote_Connection : Remote_Command_Interface.Context;

        Local_Status : Simple_Status.Condition;  
        Build_Library_Command : constant String :=
           "PATH=$PATH:/usr/bin/ada ; export PATH ; /usr/bin/ada/alibinit -p 100000 -L " &
              Remote_Directory & "/alib.list";
        List_File_Name : constant String :=
           Host_View & ".State.Tool_State." & Default_Host_List_File;
        View_Obj : Directory.Object := Es.Get_View (Host_View);
        Trace_On : constant Boolean := Rsi.Trace_On (View_Obj);
    begin
        Log.Put_Line (Message => "Creating remote program library = " &
                                    Remote_Program_Library,
                      Kind => Profile.Debug_Msg);

        Build_List_File (Host_View => Host_View,
                         Remote_Directory => Remote_Directory,
                         Remote_Machine => Remote_Machine,
                         Remote_Program_Library => Remote_Program_Library,
                         List_File_Name => List_File_Name,
                         Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status
               (Status => Status,
                Message => "Unable to create the remote library list file.");
            return;
        else
            Download_File (Host_File_Name => List_File_Name,
                           Target_File_Name => Default_Target_List_File,
                           Remote_Directory => Remote_Directory,
                           Remote_Machine => Remote_Machine,
                           Status => Status);
        end if;


        Remote_Command_Interface.Acquire
           (Remote_Connection => Remote_Connection,
            Target_Key => "Rs6000_Aix_Ibm",
            Set_Directory => "cd " & Remote_Directory,
            Remote_Machine => Remote_Machine,  
            Trace_Command => Trace_On,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to acquire connection to " &
                                      Remote_Machine);

            return;
        end if;

        Remote_Command_Interface.Execute_Command
           (Command_Line => Build_Library_Command,
            Remote_Connection => Remote_Connection,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status
               (Status => Status,
                Message => "Unable to create the remote program library, " &
                              Remote_Program_Library & ".");

        end if;

        -- Remote_Command_Interface.Release
        --   (Remote_Connection => Remote_Connection, Status => Local_Status);
    exception
        when others =>
            Unhandled_Exception (Status, "Create_Program_Library");

            --         begin
            --             Remote_Command_Interface.Release
            --                (Remote_Connection => Remote_Connection,
            --                 Status => Local_Status);
            --         exception
            --             when others =>
            --                 null;
            --         end;
    end Create_Program_Library;

    procedure Destroy_Remote_Library
                 (Remote_Directory : String;
                  Remote_Machine : String;
                  Trace_On : Boolean;
                  Status : in out Simple_Status.Condition) is

        Remote_Connection : Remote_Command_Interface.Context;

        Local_Status : Simple_Status.Condition;  
        Destroy_Library_Command : constant String :=
           "rm -r " & Remote_Directory;
    begin
        Log.Put_Line (Message =>
                         "Destroying Remote Directory = " & Remote_Directory,
                      Kind => Profile.Debug_Msg);


        Remote_Command_Interface.Acquire
           (Remote_Connection => Remote_Connection,
            Target_Key => "Rs6000_Aix_Ibm",
            Set_Directory => "cd " & Remote_Directory & "/..",
            Remote_Machine => Remote_Machine,  
            Trace_Command => Trace_On,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to acquire connection to " &
                                      Remote_Machine);

            return;
        end if;

        Remote_Command_Interface.Execute_Command
           (Command_Line => Destroy_Library_Command,
            Remote_Connection => Remote_Connection,
            Status => Status);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status
               (Status => Status,
                Message => "Unable to destroy the remote directory/library, " &
                              Remote_Directory & ".");

        end if;

        -- Remote_Command_Interface.Release
        --   (Remote_Connection => Remote_Connection, Status => Local_Status);
    exception
        when others =>
            Unhandled_Exception (Status, "Destroy_Remote_Library");

            -- begin
            --     Remote_Command_Interface.Release
            --       (Remote_Connection => Remote_Connection,
            --         Status => Local_Status);
            -- exception
            --     when others =>
            --         null;
            -- end;
    end Destroy_Remote_Library;

    procedure File_Exists (Remote_Filename : String;
                           Remote_Machine : String;
                           Status : in out Simple_Status.Condition;
                           Trace_On : Boolean;
                           Exists : out Boolean) is
        Remote_Connection : Remote_Command_Interface.Context;
    begin
        Exists := False;
        Remote_Command_Interface.Acquire
           (Remote_Connection => Remote_Connection,
            Status => Status,  
            Trace_Command => Trace_On,
            Target_Key => "Rs6000_Aix_Ibm",
            Remote_Machine => Remote_Machine);

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => Simple_Status.Message (Status),
                          Kind => Profile.Negative_Msg);

            Set_Status (Status => Status,
                        Message => "Unable to acquire connection to " &
                                      Remote_Machine);

            return;
        end if;

        Remote_Command_Interface.File_Exists
           (The_File => Remote_Filename,
            Remote_Connection => Remote_Connection,
            Status => Status,
            Exists => Exists);

    exception
        when others =>
            Unhandled_Exception (Status, "File_Exists");

    end File_Exists;

    procedure Directory_Exists (Remote_Machine : String;
                                Remote_Directory : String;
                                Status : in out Simple_Status.Condition;
                                Trace_On : Boolean;
                                Exists : out Boolean) is
    begin
        File_Exists (Remote_Filename => Remote_Directory,
                     Remote_Machine => Remote_Machine,
                     Status => Status,  
                     Trace_On => Trace_On,
                     Exists => Exists);

    exception
        when others =>
            Unhandled_Exception (Status, "Directory_Exists");
    end Directory_Exists;

    procedure Refresh_Imports (Host_View : String;
                               Trace_On : Boolean;
                               Status : in out Simple_Status.Condition) is
        Dir_Object : Directory.Object;  
        Name_Status : Naming.Name_Status;
        Local_Status : Simple_Status.Condition;
        List_File : Io.File_Type;
        Imports : Import_Interface.Import_Iterator;
        Old_Context : Directory.Naming.Context;

        Machine_Result : constant Library_Interface.String_Result :=
           Library_Interface.Remote_Machine (View => Host_View);
        Directory_Result : constant Library_Interface.String_Result :=
           Library_Interface.Remote_Directory (View => Host_View);
        Library_Result : constant Library_Interface.String_Result :=
           Library_Interface.Remote_Library (View => Host_View);

        Remote_Machine : constant String :=
           Machine_Result.Result (1 .. Machine_Result.Size);
        Remote_Directory : constant String :=
           Directory_Result.Result (1 .. Directory_Result.Size);
        Remote_Library : constant String :=
           Library_Result.Result (1 .. Library_Result.Size);
        Host_List_File : constant String :=
           Host_View & ".State.Tool_State." & Default_Host_List_File;
        Dir_Exists : Boolean;

    begin
        Log.Put_Line (Message => "Refreshing imports for target library = " &
                                    Remote_Directory & "/" & Remote_Library,
                      Kind => Profile.Debug_Msg);

        if Host_View = "" then
            Set_Status
               (Status => Status,
                Message => "A null Host_View was supplied to " &
                              "Remote_Library_Integration.Refresh_Imports");
            return;
        end if;

        Set_Context (Old_Context => Old_Context,
                     View => Host_View,
                     Status => Status);
        -- Save the  context to the current view


        Naming.Resolve (Name => Host_List_File,
                        The_Object => Dir_Object,
                        Status => Name_Status);

        begin
            case Name_Status is
                when Naming.Successful =>
                    begin
                        Io.Open (File => List_File, Name => Host_List_File);
                    exception
                        when others =>
                            Log.Put_Line ("Unable to open " & Host_List_File,
                                          Profile.Error_Msg);
                            Set_Status (Status => Status,
                                        Message => "Refresh imports failed ");
                            Reset_Context (Old_Context);
                            return;
                    end;
                when Naming.Undefined =>
                    begin
                        Io.Create (File => List_File, Name => Host_List_File);
                    exception
                        when others =>
                            Log.Put_Line ("Unable to create " & Host_List_File,
                                          Profile.Error_Msg);
                            Set_Status (Status => Status,
                                        Message => "Refresh imports failed");
                            Reset_Context (Old_Context);
                            return;
                    end;
                when others =>
                    Set_Status (Status => Status,
                                Message => "Unable to resolve " &
                                              Host_List_File & ". Status =" &
                                              Naming.Name_Status'Image
                                                 (Name_Status));
                    Reset_Context (Old_Context);
                    return;
            end case;
            Import_Interface.Get_Remote_Imports (For_View => Host_View,
                                                 Closure => True,
                                                 Imports => Imports,
                                                 Condition => Status);

            -- Add From View Comment and local working library
            Io.Put_Line (File => List_File,
                         Item => "-- Host_View => " & Host_View);

            if Remote_Library = "" then  
                Io.Put_Line (File => List_File,
                             Item => Default_Program_Library);
            else
                Io.Put_Line (File => List_File, Item => Remote_Library);
            end if;


            if Simple_Status.Error (Status) then
                Log.Put_Line ("Get remote imports failed", Profile.Error_Msg);
                Reset_Context (Old_Context);
                return;
            end if;

            while not Import_Interface.Done (Imports) loop
                declare
                    Next_Import : constant String :=
                       Import_Interface.Value (Imports);
                    Local_Library : constant String :=
                       Remote_Directory & "/" & Remote_Library;
                begin  
                    if not String_Utilities.Equal (Str1 => Next_Import,
                                                   Str2 => Local_Library,
                                                   Ignore_Case => True) then
                        if Next_Import /= "" then
                            if Next_Import (Next_Import'Last) = '/' then
                                Io.Put_Line (List_File,
                                             Next_Import &
                                                Default_Program_Library);
                            else
                                Io.Put_Line (List_File, Next_Import);
                            end if;  
                        end if;
                    end if;
                    Import_Interface.Next (Imports);
                end;

            end loop;

            -- Add predefined
            Io.Put_Line (List_File, "/usr/lpp/ada/lib/libada");
            Io.Close (List_File);

        exception
            when others =>
                Io.Close (List_File);
                raise;
        end;

        if Simple_Status.Error (Status) then
            Log.Put_Line (Message => "Unable to update remote imports.",
                          Kind => Profile.Negative_Msg);
            Reset_Context (Old_Context);
            return;
        end if;

        if Remote_Directory /= "" then
            Directory_Exists (Remote_Directory => Remote_Directory,
                              Remote_Machine => Remote_Machine,
                              Status => Status,
                              Trace_On => Trace_On,
                              Exists => Dir_Exists);

            if Dir_Exists then
                Download_File (Host_File_Name => Host_List_File,
                               Target_File_Name => Default_Target_List_File,
                               Remote_Directory => Remote_Directory,
                               Remote_Machine => Remote_Machine,
                               Status => Status);
                -- Download the alib.list file only if the remote directory
                -- for the view exist.
            else
                Log.Put_Line
                   (Message => Host_View &
                                  " has not been built on the target." &
                                  " Will not attempt to download " &
                                  Host_List_File & ".",
                    Kind => Profile.Warning_Msg);
            end if;  
        end if;  
        Reset_Context (Old_Context);
    exception
        when others =>
            Reset_Context (Old_Context);
            raise;
    end Refresh_Imports;

    procedure Update_Import_List (Host_View : String;
                                  Remote_Directory : String;
                                  Remote_Machine : String;
                                  Remote_Program_Library : String;
                                  Status : in out Simple_Status.Condition) is

        Host_List_File : constant String :=
           Host_View & ".State.Tool_State." & Default_Host_List_File;
        Target_List_File : constant String :=
           Remote_Directory & "/" & Default_Target_List_File;
    begin
        null;
    end Update_Import_List;

    function Is_View (Obj : Directory.Object) return Boolean is
        Subclass : Directory.Subclass := Directory.Get_Subclass (Obj);
        use Directory;  -- for operators
    begin  
        return (Subclass = Object_Subclass.Spec_View_Subclass) or else
                  (Subclass = Object_Subclass.Load_View_Subclass) or else
                  (Subclass = Object_Subclass.Combined_View_Subclass);

    end Is_View;

    function Get_View (Object : Directory.Object) return Directory.Object is

        N_Status : Naming.Name_Status;
        Obj : Directory.Object := Object;

        E_Status : Directory.Error_Status;
        Obj_Unit : Directory.Ada.Unit;
    begin
        if Is_View (Obj) then
            return Obj;
        end if;

        Directory.Control_Point.Enclosing_World (Obj, Obj_Unit, E_Status);

        if Directory."/=" (E_Status, Directory.Successful) then
            return Directory.Nil;
        end if;

        Obj := Directory.Ada.Get_Object (Obj_Unit);

        if Is_View (Obj) then
            return Obj;
        else
            return Directory.Nil;
        end if;

        -- if you are here, an error occurred
        return Directory.Nil;
    end Get_View;

    function Get_View (Object_Name : String) return Directory.Object is
        Obj : Directory.Object;
        Status : Naming.Name_Status;
    begin
        Naming.Resolve (Object_Name, Obj, Status);
        if Naming."/=" (Status, Naming.Successful) then
            Log.Put_Line (Message => Object_Name & " does not exist",
                          Kind => Profile.Warning_Msg);
            return Directory.Nil;
        end if;  
        return Get_View (Obj);
    end Get_View;

    procedure Make_Path_Preprocess
                 (Host_Path_Name : String;
                  For_Release : Boolean;
                  Remote_Machine : String;
                  Remote_Directory : String;
                  Remote_Program_Library : String;
                  Status : in out Simple_Status.Condition) is separate;



    procedure Make_Path_Postprocess
                 (Host_Path_Name : String;
                  For_Release : Boolean;
                  Remote_Machine : String;
                  Remote_Directory : String;
                  Remote_Program_Library : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Destroy_View_Preprocess
                 (Host_Path_Name : String;  
                  Status : in out Simple_Status.Condition) is separate;

    procedure Destroy_View_Postprocess
                 (Host_Path_Name : String;  
                  Remote_Machine : String;
                  Remote_Directory : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Update_Remote_Imports
                 (Host_View : String;
                  Status : in out Simple_Status.Condition) is separate;


    procedure Import_Postprocess
                 (Views_To_Import : Directory.Naming.Iterator;
                  Into_View : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Import_Preprocess
                 (Views_To_Import : Directory.Naming.Iterator;
                  Into_View : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Remove_Import_Preprocess
                 (View_To_Remove : Directory.Object;
                  From_View : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Remove_Import_Postprocess
                 (View_To_Remove : Directory.Object;
                  From_View : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Release_Preprocess
                 (From_Working_View : String;
                  Released_View : String;
                  Remote_Machine : String;
                  Remote_Directory : String;
                  Remote_Program_Library : String;
                  Status : in out Simple_Status.Condition) is separate;


    procedure Release_Postprocess
                 (View_To_Remove : String;
                  Released_View : String;
                  Remote_Machine : String;
                  Remote_Directory : String;
                  Remote_Program_Library : String;
                  Status : in out Simple_Status.Condition) is separate;


    procedure Link_Preprocess
                 (Main_Unit : String;
                  Executable_Name : String;
                  Status : in out Simple_Status.Condition) is separate;

    procedure Link_Postprocess
                 (Main_Unit : String;
                  Executable_Name : String;
                  Status : in out Simple_Status.Condition) is separate;

end Library_Extensions;
DataMuseum.dk

Rational R1000/400 Tapes

⟦0fe625e2c⟧ TextFile

Derivation

TextFile
