cmdutils/more/more.c

/*
 * PROJECT:     ReactOS More Command
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     Displays text stream from STDIN or from an arbitrary number
 *              of files to STDOUT, with screen capabilities (more than CAT,
 *              but less than LESS ^^).
 * COPYRIGHT:   Copyright 1999 Paolo Pantaleo
 *              Copyright 2003 Timothy Schepens
 *              Copyright 2016-2021 Hermes Belusca-Maito
 *              Copyright 2021 Katayama Hirofumi MZ
 */
/*
 * MORE.C - external command.
 *
 * clone from 4nt more command
 *
 * 26 Sep 1999 - Paolo Pantaleo <paolopan@freemail.it>
 *     started
 *
 * Oct 2003 - Timothy Schepens <tischepe at fastmail dot fm>
 *     use window size instead of buffer size.
 */

#include <stdio.h>
#include <stdlib.h>

#include <windef.h>
#include <winbase.h>
#include <winnt.h>
#include <winnls.h>
#include <winreg.h>
#include <winuser.h>

#include <conutils.h>
#include <strsafe.h>

#include "resource.h"

/* PagePrompt statistics for the current file */
DWORD dwFileSize; // In bytes
DWORD dwSumReadBytes, dwSumReadChars;
// The average number of bytes per character is equal to
// dwSumReadBytes / dwSumReadChars. Note that dwSumReadChars
// will never be == 0 when ConWritePaging (and possibly PagePrompt)
// is called.

/* Handles for file and console */
HANDLE hFile = INVALID_HANDLE_VALUE;
HANDLE hStdIn, hStdOut;
HANDLE hKeyboard;

/* Enable/Disable extensions */
BOOL bEnableExtensions = TRUE; // FIXME: By default, it should be FALSE.

/* Parser flags */
#define FLAG_HELP   (1 << 0)
#define FLAG_E      (1 << 1)
#define FLAG_C      (1 << 2)
#define FLAG_P      (1 << 3)
#define FLAG_S      (1 << 4)
#define FLAG_Tn     (1 << 5)
#define FLAG_PLUSn  (1 << 6)

/* Prompt flags */
#define PROMPT_PERCENT  (1 << 0)
#define PROMPT_LINE_AT  (1 << 1)
#define PROMPT_OPTIONS  (1 << 2)
#define PROMPT_LINES    (1 << 3)

static DWORD s_dwFlags = 0;
static LONG s_nTabWidth = 8;
static DWORD s_nNextLineNo = 0;
static BOOL s_bPrevLineIsBlank = FALSE;
static WORD s_fPrompt = 0;
static BOOL s_bDoNextFile = FALSE;

static BOOL IsBlankLine(IN PCWCH line, IN DWORD cch)
{
    DWORD ich;
    WORD wType;
    for (ich = 0; ich < cch; ++ich)
    {
        /*
         * Explicitly exclude FORM-FEED from the check,
         * so that the pager can handle it.
         */
        if (line[ich] == L'\f')
            return FALSE;

        /*
         * Otherwise do the extended blanks check.
         * Note that MS MORE.COM only checks for spaces (\x20) and TABs (\x09).
         * See http://archives.miloush.net/michkap/archive/2007/06/11/3230072.html
         * for more information.
         */
        wType = 0;
        GetStringTypeW(CT_CTYPE1, &line[ich], 1, &wType);
        if (!(wType & (C1_BLANK | C1_SPACE)))
            return FALSE;
    }
    return TRUE;
}

static BOOL
__stdcall
MorePagerLine(
    IN OUT PCON_PAGER Pager,
    IN PCWCH line,
    IN DWORD cch)
{
    if (s_dwFlags & FLAG_PLUSn) /* Skip lines */
    {
        if (Pager->lineno < s_nNextLineNo)
        {
            s_bPrevLineIsBlank = FALSE;
            return TRUE; /* Handled */
        }
        s_dwFlags &= ~FLAG_PLUSn;
    }

    if (s_dwFlags & FLAG_S) /* Shrink blank lines */
    {
        if (IsBlankLine(line, cch))
        {
            if (s_bPrevLineIsBlank)
                return TRUE; /* Handled */

            /*
             * Display a single blank line, independently of the actual size
             * of the current line, by displaying just one space: this is
             * especially needed in order to force line wrapping when the
             * ENABLE_VIRTUAL_TERMINAL_PROCESSING or DISABLE_NEWLINE_AUTO_RETURN
             * console modes are enabled.
             * Then, reposition the cursor to the next line, first column.
             */
            if (Pager->PageColumns > 0)
                ConStreamWrite(Pager->Screen->Stream, TEXT(" "), 1);
            ConStreamWrite(Pager->Screen->Stream, TEXT("\n"), 1);
            Pager->iLine++;
            Pager->iColumn = 0;

            s_bPrevLineIsBlank = TRUE;
            s_nNextLineNo = 0;

            return TRUE; /* Handled */
        }
        else
        {
            s_bPrevLineIsBlank = FALSE;
        }
    }

    s_nNextLineNo = 0;
    /* Not handled, let the pager do the default action */
    return FALSE;
}

static BOOL
__stdcall
PagePrompt(PCON_PAGER Pager, DWORD Done, DWORD Total)
{
    HANDLE hInput = ConStreamGetOSHandle(StdIn);
    HANDLE hOutput = ConStreamGetOSHandle(Pager->Screen->Stream);
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    COORD orgCursorPosition;
    DWORD dwMode;

    KEY_EVENT_RECORD KeyEvent;
    BOOL fCtrl;
    DWORD nLines;
    WCHAR chSubCommand = 0;

    /* Prompt strings (small size since the prompt should
     * hold ideally on one <= 80-character line) */
    static WCHAR StrPercent[80] = L"";
    static WCHAR StrLineAt[80]  = L"";
    static WCHAR StrOptions[80] = L"";
    static WCHAR StrLines[80]   = L"";

    WCHAR szPercent[80] = L"";
    WCHAR szLineAt[80]  = L"";

    /* Load the prompt strings */
    if (!*StrPercent)
        K32LoadStringW(NULL, IDS_CONTINUE_PERCENT, StrPercent, ARRAYSIZE(StrPercent));
    if (!*StrLineAt)
        K32LoadStringW(NULL, IDS_CONTINUE_LINE_AT, StrLineAt, ARRAYSIZE(StrLineAt));
    if (!*StrOptions)
        K32LoadStringW(NULL, IDS_CONTINUE_OPTIONS, StrOptions, ARRAYSIZE(StrOptions));
    if (!*StrLines)
        K32LoadStringW(NULL, IDS_CONTINUE_LINES, StrLines, ARRAYSIZE(StrLines));

    /*
     * Check whether the pager is prompting, but we have actually finished
     * to display a given file, or no data is present in STDIN anymore.
     * In this case, skip the prompt altogether. The only exception is when
     * we are displaying other files.
     */
    // TODO: Implement!

Restart:
    nLines = 0;

    /* Do not show the progress percentage when STDIN is being displayed */
    if (s_fPrompt & PROMPT_PERCENT) // && (hFile != hStdIn)
    {
        /*
         * The progress percentage is evaluated as follows.
         * So far we have read a total of 'dwSumReadBytes' bytes from the file.
         * Amongst those is the latest read chunk of 'dwReadBytes' bytes, to which
         * correspond a number of 'dwReadChars' characters with which we have called
         * ConWritePaging who called PagePrompt. We then have: Total == dwReadChars.
         * During this ConWritePaging call the PagePrompt was called after 'Done'
         * number of characters over 'Total'.
         * It should be noted that for 'dwSumReadBytes' number of bytes read it
         * *roughly* corresponds 'dwSumReadChars' number of characters. This is
         * because there may be some failures happening during the conversion of
         * the bytes read to the character string for a given encoding.
         * Therefore the number of characters displayed on screen is equal to:
         *   dwSumReadChars - Total + Done ,
         * but the best corresponding approximed number of bytes would be:
         *   dwSumReadBytes - (Total - Done) * (dwSumReadBytes / dwSumReadChars) ,
         * where the ratio is the average number of bytes per character.
         * The percentage is then computed relative to the total file size.
         */
        DWORD dwPercent = (dwSumReadBytes - (Total - Done) *
                           (dwSumReadBytes / dwSumReadChars)) * 100 / dwFileSize;
        StringCchPrintfW(szPercent, ARRAYSIZE(szPercent), StrPercent, dwPercent);
    }
    if (s_fPrompt & PROMPT_LINE_AT)
    {
        StringCchPrintfW(szLineAt, ARRAYSIZE(szLineAt), StrLineAt, Pager->lineno);
    }

    /* Suitably format and display the prompt */
    ConResMsgPrintf(Pager->Screen->Stream, 0, IDS_CONTINUE_PROMPT,
                    (s_fPrompt & PROMPT_PERCENT ? szPercent  : L""),
                    (s_fPrompt & PROMPT_LINE_AT ? szLineAt   : L""),
                    (s_fPrompt & PROMPT_OPTIONS ? StrOptions : L""),
                    (s_fPrompt & PROMPT_LINES   ? StrLines   : L""));

    /* Reset the prompt to a default state */
    s_fPrompt &= ~(PROMPT_LINE_AT | PROMPT_OPTIONS | PROMPT_LINES);

    /* RemoveBreakHandler */
    SetConsoleCtrlHandler(NULL, TRUE);
    /* ConInDisable */
    GetConsoleMode(hInput, &dwMode);
    dwMode &= ~ENABLE_PROCESSED_INPUT;
    SetConsoleMode(hInput, dwMode);

    // FIXME: Does not support TTY yet!
    ConGetScreenInfo(Pager->Screen, &csbi);
    orgCursorPosition = csbi.dwCursorPosition;
    for (;;)
    {
        INPUT_RECORD ir = {0};
        DWORD dwRead;
        WCHAR ch;

        do
        {
            ReadConsoleInput(hInput, &ir, 1, &dwRead);
        }
        while ((ir.EventType != KEY_EVENT) || (!ir.Event.KeyEvent.bKeyDown));

        /* Got our key */
        KeyEvent = ir.Event.KeyEvent;

        /* Ignore any unsupported keyboard press */
        if ((KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
            (KeyEvent.wVirtualKeyCode == VK_MENU)  ||
            (KeyEvent.wVirtualKeyCode == VK_CONTROL))
        {
            continue;
        }

        /* Ctrl key is pressed? */
        fCtrl = !!(KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED));

        /* Ctrl+C or Ctrl+Esc? */
        if (fCtrl && ((KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
                      (KeyEvent.wVirtualKeyCode == L'C')))
        {
            chSubCommand = 0;
            break;
        }

        /* If extended features are unavailable, or no
         * pending commands, don't do more processing. */
        if (!(s_dwFlags & FLAG_E) || (chSubCommand == 0))
            break;

        ch = KeyEvent.uChar.UnicodeChar;
        if (L'0' <= ch && ch <= L'9')
        {
            nLines *= 10;
            nLines += ch - L'0';
            ConStreamWrite(Pager->Screen->Stream, &ch, 1);
            continue;
        }
        else if (KeyEvent.wVirtualKeyCode == VK_RETURN)
        {
            /* Validate the line number */
            break;
        }
        else if (KeyEvent.wVirtualKeyCode == VK_ESCAPE)
        {
            /* Cancel the current command */
            chSubCommand = 0;
            break;
        }
        else if (KeyEvent.wVirtualKeyCode == VK_BACK)
        {
            if (nLines != 0)
                nLines /= 10;

            /* Erase the current character */
            ConGetScreenInfo(Pager->Screen, &csbi);
            if ( (csbi.dwCursorPosition.Y  > orgCursorPosition.Y) ||
                ((csbi.dwCursorPosition.Y == orgCursorPosition.Y) &&
                 (csbi.dwCursorPosition.X  > orgCursorPosition.X)) )
            {
                if (csbi.dwCursorPosition.X > 0)
                {
                    csbi.dwCursorPosition.X = csbi.dwCursorPosition.X - 1;
                }
                else if (csbi.dwCursorPosition.Y > 0)
                {
                    csbi.dwCursorPosition.Y = csbi.dwCursorPosition.Y - 1;
                    csbi.dwCursorPosition.X = (csbi.dwSize.X ? csbi.dwSize.X - 1 : 0);
                }

                SetConsoleCursorPosition(hOutput, csbi.dwCursorPosition);

                ch = L' ';
                ConStreamWrite(Pager->Screen->Stream, &ch, 1);
                SetConsoleCursorPosition(hOutput, csbi.dwCursorPosition);
            }

            continue;
        }
    }

    /* AddBreakHandler */
    SetConsoleCtrlHandler(NULL, FALSE);
    /* ConInEnable */
    GetConsoleMode(hInput, &dwMode);
    dwMode |= ENABLE_PROCESSED_INPUT;
    SetConsoleMode(hInput, dwMode);

    /* Refresh the screen information, as the console may have been
     * redimensioned. Update also the default number of lines to scroll. */
    ConGetScreenInfo(Pager->Screen, &csbi);
    Pager->ScrollRows = csbi.srWindow.Bottom - csbi.srWindow.Top;

    /*
     * Erase the full line where the cursor is, and move
     * the cursor back to the beginning of the line.
     */
    ConClearLine(Pager->Screen->Stream);

    /* Ctrl+C or Ctrl+Esc: Control Break */
    if (fCtrl && ((KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
                  (KeyEvent.wVirtualKeyCode == L'C')))
    {
        /* We break, output a newline */
        WCHAR ch = L'\n';
        ConStreamWrite(Pager->Screen->Stream, &ch, 1);
        return FALSE;
    }

    switch (chSubCommand)
    {
        case L'P':
        {
            /* If we don't display other lines, just restart the prompt */
            if (nLines == 0)
            {
                chSubCommand = 0;
                goto Restart;
            }
            /* Otherwise tell the pager to display them */
            Pager->ScrollRows = nLines;
            return TRUE;
        }
        case L'S':
        {
            s_dwFlags |= FLAG_PLUSn;
            s_nNextLineNo = Pager->lineno + nLines;
            /* Use the default Pager->ScrollRows value */
            return TRUE;
        }
        default:
            chSubCommand = 0;
            break;
    }

    /* If extended features are available */
    if (s_dwFlags & FLAG_E)
    {
        /* Ignore any key presses if Ctrl is pressed */
        if (fCtrl)
        {
            chSubCommand = 0;
            goto Restart;
        }

        /* 'Q': Quit */
        if (KeyEvent.wVirtualKeyCode == L'Q')
        {
            /* We break, output a newline */
            WCHAR ch = L'\n';
            ConStreamWrite(Pager->Screen->Stream, &ch, 1);
            return FALSE;
        }

        /* 'F': Next file */
        if (KeyEvent.wVirtualKeyCode == L'F')
        {
            s_bDoNextFile = TRUE;
            return FALSE;
        }

        /* '?': Show Options */
        if (KeyEvent.uChar.UnicodeChar == L'?')
        {
            s_fPrompt |= PROMPT_OPTIONS;
            goto Restart;
        }

        /* [Enter] key: Display one line */
        if (KeyEvent.wVirtualKeyCode == VK_RETURN)
        {
            Pager->ScrollRows = 1;
            return TRUE;
        }

        /* [Space] key: Display one page */
        if (KeyEvent.wVirtualKeyCode == VK_SPACE)
        {
            if (s_dwFlags & FLAG_C)
            {
                /* Clear the screen */
                ConClearScreen(Pager->Screen);
            }
            /* Use the default Pager->ScrollRows value */
            return TRUE;
        }

        /* 'P': Display n lines */
        if (KeyEvent.wVirtualKeyCode == L'P')
        {
            s_fPrompt |= PROMPT_LINES;
            chSubCommand = L'P';
            goto Restart;
        }

        /* 'S': Skip n lines */
        if (KeyEvent.wVirtualKeyCode == L'S')
        {
            s_fPrompt |= PROMPT_LINES;
            chSubCommand = L'S';
            goto Restart;
        }

        /* '=': Show current line number */
        if (KeyEvent.uChar.UnicodeChar == L'=')
        {
            s_fPrompt |= PROMPT_LINE_AT;
            goto Restart;
        }

        chSubCommand = 0;
        goto Restart;
    }
    else
    {
        /* Extended features are unavailable: display one page */
        /* Use the default Pager->ScrollRows value */
        return TRUE;
    }
}

/*
 * See base/applications/cmdutils/clip/clip.c!IsDataUnicode()
 * and base/applications/notepad/text.c!ReadText() for more details.
 * Also some good code example can be found at:
 * https://github.com/AutoIt/text-encoding-detect
 */
typedef enum
{
    ENCODING_ANSI    =  0,
    ENCODING_UTF16LE =  1,
    ENCODING_UTF16BE =  2,
    ENCODING_UTF8    =  3
} ENCODING;

static BOOL
IsDataUnicode(
    IN PVOID Buffer,
    IN DWORD BufferSize,
    OUT ENCODING* Encoding OPTIONAL,
    OUT PDWORD SkipBytes OPTIONAL)
{
    PBYTE pBytes = Buffer;
    ENCODING encFile = ENCODING_ANSI;
    DWORD dwPos = 0;

    /*
     * See http://archives.miloush.net/michkap/archive/2007/04/22/2239345.html
     * for more details about the algorithm and the pitfalls behind it.
     * Of course it would be actually great to make a nice function that
     * would work, once and for all, and put it into a library.
     */

    /* Look for Byte Order Marks */
    if ((BufferSize >= 2) && (pBytes[0] == 0xFF) && (pBytes[1] == 0xFE))
    {
        encFile = ENCODING_UTF16LE;
        dwPos = 2;
    }
    else if ((BufferSize >= 2) && (pBytes[0] == 0xFE) && (pBytes[1] == 0xFF))
    {
        encFile = ENCODING_UTF16BE;
        dwPos = 2;
    }
    else if ((BufferSize >= 3) && (pBytes[0] == 0xEF) && (pBytes[1] == 0xBB) && (pBytes[2] == 0xBF))
    {
        encFile = ENCODING_UTF8;
        dwPos = 3;
    }
    else
    {
        /*
         * Try using statistical analysis. Do not rely on the return value of
         * IsTextUnicode as we can get FALSE even if the text is in UTF-16 BE
         * (i.e. we have some of the IS_TEXT_UNICODE_REVERSE_MASK bits set).
         * Instead, set all the tests we want to perform, then just check
         * the passed tests and try to deduce the string properties.
         */

/*
 * This mask contains the 3 highest bits from IS_TEXT_UNICODE_NOT_ASCII_MASK
 * and the 1st highest bit from IS_TEXT_UNICODE_NOT_UNICODE_MASK.
 */
#define IS_TEXT_UNKNOWN_FLAGS_MASK  ((7 << 13) | (1 << 11))

        /* Flag out the unknown flags here, the passed tests will not have them either */
        INT Tests = (IS_TEXT_UNICODE_NOT_ASCII_MASK   |
                     IS_TEXT_UNICODE_NOT_UNICODE_MASK |
                     IS_TEXT_UNICODE_REVERSE_MASK | IS_TEXT_UNICODE_UNICODE_MASK)
                        & ~IS_TEXT_UNKNOWN_FLAGS_MASK;
        INT Results;

        IsTextUnicode(Buffer, BufferSize, &Tests);
        Results = Tests;

        /*
         * As the IS_TEXT_UNICODE_NULL_BYTES or IS_TEXT_UNICODE_ILLEGAL_CHARS
         * flags are expected to be potentially present in the result without
         * modifying our expectations, filter them out now.
         */
        Results &= ~(IS_TEXT_UNICODE_NULL_BYTES | IS_TEXT_UNICODE_ILLEGAL_CHARS);

        /*
         * NOTE: The flags IS_TEXT_UNICODE_ASCII16 and
         * IS_TEXT_UNICODE_REVERSE_ASCII16 are not reliable.
         *
         * NOTE2: Check for potential "bush hid the facts" effect by also
         * checking the original results (in 'Tests') for the absence of
         * the IS_TEXT_UNICODE_NULL_BYTES flag, as we may presumably expect
         * that in UTF-16 text there will be at some point some NULL bytes.
         * If not, fall back to ANSI. This shows the limitations of using the
         * IsTextUnicode API to perform such tests, and the usage of a more
         * improved encoding detection algorithm would be really welcome.
         */
        if (!(Results & IS_TEXT_UNICODE_NOT_UNICODE_MASK) &&
            !(Results & IS_TEXT_UNICODE_REVERSE_MASK)     &&
             (Results & IS_TEXT_UNICODE_UNICODE_MASK)     &&
             (Tests   & IS_TEXT_UNICODE_NULL_BYTES))
        {
            encFile = ENCODING_UTF16LE;
            dwPos = (Results & IS_TEXT_UNICODE_SIGNATURE) ? 2 : 0;
        }
        else
        if (!(Results & IS_TEXT_UNICODE_NOT_UNICODE_MASK) &&
            !(Results & IS_TEXT_UNICODE_UNICODE_MASK)     &&
             (Results & IS_TEXT_UNICODE_REVERSE_MASK)     &&
             (Tests   & IS_TEXT_UNICODE_NULL_BYTES))
        {
            encFile = ENCODING_UTF16BE;
            dwPos = (Results & IS_TEXT_UNICODE_REVERSE_SIGNATURE) ? 2 : 0;
        }
        else
        {
            /*
             * Either 'Results' has neither of those masks set, as it can be
             * the case for UTF-8 text (or ANSI), or it has both as can be the
             * case when analysing pure binary data chunk. This is therefore
             * invalid and we fall back to ANSI encoding.
             * FIXME: In case of failure, assume ANSI (as long as we do not have
             * correct tests for UTF8, otherwise we should do them, and at the
             * very end, assume ANSI).
             */
            encFile = ENCODING_ANSI; // ENCODING_UTF8;
            dwPos = 0;
        }
    }

    if (Encoding)
        *Encoding = encFile;
    if (SkipBytes)
        *SkipBytes = dwPos;

    return (encFile != ENCODING_ANSI);
}

/*
 * Adapted from base/shell/cmd/misc.c!FileGetString(), but with correct
 * text encoding support. Also please note that similar code should be
 * also used in the CMD.EXE 'TYPE' command.
 * Contrary to CMD's FileGetString() we do not stop at new-lines.
 *
 * Read text data from a file and convert it from a given encoding to UTF-16.
 *
 *   IN OUT PVOID pCacheBuffer and IN DWORD CacheBufferLength :
 *     Implementation detail so that the function uses an external user-provided
 *     buffer to store the data temporarily read from the file. The function
 *     could have used an internal buffer instead. The length is in number of bytes.
 *
 *   IN OUT PWSTR* pBuffer and IN OUT PDWORD pnBufferLength :
 *     Reallocated buffer containing the string data converted to UTF-16.
 *     In input, contains a pointer to the original buffer and its length.
 *     In output, contains a pointer to the reallocated buffer and its length.
 *     The length is in number of characters.
 *
 *     At first call to this function, pBuffer can be set to NULL, in which case
 *     when the function returns the pointer will point to a valid buffer.
 *     After the last call to this function, free the pBuffer pointer with:
 *     HeapFree(GetProcessHeap(), 0, *pBuffer);
 *
 *     If Encoding is set to ENCODING_UTF16LE or ENCODING_UTF16BE, since we are
 *     compiled in UNICODE, no extra conversion is performed and therefore
 *     pBuffer is unused (remains unallocated) and one can directly use the
 *     contents of pCacheBuffer as it is expected to contain valid UTF-16 text.
 *
 *   OUT PDWORD pdwReadBytes : Number of bytes read from the file (optional).
 *   OUT PDWORD pdwReadChars : Corresponding number of characters read (optional).
 */
static BOOL
FileGetString(
    IN HANDLE hFile,
    IN ENCODING Encoding,
    IN OUT PVOID pCacheBuffer,
    IN DWORD CacheBufferLength,
    IN OUT PWCHAR* pBuffer,
    IN OUT PDWORD pnBufferLength,
    OUT PDWORD pdwReadBytes OPTIONAL,
    OUT PDWORD pdwReadChars OPTIONAL)
{
    BOOL Success;
    UINT CodePage = (UINT)-1;
    DWORD dwReadBytes;
    INT len;

    // ASSERT(pCacheBuffer && (CacheBufferLength > 0));
    // ASSERT(CacheBufferLength % 2 == 0); // Cache buffer length MUST BE even!
    // ASSERT(pBuffer && pnBufferLength);

    /* Always reset the retrieved number of bytes/characters */
    if (pdwReadBytes) *pdwReadBytes = 0;
    if (pdwReadChars) *pdwReadChars = 0;

    Success = ReadFile(hFile, pCacheBuffer, CacheBufferLength, &dwReadBytes, NULL);
    if (!Success || dwReadBytes == 0)
        return FALSE;

    if (pdwReadBytes) *pdwReadBytes = dwReadBytes;

    if ((Encoding == ENCODING_ANSI) || (Encoding == ENCODING_UTF8))
    {
        /* Conversion is needed */

        if (Encoding == ENCODING_ANSI)
            CodePage = GetConsoleCP(); // CP_ACP; // FIXME: Cache GetConsoleCP() value.
        else // if (Encoding == ENCODING_UTF8)
            CodePage = CP_UTF8;

        /* Retrieve the needed buffer size */
        len = MultiByteToWideChar(CodePage, 0, pCacheBuffer, dwReadBytes,
                                  NULL, 0);
        if (len == 0)
        {
            /* Failure, bail out */
            return FALSE;
        }

        /* Initialize the conversion buffer if needed... */
        if (*pBuffer == NULL)
        {
            *pnBufferLength = len;
            *pBuffer = HeapAlloc(GetProcessHeap(), 0, *pnBufferLength * sizeof(WCHAR));
            if (*pBuffer == NULL)
            {
                // *pBuffer = NULL;
                *pnBufferLength = 0;
                // WARN("DEBUG: Cannot allocate memory for *pBuffer!\n");
                // ConErrFormatMessage(GetLastError());
                return FALSE;
            }
        }
        /* ... or reallocate only if the new length is greater than the old one */
        else if (len > *pnBufferLength)
        {
            PWSTR OldBuffer = *pBuffer;

            *pnBufferLength = len;
            *pBuffer = HeapReAlloc(GetProcessHeap(), 0, *pBuffer, *pnBufferLength * sizeof(WCHAR));
            if (*pBuffer == NULL)
            {
                /* Do not leak old buffer */
                HeapFree(GetProcessHeap(), 0, OldBuffer);
                // *pBuffer = NULL;
                *pnBufferLength = 0;
                // WARN("DEBUG: Cannot reallocate memory for *pBuffer!\n");
                // ConErrFormatMessage(GetLastError());
                return FALSE;
            }
        }

        /* Now perform the conversion proper */
        len = MultiByteToWideChar(CodePage, 0, pCacheBuffer, dwReadBytes,
                                  *pBuffer, len);
        dwReadBytes = len;
    }
    else
    {
        /*
         * No conversion needed, just convert from big to little endian if needed.
         * pBuffer and pnBufferLength are left untouched and pCacheBuffer can be
         * directly used.
         */
        PWCHAR pWChars = pCacheBuffer;
        DWORD i;

        dwReadBytes /= sizeof(WCHAR);

        if (Encoding == ENCODING_UTF16BE)
        {
            for (i = 0; i < dwReadBytes; i++)
            {
                /* Equivalent to RtlUshortByteSwap: reverse high/low bytes */
                pWChars[i] = MAKEWORD(HIBYTE(pWChars[i]), LOBYTE(pWChars[i]));
            }
        }
        // else if (Encoding == ENCODING_UTF16LE), we are good, nothing to do.
    }

    /* Return the number of characters (dwReadBytes is converted) */
    if (pdwReadChars) *pdwReadChars = dwReadBytes;

    return TRUE;
}

static VOID
LoadRegistrySettings(HKEY hKeyRoot)
{
    LONG lRet;
    HKEY hKey;
    DWORD dwType, len;
    /*
     * Buffer big enough to hold the string L"4294967295",
     * corresponding to the literal 0xFFFFFFFF (MAXULONG) in decimal.
     */
    WCHAR Buffer[sizeof("4294967295")];
    C_ASSERT(sizeof(Buffer) >= sizeof(DWORD));

    lRet = RegOpenKeyExW(hKeyRoot,
                         L"Software\\Microsoft\\Command Processor",
                         0,
                         KEY_QUERY_VALUE,
                         &hKey);
    if (lRet != ERROR_SUCCESS)
        return;

    len = sizeof(Buffer);
    lRet = RegQueryValueExW(hKey,
                            L"EnableExtensions",
                            NULL,
                            &dwType,
                            (PBYTE)&Buffer,
                            &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default setting */
        if (dwType == REG_DWORD)
            bEnableExtensions = !!*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            bEnableExtensions = (_wtol((PWSTR)Buffer) == 1);
    }
    // else, use the default setting set globally.

    RegCloseKey(hKey);
}

static BOOL IsFlag(PCWSTR param)
{
    PCWSTR pch;
    PWCHAR endptr;

    if (param[0] == L'/')
        return TRUE;

    if (param[0] == L'+')
    {
        pch = param + 1;
        if (*pch)
        {
            (void)wcstol(pch, &endptr, 10);
            return (*endptr == 0);
        }
    }
    return FALSE;
}

static BOOL ParseArgument(PCWSTR arg, BOOL* pbHasFiles)
{
    PWCHAR endptr;

    if (arg[0] == L'/')
    {
        switch (towupper(arg[1]))
        {
            case L'?':
                if (arg[2] == 0)
                {
                    s_dwFlags |= FLAG_HELP;
                    return TRUE;
                }
                break;
            case L'E':
                if (arg[2] == 0)
                {
                    s_dwFlags |= FLAG_E;
                    return TRUE;
                }
                break;
            case L'C':
                if (arg[2] == 0)
                {
                    s_dwFlags |= FLAG_C;
                    return TRUE;
                }
                break;
            case L'P':
                if (arg[2] == 0)
                {
                    s_dwFlags |= FLAG_P;
                    return TRUE;
                }
                break;
            case L'S':
                if (arg[2] == 0)
                {
                    s_dwFlags |= FLAG_S;
                    return TRUE;
                }
                break;
            case L'T':
                if (arg[2] != 0)
                {
                    s_dwFlags |= FLAG_Tn;
                    s_nTabWidth = wcstol(&arg[2], &endptr, 10);
                    if (*endptr == 0)
                        return TRUE;
                }
                break;
            default:
                break;
        }
    }
    else if (arg[0] == L'+')
    {
        if (arg[1] != 0)
        {
            s_dwFlags |= FLAG_PLUSn;
            s_nNextLineNo = wcstol(&arg[1], &endptr, 10) + 1;
            if (*endptr == 0)
                return TRUE;
        }
    }

    if (IsFlag(arg))
    {
        ConResPrintf(StdErr, IDS_BAD_FLAG, arg);
        return FALSE;
    }
    else
    {
        *pbHasFiles = TRUE;
    }

    return TRUE;
}

static BOOL ParseMoreVariable(BOOL* pbHasFiles)
{
    BOOL ret = TRUE;
    PWSTR psz;
    PWCHAR pch;
    DWORD cch;

    cch = GetEnvironmentVariableW(L"MORE", NULL, 0);
    if (cch == 0)
        return TRUE;

    psz = (PWSTR)malloc((cch + 1) * sizeof(WCHAR));
    if (!psz)
        return TRUE;

    if (!GetEnvironmentVariableW(L"MORE", psz, cch + 1))
    {
        free(psz);
        return TRUE;
    }

    for (pch = wcstok(psz, L" "); pch; pch = wcstok(NULL, L" "))
    {
        ret = ParseArgument(pch, pbHasFiles);
        if (!ret)
            break;
    }

    free(psz);
    return ret;
}

// INT CommandMore(LPTSTR cmd, LPTSTR param)
int wmain(int argc, WCHAR* argv[])
{
    // FIXME this stuff!
    CON_SCREEN Screen = {StdOut};
    CON_PAGER Pager = {&Screen, 0};

    int i;

    BOOL bRet, bContinue;

    ENCODING Encoding;
    DWORD SkipBytes = 0;
    BOOL HasFiles;

#define FileCacheBufferSize 4096
    PVOID FileCacheBuffer = NULL;
    PWCHAR StringBuffer = NULL;
    DWORD StringBufferLength = 0;
    DWORD dwReadBytes = 0, dwReadChars = 0;

    TCHAR szFullPath[MAX_PATH];

    hStdIn = GetStdHandle(STD_INPUT_HANDLE);
    hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

    /* Initialize the Console Standard Streams */
    ConStreamInit(StdIn , GetStdHandle(STD_INPUT_HANDLE) , UTF8Text, INVALID_CP);
    ConStreamInit(StdOut, GetStdHandle(STD_OUTPUT_HANDLE), UTF8Text, INVALID_CP);
    ConStreamInit(StdErr, GetStdHandle(STD_ERROR_HANDLE) , UTF8Text, INVALID_CP);

    /*
     * Bad usage (too much options) or we use the /? switch.
     * Display help for the MORE command.
     */
    if (argc > 1 && wcscmp(argv[1], L"/?") == 0)
    {
        ConResPuts(StdOut, IDS_USAGE);
        return 0;
    }

    /* Load the registry settings */
    LoadRegistrySettings(HKEY_LOCAL_MACHINE);
    LoadRegistrySettings(HKEY_CURRENT_USER);
    if (bEnableExtensions)
        s_dwFlags |= FLAG_E;

    // NOTE: We might try to duplicate the ConOut for read access... ?
    hKeyboard = CreateFileW(L"CONIN$", GENERIC_READ|GENERIC_WRITE,
                            FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
                            OPEN_EXISTING, 0, NULL);
    FlushConsoleInputBuffer(hKeyboard);
    ConStreamSetOSHandle(StdIn, hKeyboard);

    FileCacheBuffer = HeapAlloc(GetProcessHeap(), 0, FileCacheBufferSize);
    if (!FileCacheBuffer)
    {
        ConPuts(StdErr, L"Error: no memory\n");
        CloseHandle(hKeyboard);
        return 1;
    }

    /* First, load the "MORE" environment variable and parse it,
     * then parse the command-line parameters. */
    HasFiles = FALSE;
    if (!ParseMoreVariable(&HasFiles))
        return 1;
    for (i = 1; i < argc; i++)
    {
        if (!ParseArgument(argv[i], &HasFiles))
            return 1;
    }

    if (s_dwFlags & FLAG_HELP)
    {
        ConResPuts(StdOut, IDS_USAGE);
        return 0;
    }

    Pager.PagerLine = MorePagerLine;
    Pager.dwFlags |= CON_PAGER_EXPAND_TABS | CON_PAGER_CACHE_INCOMPLETE_LINE;
    if (s_dwFlags & FLAG_P)
        Pager.dwFlags |= CON_PAGER_EXPAND_FF;
    Pager.nTabWidth = s_nTabWidth;

    /* Special case where we run 'MORE' without any argument: we use STDIN */
    if (!HasFiles)
    {
        /*
         * Assign STDIN handle to hFile so that the page prompt function will
         * know the data comes from STDIN, and will take different actions.
         */
        hFile = hStdIn;

        /* Update the statistics for PagePrompt */
        dwFileSize = 0;
        dwSumReadBytes = dwSumReadChars = 0;

        /* We suppose we read text from the file */

        /* For STDIN we always suppose we are in ANSI mode */
        // SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
        Encoding = ENCODING_ANSI; // ENCODING_UTF8;

        /* Start paging */
        bContinue = ConWritePaging(&Pager, PagePrompt, TRUE, NULL, 0);
        if (!bContinue)
            goto Quit;

        do
        {
            bRet = FileGetString(hFile, Encoding,
                                 FileCacheBuffer, FileCacheBufferSize,
                                 &StringBuffer, &StringBufferLength,
                                 &dwReadBytes, &dwReadChars);
            if (!bRet || dwReadBytes == 0 || dwReadChars == 0)
            {
                /* We failed at reading the file, bail out */
                break;
            }

            /* Update the statistics for PagePrompt */
            dwSumReadBytes += dwReadBytes;
            dwSumReadChars += dwReadChars;

            bContinue = ConWritePaging(&Pager, PagePrompt, FALSE,
                                       StringBuffer, dwReadChars);
            /* If we Ctrl-C/Ctrl-Break, stop everything */
            if (!bContinue)
                break;
        }
        while (bRet && dwReadBytes > 0);

        /* Flush any cached pager buffers */
        if (bContinue)
            bContinue = ConWritePaging(&Pager, PagePrompt, FALSE, NULL, 0);

        goto Quit;
    }

    /* We have files: read them and output them to STDOUT */
    for (i = 1; i < argc; i++)
    {
        if (IsFlag(argv[i]))
            continue;

        GetFullPathNameW(argv[i], ARRAYSIZE(szFullPath), szFullPath, NULL);
        hFile = CreateFileW(szFullPath,
                            GENERIC_READ,
                            FILE_SHARE_READ,
                            NULL,
                            OPEN_EXISTING,
                            0, // FILE_ATTRIBUTE_NORMAL,
                            NULL);
        if (hFile == INVALID_HANDLE_VALUE)
        {
            ConResPrintf(StdErr, IDS_FILE_ACCESS, szFullPath);
            goto Quit;
        }

        /* We currently do not support files too big */
        dwFileSize = GetFileSize(hFile, NULL);
        if (dwFileSize == INVALID_FILE_SIZE)
        {
            ConPuts(StdErr, L"ERROR: Invalid file size!\n");
            CloseHandle(hFile);
            continue;
        }

        /* We suppose we read text from the file */

        /* Check whether the file is UNICODE and retrieve its encoding */
        SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
        bRet = ReadFile(hFile, FileCacheBuffer, FileCacheBufferSize, &dwReadBytes, NULL);
        IsDataUnicode(FileCacheBuffer, dwReadBytes, &Encoding, &SkipBytes);
        SetFilePointer(hFile, SkipBytes, NULL, FILE_BEGIN);

        /* Reset state for paging */
        s_nNextLineNo = 0;
        s_bPrevLineIsBlank = FALSE;
        s_fPrompt = PROMPT_PERCENT;
        s_bDoNextFile = FALSE;

        /* Update the statistics for PagePrompt */
        dwSumReadBytes = dwSumReadChars = 0;

        /* Start paging */
        bContinue = ConWritePaging(&Pager, PagePrompt, TRUE, NULL, 0);
        if (!bContinue)
        {
            /* We stop displaying this file */
            CloseHandle(hFile);
            if (s_bDoNextFile)
            {
                /* Bail out and continue with the other files */
                continue;
            }

            /* We Ctrl-C/Ctrl-Break, stop everything */
            goto Quit;
        }

        do
        {
            bRet = FileGetString(hFile, Encoding,
                                 FileCacheBuffer, FileCacheBufferSize,
                                 &StringBuffer, &StringBufferLength,
                                 &dwReadBytes, &dwReadChars);
            if (!bRet || dwReadBytes == 0 || dwReadChars == 0)
            {
                /*
                 * We failed at reading the file, bail out
                 * and continue with the other files.
                 */
                break;
            }

            /* Update the statistics for PagePrompt */
            dwSumReadBytes += dwReadBytes;
            dwSumReadChars += dwReadChars;

            if ((Encoding == ENCODING_UTF16LE) || (Encoding == ENCODING_UTF16BE))
            {
                bContinue = ConWritePaging(&Pager, PagePrompt, FALSE,
                                           FileCacheBuffer, dwReadChars);
            }
            else
            {
                bContinue = ConWritePaging(&Pager, PagePrompt, FALSE,
                                           StringBuffer, dwReadChars);
            }
            if (!bContinue)
            {
                /* We stop displaying this file */
                break;
            }
        }
        while (bRet && dwReadBytes > 0);

        /* Flush any cached pager buffers */
        if (bContinue)
            bContinue = ConWritePaging(&Pager, PagePrompt, FALSE, NULL, 0);

        CloseHandle(hFile);

        /* Check whether we should stop displaying this file */
        if (!bContinue)
        {
            if (s_bDoNextFile)
            {
                /* Bail out and continue with the other files */
                continue;
            }

            /* We Ctrl-C/Ctrl-Break, stop everything */
            goto Quit;
        }
    }

Quit:
    if (StringBuffer) HeapFree(GetProcessHeap(), 0, StringBuffer);
    HeapFree(GetProcessHeap(), 0, FileCacheBuffer);
    CloseHandle(hKeyboard);
    return 0;
}

/* EOF */