From e611b132f9b8abe35b362e5870b74bce94a1e58e Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 16 May 2020 20:51:50 -0700 Subject: initial commit --- private/ntos/fw/mips/jzboot.c | 1201 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1201 insertions(+) create mode 100644 private/ntos/fw/mips/jzboot.c (limited to 'private/ntos/fw/mips/jzboot.c') diff --git a/private/ntos/fw/mips/jzboot.c b/private/ntos/fw/mips/jzboot.c new file mode 100644 index 000000000..cb90de71f --- /dev/null +++ b/private/ntos/fw/mips/jzboot.c @@ -0,0 +1,1201 @@ +/*++ + +Copyright (c) 1991 Microsoft Corporation + +Module Name: + + jzboot.c + +Abstract: + + This module contains the code to manage the boot selections. + + +Author: + + David M. Robinson (davidro) 25-Oct-1991 + +Revision History: + +--*/ + +#include "jzsetup.h" + +// +// Routine prototypes. +// + +ARC_STATUS +JzPickSystemPartition ( + OUT PCHAR SystemPartition, + IN OUT PULONG CurrentLine + ); + +ARC_STATUS +JzPickOsPartition ( + OUT PCHAR OsPartition, + IN OUT PULONG CurrentLine + ); + + +ULONG +JzGetYesNo ( + IN PULONG CurrentLine, + IN PCHAR PromptString, + IN BOOLEAN YesIsDefault + ) + +/*++ + +Routine Description: + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ULONG Line; + ULONG ReturnValue; + + Line = *CurrentLine; + *CurrentLine += NUMBER_OF_YES_NO + 2; + + JzSetPosition( Line, 0); + JzPrint(PromptString); + + ReturnValue = JxDisplayMenu( YesNoChoices, + NUMBER_OF_YES_NO, + YesIsDefault ? 0 : 1, + Line + 1); + + JzSetPosition( *CurrentLine, 0); + return ReturnValue; +} + +ULONG +JzGetCountdownValue ( + IN PULONG CurrentLine + ) + +/*++ + +Routine Description: + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ULONG Line; + ULONG ReturnValue; + CHAR TempString[5]; + GETSTRING_ACTION Action; + + Line = *CurrentLine; + *CurrentLine += 1; + + JzSetPosition( Line, 0); + + JzPrint(JZ_COUNTDOWN_MSG); + JzPrint("\x9bK"); + + do { + Action = FwGetString( TempString, + sizeof(TempString), + "5", + Line, + strlen(JZ_COUNTDOWN_MSG)); + + if (Action == GetStringEscape) { + return(-1); + } + + } while ( Action != GetStringSuccess ); + + ReturnValue = atoi(TempString); + JzSetPosition( *CurrentLine, 0); + + return ReturnValue; +} + + +VOID +JzDeleteVariableSegment ( + PCHAR VariableName, + ULONG Selection + ) + +/*++ + +Routine Description: + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + PCHAR Variable; + CHAR VariableValue[MAXIMUM_ENVIRONMENT_VALUE]; + ULONG Index; + ULONG Count; + BOOLEAN FirstSegment; + + if ((Variable = ArcGetEnvironmentVariable(VariableName)) == NULL) { + return; + } + + FirstSegment = TRUE; + Index = 0; + *VariableValue = 0; + while (strchr(Variable,';') != NULL) { + Count = strchr(Variable,';') - Variable; + if (Index != Selection) { + if (!FirstSegment) { + strcat(VariableValue,";"); + } + strncat(VariableValue, Variable, Count); + FirstSegment = FALSE; + } + Variable += Count + 1; + Index++; + } + + if (Index != Selection) { + if (!FirstSegment) { + strcat(VariableValue,";"); + } + strcat(VariableValue,Variable); + } + + ArcSetEnvironmentVariable(VariableName, VariableValue); + return; +} + +VOID +JzAddBootSelection ( + VOID + ) + +/*++ + +Routine Description: + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + CHAR SystemPartition[128]; + CHAR OsloaderFilename[80]; + CHAR OsPartition[128]; + CHAR OsFilename[80]; + CHAR LoadIdentifier[80]; + PCHAR Variable; + PCHAR TempPointer; + CHAR VariableValue[256]; + ULONG Index; + UCHAR Character; + ULONG Count; + ULONG CurrentLine; + LONG YesNo; + BOOLEAN DebugOn; + GETSTRING_ACTION Action; + BOOLEAN SecondaryBoot; + + JzClearScreen(); + JzShowTime(TRUE); + CurrentLine = 2; + JzSetPosition( CurrentLine, 0); + + // + // Count the boot selections + // + + strcpy(OsPartition, BootString[OsLoadPartitionVariable]); + strcpy(OsFilename, BootString[OsLoadFilenameVariable]); + + for ( Index = 0 ; Index < 4 ; Index++ ) { + + SecondaryBoot = FwGetVariableSegment(Index, OsPartition); + SecondaryBoot = FwGetVariableSegment(Index, OsFilename) || + SecondaryBoot; + + if (!SecondaryBoot) { + break; + } + } + + // + // Increment to new boot selection. Print warning and return if too many. + // + + Index++; +// if (Index == 5) { +// JzPrint(" Too many boot selections, delete some before adding another,\r\n"); +// Index = 0; +// goto MakeError; +// } + + // + // Pick a system partition. + // + + if (JzPickSystemPartition(SystemPartition, &CurrentLine) != ESUCCESS) { + return; + } + + JzPrint(JZ_OSLOADER_MSG); + + do { + Action = FwGetString( OsloaderFilename, + sizeof(OsloaderFilename), + "\\os\\nt\\osloader.exe", + CurrentLine, + strlen(JZ_OSLOADER_MSG)); + if (Action == GetStringEscape) { + return; + } + } while ( Action != GetStringSuccess ); + + CurrentLine += 1; + JzSetPosition( CurrentLine, 0); + + YesNo = JzGetYesNo(&CurrentLine, JZ_OS_MSG, TRUE); + if (YesNo == -1) { + return; + } + + if (YesNo == 0) { + strcpy(OsPartition, SystemPartition); + } else { + + // + // Determine os partition. + // + + if (JzPickOsPartition(OsPartition, &CurrentLine) != ESUCCESS) { + return; + } + + } + + JzPrint(JZ_OS_ROOT_MSG); + + do { + Action = FwGetString( OsFilename, + sizeof(OsFilename), + "\\winnt", + CurrentLine, + strlen(JZ_OS_ROOT_MSG)); + if (Action == GetStringEscape) { + return; + } + } while ( Action != GetStringSuccess ); + CurrentLine += 1; + JzSetPosition( CurrentLine, 0); + + JzPrint(JZ_BOOT_NAME_MSG); + do { + Action = FwGetString( LoadIdentifier, + sizeof(LoadIdentifier), + "Windows NT ", + CurrentLine, + strlen(JZ_BOOT_NAME_MSG)); + if (Action == GetStringEscape) { + return; + } + } while ( Action != GetStringSuccess ); + CurrentLine += 1; + JzSetPosition( CurrentLine, 0); + + YesNo = JzGetYesNo(&CurrentLine,JZ_INIT_DEBUG_MSG , FALSE); + if (YesNo == -1) { + return; + } + + if (YesNo == 0) { + DebugOn = TRUE; + } else { + DebugOn = FALSE; + } + + Index = 0; + Status = FwSetVariableSegment(0, BootString[LoadIdentifierVariable], LoadIdentifier); + if (Status != ESUCCESS) { + goto MakeError; + } + + + Index = 1; + + // + // If the SystemPartition variable is set but the Osloader variable is null, + // clear the SystemPartition variable before adding it back. + // + + if ((ArcGetEnvironmentVariable(BootString[SystemPartitionVariable]) != NULL) && + (ArcGetEnvironmentVariable(BootString[OsLoaderVariable]) == NULL)) { + ArcSetEnvironmentVariable(BootString[SystemPartitionVariable],""); + } + Status = FwSetVariableSegment(0, BootString[SystemPartitionVariable], SystemPartition); + if (Status != ESUCCESS) { + goto MakeError; + } + + // + // Add a new selection to the OSLOADER environment variable. + // + + Index = 2; + strcpy(VariableValue, SystemPartition); + strcat(VariableValue, OsloaderFilename); + Status = FwSetVariableSegment(0, BootString[OsLoaderVariable], VariableValue); + + if (Status != ESUCCESS) { + goto MakeError; + } + + // + // Add a new selection to the OSLOADPARTITION environment variable. + // + + Index = 3; + Status = FwSetVariableSegment(0, BootString[OsLoadPartitionVariable], OsPartition); + if (Status != ESUCCESS) { + goto MakeError; + } + + // + // Add a new selection to the OSLOADFILENAME environment variable. + // + + Index = 4; + Status = FwSetVariableSegment(0, BootString[OsLoadFilenameVariable], OsFilename); + if (Status != ESUCCESS) { + goto MakeError; + } + + // + // Add a new selection to the OSLOADOPTIONS environment variable. + // + + if (DebugOn) { + strcpy(VariableValue, "debug"); + } else { + strcpy(VariableValue, "nodebug"); + } + + Index = 5; + Status = FwSetVariableSegment(0, BootString[OsLoadOptionsVariable], VariableValue); + if (Status != ESUCCESS) { + goto MakeError; + } + + return; + +MakeError: + + JzPrint(JZ_CANT_SET_VARIABLE_MSG); + + // + // Delete any segments that were added. + // + + for ( Count = 0 ; Count < Index ; Count++ ) { + JzDeleteVariableSegment(BootString[Count], 0); + } + + FwWaitForKeypress(); +} + + +LONG +JzPickBootSelection ( + IN OUT PULONG CurrentLine, + IN PCHAR PromptString + ) + +/*++ + +Routine Description: + + This routine allows the user to indicate a boot selection choice. + +Arguments: + + CurrentLine - Supplies a pointer to the current display line value. + + PromptString - Supplies a pointer to a string which indicates the reason + the boot selection choice is needed. + +Return Value: + + Returns the boot selection number, -1 if none. + +--*/ +{ + PCHAR Variable; + CHAR VariableValue[MAXIMUM_ENVIRONMENT_VALUE]; + CHAR BootChoices[5][128]; + PCHAR BootMenu[5]; + CHAR OsloadPartition[128]; + CHAR OsloadFilename[128]; + CHAR LoadIdentifier[80]; + BOOLEAN SecondaryBoot; + ULONG Index; + ULONG Selection; + + // + // Get each boot selection + // + + strcpy(OsloadPartition, BootString[OsLoadPartitionVariable]); + strcpy(OsloadFilename, BootString[OsLoadFilenameVariable]); + strcpy(LoadIdentifier, BootString[LoadIdentifierVariable]); + + for ( Index = 0 ; ; Index++ ) { + + SecondaryBoot = FwGetVariableSegment(Index, OsloadPartition); + SecondaryBoot = FwGetVariableSegment(Index, OsloadFilename) || + SecondaryBoot; + SecondaryBoot = FwGetVariableSegment(Index, LoadIdentifier) || + SecondaryBoot; + + if (LoadIdentifier[sizeof("LOADIDENTIFIER=") - 1] != 0) { + strcpy(BootChoices[Index], + &LoadIdentifier[sizeof("LOADIDENTIFIER=") - 1]); + } else { + strcpy(BootChoices[Index], + &OsloadPartition[sizeof("OsloadPartition=") - 1]); + strcat(BootChoices[Index], + &OsloadFilename[sizeof("OsloadFilename=") - 1]); + } + + BootMenu[Index] = BootChoices[Index]; + + if (!SecondaryBoot || (Index == 4)) { + break; + } + } + + JzPrint(PromptString); + *CurrentLine += 1; + + Selection = JxDisplayMenu( BootMenu, + Index + 1, + 0, + *CurrentLine); + + JzSetPosition(*CurrentLine, 0); + + return(Selection); +} + +VOID +JzDeleteBootSelection ( + VOID + ) + +/*++ + +Routine Description: + + This routine deletes a boot selection from the boot environment variables. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + ULONG CurrentLine; + LONG Selection; + ULONG Index; + + JzClearScreen(); + JzShowTime(TRUE); + CurrentLine = 2; + JzSetPosition( CurrentLine, 0); + + if (ArcGetEnvironmentVariable(BootString[OsLoadPartitionVariable]) == NULL) { + JzPrint(JZ_NO_SELECTIONS_TO_DELETE_MSG); + CurrentLine += 1; + FwWaitForKeypress(); + return; + } + + Selection = JzPickBootSelection( &CurrentLine, JZ_SELECTION_TO_DELETE_MSG); + + if (Selection == -1) { + return; + } + + for ( Index = 0 ; Index < MaximumBootVariable ; Index++ ) { + JzDeleteVariableSegment(BootString[Index],Selection); + } + + JzPrint(JZ_CRLF_MSG); + + return; +} + +VOID +JzEditSelection ( + LONG Selection + ) + +/*++ + +Routine Description: + + This routine allows the environment variables for a specified boot + selection to be edited. + +Arguments: + + Selection - Specifies the boot selection to edit. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + CHAR SystemPartition[128]; + CHAR Osloader[128]; + CHAR OsloadPartition[128]; + CHAR OsloadFilename[128]; + CHAR OsloadOptions[128]; + CHAR LoadIdentifier[128]; + + do { + JzClearScreen(); + JzShowTime(TRUE); + JzSetPosition( 7, 0); + + // + // Display the current boot selection environment variables. + // + + strcpy(SystemPartition, BootString[SystemPartitionVariable]); + strcpy(Osloader, BootString[OsLoaderVariable]); + strcpy(OsloadPartition, BootString[OsLoadPartitionVariable]); + strcpy(OsloadFilename, BootString[OsLoadFilenameVariable]); + strcpy(OsloadOptions, BootString[OsLoadOptionsVariable]); + strcpy(LoadIdentifier, BootString[LoadIdentifierVariable]); + FwGetVariableSegment(Selection, SystemPartition); + FwGetVariableSegment(Selection, Osloader); + FwGetVariableSegment(Selection, OsloadPartition); + FwGetVariableSegment(Selection, OsloadFilename); + FwGetVariableSegment(Selection, OsloadOptions); + FwGetVariableSegment(Selection, LoadIdentifier); + + JzPrint( JZ_ENVIR_FOR_BOOT_MSG, + Selection + 1); + + JzPrint(JZ_FORMAT1_MSG, LoadIdentifier); + JzPrint(JZ_FORMAT1_MSG, SystemPartition); + JzPrint(JZ_FORMAT1_MSG, Osloader); + JzPrint(JZ_FORMAT1_MSG, OsloadPartition); + JzPrint(JZ_FORMAT1_MSG, OsloadFilename); + JzPrint(JZ_FORMAT1_MSG, OsloadOptions); + + JzSetPosition( 2, 0); + JzPrint(JZ_USE_ARROWS_MSG); + + } while ( JzSetBootEnvironmentVariable(Selection) ); + return; +} + +VOID +JzEditBootSelection ( + VOID + ) + +/*++ + +Routine Description: + + This routine allows the environment variables for a boot selection to + be edited. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + ULONG CurrentLine; + LONG Selection; + + JzClearScreen(); + JzShowTime(TRUE); + CurrentLine = 2; + JzSetPosition( CurrentLine, 0); + + if (ArcGetEnvironmentVariable(BootString[OsLoadPartitionVariable]) == NULL) { + JzPrint(JZ_NO_SELECTIONS_TO_EDIT_MSG); + CurrentLine += 1; + FwWaitForKeypress(); + return; + } + + Selection = JzPickBootSelection( &CurrentLine, JZ_SELECTION_TO_EDIT_MSG); + + if (Selection == -1) { + return; + } + + JzEditSelection(Selection); + + return; +} + +VOID +JzRearrangeBootSelections ( + VOID + ) + +/*++ + +Routine Description: + + This routine allows the environment variables for a boot selection to + be rearranged. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + ULONG CurrentLine; + LONG Selection; + ULONG Index; + CHAR Segment[128]; + + JzClearScreen(); + JzShowTime(TRUE); + CurrentLine = 2; + JzSetPosition( CurrentLine, 0); + + if (ArcGetEnvironmentVariable(BootString[OsLoadPartitionVariable]) == NULL) { + JzPrint(JZ_NO_SELECTIONS_TO_REARRANGE_MSG); + CurrentLine += 1; + FwWaitForKeypress(); + return; + } + + do { + JzClearScreen(); + JzShowTime(TRUE); + CurrentLine = 2; + JzSetPosition( CurrentLine, 0); + + Selection = JzPickBootSelection( &CurrentLine, JZ_PICK_SELECTION_MSG); + + if (Selection == -1) { + continue; + } + + for ( Index = 0 ; Index < MaximumBootVariable ; Index++ ) { + strcpy( Segment, BootString[Index]); + FwGetVariableSegment( Selection, Segment ); + JzDeleteVariableSegment( BootString[Index], Selection ); + FwSetVariableSegment( 0, BootString[Index], strchr(Segment, '=') + 1); + } + } while ( Selection != -1 ); + return; +} + + +VOID +JzSetupAutoboot ( + VOID + ) + +/*++ + +Routine Description: + + This routine allows the environment variables controlling autoboot + to be set. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + ULONG Autoboot; + ULONG Countdown; + CHAR CountdownString[5]; + ULONG CurrentLine; + + JzClearScreen(); + JzShowTime(TRUE); + CurrentLine = 2; + + Autoboot = JzGetYesNo(&CurrentLine, JZ_SHOULD_AUTOBOOT_MSG, FALSE); + if (Autoboot == -1) { + return; + } + + switch (Autoboot) { + case 0: + Status = ArcSetEnvironmentVariable("AUTOLOAD", + "YES"); + break; + default: + Status = ArcSetEnvironmentVariable("AUTOLOAD", + "NO"); + break; + } + + if (Status != ESUCCESS) { + JzPrint(JZ_CANT_SET_VARIABLE_MSG); + return; + } + + if (Autoboot != 0) { + return; + } + + Countdown = JzGetCountdownValue(&CurrentLine); + if (Countdown == -1) { + return; + } + + if (Countdown != 5) { + sprintf( CountdownString, + "%d", + Countdown); + + Status = ArcSetEnvironmentVariable("COUNTDOWN", + CountdownString); + + if (Status != ESUCCESS) { + JzPrint(JZ_CANT_SET_VARIABLE_MSG); + return; + } + } else { + ArcSetEnvironmentVariable("COUNTDOWN", + ""); + } + + return; +} + + +VOID +JzEditVariable ( + VOID + ) + +/*++ + +Routine Description: + + This routine allows environment variables to be edited. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ARC_STATUS Status; + ULONG CurrentLine; + PCHAR Variable; + ULONG Index, Count; + + + do { + + JzClearScreen(); + JzShowTime(TRUE); + JzSetPosition( 7, 0); + + // + // Get the entire environment. + // + + Variable = FwEnvironmentLoad(); + + JzPrint(JZ_ENVIRONMENT_VARS_MSG); + + if (Variable != NULL) { + + // + // Print all of the other environment variables. + // + + while (*Variable) { + + if ((strstr(Variable, "SYSTEMPARTITION=") == NULL) && + (strstr(Variable, "OSLOADER=") == NULL) && + (strstr(Variable, "OSLOADPARTITION=") == NULL) && + (strstr(Variable, "OSLOADFILENAME=") == NULL) && + (strstr(Variable, "OSLOADOPTIONS=") == NULL) && + (strstr(Variable, "LOADIDENTIFIER=") == NULL)) { + + JzPrint(" "); + while (strchr(Variable,';') != NULL) { + Index = strchr(Variable,';') - Variable + 1; + ArcWrite(ARC_CONSOLE_OUTPUT, Variable, Index, &Count); + JzPrint("\r\n "); + Variable += Index; + } + JzPrint(Variable); + JzPrint(JZ_CRLF_MSG); + } + Variable = strchr(Variable,'\0') + 1; + } + } + + JzSetPosition( 2, 0); + JzPrint(JZ_USE_ARROWS_MSG); + + } while ( JzSetEnvironmentVariable() ); + return; +} + +BOOLEAN +JzCheckBootSelection ( + IN LONG Selection + ) + +/*++ + +Routine Description: + + This routine checks the integrity of a boot selection. + +Arguments: + + Selection - The number of the selection to check. + +Return Value: + + Returns TRUE if there are more selections after the current one, otherwise + returns FALSE. + +--*/ +{ + ARC_STATUS Status; + ULONG CurrentLine; + ULONG Fid; + ULONG MenuSelection; + ULONG Index; + CHAR Segment[128]; + CHAR Value[128]; + BOOLEAN MoreSelections; + BOOLEAN Problem; + + JzClearScreen(); + JzSetPosition( 2, 0); + JzPrint(JZ_CHECKING_BOOT_SEL_MSG, Selection); + + CurrentLine = 5 + NUMBER_OF_PROBLEMS; + JzSetPosition( CurrentLine, 0); + + MoreSelections = FALSE; + Problem = FALSE; + + JzSetScreenColor( ArcColorYellow, ArcColorBlue); + + for ( Index = 0 ; Index < MaximumBootVariable ; Index++ ) { + + strcpy(Segment, BootString[Index]); + MoreSelections = FwGetVariableSegment(Selection, Segment) || MoreSelections; + strcpy(Value, strchr(Segment, '=') + 1); + + // + // Check to make sure the value is not NULL, except for OsloadOptions + // which can legally have a NULL value. + // + + if (Index != OsLoadOptionsVariable) { + if (Value[0] == 0) { + Problem = TRUE; + JzPrint(JZ_VARIABLE_NULL_MSG, BootString[Index]); + continue; + } + } + + // + // If this is the SystemPartition, Osloader, or OsloadPartition variable, + // check to make sure it can be opened. + // + + if ((Index == SystemPartitionVariable) || + (Index == OsLoaderVariable) || + (Index == OsLoadPartitionVariable) ) { + + if (ArcOpen(Value, ArcOpenReadOnly, &Fid) != ESUCCESS) { + Problem = TRUE; + JzPrint( JZ_CANT_BE_FOUND_MSG, + BootString[Index]); + JzPrint( JZ_FORMAT1_MSG, + Value); + } else { + ArcClose(Fid); + } + + } + } + + JzSetScreenColor( ArcColorWhite, ArcColorBlue); + + if (Problem) { + + JzShowTime(TRUE); + CurrentLine = 2; + JzSetPosition( CurrentLine, 0); + + JzPrint( JZ_PROBLEMS_FOUND_MSG, Selection); + + MenuSelection = JxDisplayMenu( ProblemChoices, + NUMBER_OF_PROBLEMS, + 0, + CurrentLine + 2); + + // + // Switch based on the action. + // + + switch (MenuSelection) { + + // + // Ignore + // + + case 0: + break; + + // + // Delete this boot selection + // + + case 1: + + for ( Index = 0 ; Index < MaximumBootVariable ; Index++ ) { + JzDeleteVariableSegment(BootString[Index],Selection); + } + break; + + // + // Edit this boot selection + // + + case 2: + JzEditSelection(Selection); + break; + + default: + break; + } + } + + return(MoreSelections); +} + + +VOID +JzCheckBootSelections ( + VOID + ) + +/*++ + +Routine Description: + + This routine cycles through all of the boot selections and checks them. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + ULONG Index; + + // + // Look to see if any boot selections exist. Skip the SystemPartition + // variable because that can be set without any selections. + // + + for ( Index = 0 ; Index < MaximumBootVariable ; Index++ ) { + if ( (Index != SystemPartitionVariable) && + (ArcGetEnvironmentVariable(BootString[Index]) != NULL)) { + break; + } + } + + // + // If there are boot selections, check them. + // + + if (Index != MaximumBootVariable) { + Index = 0; + while (JzCheckBootSelection(Index)) { + Index++; + } + } + return; +} + + +VOID +JzBootMenu( + VOID + ) +/*++ + +Routine Description: + + This routine displays the boot menu. + +Arguments: + + None. + +Return Value: + + None. + +--*/ +{ + LONG DefaultChoice = 0; + + // + // Loop on choices until exit is selected. + // + + while (TRUE) { + + DefaultChoice = JzGetSelection(JzBootChoices, + NUMBER_OF_JZ_BOOT_CHOICES, + DefaultChoice); + + // + // If the escape key was pressed, return. + // + + if (DefaultChoice == -1) { + DefaultChoice = 0x7fffffff; + } + + // + // Switch based on the action. + // + + switch (DefaultChoice) { + + // + // Add boot selection + // + + case 0: + JzAddBootSelection(); + break; + + // + // Delete a boot selection + // + + case 1: + JzDeleteBootSelection(); + break; + + // + // Edit a boot selection + // + + case 2: + JzEditBootSelection(); + break; + + // + // Rearrange boot selections + // + + case 3: + JzRearrangeBootSelections(); + break; + + // + // Check boot selections + // + + case 4: + JzCheckBootSelections(); + break; + + // + // Setup autoboot parameters + // + + case 5: + JzSetupAutoboot(); + break; + + // + // Exit. + // + + default: + return; + } + } +} -- cgit v1.2.3