IBM Aptiva Multimedia Exploration/BPCDROM.ISO/recovery/recovery.cmd

Text File | 1995-09-22 | 73.1 KB | 2,356 lines

/*:VRX         MAIN
*/
/*
*
* Recovery: This program is intended to provide the Aptiva User with a simple
*           interface into the Aptiva OS/2 Warp Recovery Options.
*           This program will present the user with a simple menu. From this
*           menu the user will be able to;
*
*           1) Install Aptiva OS/2 Warp Software
*           2) Recover Configuration Files
*           3) Edit Autoexec.bat
*           4) Edit Config.sys
*           5) Edit Startup.cmd
*           6) Go to OS/2 Warp Command Prompt
*
*
*           The program will prompt the user for the drive letter of their
*           CD and will expect to find the needed recovery utilities in
*           the \Recovery subdirectory on the Aptiva OS/2 CD-Rom.
*
*/


/*
* Description: Entry point into recovery menu.
*
* NOTE: This program is NOT Generic and will need modifications for different
*       Preload images. The main areas for modification will be the Menus
*       and the Translated text.
*/
Main:

    /* Do not allow this menu to be interrupted.
    */
    CALL ON HALT

    /* Initialize all Global Variables
    */
    Call Initialize

    /* Allow Testing
    */
    Parse arg Testing

    if strip(Testing) <> "" then do
        GV._TESTING = 1
    end

    /* MENU LOOP - We spend ALL out time in this loop.
    */
    Call MainMenu
    Call Value "PROMPT","$_"||GV._Prompt2||"$_[$P]","OS2ENVIRONMENT"
    Call CLS
exit

/*:VRX         __VXREXX____APPENDS__
*/
__VXREXX____APPENDS__:
/*
*/
return
/*:VRX         AskForBoot
*/
/* Description: Prompt the user for the Boot Drive Letter.
*
*
*
*/
AskForBoot: procedure expose GV.

    Boot = GV._OriginalBootDrive
    /* Warn User that this Option is only valid on the Original Boot Drive
    */
    Msg = TranslateString(GV._BootPromptMsg,,
                          GV._Separator||Boot||,
                          GV._Separator||Boot||,
                          GV._Separator||Boot)
    Call Make_CurrentMessage Msg

    Call CLS

    Response = PromptMessage("GV._CurrentMessage.",,
                             GV._BootPromptTitle,,
                             GV._BootPrompt,,
                             5,5)

    /* If user says ok to continue then return the Boot Drive , else ""
    */
    /* MODIFIED - DEFECT 137983 - Make this logic a little more NLV
    *  enabled by keying it off of the text in the prompt. In reality
    *  the Translation file should explicitly specify the Correct response.
    */
    /* Pick up the response from the translation.
    *  Assumes the response is of the form "(Yes/No)"
    */
    Parse var GV._BootPrompt "(" AffirmativeResponse "/" .

    /* Clean it up
    */
    AffirmativeResponse = translate(strip(AffirmativeResponse))

    /* If we actually found a response string, use it
    */
    if Length(AffirmativeResponse) > 0 then do
        If abbrev(AffirmativeResponse,translate(Response),1) \== 1 then do
            Boot = ""
        end
    end
    /* If no string found, default to English
    */
    else do
        If abbrev("YES",translate(Response),1) \== 1 then do
            Boot = ""
        end
    end

return Boot
/*:VRX         AskForCD
*/
/* Description: Prompt the user for the CD Drive that has the Aptiva
*               software on it. The user MUST provide a valid drive
*               letter. This routine will access the Drive and Validate.
*
*/
AskForCD: procedure expose GV.
    /* Clear the Screen
    */
    Call CLS

    /* Create the CD Prompt
    */
    Call Make_CurrentMessage translatestring(GV._CDPromptMsg,,
                                             GV._Separator||GV._LeaveCDPrompt)


    /* We MUST get a CD-ROM Drive letter to continue
    */
    Do until (CD <> "")
        CD = PromptMessage("GV._CurrentMessage.",,
                           GV._CDPromptTitle,,
                           GV._CDPrompt,,
                            5,5)

        if (Translate(CD) \== GV._LeaveCDPrompt) then do

            CD = strip(left(CD,1))

            /* Is it valid ?
            */
            if pos(CD,GV._Drives) = 0 then do
                /* Put up error message
                */
                Call ErrorBeep
                Call GoToRowCol 15,5
                Call ClearToEOL
                Call Charout ,GV._BadCDMsg CD

                /* Clear choice
                */
                CD = ""
            end

            /* Now test to see that the proper CD is in the Drive
            *  Only test is a valid drive was provided.
            */
            If CD <> "" then do
                If ProperCD(CD) = "" then do
                    /* Put up error message
                    */
                    Call ErrorBeep
                    Call GoToRowCol 15,5
                    Call ClearToEOL
                    msg = translatestring(GV._WrongCDMsg,,
                                             GV._Separator||CD)
                    Call Charout ,msg

                    /* Clear choice
                    */
                    CD = ""
                end
                else do
                    /* Set DPATH to point to the \RECOVERY directory
                    */
                    Call Value "DPATH",,
                               "\;"||CD||":"||GV._RecoveryDir||";",,
                               "OS2ENVIRONMENT"
                end
            end
        end
        else do
            CD=""
            leave
        end
    end

    /* Clear the screen
    */
    Call CLS
return CD

/*:VRX         CommandProcessor
*/
/* Description: Invoke a Command Prompt, with special prompt.
*
*/
CommandProcessor: procedure expose GV.

    /* Tell the user how to get back
    */
    Call WriteAt 20, 1, GV._RememberExitMsg
    Call GotoRowCol 21,1
    Call Pause

    /* Clear the screen
    */
    Call WriteAt 1,1,GV._ANSI._BoldOff
    Call CLS

    /* Set up a local prompt
    */
    Call SetLocal
    "@Prompt $_"||GV._Prompt||"$_[$P]"

    /* Start the session
    */
    "@CMD"

    /* Make sure we have the correct diskette back in the drive
    */
    parse source . . me .
    parse var me . ":" me
    fspec = ""
    do while fspec == ""
        fspec = Stream(me,"C","Query Exists")
        if fspec == "" then do
            Call RequestCmdDisk
        end
        else do
            line = linein(fspec)
            Call Stream fspec,"C","CLOSE"
            if line <> GV._MEFLAG then do
                Call RequestCmdDisk
                fspec = ""
            end
        end
    end

    /* Resume normal prompt
    */
    Call EndLocal
return

/*:VRX         EditAFile
*/
/* Description: Edit A File
*
*/
EditAFile: procedure expose GV.
    Parse arg File

    /* Build the Editor Path, with possible Prompting
    */
    GV._EditorFullSpec = MakeEditorSpec()

    /* Make Sure we can locate the editor
    */
    SIGNAL ON NOTREADY Name NotReadyEdit
    DriveReady = 0
    Call Stream GV._EditorFullSpec, "D"
    DriveReady = 1

    FullSpec = Stream(GV._EditorFullSpec,"C","Query Exists")
    if FullSpec <> "" then do

        /* Get CD and Bootdrive
        */
        command = SubstituteParms(FullSpec File)
        if GV._BootDrive <> "" then do
            /* Pass the command to cmd.exe
            */
            command
        end
    end
    else do

        /* Break up the Message into separate lines (crlf delimted)
        *  Returns with GV._CurrentMessage.0 = # or lines
        *               GV._CurrentMessage.n = line n
        */
        Call Make_CurrentMessage translatestring(GV._EditorNotFoundMsg,,
                                             GV._Separator||GV._EditorFullSpec)

        Call WarningMessage "GV._CurrentMessage.", 5,5

    end

NotReadyEdit:
    if DriveReady = 0 then do

        /* Break up the Message into separate lines (crlf delimted)
        *  Returns with GV._CurrentMessage.0 = # or lines
        *               GV._CurrentMessage.n = line n
        */
        Call Make_CurrentMessage translatestring(GV._EditorDriveNotReadyMsg,,
                                         GV._Separator||GV._EditorFullSpec)
       Call WarningMessage "GV._CurrentMessage.",5,5

    end
return

/*:VRX         EditAutoexec
*/
/* Description: Edit Autoexec.bat
*
*/
EditAutoexec: procedure expose GV.
    Call EditAFile "%T:\Autoexec.bat"
return

/*:VRX         EditConfig
*/
/* Description: Edit Config.sys
*
*/
EditConfig: procedure expose GV.
    Call EditAFile "%T:\Config.sys"
return

/*:VRX         EditStartup
*/
/* Description: Edit Startup.cmd
*
*/
EditStartup: procedure expose GV.
    Call EditAFile "%T:\startup.cmd"
return

/*:VRX         ExecuteACommand
*/
/* Description: This is where all the work happens. Each command = line in the
*               recovery script is passed to this routine and if it is a
*               known command, the command line is massaged if needed and
*               executed. If it is an unknown command it is assumed to be a
*               REXX interpretable string and is interpreted.
*
*/
ExecuteACommand: procedure expose GV.
    parse arg Command

    /* Clear Result Code
    */
    ResultCode = ""

    /* Split command into Verb , Parameters
    */
    parse var Command Verb "," Parameters

    /* Now get the uppercase version of the command for comparison
    */
    Command= translate(Verb)

    /* Add in the CD and Bootdrives
    */
    Parameters = SubstituteParms(Parameters)

    Select
        when Command = "UNZIP" then do
            say GV._UnzipImageMsg
            GV._CD||":"||GV._RecoveryDir||"\UNZIP "Parameters
            ResultCode = rc
        end
        when Command = "LOADRAM2" then do
            GV._CD||":"||GV._RecoveryDir||"\LOADRAM2 "Parameters
            ResultCode = rc
        end
        when Command = "RESTORE" then do
            "ECHO Y | "GV._CD||":"||GV._RecoveryDir||"\RESTORE "Parameters "/S"
            ResultCode = rc
        end
        when Command = "RECOVER" then do
            "ECHO Y | "GV._CD||":"||GV._RecoveryDir||"\RESTORE "Parameters "/S"
            ResultCode = rc
        end
        when Command = "ATTRIB" then do
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "Parameters
        end
        when Command = "UNPACK" then do
            GV._CD||":\RECOVERY\UNPack /C "Parameters GV._BootDrive":"
        end
        when Command = "MKDIR" then do
            "MKDir "Parameters
        end
        when Command = "EAJOIN" then do
            GV._CD||":\RECOVERY\EAUTIL /J" Parameters
        end
        when Command = "COPY" then do
            "Copy "Parameters
            ResultCode = rc
        end
        when Command = "SYSINSTX" then do
            "SysInstX "GV._BootDrive":"
            ResultCode = rc
        end
        when Command = "DELETE" then do
            "Delete "Parameters
        end
        when Command = "RMDIR" then do
            "RmDir "Parameters
        end
        when Command = "MKMAGICBOOTABLE" then do
            /*  (126770) Enable a system to boot from DOS
            */
            call MakeSystemDOSBootable
        end
        when Command = "PRLDTBLCOPY" then do
            /*  (127646) Handle refreshing of PRLDUZIP.TBL file.
            *            This file is required for PRLDUZIP.CMD.
            *   (127707) Made "say" commands NLS enabled.
            */
            parse var Parameters fromfile tofile .
            if (Stream(fromfile,'c','query exists') == "") then do
                say GV._PrldZipTblErr
                say translatestring(GV._FileExistErr,GV._Separator||fromfile)
                ResultCode = 99
            end
            else do
                cpystr = GV._Separator||fromfile||GV._Separator||tofile
                say translatestring(GV._CopyAFileMsg,cpystr)
                "Copy "fromfile" "tofile
                ResultCode = rc
            end
        end
        when Command = "UNLOCKFILES" then do
            /*  (127707) Unlock all +R +S +H files
            */
            say GV._UnlockingFilesMsg
            if (LastPos("\",Parameters) == Length(Parameters)) then do
                 searchspec = Parameters||"*.*"
            end
            else searchspec = Parameters
            call GatherLockedFiles searchspec, GV._AttributeWorkFile
            do z = 1 to GV._LockedFileList.0
                itemstr = TurnOffAttrString(GV._LockedFileList.z._Attributes)||" "||,
                          '"'||GV._LockedFileList.z._File||'"'
                say translatestring(GV._UnLockAFileMsg,GV._Separator||GV._LockedFileList.z._File)
                GV._CD||":"||GV._RecoveryDir||"\ATTRIB "itemstr
            end
        end
        when Command = "LOCKFILES" then do
            /*  (127707) Re-lock all "unlocked" files and
            *   handle [Image File Attributes] section
            */
            say GV._LockingFilesMsg
            do z = 1 to GV._LockedFileList.0
                itemstr = TurnOnAttrString(GV._LockedFileList.z._Attributes)||" "||,
                          '"'||GV._LockedFileList.z._File||'"'
                say translatestring(GV._LockAFileMsg,GV._Separator||GV._LockedFileList.z._File)
                GV._CD||":"||GV._RecoveryDir||"\ATTRIB "itemstr
            end
            if ProcessPreservedImageAttributes() then do
                say GV._MissingPreserveSection
                ResultCode = 98
            end
        end
        when Command = "RESTORECONFIGFILES" then do
            /*  (128484) Restore configuration files.
            */
            ResultCode = RestoreConfigFiles()
        end
        otherwise do
            /*  Attempt to process unknown command
            */
            Interpret Command Parameters
        end
    end
    if ResultCode \== "" & ResultCode \== 0 then do
        Say ""
        Say GV._CommandError
        Call Pause
        Say ""; Say ""
    end

return GV.Success

/*:VRX         ExecuteCommands
*/
/* Description: Searches thru SectionNames commands and passes the commands
*               one at a time to ExecuteACommand.
*
*/
ExecuteCommands: procedure expose GV.
    Parse UPPER arg SectionName

    /* Find this SectionName
    */
    Section = 0
    do i = 1 to GV._ScriptSections.0
        if translate(GV._ScriptSections.i) = SectionName then do
            Section = i
            leave
        end
    end

    /* If we found the section
    */
    if Section <> 0 then do
        /* Look for the command= keywords
        */
        do i = 1 to GV._Script.Section.0
            line = GV._Script.Section.i
            parse var line keyword "=" value

            /* If we found one, execute it
            */
            if translate(keyword) = "COMMAND" then do
                ok = ExecuteACommand(value)
            end
        end
        /* Success if we found a section
        */
        ExitCode = GV._Success
    end
    else do
        /* Failure if we could not find a section
        */
        ExitCode = GV._Fail
    end
return ExitCode


/*:VRX         ExecuteConfig
*/
/* Description: Searches thru Config Section
*
*/
ExecuteConfig: procedure expose GV.
    Parse UPPER arg SectionName

    /* Find this SectionName
    */
    Section = 0
    do i = 1 to GV._ScriptSections.0
        if translate(GV._ScriptSections.i) = SectionName then do
            Section = i
            leave
        end
    end

    /* If we found the section
    */
    if Section <> 0 then do
        /* Look for the command= keywords
        */
        do i = 1 to GV._Script.Section.0
            line = GV._Script.Section.i
            parse var line keyword "=" value

            /* If we found one, execute it
            */
            keyword = translate(keyword)
            select
                when keyword = "BOOTDRIVE" then do
                    GV._OriginalBootDrive = value
                end
                when keyword = "RECOVERYDIR" then do
                    GV._RecoveryDir = value
                end
                otherwise do
                    nop
                end
            end
        end
        /* Success if we found a section
        */
        ExitCode = GV._Success
    end
    else do
        /* Failure if we could not find a section
        */
        ExitCode = GV._Fail
    end
return ExitCode

/*:VRX         FatalError
*/
/* Description: Warn user or Error that we cannot recover from.
*
*/
FatalError: procedure expose GV.

    Parse arg messagestem
    Col = 5
    Call ErrorMessage messagestem, 5, 5

exit

/*:VRX         Halt
*/
/* Description: Allow Control-Break but tell the user how to get back.
*
*/
Halt:
    /* Tell the user how to get back
    */
    Call WriteAt 1,1, GV._ANSI._BlackBack||GV._ANSI._WhiteFore
    Call CLS

    Call WriteAt 20, 1, GV._RememberHaltMsg
    Call GotoRowCol 22,1
    Call Pause

    /* Clear the screen
    */
    Call WriteAt 1,1,GV._ANSI._BoldOff
    Call CLS

    "@Prompt $_"||GV._HaltPrompt||"$_[$P]"

    exit
return

/*:VRX         Help
*/
Help: procedure expose GV.

    /* Set the Screen Color
    */
    Say GV._ANSI._ScreenColor

    /* Make the color take hold
    */
    Call CLS

    /* Help starts here
    */
    Row = 1 ; Col = 1

    Num = Make_CurrentMessage(GV._Helpmsg)

    Call WriteStemAt Row,Col,"GV._CurrentMessage."

    Call WriteAt 25,1,GV._ClearHelpMsg
    Call GetResponse
return

/*:VRX         Initialize
*/
/* Description: Set up Global Variables
*
*/
Initialize: procedure expose GV.

    /* Create and Text strings
    */
    GV.=""
    Call Translation

    /* Initialze ANSI Package
    */
    Call ANSIInit

    /* We control the screen
    */
    "@ECHO OFF"

    /* Load Rexx Utilities DLL
    */
    Call LoadExternalFuncs 7

    /* Flag to see if we read in the recovery script
    */
    GV._CommandFileRead = 0

    /* Path to recovery script
    */
    GV._RecoverFileSpec = ":\recovery\recover.scr"
    GV._RecoverFileSpec1 = ":\recovery\attrib.exe"
    GV._RecoverFileSpec2 = ":\recovery\unzip.exe"

    /* Recovery script Section names
    */
    GV._AptivaWare = "AptivaWare"
    GV._ConfigFiles = "ConfigFiles"
    GV._Config = "Configuration"

    /* Return Codes
    */
    GV._Fail = 1
    GV._Success = 0

    /* Possible drive letters
    */
    GV._Drives = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    /* Translation separator
    */
    GV._Separator = "%"

    /* Menu selections and associated Functions
    */
    GV._MainMenu._Selections = "1 2 3 4 5 6"
    GV._MainMenu._Functions  = "RecoverBoth "||,
                             "RecoverConfig EditAutoexec "||,
                             "EditConfig EditStartup CommandProcessor"
    GV._EscapeChars = ""

    /* Help flags
    */
    GV._HELPFLAG =  "HELP TEXT "
    GV._HELPSTART = "START"
    GV._HELPEND   = "END"

    /* Location of TEDIT
    */
    GV._EditorDisk = "2"    /* 1, 2, 3 or %S or %T or A, B */
    GV._EditorPath = "\TEDIT.EXE"

    /* Location of Recovery CMD File
    */
    GV._CmdDisk = "2"
    GV._CmdDrive = "A"

    /* Original Boot Drive that the recovery images were made from
    */
    GV._OriginalBootDrive = "C"

    /* Expected Recovery Directory
    */
    GV._RecoveryDir = "\Recovery"

    /*  (127707) Default Attribute work file and Boot Data File.
    */
    GV._AttributeWorkFile = "C:\ATTRDATA.!!!"
    GV._BootDataFile = "C:\BOOTDATA.!!!"

    /* First line of this program - used to check if correct disk is inserted
    */
    GV._MEFLAG = "/*:VRX         MAIN"

    /* Retranslate MRI with any replacable strings.
    */
    Call Translation
return

/*:VRX         MainMenu
*/
MainMenu: procedure expose GV.

    /* Set flag to Clear the Screen
    */
    Clear = 1

    /* Start with first menu item selected
    */
    HighLight = 1

    /* Flush the Keyboard
    */
    do while Chars()
        Call PrldGetKey "NOECHO"
    end

    /* Do until we get the Escape sequence
    */
    option = Menu("GV._MainMenu.", GV._MainMenuPrompt,,
                   GV._MainMenuTitle, HighLight, Clear , GV._EscapeChars)
return

/*:VRX         MakeEditorSpec
*/
/* Description: Build fully qualified filespec for editor. And possibly
*               prompt for Diskette insertion.
*/
MakeEditorSpec: procedure expose GV.
    Select
        when wordpos(GV._EditorDisk,"1 2 3") <> 0 then do
            /* Prompt for Disk Insertion
            */
            Drive = "A"
            Call Make_CurrentMessage translatestring(GV._PromptForEditorMsg,,
                                         GV._Separator||GV._EditorDisk)

            Call MessageAndWait "GV._CurrentMessage.",,
                                5,5,,
                                GV._ANSI._ScreenColor,GV._ANSI._ScreenColor

        end
        when Pos("%",GV._EditorDisk) then do
            /* Replace Drive
            */
            Drive = SubstituteParms(GV._EditorDisk)
        end
        otherwise do
            Drive = GV._EditorDisk
        end
    end
    FullSpec = Drive||":"||GV._EditorPath
return FullSpec

/*:VRX         ProperCD
*/
/* Description: Verify that the CD in the drive specified by the user
*               has the proper files in it.
*
*/
ProperCD: procedure expose GV.
    Parse arg CDDrive
    ExitCode = ""
    SIGNAL ON NOTREADY Name CDNotReady
    ExitCode = Stream(CDDrive||GV._RecoverFileSpec,"C","Query Exists")
    if ExitCode <> "" then do
        ExitCode = Stream(CDDrive||GV._RecoverFileSpec1,"C","Query Exists")
    end
    if ExitCode <> "" then do
        ExitCode = Stream(CDDrive||GV._RecoverFileSpec2,"C","Query Exists")
    end
CDNotReady:
return ExitCode

/*:VRX         ReadCommandFile
*/
/* Description: Reads in the recover script and creates the recovery structure.
*               This structure consists of;
*
*               GV._ScriptSections.0 : Number of Sections read.
*               GV._ScriptSections.1,n : Each Section Name
*               GV._Script.i.0 : The number of keys for GV._ScriptSections.i
*               GV._Script.i.1,n : Each keyword for GV._ScriptSections.i
*
*  Returns: The number of sections found.
*
*/
ReadCommandFile: procedure expose GV.
    parse arg FileName

    /* Initialize Global Script Data Variable
    */
    GV._Script.=""
    GV._ScriptSections. = ""
    GV._ScriptSections.0 = 0

    rc = Linein(FileName,1,0)

    /* Skip to first section, so we do not have to always test for it
    */
    Section = ""
    do while lines(FileName) > 0
        line = Linein(FileName)

        /* Did we find a section
        */
        if left(line,1) = "[" then do
            /* Clean it up, remove the [ ]
            */
            line = strip(line)
            Sections = GV._ScriptSections.0 + 1
            Section = substr(Line,2,length(Line) - 2)

            /* Save it and increase the count
            */
            Call Value "GV._ScriptSections."||Sections, Section
            GV._ScriptSections.0 = Sections
            leave
        end
    end

    /* Now get the rest of the file
    */
    do while lines(FileName) > 0
        line = Linein(FileName)
        Select
            /* New Section
            */
            when left(line,1) = "[" then do
                /* Clean it up, remove the [ ]
                */
                line = strip(line)
                Sections = GV._ScriptSections.0 + 1
                Section = substr(Line,2,length(Line) - 2)

                /* Save it and increase the count
                */
                Call Value "GV._ScriptSections."||Sections, Section
                GV._ScriptSections.0 = Sections
            end
            /* Comment or Empty line
            */
            when left(line,1) = ";"  | strip(line) = "" then do
                nop
            end
            when pos("=",line) <> 0 then do
                /* See if we have seen this Section/keyword before
                */
                if datatype(GV._Script.Sections.0) <> "NUM" then do
                    Call Value "GV._Script."||Sections.0 , 0
                end

                /* increase the count
                */
                index = value("GV._Script."||Sections.0) + 1

                /* Save this keyword
                */
                Call Value "GV._Script."Sections.index, line
                Call Value "GV._Script."Sections.0, index
            end
            otherwise do
                nop
            end
        end
    end
return GV._ScriptSections.0

/*:VRX         Recover
*/
Recover: procedure expose GV.
    parse arg section

    /* Make sure we have the driver info we need first
    */
    if GV._CommandFileRead = 0 then do
        if GV._CD == "" then do
            GV._CD = AskForCD()
        end
        if GV._CD <> "" then do
            GV._BootDrive = AskForBoot()
        end

        /* Get out early if the user does not want to continue
        */
        if GV._BootDrive == "" then do
            return 0
        end
        if GV._CD == "" then do
            return 0
        end

        /* Read in the recovery script
        */
        GV._CommandFileRead = ReadCommandFile(GV._CD||GV._RecoverFileSpec)
    end
    /* If read went well , execute the commands
    */
    if GV._CommandFileRead <> 0 then do
        ok = ExecuteCommands(section)
    end
    else do
        /* Report Error
        */
        Call Make_CurrentMessage GV._CouldNotReadMsg
        Call FatalError "GV._CurrentMessage.", 5,5
    end
return ok

/*:VRX         RecoverAptiva
*/
/* Description: ReCreates All Aptiva Application files on users hard drive.
*
*/
RecoverAptiva: procedure expose GV.
        ok = Recover(GV._AptivaWare)
return ok

/*:VRX         RecoverBoth
*/
/* Description: Recover Aptiva Software and OS/2
*
*/
RecoverBoth: procedure expose GV.
    ok = Recover(GV._AptivaWare)
return

/*:VRX         RecoverConfig
*/
/* Description: Recover Configuration Files
*
*/
RecoverConfig: procedure expose GV.
        ok = Recover(GV._ConfigFiles)
return

/*:VRX         RecoverOS2
*/
/* Description: Recreates all of OS2 on the users Hard drive
*
*/
RecoverOS2: procedure expose GV.
    ok = Recover(GV._OS2)
return ok

/*:VRX         RecoveryScriptSpec
*/
RecoveryScriptSpec: procedure expose GV.
/*
This section documents the format of the Recovery Scripts and the respective
keywords. The basic format is similar to the Standard Windows INI file layout
with Sections left justified and delimited with [ ].

[A Section]

Comments start in column 1 with a semi-colon.

; this is a comment

Keywords and values are paired between sections and are separated by the
equal (=) sign.

keyword=value

Keywords are not case sensitive but values are.
When using Keywords that cause execution or display text, order is important
and execution/display will occur from Top of File towards End of File.

The Following strings may be used in values and will be translated as specified
below;

%S = Source Drive Letter: The drive where the Recovery files are located.
%T = Target Drive Letter: The drive where the Recovered file will be
                         recovered to.

The Following special section if available may contain Configuration info.
[Configuration]


Keyword         Description
--------------  ---------------------------------------------------------------
description     One line of text describing this section. This should make
                sense to the end user and needs to be translated.

command         Command to be executed. This will usually consist of two parts.
                The first part is the command and if this command is not
                one of the specially interpreted commands listed below, it
                will be first concatenated with the second part  and then
                passed to the rexx processor and "INTERPRETED" thus
                allowing the dynamic assignment of variables via the script.
                The second part of the command will usually be parameters for
                the first part.

                The command and parameters will be separated by a comma.

                The following command/parameters are specially defined.

                unpack, bundlefilespec
                    Will cause the bundle to be unpacked from the Recovery
                    path to the Recovered To drive.

                unzip, zipfilespec
                    Will cause the zipfile to be unziped from the Recovery
                    path to the Recovered To drive.

                mkdir, dirspec
                    Will attempt to create the dirspec directory.

                eajoin, dirspec
                    Will look for a file in the dirspec with the same name as
                    dirspec and an extension of .eaf and will use EAUTIL to
                    join them.

                    or
                eajoin, dirspec filespec
                    Will look for filespec and will use EAUTIL to join it to
                    dirspec.

                sysinstx, driveletter
                    Will run SYSINSTX on driveletter to make it bootable.

*/
return

/*:VRX         MakeSystemDOSBootable
*/
MakeSystemDOSBootable: procedure expose GV.

    /*  (126770) Enable a system to boot from DOS
    */
    fspec = GV._BootDrive||":\OS2\SYSTEM\*.DOS"
    say translatestring(GV._UnLockAFileMsg,GV._Separator||fspec)
    GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||fspec||" -R -H -S"
    if QueryFileExists( fspec ) then do
         say translatestring(GV._EraseAFileMsg,GV._Separator||fspec)
        "erase "fspec
    end
    fspec = GV._BootDrive||":\OS2\SYSTEM\*.OS2"
    say translatestring(GV._UnLockAFileMsg,GV._Separator||fspec)
    GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||fspec||" -R -H -S"
    if QueryFileExists( fspec ) then do
         say translatestring(GV._EraseAFileMsg,GV._Separator||fspec)
        "erase "fspec
    end
    "SysInstX "GV._BootDrive":"
    cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.OS2 "||,
             GV._Separator||GV._BootDrive||":\AUTOEXEC.BAT"
    say translatestring(GV._CopyAFileMsg,cpystr)
    "copy "GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.OS2 "||GV._BootDrive||":\AUTOEXEC.BAT"
    cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\CONFIG.OS2 "||,
             GV._Separator||GV._BootDrive||":\CONFIG.SYS"
    say translatestring(GV._CopyAFileMsg,cpystr)
    "copy "GV._CD||":"||GV._RecoveryDir||"\CONFIG.OS2 "||GV._BootDrive||":\CONFIG.SYS"
    cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.DOS "||,
             GV._Separator||GV._BootDrive||":\OS2\SYSTEM\AUTOEXEC.DOS"
    say translatestring(GV._CopyAFileMsg,cpystr)
    "copy "GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.DOS "||GV._BootDrive||":\OS2\SYSTEM\AUTOEXEC.DOS"
    cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\BOOT.DOS "||,
             GV._Separator||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS"
    say translatestring(GV._CopyAFileMsg,cpystr)
    "copy "GV._CD||":"||GV._RecoveryDir||"\BOOT.DOS "||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS"
    cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\COMMAND.DOS "||,
             GV._Separator||GV._BootDrive||":\OS2\SYSTEM\COMMAND.DOS"
    say translatestring(GV._CopyAFileMsg,cpystr)
    "copy "GV._CD||":"||GV._RecoveryDir||"\COMMAND.DOS "||GV._BootDrive||":\OS2\SYSTEM\COMMAND.DOS"
    cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\CONFIG.DOS "||,
             GV._Separator||GV._BootDrive||":\OS2\SYSTEM\CONFIG.DOS"
    say translatestring(GV._CopyAFileMsg,cpystr)
    "copy "GV._CD||":"||GV._RecoveryDir||"\CONFIG.DOS "||GV._BootDrive||":\OS2\SYSTEM\CONFIG.DOS"
    say translatestring(GV._LockAFileMsg,GV._Separator||GV._BootDrive||":\OS2\SYSTEM\*.DOS")
    GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||GV._BootDrive||":\OS2\SYSTEM\*.DOS +A"
    say translatestring(GV._LockAFileMsg,GV._Separator||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS")
    GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS +R"
    Call Make_CurrentMessage GV._RemoveDisketteMsg
    Call WarningMessage "GV._CurrentMessage.", 5,5
    GV._CD||":"||GV._RecoveryDir||"\BOOT /DOS /QUIET"

return

/*:VRX         RequestCmdDisk
*/
RequestCmdDisk: procedure expose GV.
    Call CLS
    Call ErrorBeep
    Call Make_CurrentMessage translatestring(GV._ReinsertDiskMsg,,
                                         GV._Separator||GV._CmdDisk||,
                                         GV._Separator||GV._CmdDrive)


    Call WriteStemAt 5,5,"GV._CurrentMessage."
    Pull junk
return

/*:VRX         SubstituteParms
*/
/* Description: Replaces %S with Source Drive and %T with Target Drive.
*
*/
SubstituteParms: procedure expose GV.

    parse arg p

    /* Make sure the substitute parms have values
    */
    if pos("%T",translate(p)) <> 0 then do
        if GV._BootDrive = "" then do
            GV._BootDrive = AskForBoot()
        end
    end

    if GV._BootDrive <> "" then do
        if pos("%S",translate(p)) <> 0 then do
            if GV._CD = "" then do
                GV._CD = AskForCD()
            end
        end
        /* Handle %S %T
        */
        p = ReplaceAll("%S",GV._CD,p)
        p = ReplaceAll("%T",GV._BootDrive,p)
    end
return p

/*:VRX         GatherLockedFiles
*/
GatherLockedFiles: Procedure Expose GV.

    parse arg fspec, workfile;

    /*  We can not use SysFileTree() since PRLDLITE
    *   does not have this function. So, we will
    *   process the piped output of ATTRIB.
    */
    GV._CD||":"||GV._RecoveryDir||"\ATTRIB "fspec" /S > "workfile

    /*  Handle Hidden/System/Readonly Files
    */
    item = 0
    do while(Lines(workfile))
        itemstr = Linein(workfile)
        colonpos = Pos(":",itemstr)
        Select
            when(colonpos == 0) then do
                attr = itemstr
                if pos("S",attr) \== 0 | pos("H",attr) \== 0 | pos("R",attr) \== 0 then do
                    item = item + 1
                    GV._LockedFileList.item._Attributes = attr
                    GV._LockedFileList.item._File       = Linein(workfile)
                end
                else junk = Linein(workfile)
            end
            when(colonpos >= 3) then do
                attr = Strip(SubStr(itemstr,1,colonpos-2))
                if pos("S",attr) \== 0 | pos("H",attr) \== 0 | pos("R",attr) \== 0 then do
                    item = item + 1
                    GV._LockedFileList.item._File       = Strip(SubStr(itemstr,colonpos-1))
                    GV._LockedFileList.item._Attributes = attr
                end
            end
            otherwise do
                nop
            end
        end
    end
    GV._LockedFileList.0 = item
    call Lineout workfile
    say translatestring(GV._EraseAFileMsg,GV._Separator||workfile)
    'erase 'workfile

return

/*:VRX         TurnOnAttrString
*/
TurnOnAttrString: Procedure Expose GV.

    parse arg str
    newstr = ""
    do while(str \== "")
        parse var str ch 2 str
        if ch \== " " then do
            newstr = newstr" +"ch
        end
    end

return newstr

/*:VRX         TurnOffAttrString
*/
TurnOffAttrString: Procedure Expose GV.

    parse arg str
    newstr = ""
    do while(str \== "")
        parse var str ch 2 str
        if ch \== " " then do
            newstr = newstr" -"ch
        end
    end

return newstr

/*:VRX         ProcessPreservedImageAttributes
*/
/* Description: For each card in the [Image File Attribute] section
*               of the script file, process the appropriate ATTRIB
*               command.
*/
ProcessPreservedImageAttributes: procedure expose GV.

    /* See if [Image File Attributes] section exists
    */
    Section = 0
    do i = 1 to GV._ScriptSections.0
        if translate(GV._ScriptSections.i) == "IMAGE FILE ATTRIBUTES" then do
            Section = i
            leave
        end
    end

    /* If we found the section
    */
    if Section <> 0 then do
        /* Look for the attribdata= keyword
        */
        do i = 1 to GV._Script.Section.0
            line = GV._Script.Section.i
            parse var line keyword "=" valuestr

            /* If we found one, set attributes for specified file
            */
            if translate(keyword) = "ATTRIBDATA" then do
                parse var valuestr attr file
                itemstr = '"'||file||'"'||" "||TurnOnAttrString(Translate(attr," ","-"))
                say translatestring(GV._LockAFileMsg,GV._Separator||file)
                GV._CD||":"||GV._RecoveryDir||"\ATTRIB "itemstr
            end

        end
        /* Success if we found a section
        */
        ExitCode = GV._Success
    end
    else do
        /* Failure if we could not find a section
        */
        ExitCode = GV._Fail
    end

return ExitCode

/*:VRX         RestoreConfigFiles
*/
/* Description: Restore appropriate configuration files for the
*               OS currently enabled.
*/
RestoreConfigFiles: procedure expose GV.

    rcode = 0

    /*  Determine OS currently active.
    */
    GV._CD||":"||GV._RecoveryDir||"\BOOT /QUERY > "GV._BootDataFile
    bootdata = LineIn(GV._BootDataFile)
    osid = Word(bootdata,7)

    /*  Restore appropriate files for active OS.
    *   (128510) 1. Add unzip command for PS1BOOT files to DOS case.
    *            2. Fix Access Denied message on Boot.DOS|OS2 files.
    *            3. Add user messages for copy/attrib/erase commands.
    */
    Select
        when(osid == "DOS") then do
            fspec = GV._BootDrive||":\OS2\SYSTEM\*.DOS"
            say translatestring(GV._UnLockAFileMsg,GV._Separator||fspec)
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||fspec||" -R -H -S"
            if QueryFileExists( fspec ) then do
                 say translatestring(GV._EraseAFileMsg,GV._Separator||fspec)
                "erase "fspec
            end
            fspec = GV._BootDrive||":\OS2\SYSTEM\*.OS2"
            say translatestring(GV._UnLockAFileMsg,GV._Separator||fspec)
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||fspec||" -R -H -S"
            if QueryFileExists( fspec ) then do
                 say translatestring(GV._EraseAFileMsg,GV._Separator||fspec)
                "erase "fspec
            end
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.DOS "||,
                     GV._Separator||GV._BootDrive||":\AUTOEXEC.BAT"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.DOS "||GV._BootDrive||":\AUTOEXEC.BAT"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\CONFIG.DOS "||,
                     GV._Separator||GV._BootDrive||":\CONFIG.SYS"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\CONFIG.DOS "||GV._BootDrive||":\CONFIG.SYS"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.OS2 "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\AUTOEXEC.OS2"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.OS2 "||GV._BootDrive||":\OS2\SYSTEM\AUTOEXEC.OS2"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\BOOT.OS2 "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\BOOT.OS2"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\BOOT.OS2 "||GV._BootDrive||":\OS2\SYSTEM\BOOT.OS2"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\CONFIG.OS2 "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\CONFIG.OS2"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\CONFIG.OS2 "||GV._BootDrive||":\OS2\SYSTEM\CONFIG.OS2"
            say translatestring(GV._LockAFileMsg,GV._Separator||GV._BootDrive||":\OS2\SYSTEM\*.OS2")
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||GV._BootDrive||":\OS2\SYSTEM\*.OS2 +A"
            say translatestring(GV._LockAFileMsg,GV._Separator||GV._BootDrive||":\OS2\SYSTEM\BOOT.OS2")
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||GV._BootDrive||":\OS2\SYSTEM\BOOT.OS2 +R"
            GV._CD||":"||GV._RecoveryDir||"\UNZIP -o "||,
                  GV._CD||":\RECOVERY\SYSTEM.ZIP ps1boot\* -d "||GV._BootDrive||":\"
        end
        when(osid == "OS2") then do
            fspec = GV._BootDrive||":\OS2\SYSTEM\*.DOS"
            say translatestring(GV._UnLockAFileMsg,GV._Separator||fspec)
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||fspec||" -R -H -S"
            if QueryFileExists( fspec ) then do
                 say translatestring(GV._EraseAFileMsg,GV._Separator||fspec)
                "erase "fspec
            end
            fspec = GV._BootDrive||":\OS2\SYSTEM\*.OS2"
            say translatestring(GV._UnLockAFileMsg,GV._Separator||fspec)
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||fspec||" -R -H -S"
            if QueryFileExists( fspec ) then do
                 say translatestring(GV._EraseAFileMsg,GV._Separator||fspec)
                "erase "fspec
            end
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.OS2 "||,
                     GV._Separator||GV._BootDrive||":\AUTOEXEC.BAT"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.OS2 "||GV._BootDrive||":\AUTOEXEC.BAT"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\CONFIG.OS2 "||,
                     GV._Separator||GV._BootDrive||":\CONFIG.SYS"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\CONFIG.OS2 "||GV._BootDrive||":\CONFIG.SYS"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.DOS "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\AUTOEXEC.DOS"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\AUTOEXEC.DOS "||GV._BootDrive||":\OS2\SYSTEM\AUTOEXEC.DOS"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\BOOT.DOS "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\BOOT.DOS "||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\COMMAND.DOS "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\COMMAND.DOS"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\COMMAND.DOS "||GV._BootDrive||":\OS2\SYSTEM\COMMAND.DOS"
            cpystr = GV._Separator||GV._CD||":"||GV._RecoveryDir||"\CONFIG.DOS "||,
                     GV._Separator||GV._BootDrive||":\OS2\SYSTEM\CONFIG.DOS"
            say translatestring(GV._CopyAFileMsg,cpystr)
            "copy "GV._CD||":"||GV._RecoveryDir||"\CONFIG.DOS "||GV._BootDrive||":\OS2\SYSTEM\CONFIG.DOS"
            say translatestring(GV._LockAFileMsg,GV._Separator||GV._BootDrive||":\OS2\SYSTEM\*.DOS")
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||GV._BootDrive||":\OS2\SYSTEM\*.DOS +A"
            say translatestring(GV._LockAFileMsg,GV._Separator||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS")
            GV._CD||":"||GV._RecoveryDir||"\ATTRIB "||GV._BootDrive||":\OS2\SYSTEM\BOOT.DOS +R"
        end
        otherwise do
            say translatestring(GV._UnknownBootableOS,GV._Separator||osid)
            rcode = 97
        end
    end

    /*  Cleanup
    */
    call Lineout GV._BootDataFile
    say translatestring(GV._EraseAFileMsg,GV._Separator||GV._BootDataFile)
    'erase 'GV._BootDataFile

return rcode

/*:VRX         QueryFileExists
*/
/* Description: Return true(1) if file exists, otherwise return false(0)
*/
QueryFileExists: Procedure expose GV.

    parse arg fname;

    if (stream(fname,'c','query exists') \== "") then do
        fExists = 1
    end
    else fExists = 0

return fExists

/*:VRX         Translation
*/
/* Description: All translatable text
*
*/
Translation: procedure expose GV.

    crlf = "0D0A"x

    GV._MainMenu.0 = 6
    GV._MainMenu.1 = " Recuperar la imagen de OS/2 Warp de Aptiva"
    GV._MainMenu.2 = " Recuperar los archivos de configuración"
    GV._MainMenu.3 = " Editar AUTOEXEC.BAT"
    GV._MainMenu.4 = " Editar CONFIG.SYS"
    GV._MainMenu.5 = " Editar STARTUP.CMD"
    GV._MainMenu.6 = " Ir al indicador de mandatos de OS/2 Warp"

    GV._MainMenuPrompt = "Seleccione una opción."
    GV._MainMenuTitle  = "Menú Recuperación de Aptiva"

    GV._CommandError  = ,
"El mandato anterior ha indicado una anomalía. Anote el mensaje"||crlf||,
"de error y comunique este problema al Servicio de OS/2."

    GV._FatalErrorMsg = "Comunique este error al Servicio de OS/2."

    GV._CDPromptTitle = "Solicitando la letra de la unidad de CD-Rom"
    GV._CDPrompt      = "Letra de unidad: "

    GV._LeaveCDPrompt   = "ABANDONAR"
    GV._CDPromptMsg = ,
         "Inserte el CD de Exploración de Multimedia de Aptiva en  "||crlf||,
         "la unidad de CD-ROM. Seguidamente teclee la letra de unidad de  "||crlf||,
         "la unidad de CD-ROM. Si no ha modificado la      "||crlf||,
         "configuración del sistema, es probable que sea la D.        "||crlf||crlf||,
         "Teclee "||GV._LeaveCDPrompt||" y pulse INTRO para regresar al Menú."

    GV._BootPromptTitle = "¿Está seguro?"
    GV._BootPrompt      = "¿Desea continuar? (Sí/No): "

    GV._BootPromptMsg = ,
"El programa de Recuperación supone que OS/2 y el software de las aplicaciones de "||crlf||,
"Aptiva están instalados en la unidad %. Toda la restauración se llevará a cabo en    "||crlf||,
"la unidad %. Todas las opciones de Editar suponen que los archivos que deben editarse se   "||crlf||,
"encuentran en la unidad %. Si ésta no es la unidad en la que ha arrancado OS/2 o en "||crlf||,
"la que reside el software de Aptiva, no debe continuar. "


    GV._BadCDMsg    = "La siguiente unidad no es una unidad de CD-ROM válida: "
    GV._WrongCDMsg  = "No se han encontrado los archivos necesarios en la unidad %."

    GV._RememberExitMsg = "Recuerde que debe teclear EXIT para regresar al menú Recuperación"

    GV._Prompt      = "Teclee EXIT para volver al Menú"

    GV._PromptForEditorMsg = "Asegúrese de que el Disquete % de recuperación de Aptiva se encuentra en la unidad A:"

    GV._EditorNotFoundMsg = "% no se encuentra. "||crlf||,
                           "Si ha trasladado el Editor a otra unidad/directorio, es"||crlf||,
                           "probable que pueda invocarlo desde la opción 'Ir al indicador de OS/2'."

    GV._EditorDriveNotReadyMsg = "¡La unidad con el mandato % no está lista!"||crlf||,
                                "Inserte el Disquete o CD correcto."


    GV._CouldNotReadMsg ="El programa de recuperación no ha podido encontrar los archivos necesarios."||crlf||crlf||,
                          GV._FatalErrorMsg



    GV._HelpMsg = ""||,
    "                AYUDA PARA EL MENU RECUPERACION DE APTIVA                "||crlf||,
    "                                                                         "||crlf||,
    " Utilice el Disquete de RECUPERACION de Aptiva como ayuda para solucionar"||crlf||,
    " problemas (archivos de sistema corruptos o errores de software). Puede ;"||crlf||,
    "                                                                         "||crlf||,
    " (1) Instalar el software original de Aptiva y el software original del "||crlf||,
    "     sistema operativo OS/2 a partir de los disquetes que ha creado y de "||crlf||,
    "     las imágenes que acompañaban al Aptiva.                             "||crlf||,
    " (2) Recuperar archivos de Configuración.                                "||crlf||,
    " (3) Utilizar el editor TEDIT para editar el archivo AUTOEXEC.BAT.       "||crlf||,
    " (4) Utilizar el editor TEDIT para editar el archivo CONFIG.SYS.         "||crlf||,
    " (5) Utilizar el editor TEDIT para editar el archivo STARTUP.CMD.        "||crlf||,
    " (6) Ir a un indicador de mandatos de OS/2. Desde ahí puede acceder a    "||crlf||,
    "     BACKUP y RESTORE para crear y restaurar un juego de disquetes de    "||crlf||,
    "     seguridad o usar CHKDSK para buscar errores en el disco duro,       "||crlf||,
    "     o FORMAT y FDISK para corregir los errores principales de disco. Vea"||crlf||,
    "     Consulta de mandatos de OS/2 para más detalles sobre los anteriores."||crlf||,
    "                                                                         "
/*            111111111122222222223333333333444444444455555555556666666666777*/
/*   123456789012345678901234567890123456789012345678901234567890123456789012*/
/* Translators: Keep text within quotes and do not add lines                 */

    GV._ClearHelpMsg = "Pulse cualquier tecla para volver al menú Recuperación."
    GV._ReinsertDiskMsg = "Vuelva a insertar el Disquete % de recuperación en la unidad %."

    /*  (126770) Warning message to remove disktette from drive A:
    */
    GV._RemoveDisketteMsg = "El sistema está a punto de rearrancar en la imagen recuperada."||crlf||,
                            "Por favor, extraiga el Disquete #2 de recuperación de la unidad A:"

    /*  (127646) PRLDTBLCOPY error messages
    */
    GV._PrldZipTblErr = "No se puede copiar el archivo ZipTable precargado."
    GV._FileExistErr  = "% no existe."

    /*  (127707 & 128484) Additional error messages
    */
    GV._MissingPreserveSection = "El archivo de Scripts de recuperación no contiene "||,
                                 "una sección [Image File Attributes]."
    GV._UnlockingFilesMsg = "Preparándose para desbloquear los archivos de destino. ¡Tenga paciencia, por favor!"
    GV._LockingFilesMsg = "Preparándose para bloquear los archivos de destino. ¡Tenga paciencia, por favor!"
    GV._UnknownBootableOS = "El sistema operativo % no está soportado para la "||,
                            "restauración de los archivos de configuración."

    /*  (128510) Additional error messages
    */
    GV._CopyAFileMsg   = "Copiando archivo(s) % en %"
    GV._LockAFileMsg   = "Bloqueando archivo(s) %"
    GV._UnLockAFileMsg = "Desbloqueando archivo(s) %"
    GV._EraseAFileMsg  = "Suprimiendo archivo(s) %"
    GV._UnzipImageMsg  = "Restaurando datos precargados de imágenes..."

return
/* Including file 'ANSIPKG.VRS' */

/*:VRX         ANSIInit
*/
/* Description: Initializes ANSI Codes and Variables
*
*/
ANSIInit: procedure expose GV.

    /* ANSI Escape sequences
    */
    GV._ANSI._CLS             = ""
    GV._ANSI._Normal          = ""
    GV._ANSI._Bold            = ""
    GV._ANSI._Underscore      = ""
    GV._ANSI._Blink           = ""
    GV._ANSI._Reverse         = ""
    GV._ANSI._Invisible       = ""
    GV._ANSI._BlackFore       = ""
    GV._ANSI._RedFore         = ""
    GV._ANSI._GreenFore       = ""
    GV._ANSI._YellowFore      = ""
    GV._ANSI._BlueFore        = ""
    GV._ANSI._MagentaFore     = ""
    GV._ANSI._CyanFore        = ""
    GV._ANSI._WhiteFore       = ""
    GV._ANSI._BlackBack       = ""
    GV._ANSI._RedBack         = ""
    GV._ANSI._GreenBack       = ""
    GV._ANSI._YellowBack      = ""
    GV._ANSI._BlueBack        = ""
    GV._ANSI._MagentaBack     = ""
    GV._ANSI._CyanBack        = ""
    GV._ANSI._WhiteBack       = ""
    GV._ANSI._BlueOnWhite     = ""
    GV._ANSI._RedOnWhite      = ""
    GV._ANSI._WhiteOnBlue     = ""
    GV._ANSI._Shadow          = ""
    GV._ANSI._NoCursor        = ""
    GV._ANSI._ClearToEOL      = ""
    GV._ANSI._BoldOn          = ""
    GV._ANSI._BoldOff         = ""
    GV._ANSI._ScreenColor     = GV._ANSI._BlueOnWhite
    GV._ANSI._ErrorColor      = GV._ANSI._RedOnWhite
    GV._ANSI._WarningColor      = GV._ANSI._RedOnWhite
    GV._ANSI._MenuColor       = GV._ANSI._WhiteOnBlue
    GV._ANSI._SaveCursor      = "s"
    GV._ANSI._RestoreCursor   = "u"
    GV._ANSI._CursorUp        = "#A"
    GV._ANSI._CursorDown      = "#B"
    GV._ANSI._CursorForward   = "#C"
    GV._ANSI._CursorBack      = "#D"
    GV._ANSI._CursorReport    = "#;#R"
    GV._ANSI._SetMode40x25b   = "=0h"
    GV._ANSI._SetMode40x25c   = "=1h"
    GV._ANSI._SetMode80x25b   = "=2h"
    GV._ANSI._SetMode80x25c   = "=3h"
    GV._ANSI._SetMode320x200c = "=4h"
    GV._ANSI._SetMode320x200b = "=5h"
    GV._ANSI._SetMode640x200b = "=6h"
    GV._ANSI._WrapAtEnd       = "=7h"

    /* Menu strings
    */
    GV._ANSI._TopBar = "┌"||Copies("─",75)||"┐"
    GV._ANSI._BottomBar ="└"||Copies("─",75)||"┘"
    GV._ANSI._RightSide = "│"
    GV._ANSI._LeftSide = "│"

    /* KeyCodes
    */
    GV._ANSI._Up   = "H"
    GV._ANSI._Down = "P"
    GV._ANSI._Help = ";"
    GV._ANSI._Enter = '0D'x


    /* Menu escape back door
    */
    GV._ANSI._Escape = ""

    Call ANSITranslation

return

/*:VRX         ClearToEOL
*/
/* Description: Clear from Cursor to end of line
*
*/
ClearToEOL: procedure expose GV.
    Call Charout , GV._ANSI._ClearToEOL
return

/*:VRX         CLS
*/
/* Description: Clear the screen
*
*/
CLS: procedure expose GV.
    Call Charout , GV._ANSI._CLS
return

/*:VRX         GoToRowCol
*/
/* Description: Move cursor to a specified Row and Column
*
*/
GoToRowCol: procedure expose GV.
    Parse arg row, col
    Call Charout ,""||row||";"||col||"H"
return


/*:VRX         WriteAt
*/
/* Description: Writes text to Stdout, starting at Row, Col
*  Returns: The next available Row, wraps from 25 to 1
*/
WriteAt: procedure expose GV.
    Parse arg Row, Col, String
    Call GotoRowCol Row, Col
    Call Charout , String
    Row = Row + 1
    if Row = 26 then Row = 1
return Row

/*:VRX         WriteStemAt
*/
/* Description: Writes text to Stdout, starting at Row, Col
*  Returns: The next available Row, wraps from 25 to 1
*/
WriteStemAt: procedure expose GV.
    parse arg Row, Col, Stem

    if Row = "" then do
        Row = 5
    end

    if Col = "" then do
        Col = 1
    end

    if right(Stem, 1) <> "." then do
        Stem = Stem||"."
    end

    i = 0
    Do Value(Stem||0)
        i = i + 1
        Row = WriteAt( Row, Col, Value(Stem||i) )
    end
return Row


/*:VRX         ErrorMessage
*/
/* Description:Display a message in GV._ANSI._ErrorColor
*  Returns:
*/
ErrorMessage: procedure expose GV.
    parse arg messagestem, StartRow, StartCol

    Call MessageAndWait messagestem,,
                        StartRow, StartCol,,
                        GV._ANSI._ErrorColor, GV._ANSI._ScreenColor


return

/*:VRX         WarningMessage
*/
/* Description: Display a message in GV._ANSI._WarningColor
*  Returns: Nothing
*/
WarningMessage: procedure expose GV.

    parse arg messagestem, StartRow, StartCol

    Call MessageAndWait messagestem,,
                        StartRow, StartCol,,
                        GV._ANSI._WarningColor, GV._ANSI._ScreenColor

return

/*:VRX         PromptMessage
*/
/* Description: Propt for user input. Allows Title, Message and Prompt
*  Returns: Response
*
*
*/
PromptMessage: procedure expose GV.

    /* Get parameters
    */
    Parse arg MsgStem, Title, Prompt, MsgRow,,
              MsgCol, TitleRow, TitleCol, PromptRow, PromptCol

    /* Assign some defaults
    */
    if MsgCol    = "" then MsgCol    = 5
    if MsgRow    = "" then MsgRow    = 3
    if TitleRow  = "" then TitleRow  = 1
    if PromptCol = "" then PromptCol = MsgCol

    /* Create the Title
    */
    If Title <> "" then do
        If TitleCol = "" then do
            Title  = Center(Title,80)
            TitleCol = 1
        end

        /* Put up the Title
        */
        Call WriteAt TitleRow,TitleCol,Title
    end

    /* Put up the message
    */
    if MsgStem \== "" then do
        Call WriteStemAt MsgRow,MsgCol,MsgStem
    end

    /* Create the Prompt
    */
    If Prompt <> "" then do
        If PromptRow = "" then do
            PromptRow  = MsgRow + Value(MsgStem||0) + 1
        end

        /* Put up the Prompt
        */
        Call WriteAt PromptRow,PromptCol,Prompt
    end

    /* Get a response
    */
    Pull Response

    /* Clear the screen
    */
    Call CLS
return Response

/*:VRX         MessageAndWait
*/
/* Description: Display a message and wait for a key
*  Returns: Row after the message
*/
MessageAndWait: procedure expose GV.
    parse arg messagestem, StartRow, StartCol, Color, RestoreColor


    if StartRow = "" then do
        StartRow = 5
    end

    if StartCol = "" then do
        StartCol = 1
    end

    /* Set the Screen Color
    */
    if Color <> "" then do
        Say Color
    end

    /* Make the color take hold
    */
    Call CLS
    StartRow = WriteStemAt( StartRow, StartCol, messagestem )

    Call WriteAt 24,StartCol,GV._ANSI._PauseMsg
    Call GetResponse
    if RestoreColor <> '' then do
        Call Charout RestoreColor
    end
return StartRow

/*:VRX         Menu
*/
/* Description: Routine to place a Menu on the screen.
*
*  Menu Structure: Menuname.Selections : Single Characters for selection.
*                  MenuName.Functions  : Rexx Routine name coresponding to
*                                        each above selection.
*                  MenuName.0          : Number of Selections.
*                  Menuname.(1 to MenuName.0) : String for each selection.
*  Note: Menuname must begin with GV.
*  Note: You Must Provide a routine called Help
*/
Menu: procedure expose GV.
    parse arg MenuName, Prompt, Title, HighLight, Clear, EscapeChars
    option = ""
    /* Do until we get the Escape sequence
    */
    option = ""
    do while pos(option,EscapeChars) == 0
        /* Put up the actual menu and get a selection
        */
        option = ShowMenu(MenuName, Prompt,,
                          Title, HighLight, Clear, EscapeChars )

        /* See if this Selection is in our list of valid selections
        */
        position = wordpos(option, Value(MenuName||"_Selections"))
        options = words(Value(MenuName||"_Selections"))

        /* By default we Clear the Screen
        */
        Clear = 1
        select
            /* Handle Help
            */
            when length(option) = 2 then do
            Key = Right(option,1)
                Select
                    /* Up
                    */
                    when Key = GV._ANSI._UP then do
                        HighLight = HighLight - 1
                        if HighLight < 1 then do
                            HighLight = options
                        end
                        Clear = 0
                    end

                    /* Down
                    */
                    when Key = GV._ANSI._Down then do
                        HighLight = HighLight + 1
                        if HighLight > options then do
                            HighLight = 1
                        end
                        Clear = 0
                    end

                    /* F1
                    */
                    when Key = GV._ANSI._Help then do
                        Call Help
                    end
                    otherwise do
                        Nop
                    end
                end
            end

            /* Handle hitting Enter on a selected item.
            */
            when option = GV._ANSI._Enter then do
                option = HighLight
                position = wordpos(option, Value(MenuName||"_Selections"))
                if position <> 0 then do
                    /* It is valid, so call the appropriate function
                    */
                    Call CLS
                    interpret "Call "word(Value(MenuName||"_Functions"), position)
                end
            end

            /* Handle a Number key being selected
            */
            when position <> 0 then do
                /* It is valid, so call the appropriate function
                */
                Call CLS
                interpret "Call "word(Value(MenuName||"_Functions"), position)
            end
            /* Invalid Selection, Beep
            */
            otherwise do
                call ErrorBeep
            end
        end
    end
return Option

/*:VRX         ShowMenu
*/
/* Description: Displays a Menu on the Screen.
*
*  Menu Structure: Menuname.Selections : Single Characters for selection.
*                  MenuName.Functions  : Rexx Routine name coresponding to
*                                        each above selection.
*                  MenuName.0          : Number of Selections.
*                  Menuname.(1 to MenuName.0) : String for each selection.
*  Note: Menuname must begin with GV.
*/
ShowMenu: procedure expose GV.
    parse arg MenuName, Prompt, Title, HighLight, Clear, EscapeChars

    /* If no Highlight picked, use 1
    */
    if HighLight = "" then do
        HighLight = 1
    end

    /* Menu starts here
    */
    Row = 4 ; Col = 2

    /* Get the menu choice strings
    */
    Choices = Value(MenuName||"_Selections")

    /* Only do this if we are Clearing the screen
    */
    if Clear = 1 then do
        /* Set the Screen Color
        */
        Say GV._ANSI._ScreenColor

        /* Make the color take hold
        */
        Call CLS

        /* Center title in the Top of the Menu and display it.
        */
        TopBar = GV._ANSI._TopBar
        if length(title) <> 0 then do
            TopBar = overlay(Title,TopBar,(length(TopBar) - length(Title))%2)
        end
        Call WriteAt Row,Col, GV._ANSI._BoldOn GV._ANSI._WhiteOnBlue
        Row = WriteAt(Row, Col,TopBar )

        /* Add a blank line for readability
        */
        Row = WriteAt(Row, Col,GV._ANSI._LeftSide||Copies(" ",75)||GV._ANSI._RightSide||GV._ANSI._Shadow||" ")
    end
    else do
        Row = Row + 2
    end

    /* Display the Menu text
    */
    do i = 1 to Value(MenuName||"0")

        /* Handle a HighLighted Item
        */
        if i = HighLight then do
            /* Each row consists of the LeftSide, some space, the selection string
            *  a close paren, a space, the menu text, some more space, and the
            *  right side
            */
            Row = WriteAt(Row, Col,,
                      GV._ANSI._MenuColor||,
                      GV._ANSI._BoldOn||,
                      GV._ANSI._LeftSide||,
                      Copies(" ",10)||,
                      GV._ANSI._BoldOn||,
                      GV._ANSI._Shadow||,
                      word(Choices,i)")"||,
                      GV._ANSI._BoldOff||,
                      GV._ANSI._Shadow||,
                      left(Value(MenuName||i),53)||,
                      GV._ANSI._BoldOn||,
                      GV._ANSI._MenuColor||,
                      Copies(" ",10)||GV._ANSI._RightSide||GV._ANSI._Shadow||" " )
        end
        /* Handle a non-HighLighted item.
        */
        else do
            /* Each row consists of the LeftSide, some space, the selection string
            *  a close paren, a space, the menu text, some more space, and the
            *  right side
            */
            Row = WriteAt(Row, Col,,
                      GV._ANSI._MenuColor||,
                      GV._ANSI._BoldOn||,
                      GV._ANSI._LeftSide||,
                      Copies(" ",10)||,
                      GV._ANSI._BoldOn||,
                      word(Choices,i)")"||,
                      GV._ANSI._BoldOff||,
                      GV._ANSI._MenuColor||,
                      left(Value(MenuName||i),53)||,
                      GV._ANSI._BoldOn||,
                      Copies(" ",10)||GV._ANSI._RightSide||GV._ANSI._Shadow||" " )
        end
    end

    /* Only do this if clearing the screen
    */
    if Clear = 1 then do
        /* Another blank row for readability
        */
        Row = WriteAt(Row, Col, GV._ANSI._BoldOn||GV._ANSI._MenuColor||GV._ANSI._LeftSide||Copies(" ",75)||GV._ANSI._RightSide||GV._ANSI._Shadow||" ")

        /* And the bottom of the menu box
        */
        Row = WriteAt(Row, Col, GV._ANSI._BoldOn||GV._ANSI._MenuColor||GV._ANSI._BottomBar||GV._ANSI._Shadow||" ")

        /* Add the bottom Shadow
        */
        Row = WriteAt(Row, Col+1,GV._ANSI._Shadow||Copies("▄",77))

        /* Put up Help Message
        */
        Call WriteAt 25,70,GV._ANSI._ScreenColor||GV._ANSI._F1ForHelp

        /* Now the prompt and user response.
        */
        Row = WriteAt(Row+1, Col, GV._ANSI._ScreenColor||Prompt||" " )
    end

    /* Get the users response
    */
    Call WriteAt 25,80,GV._ANSI._NoCursor
    Option=GetResponse()

    Call WriteAt 1,1,GV._ANSI._ScreenColor
return Option


/*:VRX         GetResponse
*/
/* Description: Get a Key and handle Extended key sequences
*
*/
GetResponse: procedure expose GV.
    /* Get a key
    */
    key = PrldGetKey("NOECHO")

    /* If it is extended, get the next key
    */
    if key = '00'x | key = 'E0'x then do
        key ='0'||PrldGetKey("NOECHO")
     end
return key

/*:VRX         Pause
*/
/* Description: Simulate system Pause message.
*
*/
Pause: procedure expose GV.
    Call Charout , GV._ANSI._PauseMsg
    Call GetResponse
return


/*:VRX         ErrorBeep
*/
/* Description: Beep on an error
*
*/
ErrorBeep: procedure expose GV.
    Call Beep 880,400
return



/*:VRX         ANSITranslation
*/
/* Description: Initializes ANSI Package Messages
*
*/
ANSITranslation: procedure expose GV.

    /* Pause Message
    */
    GV._ANSI._PauseMsg    = "Press any key when ready . . ."

    /* Help Prompt Message
    */
    GV._ANSI._F1ForHelp   = "F1=Help"

return

/* End of included file */

/* Including file 'makecmsg.vrs' */

/*:VRX         Make_CurrentMessage
*/
/* Description: Break up the Message into separate lines (crlf delimted)
*               Returns with GV._CurrentMessage.0 = # or lines
*                            GV._CurrentMessage.n = line n
*/
Make_CurrentMessage: procedure expose GV.
    Parse arg message
    j=0

    /* Break up the long string message into an array of CRLF separated lines
    */
    do while message <> ""
       j = j + 1
       parse var message l "0D0A"x message
       GV._CurrentMessage.j = l
    end
    /* Set the array count
    */
    GV._CurrentMessage.0 = j
return j

/* End of included file */

/* Including file 'REPL-ALL.VRS' */

/*:VRX */
/*
*
* ReplaceAll: replaces all occurances of from with to in string.
* returns: changed string
*
*/
ReplaceAll: procedure
    parse arg from, to, string, case

    accum = ""
    left = string

    do while length(left) > 0
        if case = "" then do
            p = pos(translate(from), translate(left))
        end
        else do
            p = pos(from, left)
        end
        if p = 0 then do
            accum = accum||left
            left = ""
        end
        else do
            accum = accum||left(left,p-1)||to
            if p < length(left) then do
                left = substr(left, p+length(from))
            end
            else do
                left = ""
            end
        end
    end
return accum

/* End of included file */

/* Including file 'TRANSSTR.VRS' */

/*:VRX         TranslateString
*/
TranslateString: Procedure

   /*
   *  This routine takes a MRI string and replaces all occurances
   *  of a separator char with a filler string. The separator char
   *  is the first char of the "insertItems" parameter.
   *
   *  Where:  str = some MRI string with a unique separator character
   *
   *          insertItems = a string of filler items separated by the
   *                        separator char defined in position 1.
   *
   *  Examples: str = "The days of the weekend are ! and !"
   *            insertItems = "!Sat!Sun"
   *            RESULT = "The days of the weekend are Sat and Sun"
   *
   *            str = "The days of the weekend are # and #"
   *            insertItems = "!Sat!Sun"
   *            RESULT = "The days of the weekend are # and #"
   *
   */

    Parse Arg str, insertItems;

    new_str = str

    /* Determine Filler List
    */
    FillerList. = ""
    i = 0
    Replacement_Char_Identifier = LEFT(insertItems,1)
    next_identifier = POS(Replacement_Char_Identifier,insertItems)
    do while(next_identifier \= 0)
        i = i + 1
        insertItems = Substr(insertItems,next_identifier+1)
        next_identifier = POS(Replacement_Char_Identifier,insertItems)
        if (next_identifier \= 0) then do
            FillerList.i = Substr(insertItems,1,next_identifier-1)
        end
        else do
            FillerList.i = Substr(insertItems,1)
        end
    end
    FillerList.0 = i

    /* Insert filler list items into input string
    */
    cnt = 1
    next_identifier = POS(Replacement_Char_Identifier,new_str)
    do while((next_identifier \= 0) & (cnt <= FillerList.0))
        Select
            when(next_identifier == 0) then do
                nop
            end
            when(next_identifier == 1) then do
                frontpart = ""
                backpart = Substr(new_str,2)
            end
            when(next_identifier == LENGTH(new_str)) then do
                frontpart = Substr(new_str,1,LENGTH(new_str)-1)
                backpart = ""
            end
            otherwise do
                frontpart = Substr(new_str,1,next_identifier -1)
                backpart = Substr(new_str,next_identifier+1)
            end
        end
        new_str = frontpart||FillerList.cnt||backpart
        next_identifier = POS(Replacement_Char_Identifier,new_str)
        cnt = cnt + 1
    end

return new_str


/* End of included file */

/* Including file 'LOADFNCS.VRS' */

/*:VRX         BuildExternalFuncsList
*/
BuildExternalFuncsList: Procedure Expose GV.

    /* External Libraries Definitions
    *   - Modification to the List field is minimal required Change.
    *   - The syntax for the List field is that of a SPACE delimited
    *     string of indices into the GV.ExternalFuncs array.
    *   - This format is used by the LoadExternalFuncs routine
    */

    GV._ExternalFuncs._List = '1 2 3 4 5 6 7'
    GV._ExternalFuncs._Name.1         = "SysLoadFuncs"
    GV._ExternalFuncs._Module.1       = "RexxUtil"
    GV._ExternalFuncs._Procedure.1    = "SysLoadFuncs"
    GV._ExternalFuncs._ProcParamStr.1 = ""
    GV._ExternalFuncs._Name.2         = "RxLoadFuncs"
    GV._ExternalFuncs._Module.2       = "RxUtils"
    GV._ExternalFuncs._Procedure.2    = "RxLoadFuncs"
    GV._ExternalFuncs._ProcParamStr.2 = "QUIET"
    GV._ExternalFuncs._Name.3         = "RexxLibRegister"
    GV._ExternalFuncs._Module.3       = "RexxLib"
    GV._ExternalFuncs._Procedure.3    = "RexxLibRegister"
    GV._ExternalFuncs._ProcParamStr.3 = ""
    GV._ExternalFuncs._Name.4         = "W_Register"
    GV._ExternalFuncs._Module.4       = "RxWin30"
    GV._ExternalFuncs._Procedure.4    = "RxWindow"
    GV._ExternalFuncs._ProcParamStr.4 = ""
    GV._ExternalFuncs._Name.5         = "mciRxInit"
    GV._ExternalFuncs._Module.5       = "MCIAPI"
    GV._ExternalFuncs._Procedure.5    = "mciRxInit"
    GV._ExternalFuncs._ProcParamStr.5 = ""
    GV._ExternalFuncs._Name.6         = "PrldLoadFuncs"
    GV._ExternalFuncs._Module.6       = "PrldUtil"
    GV._ExternalFuncs._Procedure.6    = "PrldLoadFuncs"
    GV._ExternalFuncs._ProcParamStr.6 = ""
    GV._ExternalFuncs._Name.7         = "PrldLoadFuncs"
    GV._ExternalFuncs._Module.7       = "PrldLite"
    GV._ExternalFuncs._Procedure.7    = "PrldLoadFuncs"
    GV._ExternalFuncs._ProcParamStr.7 = ""

return

/*:VRX         LoadExternalFuncs
*/
LoadExternalFuncs: Procedure Expose GV.

    parse arg lefstr;

    call BuildExternalFuncsList
    if (lefstr <> "") then do
        GV._ExternalFuncs._List = lefstr
    end

    indexlst = GV._ExternalFuncs._List
    do while( indexlst <> "")
        parse var indexlst z indexlst
        if (rxfuncquery( GV._ExternalFuncs._Name.z )) then do
            if (rxfuncadd( GV._ExternalFuncs._Name.z,,
                           GV._ExternalFuncs._Module.z,,
                           GV._ExternalFuncs._Procedure.z) > 0) then do
                InsertItems = GV._Separator||GV._ExternalFuncs._Name.z
                ErrMsg = TranslateString( GV._MissingDlls, InsertItems )
                call DisplayError GV._ErrorTitle, ErrMsg, 0
            end
            else Interpret 'call '||GV._ExternalFuncs._Name.z GV._ExternalFuncs._ProcParamStr.z
        end
        else Interpret 'call '||GV._ExternalFuncs._Name.z GV._ExternalFuncs._ProcParamStr.z
    end

return


/* End of included file */