windows-nt-4.0/private/ntos/arcinst/almisc.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);
            }
        }
    }
}