/*++

Copyright (c) 1998  Microsoft Corporation

Module Name:

    console.c

Abstract:

    This module implements the interfaces that
    provide access to the console i/o.

Author:

    Wesley Witt (wesw) 21-Oct-1998

Revision History:

--*/

#include "cmdcons.h"
#pragma hdrstop

//
// Notes:
//
// This code needs to be correct for DBCS. A double-byte character takes up
// 2 character spaces on the screen. This means that there is not a one-to-one
// correlation between the unicode characters we want to work with and the
// representation on the screen. For this reason, the code in this module
// does a lot of converting into the OEM charset. When represented in the
// OEM charset, strlen(x) is exactly the number of char spaces taken up
// on the screen. (The fonts used in text mode setup are all OEM charset fonts
// so that's why we use OEM).
//


#define CURSOR                SplangGetCursorChar()
#define CONSOLE_HEADER_HEIGHT 0

unsigned ConsoleX,ConsoleY;

UCHAR ConsoleLeadByteTable[128/8];
BOOLEAN ConsoleDbcs;

#define IS_LEAD_BYTE(c)  ((c < 0x80) ? FALSE : (ConsoleLeadByteTable[(c & 0x7f) / 8] & (1 << ((c & 0x7f) % 8))))
#define SET_LEAD_BYTE(c) (ConsoleLeadByteTable[(c & 0x7f)/8] |= (1 << ((c & 0x7f) % 8)))

PUCHAR ConsoleOemString;
ULONG ConsoleMaxOemStringLen;

#define CONSOLE_ATTRIBUTE   (ATT_FG_WHITE | ATT_BG_BLACK)
#define CONSOLE_BACKGROUND  ATT_BLACK

//
// Globals used for more mode.
//
BOOLEAN pMoreMode;
unsigned pMoreLinesOut;
unsigned pMoreMaxLines;

#define CONSOLE_MORE_ATTRIBUTE   (ATT_FG_BLACK | ATT_BG_WHITE)
#define CONSOLE_MORE_BACKGROUND  ATT_WHITE



BOOLEAN
pRcLineDown(
    BOOLEAN *pbScrolled
    );


VOID
RcConsoleInit(
    VOID
    )
{
    unsigned i;

    //
    // Build lead-byte table, set ConsoleDbcs global
    //
    RtlZeroMemory(ConsoleLeadByteTable,sizeof(ConsoleLeadByteTable));

    if(ConsoleDbcs = NLS_MB_OEM_CODE_PAGE_TAG) {

        for(i=128; i<=255; i++) {

            if((NLS_OEM_LEAD_BYTE_INFO)[i]) {

                SET_LEAD_BYTE(i);
            }
        }
    }

    //
    // Get a buffer for unicode to oem translations.
    //
    ConsoleMaxOemStringLen = 2000;
    ConsoleOemString = SpMemAlloc(ConsoleMaxOemStringLen);

    //
    // Clear screen and initialize cursor location.
    //
    pRcCls();
}


VOID
RcConsoleTerminate(
    VOID
    )
{
    ASSERT(ConsoleOemString);

    SpMemFree(ConsoleOemString);
    ConsoleOemString = NULL;
    ConsoleMaxOemStringLen = 0;
}


#define MAX_HISTORY_LINES 30

typedef struct _LINE_HISTORY {
    WCHAR Line[RC_MAX_LINE_LEN];
    ULONG Length;
} LINE_HISTORY, *PLINE_HISTORY;

LINE_HISTORY LineHistory[MAX_HISTORY_LINES];
ULONG CurPos;
ULONG NextPos;


void
RcPurgeHistoryBuffer(
    void
    )
{
    CurPos = 0;
    NextPos = 0;
    ZeroMemory( LineHistory, sizeof(LineHistory) );
}


void
RcClearToEOL(
    void
    )
{
    unsigned uWidth = _CmdConsBlock->VideoVars->ScreenWidth;
    unsigned uY = ConsoleY + (ConsoleX / uWidth);
    unsigned uX = ConsoleX % uWidth; // taking care of roll over

    SpvidClearScreenRegion(uX, uY, uWidth-uX,
        1, CONSOLE_BACKGROUND);
}

void
RcClearLines(
    unsigned uX, unsigned uY, unsigned cLines
    )
/*++
Routine Description:

This routine clears the specified number of lines with blank characters
starting from X coordinate (0 based) on lines specifed by Y coordinate

Arguments:
    uX - starting X coordinate
    uY - starting Y coordinate
    cLines - number of lines to be cleared after Y coordinate

Return Value: None
--*/
{
    unsigned uWidth = _CmdConsBlock->VideoVars->ScreenWidth;

    if (uY < _CmdConsBlock->VideoVars->ScreenWidth) {
        SpvidClearScreenRegion(uX, uY, uWidth-uX,
            1, CONSOLE_BACKGROUND);

        if (cLines && (cLines <= _CmdConsBlock->VideoVars->ScreenWidth)) {
            SpvidClearScreenRegion(0, ++uY, uWidth,
                cLines, CONSOLE_BACKGROUND);
        }
    }
}


unsigned
_RcLineIn(
    OUT PWCHAR Buffer,
    IN unsigned MaxLineLen,
    IN BOOLEAN PasswordProtect,
    IN BOOLEAN UseBuffer
    )

/*++

Routine Description:

    Get a line of input from the user. The user can type at the keyboard.
    Control is very simple, the only control character accepted is backspace.
    A cursor will be drawn as the user types to indicate where the next
    character will end up on the screen. As the user types the screen will be
    scrolled if necessary.

    The string returned will be limited to MaxLineLen-1 characters and
    0-terminated.

    NOTE: this routine deals with double-byte characters correctly.

Arguments:

    Buffer - receives the line as typed by the user. The buffer must be
        large enough to hold least 2 characters, since the string returned
        will always get a nul-termination and requesting a string that
        can have at most only a terminating nul isn't too meaningful.

    MaxLineLen - supplies the number of unicode characters that will fit
        in the buffer pointed to by Buffer (including the terminating nul).
        As described above, must be > 1.

Return Value:

    Number of characters written into Buffer, not including the terminating
    nul character.

    Upon return the global ConsoleX and ConsoleY variables will be updated
    such that ConsoleX is 0 and ConsoleY indicates the next "empty" line.
    Also the cursor will be shut off.

--*/

{
    unsigned LineLen;
    ULONG c;
    WCHAR s[2];
    UCHAR Oem[3];
    BOOL Done;
    ULONG OemLen;
    int i,j;
    ULONG OrigConsoleX;
    ULONG ulOrigY;
    BOOLEAN bScrolled = FALSE;

    ASSERT(MaxLineLen > 1);
    MaxLineLen--;       // leave room for terminating nul
    LineLen = 0;
    Done = FALSE;
    s[1] = 0;

    //
    // We use ConsoleOemString as temp storage for char lengths.
    // Make sure we don't run off the end of the buffer.
    //
    if(MaxLineLen > ConsoleMaxOemStringLen) {
        MaxLineLen = ConsoleMaxOemStringLen;
    }

    //
    // Turn cursor on.
    //
    s[0] = CURSOR;
    SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);

    //
    // Get characters until user hits enter.
    //
    CurPos = NextPos;
    OrigConsoleX = ConsoleX;
    ulOrigY = ConsoleY;

    if (UseBuffer) {
        LineLen = wcslen(Buffer);
        RtlZeroMemory(ConsoleOemString,ConsoleMaxOemStringLen);
        RtlUnicodeToOemN(ConsoleOemString,ConsoleMaxOemStringLen,&OemLen,Buffer,LineLen*sizeof(WCHAR));
        SpvidDisplayOemString(ConsoleOemString,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);
        ConsoleX += OemLen;
        RcClearToEOL();
        s[0] = CURSOR;
        SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);
        for (i=0; i<(int)wcslen(Buffer); i++) {
            RtlUnicodeToOemN(Oem,3,&OemLen,&Buffer[i],2*sizeof(WCHAR));
            ConsoleOemString[i] = (UCHAR)OemLen-1;
        }
    }

    do {

        c = SpInputGetKeypress();

        if(c & KEY_NON_CHARACTER) {
            if (c == KEY_UP || c == KEY_DOWN) {
                if (c == KEY_UP) {
                    if (CurPos == 0) {
                        i = MAX_HISTORY_LINES - 1;
                    } else {
                        i = CurPos - 1;
                    }
                    j = i;
                    while (LineHistory[i].Length == 0) {
                        i -= 1;
                        if (i < 0) {
                            i = MAX_HISTORY_LINES - 1;
                        }
                        if (i == j) break;
                    }
                }
                if (c == KEY_DOWN) {
                    if (CurPos == MAX_HISTORY_LINES) {
                        i = 0;
                    } else {
                        i = CurPos + 1;
                    }
                    j = i;
                    while (LineHistory[i].Length == 0) {
                        i += 1;
                        if (i == MAX_HISTORY_LINES) {
                            i = 0;
                        }
                        if (i == j) break;
                    }
                }

                if (LineHistory[i].Length) {
                    wcscpy(Buffer,LineHistory[i].Line);
                    LineLen = LineHistory[i].Length;
                    RtlZeroMemory(ConsoleOemString,ConsoleMaxOemStringLen);
                    RtlUnicodeToOemN(ConsoleOemString,ConsoleMaxOemStringLen,&OemLen,Buffer,LineLen*sizeof(WCHAR));
                    ConsoleX = OrigConsoleX;

                    // clear the old command
                    RcClearLines(ConsoleX, ulOrigY, ConsoleY - ulOrigY);

                    ConsoleY = ulOrigY;

                    // scroll if needed
                    if ((ConsoleX + OemLen) >= _CmdConsBlock->VideoVars->ScreenWidth) {
                        int cNumLines = (ConsoleX + OemLen) /
                                        _CmdConsBlock->VideoVars->ScreenWidth;
                        int cAvailLines = _CmdConsBlock->VideoVars->ScreenHeight -
                                            ConsoleY - 1;

                        if (cNumLines > cAvailLines) {
                            cNumLines -= cAvailLines;

                            SpvidScrollUp( CONSOLE_HEADER_HEIGHT,
                                _CmdConsBlock->VideoVars->ScreenHeight - 1,
                                cNumLines,
                                CONSOLE_BACKGROUND
                                );

                            ConsoleY -= cNumLines;
                            ulOrigY = ConsoleY;
                        }
                    }

                    SpvidDisplayOemString(ConsoleOemString,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);

                    // clean up trailing spaces left by previous command
                    ConsoleX += OemLen;
                    //RcClearToEOL();
   	                s[0] = CURSOR;
  	
                    if (ConsoleX >= _CmdConsBlock->VideoVars->ScreenWidth) {
                        ConsoleY += (ConsoleX / _CmdConsBlock->VideoVars->ScreenWidth);
                        ConsoleY %= _CmdConsBlock->VideoVars->ScreenHeight;
                        ConsoleX %= _CmdConsBlock->VideoVars->ScreenWidth;
                    }

       	            SpvidDisplayString(s,CONSOLE_ATTRIBUTE, ConsoleX, ConsoleY);

                    CurPos = i;

                    for (i=0; i<(int)wcslen(Buffer); i++) {
                        RtlUnicodeToOemN(Oem,3,&OemLen,&Buffer[i],2*sizeof(WCHAR));
                        ConsoleOemString[i] = (UCHAR)OemLen-1;
                    }
                }
            }
        } else {
            //
            // Got a real unicode value, which could be CR, etc.
            //
            s[0] = (WCHAR)c;

            switch(s[0]) {

            case ASCI_ESC:
                LineLen = 0;
                ConsoleX = OrigConsoleX;
                CurPos = NextPos;
                // clear the extra lines from previous command if any
                RcClearLines(ConsoleX, ulOrigY, ConsoleY - ulOrigY);
                //RcClearToEOL();
                s[0] = CURSOR;
                ConsoleY = ulOrigY;
                SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);

                break;

            case ASCI_BS:

                if(LineLen) {
                    LineLen--;

                    //
                    // Write a space over the current cursor location
                    // and then back up one char and write the cursor.
                    //
                    s[0] = L' ';
                    SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);

                    OemLen = ConsoleOemString[LineLen];
                    ASSERT(OemLen <= 2);

                    if(ConsoleX) {
                        //
                        // We might have the case where the character we just erased
                        // is a double-byte character that didn't fit on the previous
                        // line because the user typed it when the cursor was at the
                        // rightmost x position.
                        //
                        if(OemLen) {
                            //
                            // No special case needed. Decrement the x position and
                            // clear out the second half of double-byte char,
                            // if necessary.
                            //
                            ConsoleX -= OemLen;
                            if(OemLen == 2) {
                                SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX+1,ConsoleY);
                            }
                        } else {
                            //
                            // Clear out the current character (which must be
                            // a double-byte character) and then hop up one line.
                            //
                            ASSERT(ConsoleX == 2);
                            SpvidDisplayString(s,CONSOLE_ATTRIBUTE,0,ConsoleY);
                            SpvidDisplayString(s,CONSOLE_ATTRIBUTE,1,ConsoleY);

                            ConsoleX = _CmdConsBlock->VideoVars->ScreenWidth-1;
                            ConsoleY--;
                        }
                    } else {
                        //
                        // The cursor is at x=0. This can't happen if
                        // there's a fill space at the end of the previous line,
                        // so we don't need to worry about handling that here.
                        //
                        ASSERT(OemLen != 3);
                        ConsoleX = _CmdConsBlock->VideoVars->ScreenWidth - OemLen;
                        ConsoleY--;

                        //
                        // Clear out second half of double-byte char if necessary.
                        //
                        if(OemLen > 1) {
                            SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX+1,ConsoleY);
                        }
                    }

                    s[0] = CURSOR;
                    SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);
                }

                ulOrigY = ConsoleY;

                break;

            case ASCI_CR:
                //
                // Erase the cursor and advance the current position one line.
                //
                s[0] = L' ';
                SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);

                ConsoleX = 0;
                pRcLineDown(0);

                //
                // We know there's room in the buffer because we accounted
                // for the terminating nul up front.
                //
                Buffer[LineLen] = 0;
                Done = TRUE;
                break;

            default:
                //
                // Plain old character. Note that it could be a double-byte char,
                // which takes up 2 char widths on the screen.
                //
                // Also disallow control chars.
                //
                if((s[0] >= L' ') && (LineLen < MaxLineLen)) {

                    //
                    // Convert to OEM, including nul byte
                    //
                    RtlUnicodeToOemN(Oem,3,&OemLen,PasswordProtect?L"*":s,2*sizeof(WCHAR));
                    OemLen--;

                    //
                    // Save the character in the caller's buffer.
                    // Also we use the ConsoleOemString buffer as temp storage space
                    // to store the length in oem chars of each char input.
                    //
                    Buffer[LineLen] = s[0];
                    ConsoleOemString[LineLen] = (UCHAR)OemLen;

                    //
                    // If the character is double-byte, then there might not be
                    // enough room on the current line for it. Check for that here.
                    //
                    if((ConsoleX+OemLen) > _CmdConsBlock->VideoVars->ScreenWidth) {

                        //
                        // Erase the cursor from the last position on the line.
                        //
                        s[0] = L' ';
                        SpvidDisplayString(
                            s,
                            CONSOLE_ATTRIBUTE,
                            _CmdConsBlock->VideoVars->ScreenWidth-1,
                            ConsoleY
                            );

                        //
                        // Adjust cursor position.
                        //
                        ConsoleX = 0;
                        // >> ulOrigY = ConsoleY;
                        bScrolled = FALSE;
                        pRcLineDown(&bScrolled);

                        //
                        // if screen scrolled then we need to adjust original Y coordinate
                        // appropriately
                        //
                        if (bScrolled && (ulOrigY > 0))
                            --ulOrigY;

                        //
                        // Special handling for this case, so backspace will
                        // work correctly.
                        //
                        ConsoleOemString[LineLen] = 0;
                    }

                    SpvidDisplayOemString(Oem,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);
                    ConsoleX += OemLen;

                    if(ConsoleX == _CmdConsBlock->VideoVars->ScreenWidth) {
                        ConsoleX = 0;
                        // >> ulOrigY = ConsoleY;
                        bScrolled = FALSE;
                        pRcLineDown(&bScrolled);

                        //
                        // if screen scrolled then we need to adjust original Y coordinate
                        // appropriately
                        //
                        if (bScrolled && (ulOrigY > 0))
                            --ulOrigY;
                    }

                    //
                    // Now display cursor at cursor position for next character.
                    //
                    s[0] = CURSOR;
                    SpvidDisplayString(s,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);

                    LineLen++;
                }

                break;
            }
        }
    } while(!Done);

    Buffer[LineLen] = 0;

    // save the line for future use only if its not a password
    if (LineLen && !PasswordProtect) {
        LineHistory[NextPos].Length = LineLen;
        wcscpy(LineHistory[NextPos].Line,Buffer);

        NextPos += 1;
        if (NextPos >= MAX_HISTORY_LINES) {
            NextPos = 0;
        }
    }

    return LineLen;
}


BOOLEAN
RcRawTextOut(
    IN LPCWSTR Text,
    IN LONG    Length
    )

/*++

Routine Description:

    Write a text string to the console at the current position
    (incidated by the ConsoleX and ConsoleY global variables). If the string
    is longer than will fit on the current line, it is broken up properly
    to span multiple lines. The screen is scrolled if necessary.

    This routine handles double-byte characters correctly, ensuring that
    no double-byte character is split across lines.

Arguments:

    Text - supplies the text to be output. Text strings longer than
        ConsoleMaxOemStringLen are truncated. The string need not be
        nul-terminated if Length is not -1.

    Length - supplies the number of characters to output. If -1, then
        Text is assumed to be nul-terminated and the length is
        calculated automatically.

Return Value:

    FALSE if we're in more mode and when prompted the user hit esc.
    TRUE otherwise.

    Upon return, the global variables ConsoleX and ConsoleY point at the next
    empty location on the screen.

--*/

{
    ULONG OemLen;
    ULONG len;
    ULONG i;
    UCHAR c;
    PUCHAR p;
    PUCHAR LastLead;
    BOOLEAN NewLine;
    BOOLEAN Dbcs;

    //
    // Convert the string to the OEM charset and determine the number
    // of character spaces the string will occupy on-screen, which is
    // equal to the number of bytes in the OEM representation of the string.
    // If this is not the same as the number of Unicode characters
    // in the string, then we've got a string with double-byte chars in it.
    //
    len = ((Length == -1) ? wcslen(Text) : Length);

    RtlUnicodeToOemN(
        ConsoleOemString,
        ConsoleMaxOemStringLen,
        &OemLen,
        (PVOID)Text,
        len * sizeof(WCHAR)
        );

    Dbcs = (OemLen != len);

    //
    // If we think we have a double-byte string, we better be prepared
    // to handle it properly.
    //
    if(Dbcs) {
        ASSERT(NLS_MB_OEM_CODE_PAGE_TAG);
        ASSERT(ConsoleDbcs);
    }

    //
    // Spit out the prompt in pieces until we've got all the characters
    // displayed.
    //
    ASSERT(ConsoleX < _CmdConsBlock->VideoVars->ScreenWidth);
    ASSERT(ConsoleY < _CmdConsBlock->VideoVars->ScreenHeight);
    p = ConsoleOemString;

    while(OemLen) {

        if((ConsoleX+OemLen) > _CmdConsBlock->VideoVars->ScreenWidth) {

            len = _CmdConsBlock->VideoVars->ScreenWidth - ConsoleX;

            //
            // Avoid splitting a double-byte character across lines.
            //
            if(Dbcs) {
                for(LastLead=NULL,i=0; i<len; i++) {
                    if(IS_LEAD_BYTE(p[i])) {
                        LastLead = &p[i];
                        i++;
                    }
                }
                if(LastLead == &p[len-1]) {
                    len--;
                }
            }

            NewLine = TRUE;

        } else {
            //
            // It fits on the current line, just display it.
            //
            len = OemLen;
            NewLine = ((ConsoleX+len) == _CmdConsBlock->VideoVars->ScreenWidth);
        }

        c = p[len];
        p[len] = 0;
        SpvidDisplayOemString(p,CONSOLE_ATTRIBUTE,ConsoleX,ConsoleY);
        p[len] = c;

        p += len;
        OemLen -= len;

        if(NewLine) {
            ConsoleX = 0;
            if(!pRcLineDown(0)) {
                return(FALSE);
            }
        } else {
            ConsoleX += len;
        }
    }

    return(TRUE);
}


NTSTATUS
RcBatchOut(
    IN PWSTR strW
    )
{
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatusBlock;
    ULONG OemLen;
    ULONG len;


    len = wcslen(strW);

    RtlUnicodeToOemN(
        ConsoleOemString,
        ConsoleMaxOemStringLen,
        &len,
        (PVOID)strW,
        len * sizeof(WCHAR)
        );

    Status = ZwWriteFile(
        OutputFileHandle,
        NULL,
        NULL,
        NULL,
        &IoStatusBlock,
        (PVOID)ConsoleOemString,
        len,
        &OutputFileOffset,
        NULL
        );
    if (NT_SUCCESS(Status)) {
        OutputFileOffset.LowPart += len;
    }

    return Status;
}


BOOLEAN
RcTextOut(
    IN LPCWSTR Text
    )
{
    LPCWSTR p,q;


    if (InBatchMode && OutputFileHandle) {
        if (RcBatchOut( (LPWSTR)Text ) == STATUS_SUCCESS) {
            return TRUE;
        }
    }
    if (InBatchMode && RedirectToNULL) {
        return TRUE;
    }

    p = Text;
    while(*p) {
        //
        // Locate line terminator, which is cr, lf, or nul.
        //
        q = p;
        while(*q && (*q != L'\r') && (*q != L'\n')) {
            q++;
        }

        //
        // Print this segment out.
        //
        if(!RcRawTextOut(p,(LONG)(q-p))) {
            return(FALSE);
        }

        //
        // Handle cr's and lf's.
        //
        p = q;

        while((*p == L'\n') || (*p == L'\r')) {

            if(*p == L'\n') {
                if(!pRcLineDown(0)) {
                    return(FALSE);
                }
            } else {
                if(*p == L'\r') {
                    ConsoleX = 0;
                }
            }

            p++;
        }
    }

    return(TRUE);
}


BOOLEAN
pRcLineDown(
    BOOLEAN *pbScrolled
    )
{
    WCHAR *p;
    unsigned u;
    ULONG c;
    BOOLEAN b;

    if (pbScrolled)
        *pbScrolled = FALSE;

    b = TRUE;

    ConsoleY++;
    pMoreLinesOut++;

    if(ConsoleY == _CmdConsBlock->VideoVars->ScreenHeight) {
        //
        // Reached the bottom of the screen, need to scroll.
        //
        ConsoleY--;

        SpvidScrollUp(
            CONSOLE_HEADER_HEIGHT,
            _CmdConsBlock->VideoVars->ScreenHeight-1,
            1,
            CONSOLE_BACKGROUND
            );

        if (pbScrolled)
            *pbScrolled = TRUE;
    }

    //
    // If we're in more mode and we've output the max number of lines
    // allowed before requiring user input, get that input now.
    //
    if(pMoreMode
    && (pMoreLinesOut == pMoreMaxLines)
    && (p = SpRetreiveMessageText(ImageBase,MSG_MORE_PROMPT,NULL,0))) {

        //
        // Don't bother calling the format message routine, since that
        // requires some other buffer. Just strip off cr/lf manually.
        //
        u = wcslen(p);
        while(u && ((p[u-1] == L'\r') || (p[u-1] == L'\n'))) {
            p[--u] = 0;
        }

        //
        // Display the more prompt at the bottom of the screen.
        //
        SpvidClearScreenRegion(
            0,
            _CmdConsBlock->VideoVars->ScreenHeight - 1,
            _CmdConsBlock->VideoVars->ScreenWidth,
            1,
            CONSOLE_MORE_BACKGROUND
            );

        SpvidDisplayString(
            p,
            CONSOLE_MORE_ATTRIBUTE,
            2,
            _CmdConsBlock->VideoVars->ScreenHeight - 1
            );

        //
        // We don't need the prompt any more.
        //
        SpMemFree(p);

        //
        // Wait for the user to hit space, cr, or esc.
        //
        pMoreLinesOut = 0;
        while(1) {
            c = SpInputGetKeypress();
            if(c == ASCI_CR) {
                //
                // Allow one more line before prompting user.
                //
                pMoreMaxLines = 1;
                break;
            } else {
                if(c == ASCI_ESC) {
                    //
                    // User wants to stop the current command.
                    //
                    b = FALSE;
                    break;
                } else {
                    if(c == L' ') {
                        //
                        // Allow a whole page more.
                        //
                        pMoreMaxLines = _CmdConsBlock->VideoVars->ScreenHeight
                                      - (CONSOLE_HEADER_HEIGHT + 1);
                        break;
                    }
                }
            }
        }

        SpvidClearScreenRegion(
            0,
            _CmdConsBlock->VideoVars->ScreenHeight - 1,
            _CmdConsBlock->VideoVars->ScreenWidth,
            1,
            CONSOLE_BACKGROUND
            );
    }

    return(b);
}


VOID
pRcEnableMoreMode(
    VOID
    )
{
    pMoreMode = TRUE;

    pMoreLinesOut = 0;

    //
    // The maximum number of lines we allow before prompting the user
    // is the screen height minus the header area. We also reserve
    // one line for the prompt area.
    //
    pMoreMaxLines = _CmdConsBlock->VideoVars->ScreenHeight - (CONSOLE_HEADER_HEIGHT + 1);
}


VOID
pRcDisableMoreMode(
    VOID
    )
{
    pMoreMode = FALSE;
}


ULONG
RcCmdCls(
    IN PTOKENIZED_LINE TokenizedLine
    )
{
    if (RcCmdParseHelp( TokenizedLine, MSG_CLS_HELP )) {
        return 1;
    }

    //
    // Call worker routine to actually do the work
    //
    pRcCls();

    return 1;
}


VOID
pRcCls(
    VOID
    )
{
    //
    // Initialize location and clear screen.
    //
    ConsoleX = 0;
    ConsoleY = CONSOLE_HEADER_HEIGHT;

    SpvidClearScreenRegion(0,0,0,0,CONSOLE_BACKGROUND);
}