//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1994 - 1996.
//
//  File:       atsign.cxx
//
//  Contents:   Functions to read commands from a script file.
//
//  History:    04-20-95   davidmun   Created
//
//----------------------------------------------------------------------------

#include <headers.hxx>
#pragma hdrstop
#include "jt.hxx"

//
// Forward references
// 

ULONG FindEol(CHAR *pstr, ULONG cchRemaining);
CHAR FindNextNonSpace(CHAR *pstr, ULONG cchRemaining);




//+---------------------------------------------------------------------------
//
//  Function:   DoAtSign
//
//  Synopsis:   Get filename from commandline and process it.
//
//  Arguments:  [ppwsz] - command line
//
//  Returns:    S_OK - file processed without error
//              E_*  - error logged
//
//  Modifies:   *[ppwsz]
//
//  History:    04-20-95   davidmun   Created
//              01-03-96   DavidMun   Support multi-line commands
//
//  Notes:      This routine may be indirectly recursive.
//
//----------------------------------------------------------------------------

HRESULT DoAtSign(WCHAR **ppwsz)
{
    HRESULT     hr = S_OK;
    ShHANDLE    shFile;
    ShHANDLE    shFileMapping;
    VOID        *pvBase = NULL;
    BOOL        fOk;
    ULONG       cchFile;
    TCHAR       tszFilename[MAX_PATH + 1] = TEXT("None");

    g_Log.Write(LOG_DEBUG, "DoAtSign");
    do
    {
        hr = GetFilename(ppwsz, L"command file name");
        BREAK_ON_FAILURE(hr);

#ifdef UNICODE
        wcscpy(tszFilename, g_wszLastStringToken);
#else
        wcstombs(tszFilename, g_wszLastStringToken, wcslen(g_wszLastStringToken)+1);
#endif

        //
        // Open the command file, then hand one line at a time to 
        // ProcessCommandLine (which is our caller, so we're recursing).  
        //

        shFile = CreateFile(
                    tszFilename,
                    GENERIC_READ,
                    FILE_SHARE_READ,
                    NULL,   // default security
                    OPEN_EXISTING,
                    FILE_ATTRIBUTE_NORMAL,
                    NULL);  // no template

        if (shFile == INVALID_HANDLE_VALUE)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_ERROR, "Can't open file %S", tszFilename);
            break;
        }

        shFileMapping = CreateFileMapping(
                            shFile,
                            NULL,   // default security
                            PAGE_READONLY,
                            0, 0,   // max size is size of file
                            NULL);  // unnamed object

        if (shFileMapping == NULL)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_ERROR, "CreateFileMapping (%u)", GetLastError());
            break;
        }

        pvBase = MapViewOfFile(
                            shFileMapping,
                            FILE_MAP_READ,
                            0, 0, // start mapping at beginning of file
                            0);   // map entire file

        if (!pvBase)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_ERROR, "MapViewOfFile (%u)", GetLastError());
            break;
        }

        //
        // pvBase points to start of mapped file.  Get the file length.
        //

        BY_HANDLE_FILE_INFORMATION bhfi;

        fOk = GetFileInformationByHandle(shFile, &bhfi);

        if (!fOk)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_ERROR, "GetFileInformationByHandle (%u)", GetLastError());
            break;
        }

        cchFile = bhfi.nFileSizeLow;

        if (bhfi.nFileSizeHigh)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_ERROR, "File too large");
            break;
        }
    }
    while (0);

    //
    // Finally ready to process file.
    //

    ULONG cchProcessed = 0;
    ULONG ulCurLine = 1;
    CHAR  *pstrFile = (CHAR *) pvBase;

    while (SUCCEEDED(hr) && cchProcessed < cchFile)
    {
        CHAR  szLine[MAX_TOKEN_LEN + 1] = "";
        ULONG cchLine = 0;
        WCHAR wszLine[MAX_TOKEN_LEN + 1];
        WCHAR wszExpandedLine[MAX_TOKEN_LEN + 1];
        BOOL  fInQuote = FALSE;
        BOOL  fFoundNextCommand = FALSE;

        //
        // Copy all chars of the next command from pstrfile into wszline, 
        // condensing whitespace into single blanks and skipping comment 
        // lines.  
        // 

        for (;
            cchProcessed < cchFile &&
            !fFoundNextCommand        &&
            cchLine < MAX_TOKEN_LEN;
            cchProcessed++)
        {
            // 
            // If we're in a quoted string, copy everything verbatim until 
            // closing quote 
            //

            if (fInQuote)
            {
                if (pstrFile[cchProcessed] == '"')
                {
                    fInQuote = FALSE;
                }

                //
                // Check for error case of newline in string
                //

                if (pstrFile[cchProcessed] == '\n')
                {
                    hr = E_FAIL;
                    g_Log.Write(LOG_FAIL, "Newline in string constant");
                    break;
                }

                szLine[cchLine++] = pstrFile[cchProcessed];
                continue;
            }

            //
            // Not already in a quoted string.  See if we're entering one.  
            // 

            if (pstrFile[cchProcessed] == '"')
            {
                fInQuote = TRUE;
                szLine[cchLine++] = pstrFile[cchProcessed];
                continue;
            }

            //
            // Not in or starting a quoted string, so we're free to condense 
            // whitespace (including newlines) and ignore comment lines 
            // 

            if (isspace(pstrFile[cchProcessed]))
            {
                // 
                // Only copy this space char if none has been copied yet.  
                // Bump the line count if the whitespace char we're skipping 
                // is a newline.  
                //

                if (cchLine && szLine[cchLine - 1] != ' ')
                {
                    szLine[cchLine++] = ' ';
                }

                if (pstrFile[cchProcessed] == '\n')
                {
                    ulCurLine++;
                }
                continue;
            }

            if (pstrFile[cchProcessed] == ';')
            {
                //
                // Skip to end of line
                //

                cchProcessed += FindEol(
                                    &pstrFile[cchProcessed],
                                    cchFile - cchProcessed);

                // subtract 1 because for loop is going to add one

                cchProcessed--;
                continue;
            }

            //
            // Next char is not quote, semicolon (start of comment), or 
            // whitespace.  If we haven't copied anything yet, copy that char 
            // as the first of the line.  
            //

            if (!cchLine)
            {
                szLine[cchLine++] = pstrFile[cchProcessed];
                continue;
            }

            //
            // Since we've already started copying stuff, we want to quit when 
            // we get to the start of the next command, i.e., when we see a 
            // switch char '/' or '-'.  
            // 
            // Unfortunately these two characters also delimit the parts of a 
            // date, and we don't want to stop copying the line because of a 
            // date.  
            // 
            // Therefore we'll only stop copying if the next non whitespace 
            // character is not a number.  This imposes the constraints that 
            // no commands can be a number (i.e.  /10 cannot be a valid 
            // command) and that dates must use only digits (i.e.  10-Feb is 
            // not valid because we'll think -Feb is a command and only copy 
            // the 10).  
            // 
            // Note it isn't safe to check that the *previous* character was a 
            // digit and assume we're in a date, since a command with a 
            // numeric argument could be mistaken for a date.  
            // 
            //  /foo bar=10 /baz
            // 

            if (pstrFile[cchProcessed] == '/' ||
                pstrFile[cchProcessed] == '-')
            {
                CHAR ch;

                ch = FindNextNonSpace(
                            &pstrFile[cchProcessed + 1],
                            cchFile - (cchProcessed + 1));

                if (isdigit(ch))
                {
                    szLine[cchLine++] = pstrFile[cchProcessed];
                }
                else
                {
                    fFoundNextCommand = TRUE;
                    cchProcessed--; // because for loop will increment it
                }
            }
            else
            {
                szLine[cchLine++] = pstrFile[cchProcessed];
            }
        }
        BREAK_ON_FAILURE(hr);

        //
        // If we stopped copying not because we found the next command or hit 
        // the end of the file, then it's because we ran out of room in 
        // szLine, which is an error.  
        // 

        if (!fFoundNextCommand && cchProcessed < cchFile)
        {
            hr = E_FAIL;
            g_Log.Write(
                LOG_ERROR,
                "Line %u is longer than %u chars",
                ulCurLine,
                MAX_TOKEN_LEN);
            break;
        }

#ifdef UNICODE
        // 
        // Convert line to wchar and null terminate it.
        // 

        mbstowcs(wszLine, szLine, cchLine);
        wszLine[cchLine] = L'\0';

        // 
        // Expand environment variables
        // 

        ULONG cchRequired;

        cchRequired = ExpandEnvironmentStrings(
                            wszLine,
                            wszExpandedLine,
                            MAX_TOKEN_LEN+1);
#else
        CHAR szExpandedLine[MAX_TOKEN_LEN + 1];

        ULONG cchRequired;

        szLine[cchLine] = '\0';

        cchRequired = ExpandEnvironmentStrings(
                            szLine,
                            szExpandedLine,
                            MAX_TOKEN_LEN+1);

        mbstowcs(wszExpandedLine, szExpandedLine, MAX_TOKEN_LEN + 1);
#endif
        if (!cchRequired || cchRequired > MAX_TOKEN_LEN + 1)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_FAIL, "ExpandEnvironmentStrings failed");
            break;
        }

        // 
        // Perform the command in wszExpandedLine, then loop around and
        // read the next command.
        // 

        if (SUCCEEDED(hr))
        {
            g_Log.Write(LOG_DEBUG, "DoAtSign: processing '%S'", wszExpandedLine);
            hr = ProcessCommandLine(wszExpandedLine);
        }
    }

    if (FAILED(hr))
    {
        g_Log.Write(LOG_ERROR, "File: %S Line: %u", tszFilename, ulCurLine);
    }

    if (pvBase)
    {
        fOk = UnmapViewOfFile(pvBase);

        if (!fOk)
        {
            hr = E_FAIL;
            g_Log.Write(LOG_ERROR, "UnmapViewOfFile (%u)", GetLastError());
        }
    }
    return hr;
}




//+---------------------------------------------------------------------------
//
//  Function:   FindEol
//
//  Synopsis:   Return the number of characters between [pstr] and the end 
//              of the line.  
//
//  Arguments:  [pstr]         - non-terminated string
//              [cchRemaining] - characters till eof
//
//  Returns:    Character count
//
//  History:    04-20-95   davidmun   Created
//
//----------------------------------------------------------------------------

ULONG FindEol(CHAR *pstr, ULONG cchRemaining)
{
    CHAR   *pstrCur;
    ULONG   cchCur;

    for (pstrCur = pstr, cchCur = 0;
         cchCur < cchRemaining;
         cchCur++, pstrCur++)
    {
        if (*pstrCur == '\r' || *pstrCur == '\n')
        {
            return cchCur;
        }
    }
    return cchCur;
}



//+---------------------------------------------------------------------------
//
//  Function:   FindNextNonSpace
//
//  Synopsis:   Return the next non-whitespace character in [pstr], or space
//              if there are no non-whitespace characters in the next
//              [cchRemaining] characters.
//
//  Arguments:  [pstr]         - non-terminated string
//              [cchRemaining] - number of characters in string
//
//  Returns:    Character as described.
//
//  History:    01-10-96   DavidMun   Created
//
//----------------------------------------------------------------------------

CHAR FindNextNonSpace(CHAR *pstr, ULONG cchRemaining)
{
    CHAR   *pstrCur;
    ULONG   cchCur;

    for (pstrCur = pstr, cchCur = 0;
         cchCur < cchRemaining;
         cchCur++, pstrCur++)
    {
        if (!isspace(*pstrCur))
        {
            return *pstrCur;
        }
    }
    return ' ';
}