DataMuseum.dk

top - metrics - download

    Length: 31854 (0x7c6e)
    Types: TextFile
    Names: »STEPS«

└─⟦afbc8121e⟧ Bits:30000532 8mm tape, Rational 1000, MC68020_OS2000 7_2_2
    └─⟦77aa8350c⟧ »DATA« 
        └─⟦this⟧ 

TextFile

AUTHORIZATION_CHECK => (
declare
    subtype Bogus is Natural range 0 .. 1;
    package Pp is new Parameter_Parser (Bogus);
    Iter : Pp.Iterator := Pp.Parse ("CMVC, CMVC.Source_Control,Motorola_68k,MC68020_OS2000"); 
    Token_Iter : Pp.Iterator := Pp.Parse ("MC68020_OS2000");
    Error : Natural := 0;

    function Product_Name (Iter : Pp.Iterator) return String is
    begin
        if String_Utilities.Equal (Pp.Name (Iter), "NAME") then
            return Pp.Get_Image (Iter);
        else
            return Pp.Name (Iter);
        end if;
    end Product_Name;

begin
    while not Pp.Done (Iter) loop
        declare
            Name : constant String := Product_Name (Iter);
        begin  
            if "!Implementation".Product_Authorization.Is_Registered
                  (Name) then
                Log.Put_Line (Name & " is authorized", Profile.Positive_Msg);
            else
                Log.Put_Line ("Need to Authorize " & Name,
                              Profile.Error_Msg);
                Error := Error + 1;
            end if;
        end;
        Pp.Next (Iter);
    end loop;
    if Error /= 0 then
        Log.Put_Line
           ("Do not proceed until all these products have been authorized",
            Profile.Error_Msg);
    end if;
    if Get_Site /= "" and then not Pp.Done (Token_Iter) then
        Error := 0;
        Log.Put_Line ("Checking Token Count");
        declare
            Limit, Current, Buy_Out : Natural;
        begin
            while not Pp.Done (Token_Iter) loop
                "!Machine.Release.Archive.MC68020_OS2000.Release7_2_2.Command_Data".
                   Token_Information
                   (Product_Name (Token_Iter), Limit, Buy_Out, Current);
                if Limit = 0 then
                    Error := Error + 1;
                    Log.Put_Line
                       ("No tokens (sessions) for " &
                        Product_Name (Token_Iter) &
                        " have been authorized.  Do not proceed until you have authorized tokens for this product",
                        Profile.Error_Msg);
                elsif (Buy_Out /= Current) and Current = Limit then
                    Log.Put_Line
                       ("Tokens (Sessions) have been authorized for " &
                        Product_Name (Token_Iter) & ", but all are in use",
                        Profile.Error_Msg);
                    Log.Put_Line
                       ("Have users which are using these tokens log off (and then back on) before continuing",
                        Profile.Error_Msg);
                    Show_Tokens (Product_Filter =>
                                    Product_Name (Token_Iter));
                else
                    Log.Put_Line (Product_Name (Token_Iter) &
                                  " has available tokens",
                                  Profile.Positive_Msg);
                end if;
                Pp.Next (Token_Iter);
            end loop;
        end;
    else
        Log.Put_Line
           ("Machine has not been configured for per session pricing (product tokens)." &
            "  Skipping product token check");
    end if;
end;
)

USERS_CHECK => (
    declare
        Iter : System_Utilities.Session_Iterator;
        Total : Natural := 0;
        use System_Utilities;
    begin
        Operator.Limit_Login (Sessions => 1);
        Log.Put_Line ("Limited logins to 1 user", Profile.Positive_Msg);
        Init (Iter);
        while not Done (Iter) loop
            if Value (Iter) /= Get_Session then
                Log.Put_Line
                   ("User " & User_Name (Value (Iter)) &
                    " is still logged in.  Have s/he log off before proceeding",
                    Profile.Warning_Msg);
            end if;
            Next (Iter);
        end loop;
    end;
)

LOAD_EEDB => (
declare
    Eedb_Config_Cmds : constant String := "!Machine.Temporary.EEDB_Config_CMDS";
    Eedb_Config_Display : constant String :=
       "!Machine.Temporary.EEDB_Config_Display";
    Eedb_Config_Output : constant String :=
       "!Machine.Temporary.Eedb_Config_Output";
    Temp_Output : constant String := "!Machine.Temporary.Eedb_Temp_Output";

    function Get_Version (Subsystem : String) return Natural is

        Eedb_Configuration : constant String :=
           "!Machine.Temporary.EEDB_Configuration";
        Eedb_Commands : constant String := "!Machine.Temporary.EEDB_Commands";

        procedure Gen_Config_File is
            Fin, Fcmds : Io.File_Type;
        begin
            Io.Create (Fcmds, Name => Eedb_Commands);
            Io.Put_Line (Fcmds,
                         "set_verbosity configuration all_code_segments false");
            Io.Put_Line (Fcmds, "set_verbosity configuration date false");
            Io.Put_Line (Fcmds,
                         "set_verbosity configuration elab_code_segment false");
            Io.Put_Line (Fcmds, "set_verbosity configuration library true");
            Io.Put_Line (Fcmds, "set_verbosity configuration module_key false");
            Io.Put_Line (Fcmds, "set_verbosity configuration name false");
            Io.Put_Line
               (Fcmds,
                "set_verbosity configuration subsystem_dependencies false");
            Io.Put_Line (Fcmds, "set_verbosity configuration user false");
            Io.Put_Line (Fcmds, "vd $");
            Io.Put (Fcmds, Ascii.Etx);
            Io.New_Line (Fcmds, 2);
            Io.Put_Line (Fcmds, "quit");
            Io.Reset (Fcmds, Io.In_File);
            Io.Set_Input (Fcmds);
            Io.Set_Output (Eedb_Configuration);
            Operator.Internal_System_Diagnosis;
            Io.Reset_Output;
            Io.Reset_Input;
        end Gen_Config_File;

        function Extract (S : String) return Natural is
            Start : Natural := String_Utilities.Locate ('.', S);
            Stop : Natural := String_Utilities.Locate (':', S);
            P1 : Natural := String_Utilities.Locate
                               ('.', S (Start + 1 .. Stop - 1));
            P2 : Natural := String_Utilities.Locate
                               ('.', S (P1 + 1 .. Stop - 1));
            subtype Numeric is Character range '0' .. '9';

        begin
            if Start = 0 or Stop = 0 then
                return 0;
            else
                if not (S (Stop - 1) in Numeric) then
                    Stop := Stop - 1;
                end if;
                return (Natural'Value (S (Start + 1 .. P1 - 1)) * 10000) +
                          (Natural'Value (S (P1 + 1 .. P2 - 1)) * 100) +
                          Natural'Value (S (P2 + 1 .. Stop - 1));
            end if;
        end Extract;

    begin
        Gen_Config_File;
        Io.Set_Input (Eedb_Configuration);
        while not Io.End_Of_File loop
            declare
                S1 : constant String := Io.Get_Line;
                Index : Natural := String_Utilities.Locate
                                      (Subsystem & '.', S1);
                Lib_Index : Natural :=
                   String_Utilities.Locate (":LIBRARIES:", S1);
            begin
                if Index /= 0 then
                    if Lib_Index = 0 then
                        declare
                            S2 : constant String :=
                               String_Utilities.Strip (Io.Get_Line);
                        begin
                            Io.Reset_Input;
                            return Extract (S1 (Index .. S1'Last) & S2);
                        end;
                    else
                        Io.Reset_Input;
                        return Extract (S1 (Index .. S1'Last));
                    end if;
                end if;
            end;
        end loop;
        Io.Reset_Input;
        return 0;
    end Get_Version;

    function Subsystem_Present (Name : String) return Boolean is
    begin
        Io.Set_Input (Eedb_Config_Output);
        while not Io.End_Of_File loop
            declare
                S : constant String := Io.Get_Line;
            begin
                if String_Utilities.Locate (Name, S) /= 0 then
                    Io.Reset_Input;
                    return True;
                end if;
            end;
        end loop;
        Io.Set_Input (Io.Standard_Input);
        Io.Set_Output (Io.Standard_Output);
        Log.Put_Line ("Missing " & Name & " from the Environment configuration",
                      Profile.Error_Msg);
        return False;
    end Subsystem_Present;

begin
    declare
        Need_To_Elaborate : Boolean := False;
        Cdf_Version : Natural := Get_Version ("Cross_Development");
        Cdf_New_Name : constant String := "CDF.Delta";
        Need_Cdf_Replacement : Boolean := Cdf_Version < 110100;
        Cdf_Uprev : Boolean := Cdf_Version > 110100;
    begin
        Log.Put_Line ("Processing CDF Environment Subsystem");
        Io.Set_Output
           ("!MACHINE.RELEASE.ARCHIVE.MC68020_OS2000.RELEASE7_2_2.LOGS.Load_EEDB_Log");
        Archive.Restore (Options => "promote, replace", Device => "Segments");
        Library.Context
           ("!Machine.Release.Archive.MC68020_OS2000.Release7_2_2.Segments",
            Response => "<ERRORS>");
        if Cdf_Uprev then
            Log.Put_Line
               ("Currently elaborated Cross_Development EEDB subsystem is greater than that in this release, nothing will be modified." &
                "Please see release note for compatible releases of this subsystem.",
                Profile.Error_Msg);
        elsif Need_Cdf_Replacement then
            Need_To_Elaborate := True;
            Library.Copy ("MLOADS_CDF", "MLOADS");
            Program.Run
               ("""!Machine.Release.Archive.MC68020_OS2000.Release7_2_2.Segments"".Get_Xfer " &
                "(Xfer_File => ""!Machine.Release.Archive.MC68020_OS2000.Release7_2_2.Segments:CDF"", Verbose => True);",
                "!Machine.Release.Archive.MC68020_OS2000.Release7_2_2.Segments");
        else
            Log.Put_Line
               ("Skipping update of Cross_Development subsystem, already set correctly");
        end if;

        Io.Reset_Output;
        Log.Filter_Errors
           (Log_File =>
               "!MACHINE.RELEASE.ARCHIVE.MC68020_OS2000.RELEASE7_2_2.LOGS.Load_EEDB_Log",
            Destination =>
               "!MACHINE.RELEASE.ARCHIVE.MC68020_OS2000.RELEASE7_2_2.LOGS.Load_EEDB_Log_Summary",
            Auxiliaries => False,
            Warnings => False,
            Exceptions => True);
        if Need_To_Elaborate then
            Io.Set_Output (Eedb_Config_Cmds);
            Io.Put_Line ("une $ native_debugger");
            if Need_Cdf_Replacement then
                Io.Put_Line ("replace $ " & Cdf_New_Name);
            end if;
            Io.Put_Line ("del cdf" & Ascii.Lf &
                         "build cdf $ cross_development ;" & Ascii.Lf &
                         "elab cdf" & Ascii.Lf & "snap");
            Io.Put_Line (Ascii.Lf & Ascii.Etx & Ascii.Lf & "quit");
            Io.Reset_Output;
            Log.Put_Line ("Elaborating the CDF subsystem");
            Io.Set_Output (Temp_Output);
            Io.Set_Input (Eedb_Config_Cmds);
            Operator.Internal_System_Diagnosis;
            Io.Reset_Input;
            Io.Reset_Output;
            Log.Put_Line ("Checking Configuration");
        end if;
        Common.Definition
           ("!MACHINE.RELEASE.ARCHIVE.MC68020_OS2000.RELEASE7_2_2.LOGS.Load_EEDB_Log_Summary");
    exception
        when others =>
            Io.Set_Input (Io.Standard_Input);
            Io.Set_Output (Io.Standard_Output);
            Log.Put_Line ("Unhandled Exception: " &
                          Debug_Tools.Get_Exception_Name,
                          Profile.Exception_Msg);
    end;

end;
)

RELEASE_RESTORE => (
    Io.Set_Output ("!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Release_Restore_Log");
    Archive.Restore (Options => "promote, replace",
                     Device => "Release");
    if Directory_Tools.Object.Is_Ok (The_Objects =>
                                        Directory_Tools.Naming.Resolution
                                           ("Release_Notes.[Data,Index]")) then
        Archive.Restore (Options => "promote, replace",
                         Device => "Release_Notes");

    end if;
    Io.Reset_Output;
    Log.Filter_Errors (Log_File => "!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Release_Restore_Log",
                       Destination => 
                            "!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Release_Restore_Log_Summary",
                       Auxiliaries => False,
                       Warnings => False,
                       Exceptions => True);
    Common.Definition ("!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Release_Restore_Log_Summary");
)

INSTALL_PRODUCT => (
    Library.Context (To_Be => "!Targets.Implementation.Release_7_2_2",
                     Response => "<ERRORS>");
    System_Utilities.Set_Page_Limit (16_000);
    "!Targets.Implementation.Release_7_2_2".Install_Product;
    Io.Reset_Output;
    if not Directory_Tools.Object.Is_Ok
              (The_Objects =>
                  Directory_Tools.Naming.Resolution
                     ("!Machine.Initialization.[Local,Site].Cross_Compiler_Configuration")) then
        Io.Set_Output
           ("!Machine.Initialization.Local.Cross_Compiler_Configuration");
        Io.Put_Line ("Motorola_68k");
        Io.Reset_Output;
    end if;
    Log.Filter_Errors (Log_File => "!Targets.Implementation.Release_7_2_2.Install_Log",
                        Destination => "!Targets.Implementation.Release_7_2_2.Install_Log_Summary",
                        Warnings => False,
                        Auxiliaries => False,
                        Exceptions => True);
    Common.Definition ("!Targets.Implementation.Release_7_2_2.Install_Log_Summary");
)

UPDATE_MODELS => (
    -- Library.Context ("!Targets.Implementation.Release_7_2_2",
    --                  Response => "<ERRORS>");
    -- "!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.command_data".
    --    Compute_Recoding
    --    (For_Unit =>
    --        "_!TARGETS.IMPLEMENTATION.RELEASE_7_2_2.MOTOROLA_68K.MC68020_OS2000.WORLD_LIST",
    --     Demote_File => "Demote_File",
    --     Install_File => "Install_File",
    --     Code_File => "Code_File",
    --     Freeze_File => "Freeze_File",
    --     Response => "<PROFILE>");
    Library.Context
       ("!Targets.Implementation.Release_7_2_2.MOTOROLA_68K.MC68020_OS2000",
        Response => "<ERRORS>");
    "!TARGETS.IMPLEMENTATION.RELEASE_7_2_2.MOTOROLA_68K.MC68020_OS2000".
       Update_Models;

)

RESTORE_STATE => (
declare
    Iter : Directory_Tools.Object.Iterator;
    J : Program.Job_Id;
    Status : Program.Condition;
    use Directory_Tools;

    procedure Split (Filename : String; Max_Units : Natural := 300) is
        Fin, Fout : Io.File_Type;
        File_Number : Natural := 1;
        Line : Natural := 0;
    begin
        begin
            Io.Open (Fin, Io.In_File, Filename);
            while not Io.End_Of_File (Fin) loop
                Io.Create
                   (Fout,
                    Name => Filename & '_' & String_Utilities.Number_To_String
                                                (Value => File_Number,
                                                 Width => 4,
                                                 Leading => '0'));
                Line := 1;
                while not Io.End_Of_File (Fin) and then (Line < Max_Units) loop
                    Line := Line + 1;
                    Io.Put_Line (Fout, Io.Get_Line (Fin));
                end loop;
                File_Number := File_Number + 1;
                Io.Close (Fout);
            end loop;
            Io.Close (Fin);
        exception
            when others =>
                Log.Put_Line ("File " & Filename & " is empty",
                              Profile.Warning_Msg);
        end;
    end Split;

begin
    Io.Set_Output
       ("!MACHINE.RELEASE.ARCHIVE.MC68020_OS2000.RELEASE7_2_2.LOGS.Restore_User_State_Log");
    Split ("!Targets.Implementation.Release_7_2_2.Install_File");
    Iter := Naming.Resolution
               ("!Targets.Implementation.Release_7_2_2.Install_File_@");
    while not Object.Done (Iter) loop
        Program.Create_Job
           (S =>
               "Op.Enable_Privileges;Compilation.Promote (Unit =>""_" &
                  Naming.Full_Name (Object.Value (Iter)) &
                  """, Scope => Compilation.Subunits_Too, Goal => Compilation.Installed, Limit => ""<ALL_WORLDS>"", Response => ""<progress>"");",
            Job => J,
            Status => Status,
            Response => "<PROFILE>");
        if Program.Started_Successfully (Status) then
            Log.Put_Line ("Waiting for compilation to complete on " &
                          Naming.Full_Name (Object.Value (Iter)),
                          Profile.Positive_Msg);

            Program.Wait_For (J);
        else
            Log.Put_Line (Simple_Status.Display_Message (Status),
                          Profile.Error_Msg);
            Log.Put_Line ("Failed to start compilation job for " &
                          Naming.Full_Name (Object.Value (Iter)),
                          Profile.Negative_Msg);
        end if;
        Object.Next (Iter);
    end loop;
    Split ("!Targets.Implementation.Release_7_2_2.Code_File");
    Iter := Naming.Resolution
               ("!Targets.Implementation.Release_7_2_2.Code_File_@");
    while not Object.Done (Iter) loop
        Program.Create_Job
           (S =>
               "Op.Enable_Privileges;Compilation.Promote (Unit =>""_" &
                  Naming.Full_Name (Object.Value (Iter)) &
                  """, Scope => Compilation.All_Parts, Goal => Compilation.Coded, Limit => ""<ALL_WORLDS>"", Response => ""<progress>"");",
            Job => J,
            Status => Status,
            Response => "<PROFILE>");
        if Program.Started_Successfully (Status) then
            Log.Put_Line ("Waiting for compilation to complete on " &
                          Naming.Full_Name (Object.Value (Iter)),
                          Profile.Positive_Msg);

            Program.Wait_For (J);
        else
            Log.Put_Line (Simple_Status.Display_Message (Status),
                          Profile.Error_Msg);
            Log.Put_Line ("Failed to start compilation job for " &
                          Naming.Full_Name (Object.Value (Iter)),
                          Profile.Negative_Msg);
        end if;
        Object.Next (Iter);
    end loop;
    Library.Freeze (Existing =>
                       "_!Targets.Implementation.Release_7_2_2.Freeze_File",
                    Recursive => True,
                    Response => "<progress>");
    Io.Reset_Output;
    Log.Filter_Errors
       (Log_File =>
           "!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_User_State_Log",
        Destination =>
           "!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_User_State_Log_Summary",
        Auxiliaries => False,
        Warnings => False,
        Exceptions => True);
    Common.Definition
       ("!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_User_State_Log_Summary");
exception
    when others =>
        Io.Reset_Output;
        Log.Put_Line ("Unhandled Exception", Profile.Error_Msg);
end;

)

RESTART_COMPILER => (
    M68k.Restart_Compiler (Streams => 1);
)

BUILD_PROGRAM_LIBRARIES => (
    Io.Set_Output ("!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Build_Program_Libraries_Log");
    Program_Library_Maintenance.Build
       (Worlds => "[_!Targets.Implementation.Release_7_2_2.Motorola_68k.Mc68020_Os2000.World_List]",
        Atomic => False,
        Preserve_Unreconstructable_Libraries => True,
        Options => "",
        Response => "<PROFILE>");
    Io.Reset_Output;
    Log.Filter_Errors (Log_File => "!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Build_Program_Libraries_Log",
                       Destination => 
                            "!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Build_Program_Libraries_Log_Summary",
                       Auxiliaries => False,
                       Warnings => False,
                       Exceptions => True);
    Common.Definition ("!Machine.Release.Archive.Mc68020_Os2000.Release7_2_2.Logs.Build_Program_Libraries_Log_Summary");
)

ACTIVITY_UPDATE => (
    Log.Put_Line ("Updating System Activity to <unknown>");
    Activity.Create (The_Activity => "!machine.temporary.activity",
                     Source => Activity.Nil,
                     Mode => Activity.Exact_Copy,
                     Response => "<ERRORS>");
    Activity.Add (Subsystem =>
                     "!<subsystem>",
                  Load_Value => "<load_view>",
                  Spec_Value => "<spec_view>",
                  The_Activity => "!Machine.Temporary.Activity",
                  Mode => Activity.Exact_Copy,
                  Response => "<ERRORS>");
    Activity.Merge (Source => "!Machine.Temporary.Activity",
                    Subsystem => "?",
                    Spec_View => "?",
                    Load_View => "?",
                    Mode => Activity.Exact_Copy,
                    Target => "!Machine.Release.Current.Activity",
                    Response => "<ERRORS>");
    Lib.Delete (Existing => "!Machine.Temporary.Activity",
                Limit => "<DIRECTORIES>",
                Response => "<ERRORS>");
)

FIXUP_INITIALIZATION => (
    Log.Put_Line ("Destroying !Machine.Initialize_Cross_Compilers",
                  Profile.Positive_Msg);
    Compilation.Destroy (Unit => "!MACHINE.INITIALIZE_CROSS_COMPILERS'C(ADA)",
                         Threshold => 2,
                         Limit => "<WORLDS>",
                         Response => "<ERRORS>");
    Log.Put_Line ("Moving CROSS_COMPILERS to !Machine.Initialization.Local",
                  Profile.Positive_Msg);
    Library.Move
       (From => "!Machine.Cross_Compilers",
        To => "!Machine.Initialization.Local.Cross_Compiler_Configuration",
        Recursive => True,
        Response => "<ERRORS>",
        Copy_Links => True,
        Options => "");
    Common.Definition
       ("!Machine.Initialization.Local.Cross_Compiler_Configuration");
)

 
RESTORE_LOGINS => (
    Operator.Limit_Login;
    Operator.Show_Login_Limit;
)

TEST_RESTORE => (
declare
    type Ptr_String is access String;
    Machine, RDirectory : Ptr_String;

    function Get_Line
                (Prompt : String; Min_Length : Natural := 1) return String is
        S : String (1 .. 80);
        Last : Natural := 0;
    begin
        loop
            Io.Put (Prompt);
            Io.Get_Line (S, Last);
            exit when Last >= Min_Length;
            Io.Put_Line ("ERROR: Must enter a value with" &
                         Natural'Image (Min_Length) & " characters");
        end loop;
        return (S (1 .. Last));
    end Get_Line;
begin
    Machine := new String'(String_Utilities.Upper_Case (Get_Line ("Enter Remote Target Machine Name : ", 1)));
    if Machine.all = String_Utilities.Upper_Case
                        (Transport_Name.Host_Id_To_Host
                            (Transport_Name.Host_To_Host_Id (Machine.all))) then
        Log.Put_Line ("Resolved " & Machine.all & " successfully");
    else
        Log.Put_Line ("Resolved " & Machine.all & " successfully");
        Log.Put_Line (Transport_Name.Host_Id_To_Host
                         (Transport_Name.Host_To_Host_Id (Machine.all)) &
                      " is also defined to use the same IP Address/Port",
                      Profile.Warning_Msg);

    end if;
    RDirectory := new String'(Get_Line ("Enter Remote Directory Name (example /h0/USR/SMSE) : ", 1));
    Log.Put_Line ("Restoring Test Data");
    Io.Set_Output
       ("!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_Tests_Log");
    Compilation.Destroy
       (Unit => "!TESTS.STAGING.INSTALL_VERIFICATIONS.MC68020_OS2000",
        Threshold => 90,
        Limit => "<WORLDS>",
        Response => "");
    Archive.Restore (Options => "Promote, Replace", Device => "Tests");
    Switches.Set
       (Spec => "Ftp.Remote_Machine:=""" & Machine.all & """" &
                 ";Ftp.Remote_Directory:=""" & RDirectory.all & """",
        File => "!TESTS.STAGING.INSTALL_VERIFICATIONS.MC68020_OS2000.SWITCHES",
        Response => "<ERRORS>");
    Compilation.Make
       (Unit => "!TESTS.STAGING.INSTALL_VERIFICATIONS.MC68020_OS2000.Hello",
        Scope => Compilation.Load_Views,
        Goal => Compilation.Coded,
        Limit => "<ALL_WORLDS>",
        Effort_Only => False,
        Response => "<PROFILE>");
    Convert
       (Old_Module =>
           "!Tests.Staging.Install_Verifications.Mc68020_Os2000.Hello.<EXE>",
        Old_Format => "RATIONAL",
        New_Module => "!Tests.Staging.Install_Verifications.Mc68020_Os2000.Hello.<OS2000>",
        New_Format => "<DEFAULT>",
        Options => "",
        Response => "<ERRORS>");
    Library.Context ("!Tests.Staging.Install_Verifications.Mc68020_OS2000");
    Os2000_Put (From_Local_File => "!Tests.Staging.Install_Verifications.Mc68020_OS2000.Hello.<OS2000>",
                To_Remote_File => "hello",
                Remote_Machine => "<DEFAULT>",
                Remote_Directory => "<DEFAULT>",
                Transliterate => False,
                Response => "<PROFILE>");
    Io.Reset_Output;
    Log.Filter_Errors
       (Log_File =>
           "!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_Tests_Log",
        Destination =>
           "!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_Tests_Log_Summary",
        Auxiliaries => False,
        Warnings => False,
        Exceptions => True);
    Common.Definition("!Tests.Staging.Install_Verifications.Mc68020_OS2000");
    Common.Definition
       ("!Machine.Release.Archive.Mc68020_OS2000.Release7_2_2.Logs.Restore_Tests_Log_Summary");
exception
    when Transport_Name.Undefined =>
        Log.Put_Line
           ("Cannot resolve the machine name, please enter this into the Transport_Name_Map and rerun this step",
            Profile.Error_Msg);
end;
)
DOWNLOAD => (
    Library.Context (To_Be => "!TESTS.STAGING.INSTALL_VERIFICATIONS.MC68020_OS2000",
                     Response => "<ERRORS>");
    Os2000_Put
       (From_Local_File =>
           "!TESTS.STAGING.INSTALL_VERIFICATIONS.MC68020_OS2000.HELLO.<OS2000>",
        To_Remote_File => "Hello",
        Remote_Machine => "<DEFAULT>",
        Remote_Directory => "<DEFAULT>",
        Transliterate => False,
        Response => "<PROFILE>");
    Common.Definition ("!Tests.Staging.Install_Verifications.Mc68020_Os2000");
)

RECORD_INSTALLATION => (
declare
    Product : constant String := Directory_Tools.Naming.Simple_Name
                                    (Directory_Tools.Naming.Full_Name ("^"));
    Release : constant String := Directory_Tools.Naming.Simple_Name
                                    (Directory_Tools.Naming.Full_Name ("$"));
    Product_Info : constant String :=
       "(RELEASE => " & Release & ", DATE => (" &
          Time_Utilities.Image (Time_Utilities.Get_Time,
                                Time_Utilities.Year_Month_Day) &
          "), USER => " & System_Utilities.User_Name &
          '.' & System_Utilities.Session_Name & ")";
    Product_Filename : constant String := "!Machine.Release.Current.Products";
    F : Io.File_Type;
begin
    Io.Append (F, Name => Product_Filename);
    Io.Put_Line (F, Product & " => " & Product_Info);
    Io.Close (F);
    Log.Put_Line ("Recording product " & Product &
                  " current release as " & Release,
                  Profile.Positive_Msg);
end;
)

DESTROY_ARCHIVE => (
    Library.Context ("!Targets.Implementation.Object_Conversion",
                     Response => "<ERRORS>");
    Cmvc.Destroy_View (What_View => "CODE7_2_0",
                       Destroy_Configuration_Also => True,
                       Response => "<ERRORS>");
    Cmvc.Destroy_View (What_View => "Rev7_2_Spec",
                       Destroy_Configuration_Also => True,
                       Response => "<ERRORS>");
    Compilation.Destroy
        (Unit => "!Machine.Release.Archive.MC68020_OS2000.Release7_2_2",
            Threshold => 999,
            Limit => "<ALL_WORLDS>",
            Response => "<ERRORS>");

)

SCHEDULE_SHUTDOWN => (
declare
    use Directory_Tools;

    Current_Terminal_Type : constant String := System_Utilities.Terminal_Type;

    function Is_State (Object : String;
                       Goal_State : Directory_Tools.Ada_Object.Unit_State)
                      return Boolean;
    function Is_Coded (Object : String;
                       Goal_State : Directory_Tools.Ada_Object.Unit_State :=
                          Directory_Tools.Ada_Object.Coded) return Boolean
        renames Is_State;
    function Is_Installed
                (Object : String;
                 Goal_State : Directory_Tools.Ada_Object.Unit_State :=
                    Directory_Tools.Ada_Object.Installed) return Boolean
        renames Is_State;


    function Is_State (Object : String;
                       Goal_State : Directory_Tools.Ada_Object.Unit_State)
                      return Boolean is
        use Directory_Tools.Ada_Object;
        Is_Ok : Boolean := (Unit_State'Pos (State (Object)) >=
                            Unit_State'Pos (Goal_State));
    begin
        if not Is_Ok then
            Log.Put_Line (Object & " is not at the " &
                          Unit_State'Image (Goal_State) & " state",
                          Profile.Error_Msg);
        end if;
        return Is_Ok;
    end Is_State;

begin
    if (Object.Is_Ok (The_Object =>
                         Naming.Resolution
                            ("!Machine.Initialization.Rational")) or else
        Is_Coded ("!Machine.Initialize'Body")) and
       Is_Installed ("!Machine.Editor_Data.Rational_Commands'Body") and
       Is_Installed ("!Machine.Editor_Data.Facit_Commands'Body") and
       Is_Installed ("!Machine.Editor_Data." &
                     Current_Terminal_Type & "_Commands'Body") then
        Log.Put_Line ("Scheduling shutdown in 5 minutes");
        Op.Shutdown_Warning (300.0);
        Op.Shutdown (Reason => "Release",
                     Explanation => "Install MC68020_OS2000 Rev7");
    end if;
end;
)

CHECK_COMPILER => (
declare
    function Job_Running
                (N : String; Kind : Profile.Msg_Kind := Profile.Error_Msg)
                return Boolean is
        Found : Boolean := False;
    begin
        for J in System_Utilities.Job_Id loop
            begin
                if String_Utilities.Locate (N, System_Utilities.Job_Name (J)) /=
                   0 then
                    Log.Put_Line ("Job " & System_Utilities.Job_Name (J) &
                                  " is running", Profile.Positive_Msg);
                    Found := True;
                end if;
            exception
                when others =>
                    null;
            end;
        end loop;
        if not Found then
            Log.Put_Line ("Job " & N & " is not running", Kind);
        end if;
        return Found;
    end Job_Running;
begin
    if Job_Running ("Motorola_68k Compiler Control 7.2.46") and
       Job_Running ("Cross Compiler Common Layer 7.2.28") and
       Job_Running ("Motorola_68k Stream_1 7.2.53") then
        null;
    end if;
end;
)

STEP_CHECK => (
    -- This must remain the last step in the step file and is used 
    -- as a first level verification of the step file parse and
    -- tape load.
    Log.Put_Line ("Step File parses correctly", Profile.Positive_Msg);
)