1566 lines
31 KiB
C
1566 lines
31 KiB
C
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
|
|
// Internal function definitions
|
|
|
|
|
|
ARC_STATUS
|
|
AlpFreeComponents(
|
|
IN PCHAR *EnvVarComponents
|
|
);
|
|
|
|
BOOLEAN
|
|
AlpMatchComponent(
|
|
IN PCHAR Value1,
|
|
IN PCHAR Value2
|
|
);
|
|
|
|
|
|
// Function implementations
|
|
|
|
|
|
|
|
ARC_STATUS
|
|
AlGetEnvVarComponents (
|
|
IN PCHAR EnvValue,
|
|
OUT PCHAR **EnvVarComponents,
|
|
OUT PULONG PNumComponents
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine takes an environment variable string and turns it into
|
|
the constituent value strings:
|
|
|
|
Example EnvValue = "Value1;Value2;Value3" is turned into:
|
|
|
|
"Value1", "Value2", "Value3"
|
|
|
|
The following are valid value strings:
|
|
|
|
1. " " :one null value is found
|
|
2. ";;;; " :five null values are found
|
|
3. " ;Value1 ; Value2;Value3;;;;;;; ;" :12 value strings are found,
|
|
:9 of which are null
|
|
|
|
If an invalid component (contains embedded white space) is found in the
|
|
string then this routine attempts to resynch to the next value, no error
|
|
is returned, and a the first part of the invalid value is returned for the
|
|
bad component.
|
|
|
|
1. " Value1;Bad Value2; Value3" : 2 value strings are found
|
|
|
|
The value strings returned suppress all whitespace before and after the
|
|
value.
|
|
|
|
|
|
Arguments:
|
|
|
|
EnvValue: ptr to zero terminated environment value string
|
|
|
|
EnvVarComponents: ptr to a PCHAR * variable to receive the buffer of
|
|
ptrs to the constituent value strings.
|
|
|
|
PNumComponents: ptr to a ULONG to receive the number of value strings found
|
|
|
|
Return Value:
|
|
|
|
The function returns the following error codes:
|
|
EACCES if EnvValue is NULL
|
|
ENOMEM if the memory allocation fails
|
|
|
|
|
|
The function returns the following success codes:
|
|
ESUCCESS.
|
|
|
|
When the function returns ESUCCESS:
|
|
- *PNumComponent field gets the number of value strings found
|
|
- if the number is non zero the *EnvVarComponents field gets the
|
|
ptr to the buffer containing ptrs to value strings
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
PCHAR pchStart, pchEnd, pchNext;
|
|
PCHAR pchComponents[MAX_COMPONENTS + 1];
|
|
ULONG NumComponents, i;
|
|
PCHAR pch;
|
|
ULONG size;
|
|
|
|
|
|
// Validate the EnvValue
|
|
|
|
if (EnvValue == NULL) {
|
|
return (EACCES);
|
|
}
|
|
|
|
|
|
// Initialise the ptr array with nulls
|
|
|
|
for (i = 0; i < (MAX_COMPONENTS+1); i++) {
|
|
pchComponents[i] = NULL;
|
|
}
|
|
|
|
|
|
// Initialise ptrs to search components
|
|
|
|
pchStart = EnvValue;
|
|
NumComponents = 0;
|
|
|
|
|
|
|
|
// search till either pchStart reaches the end or till max components
|
|
// is reached, the below has been programmed from a dfsa.
|
|
|
|
while (*pchStart && NumComponents < MAX_COMPONENTS) {
|
|
|
|
|
|
// STATE 1: find the beginning of next variable value
|
|
|
|
while (*pchStart!=0 && isspace(*pchStart)) {
|
|
pchStart++;
|
|
}
|
|
|
|
|
|
if (*pchStart == 0) {
|
|
break;
|
|
}
|
|
|
|
|
|
// STATE 2: In the midst of a value
|
|
|
|
pchEnd = pchStart;
|
|
while (*pchEnd!=0 && !isspace(*pchEnd) && *pchEnd!=';') {
|
|
pchEnd++;
|
|
}
|
|
|
|
|
|
// STATE 3: spit out the value found
|
|
|
|
|
|
size = pchEnd - pchStart;
|
|
if ((pch = AlAllocateHeap(size+1)) == NULL) {
|
|
AlpFreeComponents(pchComponents);
|
|
return (ENOMEM);
|
|
}
|
|
strncpy (pch, pchStart, size);
|
|
pch[size]=0;
|
|
pchComponents[NumComponents++]=pch;
|
|
|
|
|
|
// STATE 4: variable value end has been reached, find the beginning
|
|
// of the next value
|
|
|
|
if ((pchNext = strchr(pchEnd, ';')) == NULL) {
|
|
break; // out of the big while loop because we are done
|
|
}
|
|
|
|
|
|
// Advance beyond the semicolon.
|
|
|
|
|
|
pchNext++;
|
|
|
|
|
|
// reinitialise to begin STATE 1
|
|
|
|
pchStart = pchNext;
|
|
|
|
} // end while.
|
|
|
|
|
|
// Get memory to hold an environment pointer and return that
|
|
|
|
|
|
if ( NumComponents!=0 ) {
|
|
PCHAR *pch;
|
|
|
|
if ((pch = (PCHAR *)AlAllocateHeap((NumComponents+1)*sizeof(PCHAR))) == NULL) {
|
|
AlpFreeComponents(pchComponents);
|
|
return (ENOMEM);
|
|
}
|
|
|
|
|
|
// the last one is NULL because we initialised the array with NULLs
|
|
|
|
|
|
for ( i = 0; i <= NumComponents; i++) {
|
|
pch[i] = pchComponents[i];
|
|
}
|
|
|
|
|
|
*EnvVarComponents = pch;
|
|
}
|
|
|
|
|
|
// Update the number of elements field and return success
|
|
|
|
*PNumComponents = NumComponents;
|
|
return (ESUCCESS);
|
|
}
|
|
|
|
|
|
ARC_STATUS
|
|
AlFreeEnvVarComponents (
|
|
IN PCHAR *EnvVarComponents
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine frees up all the components in the ptr array and frees
|
|
up the storage for the ptr array itself too
|
|
|
|
Arguments:
|
|
|
|
EnvVarComponents: the ptr to the PCHAR * Buffer
|
|
|
|
Return Value:
|
|
|
|
ESUCCESS if freeing successful
|
|
EACCES if memory ptr invalid
|
|
|
|
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
ARC_STATUS Status;
|
|
|
|
|
|
// if the pointer is NULL just return success
|
|
|
|
if (EnvVarComponents == NULL) {
|
|
return (ESUCCESS);
|
|
}
|
|
|
|
|
|
// free all the components first, if error in freeing return
|
|
|
|
Status = AlpFreeComponents(EnvVarComponents);
|
|
if (Status != ESUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
|
|
// free the component holder too
|
|
|
|
if( AlDeallocateHeap(EnvVarComponents) != NULL) {
|
|
return (EACCES);
|
|
}
|
|
else {
|
|
return (ESUCCESS);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
ARC_STATUS
|
|
AlpFreeComponents(
|
|
IN PCHAR *EnvVarComponents
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine frees up only the components in the ptr array, but doesn't
|
|
free the ptr array storage itself.
|
|
|
|
Arguments:
|
|
|
|
EnvVarComponents: the ptr to the PCHAR * Buffer
|
|
|
|
Return Value:
|
|
|
|
ESUCCESS if freeing successful
|
|
EACCES if memory ptr invalid
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
|
|
// get all the components and free them
|
|
|
|
while (*EnvVarComponents != NULL) {
|
|
if(AlDeallocateHeap(*EnvVarComponents++) != NULL) {
|
|
return(EACCES);
|
|
}
|
|
}
|
|
|
|
return(ESUCCESS);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlpMatchComponent(
|
|
IN PCHAR Value1,
|
|
IN PCHAR Value2
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine compares two components to see if they are equal. This is
|
|
essentially comparing strings except that leading zeros are stripped from
|
|
key values.
|
|
|
|
Arguments:
|
|
|
|
Value1 - Supplies a pointer to the first value to match.
|
|
|
|
Value2 - Supplies a pointer to the second value to match.
|
|
|
|
|
|
Return Value:
|
|
|
|
If the components match, TRUE is returned, otherwise FALSE is returned.
|
|
|
|
--*/
|
|
|
|
{
|
|
while ((*Value1 != 0) && (*Value2 != 0)) {
|
|
if (tolower(*Value1) != tolower(*Value2)) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (*Value1 == '(') {
|
|
do {
|
|
*Value1++;
|
|
} while (*Value1 == '0');
|
|
} else {
|
|
*Value1++;
|
|
}
|
|
|
|
if (*Value2 == '(') {
|
|
do {
|
|
*Value2++;
|
|
} while (*Value2 == '0');
|
|
} else {
|
|
*Value2++;
|
|
}
|
|
}
|
|
|
|
if ((*Value1 == 0) && (*Value2 == 0)) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlFindNextMatchComponent(
|
|
IN PCHAR EnvValue,
|
|
IN PCHAR MatchValue,
|
|
IN ULONG StartComponent,
|
|
OUT PULONG MatchComponent OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine compares each component of EnvValue, starting with
|
|
StartComponent, until a match is found or there are no more components.
|
|
|
|
Arguments:
|
|
|
|
EnvValue - Supplies a pointer to the environment variable value.
|
|
|
|
MatchValue - Supplies a pointer to the value to match.
|
|
|
|
StartComponent - Supplies the component number to start the match.
|
|
|
|
MatchComponent - Supplies an optional pointer to a variable to receive
|
|
the number of the component that matched.
|
|
|
|
Return Value:
|
|
|
|
If a match is found, TRUE is returned, otherwise FALSE is returned.
|
|
|
|
--*/
|
|
|
|
{
|
|
ARC_STATUS Status;
|
|
PCHAR *EnvVarComponents;
|
|
ULONG NumComponents;
|
|
ULONG Index;
|
|
BOOLEAN Match;
|
|
|
|
|
|
Status = AlGetEnvVarComponents(EnvValue, &EnvVarComponents, &NumComponents);
|
|
|
|
if (Status != ESUCCESS) {
|
|
return FALSE;
|
|
}
|
|
|
|
Match = FALSE;
|
|
for (Index = StartComponent ; Index < NumComponents ; Index++ ) {
|
|
if (AlpMatchComponent(EnvVarComponents[Index], MatchValue)) {
|
|
Match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ARGUMENT_PRESENT(MatchComponent)) {
|
|
*MatchComponent = Index;
|
|
}
|
|
|
|
AlFreeEnvVarComponents(EnvVarComponents);
|
|
return Match;
|
|
}
|
|
|
|
|
|
ARC_STATUS
|
|
AlAddSystemPartition(
|
|
IN PCHAR NewSystemPartition
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine adds a system partition to the SystemPartition environment
|
|
variable, and updates the Osloader, OsloadPartition, OsloadFilename,
|
|
and OsloadOptions variables.
|
|
|
|
Arguments:
|
|
|
|
SystemPartition - Supplies a pointer to the pathname of the system
|
|
partition to add.
|
|
|
|
Return Value:
|
|
|
|
If the system partition was successfully added, ESUCCESS is returned,
|
|
otherwise an error code is returned.
|
|
|
|
BUGBUG - This program is simplistic and doesn't attempt to make sure all
|
|
the variables are consistent. It also doesn't fail gracefully.
|
|
|
|
--*/
|
|
|
|
{
|
|
ARC_STATUS Status;
|
|
PCHAR SystemPartition;
|
|
CHAR TempValue[MAXIMUM_ENVIRONMENT_VALUE];
|
|
//PCHAR Osloader;
|
|
//PCHAR OsloadPartition;
|
|
//PCHAR OsloadFilename;
|
|
//PCHAR OsloadOptions;
|
|
|
|
|
|
// Get the system partition environment variable.
|
|
|
|
|
|
SystemPartition = ArcGetEnvironmentVariable("SystemPartition");
|
|
|
|
|
|
// If the variable doesn't exist, add it and exit.
|
|
|
|
|
|
if (SystemPartition == NULL) {
|
|
if(strlen(NewSystemPartition) < MAXIMUM_ENVIRONMENT_VALUE) {
|
|
Status = ArcSetEnvironmentVariable("SystemPartition",
|
|
NewSystemPartition);
|
|
} else {
|
|
Status = E2BIG;
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
|
|
// If the variable exists, add the new partition to the end.
|
|
|
|
if(strlen(SystemPartition)+strlen(NewSystemPartition)+2 > MAXIMUM_ENVIRONMENT_VALUE) {
|
|
return(E2BIG);
|
|
}
|
|
|
|
strcpy(TempValue, SystemPartition);
|
|
strcat(TempValue, ";");
|
|
strcat(TempValue, NewSystemPartition);
|
|
Status = ArcSetEnvironmentVariable("SystemPartition",
|
|
TempValue);
|
|
|
|
if (Status != ESUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
#if 0
|
|
|
|
// Add semicolons to the end of each of the associated variables.
|
|
// If they don't exist add them.
|
|
|
|
|
|
|
|
// Get the Osloader environment variable and add a semicolon to the end.
|
|
|
|
|
|
Osloader = ArcGetEnvironmentVariable("Osloader");
|
|
if (Osloader == NULL) {
|
|
*TempValue = 0;
|
|
} else {
|
|
strcpy(TempValue, Osloader);
|
|
}
|
|
strcat(TempValue, ";");
|
|
Status = ArcSetEnvironmentVariable("Osloader",TempValue);
|
|
|
|
if (Status != ESUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
|
|
// Get the OsloadPartition environment variable and add a semicolon to the end.
|
|
|
|
|
|
OsloadPartition = ArcGetEnvironmentVariable("OsloadPartition");
|
|
if (OsloadPartition == NULL) {
|
|
*TempValue = 0;
|
|
} else {
|
|
strcpy(TempValue, OsloadPartition);
|
|
}
|
|
strcat(TempValue, ";");
|
|
Status = ArcSetEnvironmentVariable("OsloadPartition",TempValue);
|
|
|
|
if (Status != ESUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
|
|
// Get the OsloadFilename environment variable and add a semicolon to the end.
|
|
|
|
|
|
OsloadFilename = ArcGetEnvironmentVariable("OsloadFilename");
|
|
if (OsloadFilename == NULL) {
|
|
*TempValue = 0;
|
|
} else {
|
|
strcpy(TempValue, OsloadFilename);
|
|
}
|
|
strcat(TempValue, ";");
|
|
Status = ArcSetEnvironmentVariable("OsloadFilename",TempValue);
|
|
|
|
if (Status != ESUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
|
|
// Get the OsloadOptions environment variable and add a semicolon to the end.
|
|
|
|
|
|
OsloadOptions = ArcGetEnvironmentVariable("OsloadOptions");
|
|
if (OsloadOptions == NULL) {
|
|
*TempValue = 0;
|
|
} else {
|
|
strcpy(TempValue, OsloadOptions);
|
|
}
|
|
strcat(TempValue, ";");
|
|
Status = ArcSetEnvironmentVariable("OsloadOptions",TempValue);
|
|
#endif
|
|
return Status;
|
|
}
|
|
|
|
|
|
typedef struct _tagMENUITEM {
|
|
PCHAR Text;
|
|
ULONG AssociatedData;
|
|
} MENUITEM,*PMENUITEM;
|
|
|
|
typedef struct _tagMENUCOOKIE {
|
|
ULONG ItemCount;
|
|
PMENUITEM Items;
|
|
} MENUCOOKIE,*PMENUCOOKIE;
|
|
|
|
|
|
// indent for menus, status, etc.
|
|
|
|
char MARGIN[] = " ";
|
|
char MSGMARGIN[] = " ";
|
|
|
|
// special constants used when fetching keystrokes
|
|
|
|
#define KEY_UP 1
|
|
#define KEY_DOWN 2
|
|
|
|
|
|
VOID
|
|
MarkLine(
|
|
ULONG Line,
|
|
BOOLEAN Selected,
|
|
PCHAR String
|
|
);
|
|
|
|
BOOLEAN
|
|
CommonMenuDisplay(
|
|
PMENUCOOKIE Menu,
|
|
BOOLEAN StaticMenu,
|
|
PCHAR Items[],
|
|
ULONG ItemCount,
|
|
BOOLEAN PrintOnly,
|
|
ULONG AssociatedDataOfDefaultChoice,
|
|
ULONG *AssociatedDataOfChoice,
|
|
PCHAR MenuName,
|
|
ULONG Row
|
|
);
|
|
|
|
char
|
|
GetChar(
|
|
VOID
|
|
);
|
|
|
|
|
|
BOOLEAN
|
|
AlInitializeMenuPackage(
|
|
VOID
|
|
)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
ULONG
|
|
AlGetMenuNumberItems(
|
|
PVOID MenuID
|
|
)
|
|
{
|
|
return(((PMENUCOOKIE)MenuID)->ItemCount);
|
|
}
|
|
|
|
|
|
ULONG
|
|
AlGetMenuAssociatedData(
|
|
PVOID MenuID,
|
|
ULONG n
|
|
)
|
|
{
|
|
return(((PMENUCOOKIE)MenuID)->Items[n].AssociatedData);
|
|
}
|
|
|
|
BOOLEAN
|
|
AlNewMenu(
|
|
PVOID *MenuID
|
|
)
|
|
{
|
|
PMENUCOOKIE p;
|
|
|
|
if(!(p = AlAllocateHeap(sizeof(MENUCOOKIE)))) {
|
|
return(FALSE);
|
|
}
|
|
p->ItemCount = 0;
|
|
p->Items = NULL;
|
|
*MenuID = p;
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
VOID
|
|
AlFreeMenu(
|
|
PVOID MenuID
|
|
)
|
|
{
|
|
PMENUCOOKIE p = MenuID;
|
|
ULONG i;
|
|
|
|
for(i=0; i<p->ItemCount; i++) {
|
|
if(p->Items[i].Text != NULL) {
|
|
AlDeallocateHeap(p->Items[i].Text);
|
|
}
|
|
}
|
|
if(p->Items) {
|
|
AlDeallocateHeap(p->Items);
|
|
}
|
|
AlDeallocateHeap(p);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlAddMenuItem(
|
|
PVOID MenuID,
|
|
PCHAR Text,
|
|
ULONG AssociatedData,
|
|
ULONG Attributes // unused
|
|
)
|
|
{
|
|
PMENUCOOKIE Menu = MenuID;
|
|
PMENUITEM p;
|
|
|
|
DBG_UNREFERENCED_PARAMETER(Attributes);
|
|
|
|
if(!Menu->ItemCount) {
|
|
if((Menu->Items = AlAllocateHeap(sizeof(MENUITEM))) == NULL) {
|
|
return(FALSE);
|
|
}
|
|
Menu->ItemCount = 1;
|
|
p = Menu->Items;
|
|
} else {
|
|
if((p = AlReallocateHeap(Menu->Items,sizeof(MENUITEM)*(Menu->ItemCount+1))) == NULL) {
|
|
return(FALSE);
|
|
}
|
|
Menu->Items = p;
|
|
p = &Menu->Items[Menu->ItemCount++];
|
|
}
|
|
|
|
if((p->Text = AlAllocateHeap(strlen(Text)+1)) == NULL) {
|
|
return(FALSE);
|
|
}
|
|
strcpy(p->Text,Text);
|
|
p->AssociatedData = AssociatedData;
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlAddMenuItems(
|
|
PVOID MenuID,
|
|
PCHAR Text[],
|
|
ULONG ItemCount
|
|
)
|
|
{
|
|
ULONG base,i;
|
|
|
|
base = AlGetMenuNumberItems(MenuID);
|
|
|
|
for(i=0; i<ItemCount; i++) {
|
|
if(!AlAddMenuItem(MenuID,Text[i],i+base,0)) {
|
|
return(FALSE);
|
|
}
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlDisplayMenu(
|
|
PVOID MenuID,
|
|
BOOLEAN PrintOnly,
|
|
ULONG AssociatedDataOfDefaultChoice,
|
|
ULONG *AssociatedDataOfChoice,
|
|
ULONG Row,
|
|
PCHAR MenuName
|
|
)
|
|
{
|
|
return(CommonMenuDisplay((PMENUCOOKIE)MenuID,
|
|
FALSE,
|
|
NULL,
|
|
((PMENUCOOKIE)MenuID)->ItemCount,
|
|
PrintOnly,
|
|
AssociatedDataOfDefaultChoice,
|
|
AssociatedDataOfChoice,
|
|
MenuName,
|
|
Row
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlDisplayStaticMenu(
|
|
PCHAR Items[],
|
|
ULONG ItemCount,
|
|
ULONG DefaultChoice,
|
|
ULONG Row,
|
|
ULONG *IndexOfChoice
|
|
)
|
|
{
|
|
return(CommonMenuDisplay(NULL,
|
|
TRUE,
|
|
Items,
|
|
ItemCount,
|
|
FALSE,
|
|
DefaultChoice,
|
|
IndexOfChoice,
|
|
NULL,
|
|
Row
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
|
|
BOOLEAN
|
|
CommonMenuDisplay(
|
|
PMENUCOOKIE Menu,
|
|
BOOLEAN StaticMenu,
|
|
PCHAR Items[],
|
|
ULONG ItemCount,
|
|
BOOLEAN PrintOnly,
|
|
ULONG AssociatedDataOfDefaultChoice,
|
|
ULONG *AssociatedDataOfChoice,
|
|
PCHAR MenuName,
|
|
ULONG Row
|
|
)
|
|
{
|
|
// ULONG x;
|
|
ULONG i,MenuBaseLine,Selection;
|
|
char c;
|
|
PCHAR String;
|
|
|
|
AlSetPosition(Row,0);
|
|
AlPrint("%cJ",ASCI_CSI); // clear to end of screen.
|
|
MenuBaseLine = Row;
|
|
|
|
AlSetScreenColor(7,4); // white on blue
|
|
|
|
// if(MenuName) {
|
|
// AlPrint("%s%s\r\n%s",MARGIN,MenuName,MARGIN);
|
|
// x = strlen(MenuName);
|
|
// for(i=0; i<x; i++) {
|
|
// AlPrint("-");
|
|
// }
|
|
// AlPrint("\r\n\r\n");
|
|
// MenuBaseLine += 3;
|
|
// }
|
|
|
|
for(i=0; i<ItemCount; i++) {
|
|
AlSetScreenAttributes(1,0,0); // hi intensity
|
|
AlPrint("%s%s\r\n",MARGIN,StaticMenu ? Items[i] : Menu->Items[i].Text);
|
|
}
|
|
|
|
if(PrintOnly) {
|
|
|
|
char dummy;
|
|
AlPrint("\r\nPress any key to continue.");
|
|
AlGetString(&dummy,0);
|
|
|
|
} else {
|
|
|
|
// AlPrint("\r\n%sMake Selection using arrow keys and return,\r\n%sor escape to cancel",MARGIN,MARGIN);
|
|
|
|
Selection = 0;
|
|
if(StaticMenu) {
|
|
Selection = AssociatedDataOfDefaultChoice;
|
|
} else {
|
|
for(i=0; i<ItemCount; i++) {
|
|
if(Menu->Items[i].AssociatedData == AssociatedDataOfDefaultChoice) {
|
|
Selection = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
String = StaticMenu ? Items[Selection] : Menu->Items[Selection].Text;
|
|
MarkLine(MenuBaseLine+Selection,TRUE, String);
|
|
|
|
while(((c = GetChar()) != ASCI_ESC) && (c != ASCI_LF) && (c != ASCI_CR)) {
|
|
|
|
String = StaticMenu ? Items[Selection] : Menu->Items[Selection].Text;
|
|
MarkLine(MenuBaseLine+Selection,FALSE,String);
|
|
|
|
if(c == KEY_UP) {
|
|
if(!Selection--) {
|
|
Selection = ItemCount - 1;
|
|
}
|
|
} else if(c == KEY_DOWN) {
|
|
if(++Selection == ItemCount) {
|
|
Selection = 0;
|
|
}
|
|
}
|
|
|
|
String = StaticMenu ? Items[Selection] : Menu->Items[Selection].Text;
|
|
MarkLine(MenuBaseLine+Selection,TRUE,String);
|
|
}
|
|
|
|
// set cursor to a free place on the screen.
|
|
AlSetPosition(MenuBaseLine + ItemCount + 4,0);
|
|
|
|
if(c == ASCI_ESC) {
|
|
return(FALSE);
|
|
}
|
|
|
|
*AssociatedDataOfChoice = StaticMenu ? Selection : Menu->Items[Selection].AssociatedData;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
MarkLine(
|
|
ULONG Line,
|
|
BOOLEAN Selected,
|
|
PCHAR String
|
|
)
|
|
{
|
|
AlSetPosition(Line,sizeof(MARGIN));
|
|
if (Selected) {
|
|
AlSetScreenAttributes(1,0,1); // hi intensity, Reverse Video
|
|
}
|
|
AlPrint("%s\r\n", String);
|
|
AlSetScreenAttributes(1,0,0); // hi intensity
|
|
}
|
|
|
|
|
|
|
|
char
|
|
GetChar(
|
|
VOID
|
|
)
|
|
{
|
|
UCHAR c;
|
|
ULONG count;
|
|
|
|
ArcRead(ARC_CONSOLE_INPUT,&c,1,&count);
|
|
switch(c) {
|
|
// case ASCI_ESC:
|
|
// ArcRead(ARC_CONSOLE_INPUT,&c,1,&count);
|
|
// if(c != '[') {
|
|
// break;
|
|
// }
|
|
case ASCI_CSI:
|
|
ArcRead(ARC_CONSOLE_INPUT,&c,1,&count);
|
|
switch(c) {
|
|
case 'A':
|
|
case 'D':
|
|
return(KEY_UP);
|
|
case 'B':
|
|
case 'C':
|
|
return(KEY_DOWN);
|
|
}
|
|
default:
|
|
return(c);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
AlWaitKey(
|
|
PCHAR Prompt
|
|
)
|
|
{
|
|
char buff[1];
|
|
|
|
AlPrint(MSGMARGIN);
|
|
AlPrint(Prompt ? Prompt : "Press any key to continue...");
|
|
AlGetString(buff,0);
|
|
}
|
|
|
|
|
|
VOID
|
|
vAlStatusMsg(
|
|
IN ULONG Row,
|
|
IN BOOLEAN Error,
|
|
IN PCHAR FormatString,
|
|
IN va_list ArgumentList
|
|
)
|
|
{
|
|
char text[256];
|
|
ULONG Length,Count;
|
|
|
|
AlSetPosition(Row,0);
|
|
AlPrint(MSGMARGIN);
|
|
Length = vsprintf(text,FormatString,ArgumentList);
|
|
if(Error) {
|
|
AlSetScreenColor(1,4); // red on blue
|
|
} else {
|
|
AlSetScreenColor(3,4); // yellow on blue
|
|
}
|
|
AlSetScreenAttributes(1,0,0); // hi intensity
|
|
ArcWrite(ARC_CONSOLE_OUTPUT,text,Length,&Count);
|
|
AlPrint("\r\n");
|
|
AlSetScreenColor(7,4); // white on blue
|
|
AlSetScreenAttributes(1,0,0); // hi intensity
|
|
}
|
|
|
|
|
|
VOID
|
|
AlStatusMsg(
|
|
IN ULONG TopRow,
|
|
IN ULONG BottomRow,
|
|
IN BOOLEAN Error,
|
|
IN PCHAR FormatString,
|
|
...
|
|
)
|
|
{
|
|
va_list ArgList;
|
|
|
|
va_start(ArgList,FormatString);
|
|
vAlStatusMsg(TopRow,Error,FormatString,ArgList);
|
|
|
|
AlWaitKey(NULL);
|
|
AlClearStatusArea(TopRow,BottomRow);
|
|
}
|
|
|
|
|
|
VOID
|
|
AlStatusMsgNoWait(
|
|
IN ULONG TopRow,
|
|
IN ULONG BottomRow,
|
|
IN BOOLEAN Error,
|
|
IN PCHAR FormatString,
|
|
...
|
|
)
|
|
{
|
|
va_list ArgList;
|
|
|
|
AlClearStatusArea(TopRow,BottomRow);
|
|
va_start(ArgList,FormatString);
|
|
vAlStatusMsg(TopRow,Error,FormatString,ArgList);
|
|
}
|
|
|
|
|
|
VOID
|
|
AlClearStatusArea(
|
|
IN ULONG TopRow,
|
|
IN ULONG BottomRow
|
|
)
|
|
{
|
|
ULONG i;
|
|
|
|
for(i=BottomRow; i>=TopRow; --i) {
|
|
AlSetPosition(i,0);
|
|
AlClearLine();
|
|
}
|
|
}
|
|
|
|
|
|
ARC_STATUS
|
|
AlGetMenuSelection(
|
|
|
|
IN PCHAR szTitle,
|
|
IN PCHAR *rgszSelections,
|
|
IN ULONG crgsz,
|
|
IN ULONG crow,
|
|
IN ULONG irgszDefault,
|
|
OUT PULONG pirgsz,
|
|
OUT PCHAR *pszSelection
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine takes an array of strings, turns them into a menu
|
|
and gets a selection. If ESC hit then ESUCCESS is returned with
|
|
the *pszSelection NULL.
|
|
|
|
crgsz is assume to be 1 or greater.
|
|
|
|
|
|
Arguments:
|
|
|
|
szTitle - Pointer to menu title to pass to AlDisplayMenu
|
|
prgszSelection - pointer to an array of strings for menu
|
|
crgsz - count of strings
|
|
irgszDefault - index in rgszSelection to use as default selection
|
|
|
|
Return Value:
|
|
|
|
irgsz - index to selection
|
|
pszSelection - pointer int rgszSelection for selection. Note that
|
|
this is not a dup and should not be freed seperately
|
|
then rgszSelections.
|
|
|
|
Note: if ARC_STATUS == ESUCCESS and pszSelection == NULL then the
|
|
menu was successfully displayed but the user hit ESC to select
|
|
nothing from the menu.
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
PVOID hdMenuId;
|
|
|
|
*pszSelection = NULL;
|
|
if (!AlNewMenu(&hdMenuId)) {
|
|
|
|
return( ENOMEM );
|
|
|
|
}
|
|
|
|
|
|
// BUGBUG for now 1 selection will also build a menu, in the
|
|
// future once this is working we should just return that selection
|
|
|
|
|
|
if (!AlAddMenuItems(hdMenuId, rgszSelections, crgsz)) {
|
|
|
|
AlFreeMenu(hdMenuId);
|
|
return( ENOMEM );
|
|
|
|
}
|
|
|
|
if (!AlDisplayMenu(hdMenuId,
|
|
FALSE,
|
|
irgszDefault,
|
|
pirgsz,
|
|
crow,
|
|
szTitle)) {
|
|
|
|
|
|
// User did not pick a system partition. return NULL
|
|
// can caller should abort
|
|
|
|
AlFreeMenu(hdMenuId);
|
|
return( ESUCCESS );
|
|
|
|
}
|
|
|
|
AlFreeMenu(hdMenuId);
|
|
*pszSelection = rgszSelections[*pirgsz];
|
|
return( ESUCCESS );
|
|
|
|
}
|
|
|
|
PCHAR
|
|
AlStrDup(
|
|
|
|
IN PCHAR szString
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine makes a copy of the passed in string. I do not use
|
|
the CRT strdup since it uses malloc.
|
|
|
|
Arguments:
|
|
|
|
szString - pointer of string to dup.
|
|
|
|
Return Value:
|
|
|
|
pointer to dup'd string. NULL if could not allocate
|
|
|
|
--*/
|
|
{
|
|
|
|
PCHAR szT;
|
|
|
|
if (szT = AlAllocateHeap(strlen(szString) + 1)) {
|
|
|
|
strcpy(szT, szString);
|
|
return(szT);
|
|
|
|
}
|
|
return( NULL );
|
|
|
|
}
|
|
|
|
|
|
PCHAR
|
|
AlCombinePaths (
|
|
|
|
IN PCHAR szPath1,
|
|
IN PCHAR szPath2
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine combines to strings. It allocate a new string
|
|
to hold both strings.
|
|
|
|
Arguments:
|
|
|
|
pointer to combined path. NULL if failed to allocate.
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
|
|
PCHAR szT;
|
|
|
|
if (szT = AlAllocateHeap(strlen(szPath1) + strlen(szPath2) + 1)) {
|
|
|
|
strcpy(szT, szPath1);
|
|
strcat(szT, szPath2);
|
|
return( szT );
|
|
|
|
} else {
|
|
|
|
return ( NULL );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
AlFreeArray (
|
|
|
|
IN BOOLEAN fFreeArray,
|
|
IN PCHAR *rgsz,
|
|
IN ULONG csz
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine iterates through an array of pointers to strings freeing
|
|
each string and finally the array itself.
|
|
|
|
Arguments:
|
|
|
|
fFreeArray - flag wither to free the array itself.
|
|
rgsz - pointer to array of strings.
|
|
csz - size of array.
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
ULONG irgsz;
|
|
|
|
if (!csz) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for( irgsz = 0; irgsz < csz; irgsz++ ) {
|
|
|
|
if (rgsz[irgsz]) {
|
|
|
|
AlDeallocateHeap(rgsz[irgsz]);
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
if (fFreeArray) {
|
|
AlDeallocateHeap( rgsz );
|
|
}
|
|
|
|
}
|
|
|
|
ARC_STATUS
|
|
AlGetBase (
|
|
IN PCHAR szPath,
|
|
OUT PCHAR *pszBase
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
This routine strips the filename off a path.
|
|
|
|
Arguments:
|
|
|
|
szPath - path to strip.
|
|
|
|
Return Value:
|
|
|
|
pszBaseh - pointer to buffer holding new base. (this is a copy)
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PCHAR szPathT;
|
|
|
|
|
|
// Make local copy of szArcInstPath so we can alter it
|
|
|
|
*pszBase = AlStrDup(szPath);
|
|
if ( *pszBase == NULL ) {
|
|
|
|
return( ENOMEM );
|
|
}
|
|
|
|
|
|
// The start of the path part should be either a \ or a ) where
|
|
// ) is the end of the arc name
|
|
|
|
if ((szPathT = strrchr(*pszBase,'\\')) == 0) {
|
|
if ((szPathT = strrchr(*pszBase, ')')) == 0) {
|
|
|
|
AlDeallocateHeap(*pszBase);
|
|
return( EBADSYNTAX );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Cut filename out
|
|
|
|
// szPath points to either ')' or '\' so need to move over that
|
|
// onto actual name
|
|
|
|
*(szPathT + 1) = 0;
|
|
return( ESUCCESS );
|
|
|
|
|
|
}
|
|
|
|
|
|
// Define static data.
|
|
|
|
|
|
|
|
PCHAR AdapterTypes[AdapterMaximum + 1] = {"eisa","scsi", "multi", NULL};
|
|
|
|
PCHAR ControllerTypes[ControllerMaximum + 1] = {"cdrom", "disk", NULL};
|
|
|
|
PCHAR PeripheralTypes[PeripheralMaximum + 1] = {"rdisk", "fdisk", NULL};
|
|
|
|
|
|
|
|
PCHAR
|
|
AlGetNextArcNamToken (
|
|
IN PCHAR TokenString,
|
|
OUT PCHAR OutputToken,
|
|
OUT PULONG UnitNumber
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine scans the specified token string for the next token and
|
|
unit number. The token format is:
|
|
|
|
name[(unit)]
|
|
|
|
Arguments:
|
|
|
|
TokenString - Supplies a pointer to a zero terminated token string.
|
|
|
|
OutputToken - Supplies a pointer to a variable that receives the next
|
|
token.
|
|
|
|
UnitNumber - Supplies a pointer to a variable that receives the unit
|
|
number.
|
|
|
|
Return Value:
|
|
|
|
If another token exists in the token string, then a pointer to the
|
|
start of the next token is returned. Otherwise, a value of NULL is
|
|
returned.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
|
|
// If there are more characters in the token string, then parse the
|
|
// next token. Otherwise, return a value of NULL.
|
|
|
|
|
|
if (*TokenString == '\0') {
|
|
return NULL;
|
|
|
|
} else {
|
|
while ((*TokenString != '\0') && (*TokenString != '(')) {
|
|
*OutputToken++ = *TokenString++;
|
|
}
|
|
|
|
*OutputToken = '\0';
|
|
|
|
|
|
// If a unit number is specified, then convert it to binary.
|
|
// Otherwise, default the unit number to zero.
|
|
|
|
|
|
*UnitNumber = 0;
|
|
if (*TokenString == '(') {
|
|
TokenString += 1;
|
|
while ((*TokenString != '\0') && (*TokenString != ')')) {
|
|
*UnitNumber = (*UnitNumber * 10) + (*TokenString++ - '0');
|
|
}
|
|
|
|
if (*TokenString == ')') {
|
|
TokenString += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TokenString;
|
|
}
|
|
|
|
|
|
ULONG
|
|
AlMatchArcNamToken (
|
|
IN PCHAR TokenValue,
|
|
IN TOKEN_TYPE TokenType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine attempts to match a token with an array of possible
|
|
values.
|
|
|
|
Arguments:
|
|
|
|
TokenValue - Supplies a pointer to a zero terminated token value.
|
|
|
|
TokenType - Indicates which type of token we are dealing with
|
|
(AdapterType/ControllerType/PeripheralType)
|
|
|
|
Return Value:
|
|
|
|
If the token type is invalid, INVALID_TOKEN_TYPE is returned.
|
|
|
|
If a token match is not located, then a value INVALID_TOKEN_VALUE
|
|
is returned.
|
|
|
|
If a token match is located, then the ENUM value of the token is
|
|
returned.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
ULONG Index;
|
|
PCHAR MatchString;
|
|
PCHAR TokenString;
|
|
PCHAR *TokenArray;
|
|
BOOLEAN Found;
|
|
|
|
|
|
// Depending on token type choose the appropriate token string array
|
|
|
|
switch (TokenType) {
|
|
case AdapterType:
|
|
TokenArray = AdapterTypes;
|
|
break;
|
|
|
|
case ControllerType:
|
|
TokenArray = ControllerTypes;
|
|
break;
|
|
|
|
case PeripheralType:
|
|
TokenArray = PeripheralTypes;
|
|
break;
|
|
|
|
default:
|
|
return ((ULONG)INVALID_TOKEN_TYPE);
|
|
}
|
|
|
|
|
|
// Scan the match array until either a match is found or all of
|
|
// the match strings have been scanned.
|
|
|
|
// BUGBUG** The code below can be easily implemented using _strcmpi.
|
|
|
|
|
|
Index = 0;
|
|
Found = FALSE;
|
|
while (TokenArray[Index] != NULL) {
|
|
MatchString = TokenArray[Index];
|
|
TokenString = TokenValue;
|
|
while ((*MatchString != '\0') && (*TokenString != '\0')) {
|
|
if (toupper(*MatchString) != toupper(*TokenString)) {
|
|
break;
|
|
}
|
|
|
|
MatchString += 1;
|
|
TokenString += 1;
|
|
}
|
|
|
|
if ((*MatchString == '\0') && (*TokenString == '\0')) {
|
|
Found = TRUE;
|
|
break;
|
|
}
|
|
|
|
Index += 1;
|
|
}
|
|
|
|
return (Found ? Index : INVALID_TOKEN_VALUE);
|
|
}
|
|
|
|
ULONG
|
|
AlPrint (
|
|
PCHAR Format,
|
|
...
|
|
)
|
|
|
|
{
|
|
|
|
va_list arglist;
|
|
UCHAR Buffer[256];
|
|
ULONG Count;
|
|
ULONG Length;
|
|
|
|
|
|
// Format the output into a buffer and then print it.
|
|
|
|
|
|
va_start(arglist, Format);
|
|
Length = vsprintf(Buffer, Format, arglist);
|
|
ArcWrite( ARC_CONSOLE_OUTPUT, Buffer, Length, &Count);
|
|
va_end(arglist);
|
|
return 0;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AlGetString(
|
|
OUT PCHAR String,
|
|
IN ULONG StringLength
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine reads a string from standardin until a
|
|
carriage return or escape is found or StringLength is reached.
|
|
|
|
Arguments:
|
|
|
|
String - Supplies a pointer to where the string will be stored.
|
|
|
|
StringLength - Supplies the Max Length to read.
|
|
|
|
Return Value:
|
|
|
|
FALSE if user pressed esc, TRUE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
CHAR c;
|
|
ULONG Count;
|
|
PCHAR Buffer;
|
|
|
|
Buffer = String;
|
|
while (ArcRead(ARC_CONSOLE_INPUT,&c,1,&Count)==ESUCCESS) {
|
|
if(c == ASCI_ESC) {
|
|
return(FALSE);
|
|
}
|
|
if ((c=='\r') || (c=='\n') || ((ULONG)(Buffer-String) == StringLength)) {
|
|
*Buffer='\0';
|
|
ArcWrite(ARC_CONSOLE_OUTPUT,"\r\n",2,&Count);
|
|
return(TRUE);
|
|
}
|
|
|
|
// Check for backspace;
|
|
|
|
if (c=='\b') {
|
|
if (((ULONG)Buffer > (ULONG)String)) {
|
|
Buffer--;
|
|
ArcWrite(ARC_CONSOLE_OUTPUT,"\b \b",3,&Count);
|
|
}
|
|
} else {
|
|
|
|
// If it's a printable char store it and display it.
|
|
|
|
if (isprint(c)) {
|
|
*Buffer++ = c;
|
|
ArcWrite(ARC_CONSOLE_OUTPUT,&c,1,&Count);
|
|
}
|
|
}
|
|
}
|
|
}
|