cmd.c File Reference

#include "precomp.h"
#include <reactos/buildno.h>
#include <reactos/version.h>

Include dependency graph for cmd.c:

Go to the source code of this file.

Macros
#define	SHELLEXECUTETEXT   "ShellExecuteExA"
#define	SeenGoto()   (bc && bc->current == NULL)
#define	APPEND(From, Length)
#define	APPEND1(Char)
#define	APPEND(From, Length)
#define	APPEND1(Char)
#define	APPEND1(Char)

Typedefs
typedef NTSTATUS(WINAPI *	NtQueryInformationProcessProc) (HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG)
typedef NTSTATUS(WINAPI *	NtReadVirtualMemoryProc) (HANDLE, PVOID, PVOID, SIZE_T, PSIZE_T)
typedef BOOL(WINAPI *	MYEX) (LPSHELLEXECUTEINFO lpExecInfo)

Functions
INT	ConvertULargeInteger (ULONGLONG num, LPTSTR des, UINT len, BOOL bPutSeparator)
static BOOL	IsConsoleProcess (HANDLE Process)
HANDLE	RunFile (DWORD flags, LPTSTR filename, LPTSTR params, LPTSTR directory, INT show)
static VOID	SetConTitle (LPCTSTR pszTitle)
static VOID	ResetConTitle (VOID)
static INT	Execute (LPTSTR Full, LPTSTR First, LPTSTR Rest, PARSED_COMMAND *Cmd)
INT	DoCommand (LPTSTR first, LPTSTR rest, PARSED_COMMAND *Cmd)
INT	ParseCommandLine (LPTSTR cmd)
static HANDLE	ExecuteAsync (PARSED_COMMAND *Cmd)
static INT	ExecutePipeline (PARSED_COMMAND *Cmd)
INT	ExecuteCommand (IN PARSED_COMMAND *Cmd)
INT	ExecuteCommandWithEcho (IN PARSED_COMMAND *Cmd)
LPTSTR	GetEnvVar (LPCTSTR varName)
LPCTSTR	GetEnvVarOrSpecial (LPCTSTR varName)
static PCTSTR	GetEnhancedVar (IN OUT PCTSTR *pFormat, IN BOOL(*GetVar)(TCHAR, PCTSTR *, BOOL *))
static PCTSTR	GetBatchVar (IN PCTSTR varName, OUT PUINT varNameLen)
BOOL	SubstituteVar (IN PCTSTR Src, OUT size_t *SrcIncLen, OUT PTCHAR Dest, IN PTCHAR DestEnd, OUT size_t *DestIncLen, IN TCHAR Delim)
BOOL	SubstituteVars (IN PCTSTR Src, OUT PTSTR Dest, IN TCHAR Delim)
static BOOL	FindForVar (IN TCHAR Var, OUT PCTSTR *VarPtr, OUT BOOL *IsParam0)
BOOL	SubstituteForVars (IN PCTSTR Src, OUT PTSTR Dest)
PTSTR	DoDelayedExpansion (IN PCTSTR Line)
BOOL	ReadLine (TCHAR *commandline, BOOL bMore)
static INT	ProcessInput (VOID)
static BOOL WINAPI	BreakHandler (IN DWORD dwCtrlType)
VOID	AddBreakHandler (VOID)
VOID	RemoveBreakHandler (VOID)
static VOID	LoadRegistrySettings (HKEY hKeyRoot)
static VOID	ExecuteAutoRunFile (HKEY hKeyRoot)
static VOID	GetCmdLineCommand (OUT LPTSTR commandline, IN LPCTSTR ptr, IN BOOL AlwaysStrip)
static LPCTSTR	Initialize (VOID)
static VOID	Cleanup (VOID)
int	_tmain (int argc, const TCHAR *argv[])

Variables
BOOL	bExit = FALSE
BOOL	bCanExit = TRUE
BOOL	bCtrlBreak = FALSE
BOOL	bIgnoreEcho = FALSE
static BOOL	fSingleCommand = 0
static BOOL	bAlwaysStrip = FALSE
INT	nErrorLevel = 0
CRITICAL_SECTION	ChildProcessRunningLock
BOOL	bDisableBatchEcho = FALSE
BOOL	bEnableExtensions = TRUE
BOOL	bDelayedExpansion = FALSE
DWORD	dwChildProcessId = 0
LPTSTR	lpOriginalEnvironment
HANDLE	CMD_ModuleHandle
BOOL	bTitleSet = FALSE
TCHAR	szCurTitle [MAX_PATH]
static NtQueryInformationProcessProc	NtQueryInformationProcessPtr = NULL
static NtReadVirtualMemoryProc	NtReadVirtualMemoryPtr = NULL
CON_STREAM_MODE	OutputStreamMode = UTF8Text
WORD	wDefColor = 0

Macro Definition Documentation

APPEND [1/2]

#define APPEND	(		From,
			Length
	)

Value:

do { \
    if (Dest + (Length) > DestEnd) \
        goto too_long; \
    memcpy(Dest, (From), (Length) * sizeof(TCHAR)); \
    Dest += (Length); \
} while (0)

APPEND [2/2]

#define APPEND	(		From,
			Length
	)

Value:

do { \
    if (Dest + (Length) > DestEnd) \
        goto too_long; \
    memcpy(Dest, (From), (Length) * sizeof(TCHAR)); \
    Dest += (Length); \
} while (0)

APPEND1 [1/3]

#define APPEND1

(

Char

)

Value:

do { \
    if (Dest >= DestEnd) \
        goto too_long; \
    *Dest++ = (Char); \
} while (0)

APPEND1 [2/3]

#define APPEND1

(

Char

)

Value:

do { \
    if (Dest >= DestEnd) \
        goto too_long; \
    *Dest++ = (Char); \
} while (0)

APPEND1 [3/3]

#define APPEND1

(

Char

)

Value:

do { \
    if (Dst >= DestEnd) \
        goto too_long; \
    *Dst++ = (Char); \
} while (0)

SeenGoto

#define SeenGoto

(

)

(bc && bc->current == NULL)

SHELLEXECUTETEXT

#define SHELLEXECUTETEXT   "ShellExecuteExA"

Definition at line 261 of file cmd.c.

Typedef Documentation

MYEX

typedef BOOL(WINAPI * MYEX) (LPSHELLEXECUTEINFO lpExecInfo)

Definition at line 264 of file cmd.c.

NtQueryInformationProcessProc

typedef NTSTATUS(WINAPI * NtQueryInformationProcessProc) (HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG)

Definition at line 148 of file cmd.c.

NtReadVirtualMemoryProc

typedef NTSTATUS(WINAPI * NtReadVirtualMemoryProc) (HANDLE, PVOID, PVOID, SIZE_T, PSIZE_T)

Definition at line 150 of file cmd.c.

Function Documentation

_tmain()

int _tmain	(	int	argc,
		const TCHAR *	argv[]
	)

Definition at line 2359 of file cmd.c.

{
    INT nExitCode;
    LPCTSTR pCmdLine;
    TCHAR startPath[MAX_PATH];

    InitializeCriticalSection(&ChildProcessRunningLock);
    lpOriginalEnvironment = DuplicateEnvironment();

    GetCurrentDirectory(ARRAYSIZE(startPath), startPath);
    _tchdir(startPath);

    SetFileApisToOEM();
    InputCodePage  = GetConsoleCP();
    OutputCodePage = GetConsoleOutputCP();

    /* Initialize the Console Standard Streams */
    ConStreamInit(StdIn , GetStdHandle(STD_INPUT_HANDLE) , /*OutputStreamMode*/ AnsiText, InputCodePage);
    ConStreamInit(StdOut, GetStdHandle(STD_OUTPUT_HANDLE), OutputStreamMode, OutputCodePage);
    ConStreamInit(StdErr, GetStdHandle(STD_ERROR_HANDLE) , OutputStreamMode, OutputCodePage);

    CMD_ModuleHandle = GetModuleHandle(NULL);

    /*
     * Perform general initialization, parse switches on command-line.
     * Initialize the exit code with the errorlevel as Initialize() can set it.
     */
    pCmdLine = Initialize();
    nExitCode = nErrorLevel;

    if (pCmdLine && *pCmdLine)
    {
        TCHAR commandline[CMDLINE_LENGTH];

        /* Do the /C or /K command */
        GetCmdLineCommand(commandline, &pCmdLine[2], bAlwaysStrip);
        nExitCode = ParseCommandLine(commandline);
        if (fSingleCommand == 1)
        {
            // nErrorLevel = nExitCode;
            bExit = TRUE;
        }
        fSingleCommand = 0;
    }
    if (!bExit)
    {
        /* Call prompt routine */
        nExitCode = ProcessInput();
    }

    /* Do the cleanup */
    Cleanup();
    cmd_free(lpOriginalEnvironment);

    cmd_exit(nExitCode);
    return nExitCode;
}

AddBreakHandler()

VOID AddBreakHandler

(

VOID

)

Definition at line 1842 of file cmd.c.

{
    SetConsoleCtrlHandler(BreakHandler, TRUE);
}

Referenced by FilePromptYN(), FilePromptYNA(), Initialize(), and PagePrompt().

BreakHandler()

static BOOL WINAPI BreakHandler ( IN DWORD  dwCtrlType )

static

Definition at line 1797 of file cmd.c.

{
    DWORD dwWritten;
    INPUT_RECORD rec;

    if ((dwCtrlType != CTRL_C_EVENT) &&
        (dwCtrlType != CTRL_BREAK_EVENT))
    {
        return FALSE;
    }

    if (!TryEnterCriticalSection(&ChildProcessRunningLock))
    {
        /* Child process is running and will have received the control event */
        return TRUE;
    }
    else
    {
        LeaveCriticalSection(&ChildProcessRunningLock);
    }

    bCtrlBreak = TRUE;

    rec.EventType = KEY_EVENT;
    rec.Event.KeyEvent.bKeyDown = TRUE;
    rec.Event.KeyEvent.wRepeatCount = 1;
    rec.Event.KeyEvent.wVirtualKeyCode = _T('C');
    rec.Event.KeyEvent.wVirtualScanCode = _T('C') - 35;
    rec.Event.KeyEvent.uChar.AsciiChar = _T('C');
    rec.Event.KeyEvent.uChar.UnicodeChar = _T('C');
    rec.Event.KeyEvent.dwControlKeyState = RIGHT_CTRL_PRESSED;

    WriteConsoleInput(ConStreamGetOSHandle(StdIn),
                      &rec,
                      1,
                      &dwWritten);

    /* FIXME: Handle batch files */

    // ConOutPrintf(_T("^C"));

    return TRUE;
}

Referenced by AddBreakHandler(), and RemoveBreakHandler().

Cleanup()

static VOID Cleanup ( VOID  )

static

Definition at line 2318 of file cmd.c.

{
    /* Run cmdexit.bat */
    if (IsExistingFile(_T("cmdexit.bat")))
    {
        ConErrResPuts(STRING_CMD_ERROR5);
        ParseCommandLine(_T("cmdexit.bat"));
    }
    else if (IsExistingFile(_T("\\cmdexit.bat")))
    {
        ConErrResPuts(STRING_CMD_ERROR5);
        ParseCommandLine(_T("\\cmdexit.bat"));
    }

#ifdef FEATURE_DIRECTORY_STACK
    /* Destroy directory stack */
    DestroyDirectoryStack();
#endif

#ifdef FEATURE_HISTORY
    CleanHistory();
#endif

    /* Free GetEnvVar's buffer */
    GetEnvVar(NULL);

    /* Remove ctrl break handler */
    RemoveBreakHandler();

    /* Restore the default console mode */
    SetConsoleMode(ConStreamGetOSHandle(StdIn),
                   ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);
    SetConsoleMode(ConStreamGetOSHandle(StdOut),
                   ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);

    DeleteCriticalSection(&ChildProcessRunningLock);
}

Referenced by _tmain().

ConvertULargeInteger()

INT ConvertULargeInteger	(	ULONGLONG	num,
		LPTSTR	des,
		UINT	len,
		BOOL	bPutSeparator
	)

Definition at line 189 of file cmd.c.

{
    TCHAR temp[39];   /* maximum length with nNumberGroups == 1 */
    UINT  n, iTarget;

    if (len <= 1)
        return 0;

    n = 0;
    iTarget = nNumberGroups;
    if (!nNumberGroups)
        bPutSeparator = FALSE;

    do
    {
        if (iTarget == n && bPutSeparator)
        {
            iTarget += nNumberGroups + 1;
            temp[38 - n++] = cThousandSeparator;
        }
        temp[38 - n++] = (TCHAR)(num % 10) + _T('0');
        num /= 10;
    } while (num > 0);
    if (n > len-1)
        n = len-1;

    memcpy(des, temp + 39 - n, n * sizeof(TCHAR));
    des[n] = _T('\0');

    return n;
}

Referenced by CommandMemory(), DirPrintNewList(), DirPrintOldList(), PrintDiskInfo(), and PrintSummary().

DoCommand()

INT DoCommand	(	LPTSTR	first,
		LPTSTR	rest,
		PARSED_COMMAND *	Cmd
	)

Definition at line 553 of file cmd.c.

{
    TCHAR *com;
    TCHAR *cp;
    LPTSTR param;   /* Pointer to command's parameters */
    INT cl;
    LPCOMMAND cmdptr;
    BOOL nointernal = FALSE;
    INT ret;

    TRACE ("DoCommand: (\'%s\' \'%s\')\n", debugstr_aw(first), debugstr_aw(rest));

    /* Full command line */
    com = cmd_alloc((_tcslen(first) + _tcslen(rest) + 2) * sizeof(TCHAR));
    if (com == NULL)
    {
        error_out_of_memory();
        return 1;
    }

    /* If present in the first word, these characters end the name of an
     * internal command and become the beginning of its parameters. */
    cp = first + _tcscspn(first, _T("\t +,/;=[]"));

    for (cl = 0; cl < (cp - first); cl++)
    {
        /* These characters do it too, but if one of them is present,
         * then we check to see if the word is a file name and skip
         * checking for internal commands if so.
         * This allows running programs with names like "echo.exe" */
        if (_tcschr(_T(".:\\"), first[cl]))
        {
            TCHAR tmp = *cp;
            *cp = _T('\0');
            nointernal = IsExistingFile(first);
            *cp = tmp;
            break;
        }
    }

    /* Scan internal command table */
    for (cmdptr = cmds; !nointernal && cmdptr->name; cmdptr++)
    {
        if (!_tcsnicmp(first, cmdptr->name, cl) && cmdptr->name[cl] == _T('\0'))
        {
            _tcscpy(com, first);
            _tcscat(com, rest);
            param = &com[cl];

            /* Skip over whitespace to rest of line, exclude 'echo' command */
            if (_tcsicmp(cmdptr->name, _T("echo")) != 0)
            {
                while (_istspace(*param))
                    param++;
            }

            /* Set the new console title */
            SetConTitle(com);

            ret = cmdptr->func(param);

            /* Restore the original console title */
            ResetConTitle();

            cmd_free(com);
            return ret;
        }
    }

    ret = Execute(com, first, rest, Cmd);
    cmd_free(com);
    return ret;
}

Referenced by ExecuteCommand().

DoDelayedExpansion()

PTSTR DoDelayedExpansion

(

IN PCTSTR

Line

)

Definition at line 1638 of file cmd.c.

{
    TCHAR Buf1[CMDLINE_LENGTH];
    TCHAR Buf2[CMDLINE_LENGTH];
    PTCHAR Src, Dst;
    PTCHAR DestEnd = Buf2 + CMDLINE_LENGTH - 1;
    size_t SrcIncLen, DestIncLen;

    /* First, substitute FOR variables */
    if (!SubstituteForVars(Line, Buf1))
        return NULL;

    if (!bDelayedExpansion || !_tcschr(Buf1, _T('!')))
        return cmd_dup(Buf1);

    /*
     * Delayed substitutions are not actually completely the same as
     * immediate substitutions. In particular, it is possible to escape
     * the exclamation point using the escape caret.
     */

    /*
     * Perform delayed expansion: expand variables around '!',
     * and reparse escape carets.
     */

#define APPEND1(Char) \
do { \
    if (Dst >= DestEnd) \
        goto too_long; \
    *Dst++ = (Char); \
} while (0)

    Src = Buf1;
    Dst = Buf2;
    while (*Src && (Src < &Buf1[CMDLINE_LENGTH]))
    {
        if (*Src == _T('^'))
        {
            ++Src;
            if (!*Src || !(Src < &Buf1[CMDLINE_LENGTH]))
                break;

            APPEND1(*Src++);
        }
        else if (*Src == _T('!'))
        {
            if (!SubstituteVar(Src, &SrcIncLen, Dst, DestEnd, &DestIncLen, _T('!')))
            {
                return NULL; // Got an error during parsing.
            }
            else
            {
                Src += SrcIncLen;
                Dst += DestIncLen;
            }
        }
        else
        {
            APPEND1(*Src++);
        }
        continue;
    }
    APPEND1(_T('\0'));

    return cmd_dup(Buf2);

too_long:
    ConOutResPrintf(STRING_ALIAS_ERROR);
    nErrorLevel = 9023;
    return NULL;

#undef APPEND1
}

Referenced by Batch(), ExecuteCommand(), ExecuteFor(), ExecuteIf(), and PerformRedirection().

Execute()

static INT Execute ( LPTSTR  Full, LPTSTR  First, LPTSTR  Rest, PARSED_COMMAND *  Cmd  )

static

Definition at line 347 of file cmd.c.

{
    TCHAR *first, *rest, *dot;
    DWORD dwExitCode = 0;
    TCHAR *FirstEnd;
    TCHAR szFullName[MAX_PATH];
    TCHAR szFullCmdLine[CMDLINE_LENGTH];

    TRACE ("Execute: \'%s\' \'%s\'\n", debugstr_aw(First), debugstr_aw(Rest));

    /* Though it was already parsed once, we have a different set of rules
       for parsing before we pass to CreateProcess */
    if (First[0] == _T('/') || (First[0] && First[1] == _T(':')))
    {
        /* Use the entire first word as the program name (no change) */
        FirstEnd = First + _tcslen(First);
    }
    else
    {
        /* If present in the first word, spaces and ,;=/ end the program
         * name and become the beginning of its parameters. */
        BOOL bInside = FALSE;
        for (FirstEnd = First; *FirstEnd; FirstEnd++)
        {
            if (!bInside && (_istspace(*FirstEnd) || _tcschr(_T(",;=/"), *FirstEnd)))
                break;
            bInside ^= *FirstEnd == _T('"');
        }
    }

    /* Copy the new first/rest into the buffer */
    rest = &Full[FirstEnd - First + 1];
    _tcscpy(rest, FirstEnd);
    _tcscat(rest, Rest);
    first = Full;
    *FirstEnd = _T('\0');
    _tcscpy(first, First);

    /* check for a drive change */
    if ((_istalpha (first[0])) && (!_tcscmp (first + 1, _T(":"))))
    {
        BOOL working = TRUE;
        if (!SetCurrentDirectory(first))
        {
            /* Guess they changed disc or something, handle that gracefully and get to root */
            TCHAR str[4];
            str[0]=first[0];
            str[1]=_T(':');
            str[2]=_T('\\');
            str[3]=0;
            working = SetCurrentDirectory(str);
        }

        if (!working) ConErrResPuts (STRING_FREE_ERROR1);
        return !working;
    }

    /* get the PATH environment variable and parse it */
    /* search the PATH environment variable for the binary */
    StripQuotes(First);
    if (!SearchForExecutable(First, szFullName))
    {
        error_bad_command(first);
        return 1;
    }

    /* Set the new console title */
    FirstEnd = first + (FirstEnd - First); /* Point to the separating NULL in the full built string */
    *FirstEnd = _T(' ');
    SetConTitle(Full);

    /* check if this is a .BAT or .CMD file */
    dot = _tcsrchr (szFullName, _T('.'));
    if (dot && (!_tcsicmp (dot, _T(".bat")) || !_tcsicmp (dot, _T(".cmd"))))
    {
        while (*rest == _T(' '))
            rest++;

        *FirstEnd = _T('\0');
        TRACE ("[BATCH: %s %s]\n", debugstr_aw(szFullName), debugstr_aw(rest));
        dwExitCode = Batch(szFullName, first, rest, Cmd);
    }
    else
    {
        /* exec the program */
        PROCESS_INFORMATION prci;
        STARTUPINFO stui;

        /* build command line for CreateProcess(): FullName + " " + rest */
        BOOL quoted = !!_tcschr(First, _T(' '));
        _tcscpy(szFullCmdLine, quoted ? _T("\"") : _T(""));
        _tcsncat(szFullCmdLine, First, CMDLINE_LENGTH - _tcslen(szFullCmdLine) - 1);
        _tcsncat(szFullCmdLine, quoted ? _T("\"") : _T(""), CMDLINE_LENGTH - _tcslen(szFullCmdLine) - 1);

        if (*rest)
        {
            _tcsncat(szFullCmdLine, _T(" "), CMDLINE_LENGTH - _tcslen(szFullCmdLine) - 1);
            _tcsncat(szFullCmdLine, rest, CMDLINE_LENGTH - _tcslen(szFullCmdLine) - 1);
        }

        TRACE ("[EXEC: %s]\n", debugstr_aw(szFullCmdLine));

        /* fill startup info */
        memset(&stui, 0, sizeof(stui));
        stui.cb = sizeof(stui);
        stui.lpTitle = Full;
        stui.dwFlags = STARTF_USESHOWWINDOW;
        stui.wShowWindow = SW_SHOWDEFAULT;

        /* Set the console to standard mode */
        SetConsoleMode(ConStreamGetOSHandle(StdIn),
                       ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);

        if (CreateProcess(szFullName,
                          szFullCmdLine,
                          NULL,
                          NULL,
                          TRUE,
                          0,
                          NULL,
                          NULL,
                          &stui,
                          &prci))
        {
            CloseHandle(prci.hThread);
        }
        else
        {
            // See if we can run this with ShellExecute() ie myfile.xls
            prci.hProcess = RunFile(SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NO_CONSOLE,
                                    szFullName,
                                    rest,
                                    NULL,
                                    SW_SHOWNORMAL);
        }

        *FirstEnd = _T('\0');

        if (prci.hProcess != NULL)
        {
            if (bc != NULL || fSingleCommand != 0 || IsConsoleProcess(prci.hProcess))
            {
                /* when processing a batch file or starting console processes: execute synchronously */
                EnterCriticalSection(&ChildProcessRunningLock);
                dwChildProcessId = prci.dwProcessId;

                WaitForSingleObject(prci.hProcess, INFINITE);

                LeaveCriticalSection(&ChildProcessRunningLock);

                GetExitCodeProcess(prci.hProcess, &dwExitCode);
                nErrorLevel = (INT)dwExitCode;
            }
            CloseHandle(prci.hProcess);
        }
        else
        {
            TRACE ("[ShellExecute failed!: %s]\n", debugstr_aw(Full));
            error_bad_command(first);
            dwExitCode = 1;
        }

        /* Restore our default console mode */
        SetConsoleMode(ConStreamGetOSHandle(StdIn),
                       ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);
        SetConsoleMode(ConStreamGetOSHandle(StdOut),
                       ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);
    }

    /* Update our local codepage cache */
    {
        UINT uNewInputCodePage  = GetConsoleCP();
        UINT uNewOutputCodePage = GetConsoleOutputCP();

        if ((InputCodePage  != uNewInputCodePage) ||
            (OutputCodePage != uNewOutputCodePage))
        {
            /* Update the locale as well */
            InitLocale();
        }

        InputCodePage  = uNewInputCodePage;
        OutputCodePage = uNewOutputCodePage;

        /* Update the streams codepage cache as well */
        ConStreamSetCacheCodePage(StdIn , InputCodePage );
        ConStreamSetCacheCodePage(StdOut, OutputCodePage);
        ConStreamSetCacheCodePage(StdErr, OutputCodePage);
    }

    /* Restore the original console title */
    ResetConTitle();

    return dwExitCode;
}

Referenced by DoCommand().

ExecuteAsync()

static HANDLE ExecuteAsync ( PARSED_COMMAND *  Cmd )

static

Definition at line 655 of file cmd.c.

{
    TCHAR CmdPath[MAX_PATH];
    TCHAR CmdParams[CMDLINE_LENGTH], *ParamsEnd;
    STARTUPINFO stui;
    PROCESS_INFORMATION prci;

    /* Get the path to cmd.exe */
    GetModuleFileName(NULL, CmdPath, ARRAYSIZE(CmdPath));

    /* Build the parameter string to pass to cmd.exe */
    ParamsEnd = _stpcpy(CmdParams, _T("/S/D/C\""));
    ParamsEnd = UnparseCommand(Cmd, ParamsEnd, &CmdParams[CMDLINE_LENGTH - 2]);
    if (!ParamsEnd)
    {
        error_out_of_memory();
        return NULL;
    }
    _tcscpy(ParamsEnd, _T("\""));

    memset(&stui, 0, sizeof stui);
    stui.cb = sizeof(STARTUPINFO);
    if (!CreateProcess(CmdPath, CmdParams, NULL, NULL, TRUE, 0,
                       NULL, NULL, &stui, &prci))
    {
        ErrorMessage(GetLastError(), NULL);
        return NULL;
    }

    CloseHandle(prci.hThread);
    return prci.hProcess;
}

Referenced by ExecutePipeline().

ExecuteAutoRunFile()

static VOID ExecuteAutoRunFile ( HKEY  hKeyRoot )

static

Definition at line 2038 of file cmd.c.

{
    LONG lRet;
    HKEY hKey;
    DWORD dwType, len;
    TCHAR AutoRun[2048];

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

    len = sizeof(AutoRun);
    lRet = RegQueryValueEx(hKey,
                           _T("AutoRun"),
                           NULL,
                           &dwType,
                           (LPBYTE)&AutoRun,
                           &len);
    if ((lRet == ERROR_SUCCESS) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
    {
        if (*AutoRun)
            ParseCommandLine(AutoRun);
    }

    RegCloseKey(hKey);
}

Referenced by Initialize().

ExecuteCommand()

INT ExecuteCommand

(

IN PARSED_COMMAND *

Cmd

)

Definition at line 778 of file cmd.c.

{
#define SeenGoto() \
    (bc && bc->current == NULL)

    PARSED_COMMAND *Sub;
    LPTSTR First, Rest;
    INT Ret = 0;

    /* If we don't have any command, or if this is REM, ignore it */
    if (!Cmd || (Cmd->Type == C_REM))
        return 0;
    /*
     * Do not execute any command if we are about to exit CMD, or about to
     * change batch execution context, e.g. in case of a CALL / GOTO / EXIT.
     */
    if (bExit || SeenGoto())
        return 0;

    if (!PerformRedirection(Cmd->Redirections))
        return 1;

    switch (Cmd->Type)
    {
    case C_COMMAND:
        Ret = 1;
        First = DoDelayedExpansion(Cmd->Command.First);
        if (First)
        {
            Rest = DoDelayedExpansion(Cmd->Command.Rest);
            if (Rest)
            {
                Ret = DoCommand(First, Rest, Cmd);
                cmd_free(Rest);
            }
            cmd_free(First);
        }
        /* Fall through */
    case C_REM:
        break;

    case C_QUIET:
    case C_BLOCK:
    case C_MULTI:
        for (Sub = Cmd->Subcommands; Sub && !SeenGoto(); Sub = Sub->Next)
            Ret = ExecuteCommand(Sub);
        break;

    case C_OR:
        Sub = Cmd->Subcommands;
        Ret = ExecuteCommand(Sub);
        if ((Ret != 0) && !SeenGoto())
        {
            nErrorLevel = Ret;
            Ret = ExecuteCommand(Sub->Next);
        }
        break;

    case C_AND:
        Sub = Cmd->Subcommands;
        Ret = ExecuteCommand(Sub);
        if ((Ret == 0) && !SeenGoto())
            Ret = ExecuteCommand(Sub->Next);
        break;

    case C_PIPE:
        Ret = ExecutePipeline(Cmd);
        break;

    case C_FOR:
        Ret = ExecuteFor(Cmd);
        break;

    case C_IF:
        Ret = ExecuteIf(Cmd);
        break;
    }

    UndoRedirection(Cmd->Redirections, NULL);
    return Ret;

#undef SeenGoto
}

Referenced by ExecuteCommandWithEcho(), ExecuteIf(), ParseCommandLine(), and ProcessInput().

ExecuteCommandWithEcho()

INT ExecuteCommandWithEcho

(

IN PARSED_COMMAND *

Cmd

)

Definition at line 864 of file cmd.c.

{
    /* Echo the reconstructed command line */
    if (bEcho && !bDisableBatchEcho && Cmd && (Cmd->Type != C_QUIET))
    {
        if (!bIgnoreEcho)
            ConOutChar(_T('\n'));
        PrintPrompt();
        EchoCommand(Cmd);
        ConOutChar(_T('\n'));
    }

    /* Run the command */
    return ExecuteCommand(Cmd);
}

Referenced by Batch().

ExecutePipeline()

static INT ExecutePipeline ( PARSED_COMMAND *  Cmd )

static

Definition at line 689 of file cmd.c.

{
#ifdef FEATURE_REDIRECTION
    HANDLE hInput = NULL;
    HANDLE hOldConIn = GetStdHandle(STD_INPUT_HANDLE);
    HANDLE hOldConOut = GetStdHandle(STD_OUTPUT_HANDLE);
    HANDLE hProcess[MAXIMUM_WAIT_OBJECTS];
    INT nProcesses = 0;
    DWORD dwExitCode;

    /* Do all but the last pipe command */
    do
    {
        HANDLE hPipeRead, hPipeWrite;
        if (nProcesses > (MAXIMUM_WAIT_OBJECTS - 2))
        {
            error_too_many_parameters(_T("|"));
            goto failed;
        }

        /* Create the pipe that this process will write into.
         * Make the handles non-inheritable initially, because this
         * process shouldn't inherit the reading handle. */
        if (!CreatePipe(&hPipeRead, &hPipeWrite, NULL, 0))
        {
            error_no_pipe();
            goto failed;
        }

        /* The writing side of the pipe is STDOUT for this process */
        SetHandleInformation(hPipeWrite, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
        SetStdHandle(STD_OUTPUT_HANDLE, hPipeWrite);

        /* Execute it (error check is done later for easier cleanup) */
        hProcess[nProcesses] = ExecuteAsync(Cmd->Subcommands);
        CloseHandle(hPipeWrite);
        if (hInput)
            CloseHandle(hInput);

        /* The reading side of the pipe will be STDIN for the next process */
        SetHandleInformation(hPipeRead, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT);
        SetStdHandle(STD_INPUT_HANDLE, hPipeRead);
        hInput = hPipeRead;

        if (!hProcess[nProcesses])
            goto failed;
        nProcesses++;

        Cmd = Cmd->Subcommands->Next;
    } while (Cmd->Type == C_PIPE);

    /* The last process uses the original STDOUT */
    SetStdHandle(STD_OUTPUT_HANDLE, hOldConOut);
    hProcess[nProcesses] = ExecuteAsync(Cmd);
    if (!hProcess[nProcesses])
        goto failed;
    nProcesses++;
    CloseHandle(hInput);
    SetStdHandle(STD_INPUT_HANDLE, hOldConIn);

    /* Wait for all processes to complete */
    EnterCriticalSection(&ChildProcessRunningLock);
    WaitForMultipleObjects(nProcesses, hProcess, TRUE, INFINITE);
    LeaveCriticalSection(&ChildProcessRunningLock);

    /* Use the exit code of the last process in the pipeline */
    GetExitCodeProcess(hProcess[nProcesses - 1], &dwExitCode);
    nErrorLevel = (INT)dwExitCode;

    while (--nProcesses >= 0)
        CloseHandle(hProcess[nProcesses]);
    return nErrorLevel;

failed:
    if (hInput)
        CloseHandle(hInput);
    while (--nProcesses >= 0)
    {
        TerminateProcess(hProcess[nProcesses], 0);
        CloseHandle(hProcess[nProcesses]);
    }
    SetStdHandle(STD_INPUT_HANDLE, hOldConIn);
    SetStdHandle(STD_OUTPUT_HANDLE, hOldConOut);
#endif

    return nErrorLevel;
}

Referenced by ExecuteCommand().

FindForVar()

static BOOL FindForVar ( IN TCHAR  Var, OUT PCTSTR *  VarPtr, OUT BOOL *  IsParam0  )

static

Definition at line 1572 of file cmd.c.

{
    PFOR_CONTEXT Ctx;

    *VarPtr = NULL;
    *IsParam0 = FALSE;

    for (Ctx = fc; Ctx != NULL; Ctx = Ctx->prev)
    {
        if ((UINT)(Var - Ctx->firstvar) < Ctx->varcount)
        {
            *VarPtr = Ctx->values[Var - Ctx->firstvar];
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by SubstituteForVars().

GetBatchVar()

static PCTSTR GetBatchVar ( IN PCTSTR  varName, OUT PUINT  varNameLen  )

static

Definition at line 1271 of file cmd.c.

{
    PCTSTR ret;
    PCTSTR varNameEnd;

    *varNameLen = 1;

    switch (*varName)
    {
    case _T('~'):
    {
        varNameEnd = varName + 1;
        ret = GetEnhancedVar(&varNameEnd, FindArg);
        if (!ret)
        {
            ParseErrorEx(varName);
            return NULL;
        }
        *varNameLen = varNameEnd - varName;
        return ret;
    }

    case _T('0'):
    case _T('1'):
    case _T('2'):
    case _T('3'):
    case _T('4'):
    case _T('5'):
    case _T('6'):
    case _T('7'):
    case _T('8'):
    case _T('9'):
    {
        BOOL dummy;
        if (!FindArg(*varName, &ret, &dummy))
            return NULL;
        else
            return ret;
    }

    case _T('*'):
        /* Copy over the raw params (not including the batch file name) */
        return bc->raw_params;

    case _T('%'):
        return _T("%");
    }
    return NULL;
}

Referenced by SubstituteVar().

GetCmdLineCommand()

static VOID GetCmdLineCommand ( OUT LPTSTR  commandline, IN LPCTSTR  ptr, IN BOOL  AlwaysStrip  )

static

Definition at line 2071 of file cmd.c.

{
    TCHAR* LastQuote;

    while (_istspace(*ptr))
        ++ptr;

    /* Remove leading quote, find final quote */
    if (*ptr == _T('"') &&
        (LastQuote = _tcsrchr(++ptr, _T('"'))) != NULL)
    {
        const TCHAR* Space;
        /* Under certain circumstances, all quotes are preserved.
         * CMD /? documents these conditions as follows:
         *  1. No /S switch
         *  2. Exactly two quotes
         *  3. No "special characters" between the quotes
         *     (CMD /? says &<>()@^| but parentheses did not
         *     trigger this rule when I tested them.)
         *  4. Whitespace exists between the quotes
         *  5. Enclosed string is an executable filename
         */
        *LastQuote = _T('\0');
        for (Space = ptr + 1; Space < LastQuote; ++Space)
        {
            if (_istspace(*Space))                         /* Rule 4 */
            {
                if (!AlwaysStrip &&                        /* Rule 1 */
                    !_tcspbrk(ptr, _T("\"&<>@^|")) &&      /* Rules 2, 3 */
                    SearchForExecutable(ptr, commandline)) /* Rule 5 */
                {
                    /* All conditions met: preserve both the quotes */
                    *LastQuote = _T('"');
                    _tcscpy(commandline, ptr - 1);
                    return;
                }
                break;
            }
        }

        /* The conditions were not met: remove both the
         * leading quote and the last quote */
        _tcscpy(commandline, ptr);
        _tcscpy(&commandline[LastQuote - ptr], LastQuote + 1);
        return;
    }

    /* No quotes; just copy */
    _tcscpy(commandline, ptr);
}

Referenced by _tmain().

GetEnhancedVar()

static PCTSTR GetEnhancedVar ( IN OUT PCTSTR *  pFormat, IN BOOL(*)(TCHAR, PCTSTR *, BOOL *)  GetVar  )

static

Definition at line 971 of file cmd.c.

{
    static const TCHAR ModifierTable[] = _T("dpnxfsatz");
    enum {
        M_DRIVE = 1,   /* D: drive letter */
        M_PATH  = 2,   /* P: path */
        M_NAME  = 4,   /* N: filename */
        M_EXT   = 8,   /* X: extension */
        M_FULL  = 16,  /* F: full path (drive+path+name+ext) */
        M_SHORT = 32,  /* S: full path (drive+path+name+ext), use short names */
        M_ATTR  = 64,  /* A: attributes */
        M_TIME  = 128, /* T: modification time */
        M_SIZE  = 256, /* Z: file size */
    } Modifiers = 0;

    PCTSTR Format, FormatEnd;
    PCTSTR PathVarName = NULL;
    PCTSTR Variable;
    PCTSTR VarEnd;
    BOOL VariableIsParam0;
    TCHAR FullPath[MAX_PATH];
    TCHAR FixedPath[MAX_PATH];
    PTCHAR Filename, Extension;
    HANDLE hFind;
    WIN32_FIND_DATA w32fd;
    PTCHAR In, Out;

    static TCHAR Result[CMDLINE_LENGTH];

     /* Check whether the current character is a recognized variable.
      * If it is not, then restore the previous one: there is indeed
      * ambiguity between modifier characters and FOR variables;
      * the rule that CMD uses is to pick the longest possible match.
      * This case can happen if we have a FOR-variable specification
      * of the following form:
      *
      *   %~<modifiers><actual FOR variable character><other characters>
      *
      * where the FOR variable character is also a similar to a modifier,
      * but should not be interpreted as is, and the following other
      * characters are not part of the possible modifier characters, and
      * are unrelated to the FOR variable (they can be part of a command).
      * For example, if there is a %n variable, then out of %~anxnd,
      * %~anxn will be substituted rather than just %~an.
      *
      * In the following examples, all characters 'd','p','n','x' are valid modifiers.
      *
      * 1. In this example, the FOR variable character is 'x' and the actual
      *    modifiers are 'dpn'. Parsing will first determine that 'dpnx'
      *    are modifiers, with the possible (last) valid variable being 'x',
      *    and will stop at the letter 'g'. Since 'g' is not a valid
      *    variable, then the actual variable is the lattest one 'x',
      *    and the modifiers are then actually 'dpn'.
      *    The FOR-loop will then display the %x variable formatted with 'dpn'
      *    and will append any other characters following, 'g'.
      *
      *  C:\Temp>for %x in (foo.exe bar.txt) do @echo %~dpnxg
      *  C:\Temp\foog
      *  C:\Temp\barg
      *
      *
      * 2. In this second example, the FOR variable character is 'g' and
      *    the actual modifiers are 'dpnx'. Parsing will determine also that
      *    the possible (last) valid variable could be 'x', but since it's
      *    not present in the FOR-variables list, it won't be the case.
      *    This means that the actual FOR variable character must follow,
      *    in this case, 'g'.
      *
      *  C:\Temp>for %g in (foo.exe bar.txt) do @echo %~dpnxg
      *  C:\Temp\foo.exe
      *  C:\Temp\bar.txt
      */

    /* First, go through as many modifier characters as possible */
    FormatEnd = Format = *pFormat;
    while (*FormatEnd && _tcschr(ModifierTable, _totlower(*FormatEnd)))
        ++FormatEnd;

    if (*FormatEnd == _T('$'))
    {
        /* $PATH: syntax */
        PathVarName = FormatEnd + 1;
        FormatEnd = _tcschr(PathVarName, _T(':'));
        if (!FormatEnd)
            return NULL;

        /* Must be immediately followed by the variable */
        if (!GetVar(*++FormatEnd, &Variable, &VariableIsParam0))
            return NULL;
    }
    else
    {
        /* Backtrack if necessary to get a variable name match */
        while (!GetVar(*FormatEnd, &Variable, &VariableIsParam0))
        {
            if (FormatEnd == Format)
                return NULL;
            --FormatEnd;
        }
    }

    *pFormat = FormatEnd + 1;

    /* If the variable is empty, return an empty string */
    if (!Variable || !*Variable)
        return _T("");

    /* Exclude the leading and trailing quotes */
    VarEnd = &Variable[_tcslen(Variable)];
    if (*Variable == _T('"'))
    {
        ++Variable;
        if (VarEnd > Variable && VarEnd[-1] == _T('"'))
            --VarEnd;
    }

    if ((ULONG_PTR)VarEnd - (ULONG_PTR)Variable >= sizeof(Result))
        return _T("");
    memcpy(Result, Variable, (ULONG_PTR)VarEnd - (ULONG_PTR)Variable);
    Result[VarEnd - Variable] = _T('\0');

    /* Now determine the actual modifiers */
    for (; Format < FormatEnd && *Format != _T('$'); ++Format)
        Modifiers |= 1 << (_tcschr(ModifierTable, _totlower(*Format)) - ModifierTable);

    if (PathVarName)
    {
        /* $PATH: syntax - search the directories listed in the
         * specified environment variable for the file */
        PTSTR PathVar;
        ((PTSTR)FormatEnd)[-1] = _T('\0'); // FIXME: HACK!
        PathVar = GetEnvVar(PathVarName);
        ((PTSTR)FormatEnd)[-1] = _T(':');
        if (!PathVar ||
            !SearchPath(PathVar, Result, NULL, ARRAYSIZE(FullPath), FullPath, NULL))
        {
            return _T("");
        }
    }
    else if (Modifiers == 0)
    {
        /* For plain %~var with no modifiers, just return the variable without quotes */
        return Result;
    }
    else if (VariableIsParam0)
    {
        /* Special case: If the variable is %0 and modifier characters are present,
         * use the batch file's path (which includes the .bat/.cmd extension)
         * rather than the actual %0 variable (which might not). */
        ASSERT(bc);
        _tcscpy(FullPath, bc->BatchFilePath);
    }
    else
    {
        /* Convert the variable, now without quotes, to a full path */
        if (!GetFullPathName(Result, ARRAYSIZE(FullPath), FullPath, NULL))
            return _T("");
    }

    /* Next step is to change the path to fix letter case (e.g.
     * C:\ReAcToS -> C:\ReactOS) and, if requested with the S modifier,
     * replace long filenames with short. */

    In = FullPath;
    Out = FixedPath;

    /* Copy drive letter */
    *Out++ = *In++;
    *Out++ = *In++;
    *Out++ = *In++;
    /* Loop over each \-separated component in the path */
    do {
        TCHAR *Next = _tcschr(In, _T('\\'));
        if (Next)
            *Next++ = _T('\0');
        /* Use FindFirstFile to get the correct name */
        if (Out + _tcslen(In) + 1 >= &FixedPath[ARRAYSIZE(FixedPath)])
            return _T("");
        _tcscpy(Out, In);
        hFind = FindFirstFile(FixedPath, &w32fd);
        /* If it doesn't exist, just leave the name as it was given */
        if (hFind != INVALID_HANDLE_VALUE)
        {
            PTSTR FixedComponent = w32fd.cFileName;
            if (*w32fd.cAlternateFileName &&
                ((Modifiers & M_SHORT) || !_tcsicmp(In, w32fd.cAlternateFileName)))
            {
                FixedComponent = w32fd.cAlternateFileName;
            }
            FindClose(hFind);

            if (Out + _tcslen(FixedComponent) + 1 >= &FixedPath[ARRAYSIZE(FixedPath)])
                return _T("");
            _tcscpy(Out, FixedComponent);
        }
        Filename = Out;
        Out += _tcslen(Out);
        *Out++ = _T('\\');

        In = Next;
    } while (In != NULL);
    Out[-1] = _T('\0');

    /* Build the result string. Start with attributes, modification time, and
     * file size. If the file didn't exist, these fields will all be empty. */
    Out = Result;
    if (hFind != INVALID_HANDLE_VALUE)
    {
        if (Modifiers & M_ATTR)
        {
            static const struct {
                TCHAR Character;
                WORD  Value;
            } *Attrib, Table[] = {
                { _T('d'), FILE_ATTRIBUTE_DIRECTORY },
                { _T('r'), FILE_ATTRIBUTE_READONLY },
                { _T('a'), FILE_ATTRIBUTE_ARCHIVE },
                { _T('h'), FILE_ATTRIBUTE_HIDDEN },
                { _T('s'), FILE_ATTRIBUTE_SYSTEM },
                { _T('c'), FILE_ATTRIBUTE_COMPRESSED },
                { _T('o'), FILE_ATTRIBUTE_OFFLINE },
                { _T('t'), FILE_ATTRIBUTE_TEMPORARY },
                { _T('l'), FILE_ATTRIBUTE_REPARSE_POINT },
#if (NTDDI_VERSION >= NTDDI_WIN8)
                { _T('v'), FILE_ATTRIBUTE_INTEGRITY_STREAM },
                { _T('x'), FILE_ATTRIBUTE_NO_SCRUB_DATA /* 0x20000 */ },
#endif
            };
            for (Attrib = Table; Attrib != &Table[ARRAYSIZE(Table)]; Attrib++)
            {
                *Out++ = w32fd.dwFileAttributes & Attrib->Value
                         ? Attrib->Character
                         : _T('-');
            }
            *Out++ = _T(' ');
        }
        if (Modifiers & M_TIME)
        {
            FILETIME ft;
            SYSTEMTIME st;
            FileTimeToLocalFileTime(&w32fd.ftLastWriteTime, &ft);
            FileTimeToSystemTime(&ft, &st);

            Out += FormatDate(Out, &st, TRUE);
            *Out++ = _T(' ');
            Out += FormatTime(Out, &st);
            *Out++ = _T(' ');
        }
        if (Modifiers & M_SIZE)
        {
            ULARGE_INTEGER Size;
            Size.LowPart = w32fd.nFileSizeLow;
            Size.HighPart = w32fd.nFileSizeHigh;
            Out += _stprintf(Out, _T("%I64u "), Size.QuadPart);
        }
    }

    /* When using the path-searching syntax or the S modifier,
     * at least part of the file path is always included.
     * If none of the DPNX modifiers are present, include the full path */
    if (PathVarName || (Modifiers & M_SHORT))
        if ((Modifiers & (M_DRIVE | M_PATH | M_NAME | M_EXT)) == 0)
            Modifiers |= M_FULL;

    /* Now add the requested parts of the name.
     * With the F modifier, add all parts to form the full path. */
    Extension = _tcsrchr(Filename, _T('.'));
    if (Modifiers & (M_DRIVE | M_FULL))
    {
        *Out++ = FixedPath[0];
        *Out++ = FixedPath[1];
    }
    if (Modifiers & (M_PATH | M_FULL))
    {
        memcpy(Out, &FixedPath[2], (ULONG_PTR)Filename - (ULONG_PTR)&FixedPath[2]);
        Out += Filename - &FixedPath[2];
    }
    if (Modifiers & (M_NAME | M_FULL))
    {
        while (*Filename && Filename != Extension)
            *Out++ = *Filename++;
    }
    if (Modifiers & (M_EXT | M_FULL))
    {
        if (Extension)
            Out = _stpcpy(Out, Extension);
    }

    /* Trim trailing space which otherwise would appear as a
     * result of using the A/T/Z modifiers but no others. */
    while (Out != &Result[0] && Out[-1] == _T(' '))
        Out--;
    *Out = _T('\0');

    return Result;
}

Referenced by GetBatchVar(), and SubstituteForVars().

GetEnvVar()

LPTSTR GetEnvVar

(

LPCTSTR

varName

)

Definition at line 882 of file cmd.c.

{
    static LPTSTR ret = NULL;
    UINT size;

    cmd_free(ret);
    ret = NULL;
    size = GetEnvironmentVariable(varName, NULL, 0);
    if (size > 0)
    {
        ret = cmd_alloc(size * sizeof(TCHAR));
        if (ret != NULL)
            GetEnvironmentVariable(varName, ret, size + 1);
    }
    return ret;
}

Referenced by Cleanup(), GetEnhancedVar(), and GetEnvVarOrSpecial().

GetEnvVarOrSpecial()

LPCTSTR GetEnvVarOrSpecial

(

LPCTSTR

varName

)

Definition at line 900 of file cmd.c.

{
    static TCHAR ret[MAX_PATH];

    LPTSTR var = GetEnvVar(varName);
    if (var)
        return var;

    /* The environment variable doesn't exist, look for
     * a "special" one only if extensions are enabled. */
    if (!bEnableExtensions)
        return NULL;

    /* %CD% */
    if (_tcsicmp(varName, _T("CD")) == 0)
    {
        GetCurrentDirectory(ARRAYSIZE(ret), ret);
        return ret;
    }
    /* %DATE% */
    else if (_tcsicmp(varName, _T("DATE")) == 0)
    {
        return GetDateString();
    }
    /* %TIME% */
    else if (_tcsicmp(varName, _T("TIME")) == 0)
    {
        return GetTimeString();
    }
    /* %RANDOM% */
    else if (_tcsicmp(varName, _T("RANDOM")) == 0)
    {
        /* Get random number */
        _itot(rand(), ret, 10);
        return ret;
    }
    /* %CMDCMDLINE% */
    else if (_tcsicmp(varName, _T("CMDCMDLINE")) == 0)
    {
        return GetCommandLine();
    }
    /* %CMDEXTVERSION% */
    else if (_tcsicmp(varName, _T("CMDEXTVERSION")) == 0)
    {
        /* Set Command Extensions version number to CMDEXTVERSION */
        _itot(CMDEXTVERSION, ret, 10);
        return ret;
    }
    /* %ERRORLEVEL% */
    else if (_tcsicmp(varName, _T("ERRORLEVEL")) == 0)
    {
        _itot(nErrorLevel, ret, 10);
        return ret;
    }
#if (NTDDI_VERSION >= NTDDI_WIN7)
    /* Available in Win7+, even if the underlying API is available in Win2003+ */
    /* %HIGHESTNUMANODENUMBER% */
    else if (_tcsicmp(varName, _T("HIGHESTNUMANODENUMBER")) == 0)
    {
        ULONG NumaNodeNumber = 0;
        GetNumaHighestNodeNumber(&NumaNodeNumber);
        _itot(NumaNodeNumber, ret, 10);
        return ret;
    }
#endif

    return NULL;
}

Referenced by ExecuteIf(), seta_identval(), and SubstituteVar().

Initialize()

static LPCTSTR Initialize ( VOID  )

static

Definition at line 2131 of file cmd.c.

{
    HMODULE NtDllModule;
    HANDLE hIn, hOut;
    LPTSTR ptr, cmdLine;
    TCHAR option = 0;
    BOOL AutoRun = TRUE;
    TCHAR ModuleName[MAX_PATH + 1];

    /* Get version information */
    InitOSVersion();

    /* Some people like to run ReactOS cmd.exe on Win98, it helps in the
     * build process. So don't link implicitly against ntdll.dll, load it
     * dynamically instead */
    NtDllModule = GetModuleHandle(TEXT("ntdll.dll"));
    if (NtDllModule != NULL)
    {
        NtQueryInformationProcessPtr = (NtQueryInformationProcessProc)GetProcAddress(NtDllModule, "NtQueryInformationProcess");
        NtReadVirtualMemoryPtr = (NtReadVirtualMemoryProc)GetProcAddress(NtDllModule, "NtReadVirtualMemory");
    }

    /* Load the registry settings */
    LoadRegistrySettings(HKEY_LOCAL_MACHINE);
    LoadRegistrySettings(HKEY_CURRENT_USER);

    /* Initialize our locale */
    InitLocale();

    /* Initialize prompt support */
    InitPrompt();

#ifdef FEATURE_DIRECTORY_STACK
    /* Initialize directory stack */
    InitDirectoryStack();
#endif

#ifdef FEATURE_HISTORY
    /* Initialize history */
    InitHistory();
#endif

    /* Set COMSPEC environment variable */
    if (GetModuleFileName(NULL, ModuleName, ARRAYSIZE(ModuleName)) != 0)
    {
        ModuleName[MAX_PATH] = _T('\0');
        SetEnvironmentVariable (_T("COMSPEC"), ModuleName);
    }

    /* Add ctrl break handler */
    AddBreakHandler();

    /* Set our default console mode */
    hOut = ConStreamGetOSHandle(StdOut);
    hIn  = ConStreamGetOSHandle(StdIn);
    SetConsoleMode(hOut, 0); // Reinitialize the console output mode
    SetConsoleMode(hOut, ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);
    SetConsoleMode(hIn , ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);

    cmdLine = GetCommandLine();
    TRACE ("[command args: %s]\n", debugstr_aw(cmdLine));

    for (ptr = cmdLine; *ptr; ++ptr)
    {
        if (*ptr == _T('/'))
        {
            option = _totupper(ptr[1]);
            if (option == _T('?'))
            {
                ConOutResPaging(TRUE, STRING_CMD_HELP8);
                nErrorLevel = 1;
                bExit = TRUE;
                return NULL;
            }
            else if (option == _T('P'))
            {
                if (!IsExistingFile(_T("\\autoexec.bat")))
                {
#ifdef INCLUDE_CMD_DATE
                    cmd_date(_T(""));
#endif
#ifdef INCLUDE_CMD_TIME
                    cmd_time(_T(""));
#endif
                }
                else
                {
                    ParseCommandLine(_T("\\autoexec.bat"));
                }
                bCanExit = FALSE;
            }
            else if (option == _T('A'))
            {
                OutputStreamMode = AnsiText;
            }
            else if (option == _T('C') || option == _T('K') || option == _T('R'))
            {
                /* Remainder of command line is a command to be run */
                fSingleCommand = ((option == _T('K')) << 1) | 1;
                break;
            }
            else if (option == _T('D'))
            {
                AutoRun = FALSE;
            }
            else if (option == _T('Q'))
            {
                bDisableBatchEcho = TRUE;
            }
            else if (option == _T('S'))
            {
                bAlwaysStrip = TRUE;
            }
#ifdef INCLUDE_CMD_COLOR
            else if (!_tcsnicmp(ptr, _T("/T:"), 3))
            {
                /* Process /T (color) argument; overwrite any previous settings */
                wDefColor = (WORD)_tcstoul(&ptr[3], &ptr, 16);
            }
#endif
            else if (option == _T('U'))
            {
                OutputStreamMode = UTF16Text;
            }
            else if (option == _T('V'))
            {
                // FIXME: Check validity of the parameter given to V !
                bDelayedExpansion = _tcsnicmp(&ptr[2], _T(":OFF"), 4);
            }
            else if (option == _T('E'))
            {
                // FIXME: Check validity of the parameter given to E !
                bEnableExtensions = _tcsnicmp(&ptr[2], _T(":OFF"), 4);
            }
            else if (option == _T('X'))
            {
                /* '/X' is identical to '/E:ON' */
                bEnableExtensions = TRUE;
            }
            else if (option == _T('Y'))
            {
                /* '/Y' is identical to '/E:OFF' */
                bEnableExtensions = FALSE;
            }
        }
    }

#ifdef INCLUDE_CMD_COLOR
    if (wDefColor == 0)
    {
        /*
         * If we still do not have the console colour attribute set,
         * retrieve the default one.
         */
        ConGetDefaultAttributes(&wDefColor);
    }

    if (wDefColor != 0)
        ConSetScreenColor(ConStreamGetOSHandle(StdOut), wDefColor, TRUE);
#endif

    /* Reset the output Standard Streams translation modes and codepage caches */
    // ConStreamSetMode(StdIn , OutputStreamMode, InputCodePage );
    ConStreamSetMode(StdOut, OutputStreamMode, OutputCodePage);
    ConStreamSetMode(StdErr, OutputStreamMode, OutputCodePage);

    if (!*ptr)
    {
        /* If neither /C or /K was given, display a simple version string */
        ConOutChar(_T('\n'));
        ConOutResPrintf(STRING_REACTOS_VERSION,
                        _T(KERNEL_VERSION_STR),
                        _T(KERNEL_VERSION_BUILD_STR));
        ConOutPuts(_T("(C) Copyright 1998-") _T(COPYRIGHT_YEAR) _T(" ReactOS Team.\n"));
    }

    if (AutoRun)
    {
        ExecuteAutoRunFile(HKEY_LOCAL_MACHINE);
        ExecuteAutoRunFile(HKEY_CURRENT_USER);
    }

    /* Returns the rest of the command line */
    return ptr;
}

Referenced by _tmain().

IsConsoleProcess()

static BOOL IsConsoleProcess ( HANDLE  Process )

static

Definition at line 224 of file cmd.c.

{
    NTSTATUS Status;
    PROCESS_BASIC_INFORMATION Info;
    PEB ProcessPeb;
    SIZE_T BytesRead;

    if (NULL == NtQueryInformationProcessPtr || NULL == NtReadVirtualMemoryPtr)
    {
        return TRUE;
    }

    Status = NtQueryInformationProcessPtr (
        Process, ProcessBasicInformation,
        &Info, sizeof(PROCESS_BASIC_INFORMATION), NULL);
    if (! NT_SUCCESS(Status))
    {
        WARN ("NtQueryInformationProcess failed with status %08x\n", Status);
        return TRUE;
    }
    Status = NtReadVirtualMemoryPtr (
        Process, Info.PebBaseAddress, &ProcessPeb,
        sizeof(PEB), &BytesRead);
    if (! NT_SUCCESS(Status) || sizeof(PEB) != BytesRead)
    {
        WARN ("Couldn't read virt mem status %08x bytes read %Iu\n", Status, BytesRead);
        return TRUE;
    }

    return IMAGE_SUBSYSTEM_WINDOWS_CUI == ProcessPeb.ImageSubsystem;
}

Referenced by Execute().

LoadRegistrySettings()

static VOID LoadRegistrySettings ( HKEY  hKeyRoot )

static

Definition at line 1889 of file cmd.c.

{
    LONG lRet;
    HKEY hKey;
    DWORD dwType, len;
    /*
     * Buffer big enough to hold the string L"4294967295",
     * corresponding to the literal 0xFFFFFFFF (MAXULONG) in decimal.
     */
    DWORD Buffer[6];

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

#ifdef INCLUDE_CMD_COLOR
    len = sizeof(Buffer);
    lRet = RegQueryValueEx(hKey,
                           _T("DefaultColor"),
                           NULL,
                           &dwType,
                           (LPBYTE)&Buffer,
                           &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default attributes */
        if (dwType == REG_DWORD)
            wDefColor = (WORD)*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            wDefColor = (WORD)_tcstol((PTSTR)Buffer, NULL, 0);
    }
    // else, use the default attributes retrieved before.
#endif

#if 0
    len = sizeof(Buffer);
    lRet = RegQueryValueEx(hKey,
                           _T("DisableUNCCheck"),
                           NULL,
                           &dwType,
                           (LPBYTE)&Buffer,
                           &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default setting */
        if (dwType == REG_DWORD)
            bDisableUNCCheck = !!*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            bDisableUNCCheck = (_ttol((PTSTR)Buffer) == 1);
    }
    // else, use the default setting set globally.
#endif

    len = sizeof(Buffer);
    lRet = RegQueryValueEx(hKey,
                           _T("DelayedExpansion"),
                           NULL,
                           &dwType,
                           (LPBYTE)&Buffer,
                           &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default setting */
        if (dwType == REG_DWORD)
            bDelayedExpansion = !!*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            bDelayedExpansion = (_ttol((PTSTR)Buffer) == 1);
    }
    // else, use the default setting set globally.

    len = sizeof(Buffer);
    lRet = RegQueryValueEx(hKey,
                           _T("EnableExtensions"),
                           NULL,
                           &dwType,
                           (LPBYTE)&Buffer,
                           &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default setting */
        if (dwType == REG_DWORD)
            bEnableExtensions = !!*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            bEnableExtensions = (_ttol((PTSTR)Buffer) == 1);
    }
    // else, use the default setting set globally.

    len = sizeof(Buffer);
    lRet = RegQueryValueEx(hKey,
                           _T("CompletionChar"),
                           NULL,
                           &dwType,
                           (LPBYTE)&Buffer,
                           &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default setting */
        if (dwType == REG_DWORD)
            AutoCompletionChar = (TCHAR)*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            AutoCompletionChar = (TCHAR)_tcstol((PTSTR)Buffer, NULL, 0);
    }
    // else, use the default setting set globally.

    /* Validity check */
    if (IS_COMPLETION_DISABLED(AutoCompletionChar))
    {
        /* Disable autocompletion */
        AutoCompletionChar = 0x20;
    }

    len = sizeof(Buffer);
    lRet = RegQueryValueEx(hKey,
                           _T("PathCompletionChar"),
                           NULL,
                           &dwType,
                           (LPBYTE)&Buffer,
                           &len);
    if (lRet == ERROR_SUCCESS)
    {
        /* Overwrite the default setting */
        if (dwType == REG_DWORD)
            PathCompletionChar = (TCHAR)*(PDWORD)Buffer;
        else if (dwType == REG_SZ)
            PathCompletionChar = (TCHAR)_tcstol((PTSTR)Buffer, NULL, 0);
    }
    // else, use the default setting set globally.

    /* Validity check */
    if (IS_COMPLETION_DISABLED(PathCompletionChar))
    {
        /* Disable autocompletion */
        PathCompletionChar = 0x20;
    }

    /* Adjust completion chars */
    if (PathCompletionChar >= 0x20 && AutoCompletionChar < 0x20)
        PathCompletionChar = AutoCompletionChar;
    else if (AutoCompletionChar >= 0x20 && PathCompletionChar < 0x20)
        AutoCompletionChar = PathCompletionChar;

    RegCloseKey(hKey);
}

Referenced by Initialize().

ParseCommandLine()

INT ParseCommandLine

(

LPTSTR

cmd

)

Definition at line 632 of file cmd.c.

{
    INT Ret = 0;
    PARSED_COMMAND *Cmd;

    Cmd = ParseCommand(cmd);
    if (!Cmd)
    {
        /* Return an adequate error code */
        return (!bParseError ? 0 : 1);
    }

    Ret = ExecuteCommand(Cmd);
    FreeCommand(Cmd);
    return Ret;
}

Referenced by _tmain(), Cleanup(), ExecuteAutoRunFile(), and Initialize().

ProcessInput()

static INT ProcessInput ( VOID  )

static

Definition at line 1770 of file cmd.c.

{
    INT Ret = 0;
    PARSED_COMMAND *Cmd;

    while (!bCanExit || !bExit)
    {
        /* Reset the Ctrl-Break / Ctrl-C state */
        bCtrlBreak = FALSE;

        Cmd = ParseCommand(NULL);
        if (!Cmd)
            continue;

        Ret = ExecuteCommand(Cmd);
        FreeCommand(Cmd);
    }

    return Ret;
}

Referenced by _tmain().

ReadLine()

BOOL ReadLine	(	TCHAR *	commandline,
		BOOL	bMore
	)

Definition at line 1719 of file cmd.c.

{
    TCHAR readline[CMDLINE_LENGTH];
    LPTSTR ip;

    /* if no batch input then... */
    if (bc == NULL)
    {
        if (bMore)
        {
            ConOutResPrintf(STRING_MORE);
        }
        else
        {
            /* JPP 19980807 - if echo off, don't print prompt */
            if (bEcho)
            {
                if (!bIgnoreEcho)
                    ConOutChar(_T('\n'));
                PrintPrompt();
            }
        }

        if (!ReadCommand(readline, CMDLINE_LENGTH - 1))
        {
            bExit = TRUE;
            return FALSE;
        }

        if (readline[0] == _T('\0'))
            ConOutChar(_T('\n'));

        if (CheckCtrlBreak(BREAK_INPUT))
            return FALSE;

        if (readline[0] == _T('\0'))
            return FALSE;

        ip = readline;
    }
    else
    {
        ip = ReadBatchLine();
        if (!ip)
            return FALSE;
    }

    return SubstituteVars(ip, commandline, _T('%'));
}

Referenced by ParseChar(), and ParseCommand().

RemoveBreakHandler()

VOID RemoveBreakHandler

(

VOID

)

Definition at line 1848 of file cmd.c.

{
    SetConsoleCtrlHandler(BreakHandler, FALSE);
}

Referenced by Cleanup(), FilePromptYN(), FilePromptYNA(), and PagePrompt().

ResetConTitle()

static VOID ResetConTitle ( VOID  )

static

Definition at line 329 of file cmd.c.

{
    /* Restore the original console title */
    if (!bc && bTitleSet)
    {
        ConSetTitle(szCurTitle);
        bTitleSet = FALSE;
    }
}

Referenced by DoCommand(), and Execute().

RunFile()

HANDLE RunFile	(	DWORD	flags,
		LPTSTR	filename,
		LPTSTR	params,
		LPTSTR	directory,
		INT	show
	)

Definition at line 266 of file cmd.c.

{
    SHELLEXECUTEINFO sei;
    HMODULE     hShell32;
    MYEX        hShExt;
    BOOL        ret;

    TRACE ("RunFile(%s)\n", debugstr_aw(filename));
    hShell32 = LoadLibrary(_T("SHELL32.DLL"));
    if (!hShell32)
    {
        WARN ("RunFile: couldn't load SHELL32.DLL!\n");
        return NULL;
    }

    hShExt = (MYEX)(FARPROC)GetProcAddress(hShell32, SHELLEXECUTETEXT);
    if (!hShExt)
    {
        WARN ("RunFile: couldn't find ShellExecuteExA/W in SHELL32.DLL!\n");
        FreeLibrary(hShell32);
        return NULL;
    }

    TRACE ("RunFile: ShellExecuteExA/W is at %x\n", hShExt);

    memset(&sei, 0, sizeof sei);
    sei.cbSize = sizeof sei;
    sei.fMask = flags;
    sei.lpFile = filename;
    sei.lpParameters = params;
    sei.lpDirectory = directory;
    sei.nShow = show;
    ret = hShExt(&sei);

    TRACE ("RunFile: ShellExecuteExA/W returned 0x%p\n", ret);

    FreeLibrary(hShell32);
    return ret ? sei.hProcess : NULL;
}

Referenced by cmd_start(), and Execute().

SetConTitle()

static VOID SetConTitle ( LPCTSTR  pszTitle )

static

Definition at line 309 of file cmd.c.

{
    TCHAR szNewTitle[MAX_PATH];

    if (!pszTitle)
        return;

    /* Don't do anything if we run inside a batch file, or we are just running a single command */
    if (bc || (fSingleCommand == 1))
        return;

    /* Save the original console title and build a new one */
    GetConsoleTitle(szCurTitle, ARRAYSIZE(szCurTitle));
    StringCchPrintf(szNewTitle, ARRAYSIZE(szNewTitle),
                    _T("%s - %s"), szCurTitle, pszTitle);
    bTitleSet = TRUE;
    ConSetTitle(szNewTitle);
}

Referenced by DoCommand(), and Execute().

SubstituteForVars()

BOOL SubstituteForVars	(	IN PCTSTR	Src,
		OUT PTSTR	Dest
	)

Definition at line 1594 of file cmd.c.

{
    PTCHAR DestEnd = &Dest[CMDLINE_LENGTH - 1];
    while (*Src)
    {
        if (Src[0] == _T('%'))
        {
            BOOL Dummy;
            PCTSTR End = &Src[2];
            PCTSTR Value = NULL;

            if (Src[1] == _T('~'))
                Value = GetEnhancedVar(&End, FindForVar);

            if (!Value && Src[1])
            {
                if (FindForVar(Src[1], &Value, &Dummy) && !Value)
                {
                    /* The variable is empty, return an empty string */
                    Value = _T("");
                }
            }

            if (Value)
            {
                if (Dest + _tcslen(Value) > DestEnd)
                    return FALSE;
                Dest = _stpcpy(Dest, Value);
                Src = End;
                continue;
            }
        }
        /* Not a variable; just copy the character */
        if (Dest >= DestEnd)
            return FALSE;
        *Dest++ = *Src++;
    }
    *Dest = _T('\0');
    return TRUE;
}

Referenced by DoDelayedExpansion(), EchoCommand(), and UnparseCommand().

SubstituteVar()

BOOL SubstituteVar	(	IN PCTSTR	Src,
		OUT size_t *	SrcIncLen,
		OUT PTCHAR	Dest,
		IN PTCHAR	DestEnd,
		OUT size_t *	DestIncLen,
		IN TCHAR	Delim
	)

Definition at line 1324 of file cmd.c.

{
#define APPEND(From, Length) \
do { \
    if (Dest + (Length) > DestEnd) \
        goto too_long; \
    memcpy(Dest, (From), (Length) * sizeof(TCHAR)); \
    Dest += (Length); \
} while (0)

#define APPEND1(Char) \
do { \
    if (Dest >= DestEnd) \
        goto too_long; \
    *Dest++ = (Char); \
} while (0)

    PCTSTR Var;
    PCTSTR Start, End, SubstStart;
    TCHAR EndChr;
    size_t VarLength;

    Start = Src;
    End = Dest;
    *SrcIncLen = 0;
    *DestIncLen = 0;

    if (!Delim)
        return FALSE;
    if (*Src != Delim)
        return FALSE;

    ++Src;

    /* If we are already at the end of the string, fail the substitution */
    SubstStart = Src;
    if (!*Src || *Src == _T('\r') || *Src == _T('\n'))
        goto bad_subst;

    if (bc && Delim == _T('%'))
    {
        UINT NameLen;
        Var = GetBatchVar(Src, &NameLen);
        if (!Var && bParseError)
        {
            /* Return the partially-parsed command to be
             * echoed for error diagnostics purposes. */
            APPEND1(Delim);
            APPEND(Src, _tcslen(Src) + 1);
            return FALSE;
        }
        if (Var != NULL)
        {
            VarLength = _tcslen(Var);
            APPEND(Var, VarLength);
            Src += NameLen;
            goto success;
        }
    }

    /* Find the end of the variable name. A colon (:) will usually
     * end the name and begin the optional modifier, but not if it
     * is immediately followed by the delimiter (%VAR:%). */
    SubstStart = Src;
    while (*Src && *Src != Delim && !(*Src == _T(':') && Src[1] != Delim))
    {
        ++Src;
    }
    /* If we are either at the end of the string, or the delimiter
     * has been repeated more than once, fail the substitution. */
    if (!*Src || Src == SubstStart)
        goto bad_subst;

    EndChr = *Src;
    *(PTSTR)Src = _T('\0'); // FIXME: HACK!
    Var = GetEnvVarOrSpecial(SubstStart);
    *(PTSTR)Src++ = EndChr;
    if (Var == NULL)
    {
        /* In a batch context, %NONEXISTENT% "expands" to an
         * empty string, otherwise fail the substitution. */
        if (bc)
            goto success;
        goto bad_subst;
    }
    VarLength = _tcslen(Var);

    if (EndChr == Delim)
    {
        /* %VAR% - use as-is */
        APPEND(Var, VarLength);
    }
    else if (*Src == _T('~'))
    {
        /* %VAR:~[start][,length]% - Substring.
         * Negative values are offsets from the end.
         */
        SSIZE_T Start = _tcstol(Src + 1, (PTSTR*)&Src, 0);
        SSIZE_T End = (SSIZE_T)VarLength;
        if (Start < 0)
            Start += VarLength;
        Start = min(max(Start, 0), VarLength);
        if (*Src == _T(','))
        {
            End = _tcstol(Src + 1, (PTSTR*)&Src, 0);
            End += (End < 0) ? VarLength : Start;
            End = min(max(End, Start), VarLength);
        }
        if (*Src++ != Delim)
            goto bad_subst;
        APPEND(&Var[Start], End - Start);
    }
    else
    {
        /* %VAR:old=new%  - Replace all occurrences of old with new.
         * %VAR:*old=new% - Replace first occurrence only,
         *                  and remove everything before it.
         */
        PCTSTR Old, New;
        size_t OldLength, NewLength;
        BOOL Star = FALSE;
        size_t LastMatch = 0, i = 0;

        if (*Src == _T('*'))
        {
            Star = TRUE;
            Src++;
        }

        /* The string to replace may contain the delimiter */
        Src = _tcschr(Old = Src, _T('='));
        if (Src == NULL)
            goto bad_subst;
        OldLength = Src++ - Old;
        if (OldLength == 0)
            goto bad_subst;

        Src = _tcschr(New = Src, Delim);
        if (Src == NULL)
            goto bad_subst;
        NewLength = Src++ - New;

        while (i < VarLength)
        {
            if (_tcsnicmp(&Var[i], Old, OldLength) == 0)
            {
                if (!Star)
                    APPEND(&Var[LastMatch], i - LastMatch);
                APPEND(New, NewLength);
                i += OldLength;
                LastMatch = i;
                if (Star)
                    break;
                continue;
            }
            i++;
        }
        APPEND(&Var[LastMatch], VarLength - LastMatch);
    }

success:
    *SrcIncLen = (Src - Start);
    *DestIncLen = (Dest - End);
    return TRUE;

bad_subst:
    Src = SubstStart;
    /* Only if no batch context active do we echo the delimiter */
    if (!bc)
        APPEND1(Delim);
    goto success;

too_long:
    ConOutResPrintf(STRING_ALIAS_ERROR);
    nErrorLevel = 9023;
    return FALSE;

#undef APPEND
#undef APPEND1
}

Referenced by DoDelayedExpansion(), and SubstituteVars().

SubstituteVars()

BOOL SubstituteVars	(	IN PCTSTR	Src,
		OUT PTSTR	Dest,
		IN TCHAR	Delim
	)

Definition at line 1512 of file cmd.c.

{
#define APPEND(From, Length) \
do { \
    if (Dest + (Length) > DestEnd) \
        goto too_long; \
    memcpy(Dest, (From), (Length) * sizeof(TCHAR)); \
    Dest += (Length); \
} while (0)

#define APPEND1(Char) \
do { \
    if (Dest >= DestEnd) \
        goto too_long; \
    *Dest++ = (Char); \
} while (0)

    PTCHAR DestEnd = Dest + CMDLINE_LENGTH - 1;
    PCTSTR End;
    size_t SrcIncLen, DestIncLen;

    while (*Src /* && (Dest < DestEnd) */)
    {
        if (*Src != Delim)
        {
            End = _tcschr(Src, Delim);
            if (End == NULL)
                End = Src + _tcslen(Src);
            APPEND(Src, End - Src);
            Src = End;
            continue;
        }

        if (!SubstituteVar(Src, &SrcIncLen, Dest, DestEnd, &DestIncLen, Delim))
        {
            return FALSE;
        }
        else
        {
            Src += SrcIncLen;
            Dest += DestIncLen;
        }
    }
    APPEND1(_T('\0'));
    return TRUE;

too_long:
    ConOutResPrintf(STRING_ALIAS_ERROR);
    nErrorLevel = 9023;
    return FALSE;

#undef APPEND
#undef APPEND1
}

Referenced by ParseCommand(), and ReadLine().

Variable Documentation

bAlwaysStrip

BOOL bAlwaysStrip = FALSE

static

Definition at line 157 of file cmd.c.

Referenced by _tmain(), and Initialize().

bCanExit

BOOL bCanExit = TRUE

Definition at line 153 of file cmd.c.

Referenced by Initialize(), and ProcessInput().

bCtrlBreak

BOOL bCtrlBreak = FALSE

Definition at line 154 of file cmd.c.

Referenced by BreakHandler(), cgetchar(), CheckCtrlBreak(), DeleteFolder(), DoTypeFile(), PagePrompt(), ProcessInput(), and ReadCommand().

bDelayedExpansion

BOOL bDelayedExpansion = FALSE

Definition at line 162 of file cmd.c.

Referenced by cmd_endlocal(), cmd_setlocal(), DoDelayedExpansion(), Initialize(), and LoadRegistrySettings().

bDisableBatchEcho

BOOL bDisableBatchEcho = FALSE

Definition at line 160 of file cmd.c.

Referenced by Batch(), ExecuteCommandWithEcho(), and Initialize().

bEnableExtensions

BOOL bEnableExtensions = TRUE

Definition at line 161 of file cmd.c.

Referenced by Batch(), cmd_call(), cmd_chdir(), cmd_date(), cmd_endlocal(), cmd_goto(), cmd_setlocal(), cmd_time(), CommandExit(), ExecuteFor(), ExecuteIf(), GetEnvVarOrSpecial(), Initialize(), LoadRegistrySettings(), ParseFor(), ParseIf(), and SetRootPath().

bExit

BOOL bExit = FALSE

Definition at line 152 of file cmd.c.

Referenced by _tmain(), Batch(), CommandExit(), ExecuteCommand(), Fbt_Dispatch(), Initialize(), ProcessInput(), ReadLine(), and WINHELP_DeleteWindow().

bIgnoreEcho

BOOL bIgnoreEcho = FALSE

Definition at line 155 of file cmd.c.

Referenced by Batch(), CommandScreen(), ExecuteCommandWithEcho(), ParseCommand(), and ReadLine().

bTitleSet

BOOL bTitleSet = FALSE

Definition at line 167 of file cmd.c.

Referenced by cmd_title(), ResetConTitle(), and SetConTitle().

ChildProcessRunningLock

CRITICAL_SECTION ChildProcessRunningLock

Definition at line 159 of file cmd.c.

Referenced by _tmain(), BreakHandler(), Cleanup(), Execute(), and ExecutePipeline().

CMD_ModuleHandle

HANDLE CMD_ModuleHandle

Definition at line 165 of file cmd.c.

Referenced by _tmain(), CheckCtrlBreak(), CommandChoice(), DirPrintFiles(), error_sfile_not_found(), error_syntax(), ErrorMessage(), FilePromptYN(), FilePromptYNA(), LoadStrings(), PrintDirectoryHeader(), PrintDiskInfo(), PrintInfoLine(), and PrintSummary().

dwChildProcessId

DWORD dwChildProcessId = 0

Definition at line 163 of file cmd.c.

Referenced by Execute().

fSingleCommand

BOOL fSingleCommand = 0

static

Definition at line 156 of file cmd.c.

Referenced by _tmain(), Execute(), Initialize(), and SetConTitle().

lpOriginalEnvironment

LPTSTR lpOriginalEnvironment

Definition at line 164 of file cmd.c.

Referenced by _tmain(), and cmd_start().

nErrorLevel

INT nErrorLevel = 0

Definition at line 158 of file cmd.c.

Referenced by _tmain(), Batch(), calc(), cmd_call(), cmd_chdir(), cmd_copy(), cmd_date(), cmd_mkdir(), cmd_mklink(), cmd_move(), cmd_path(), cmd_prompt(), cmd_rename(), cmd_set(), cmd_setlocal(), cmd_shift(), cmd_start(), cmd_time(), cmd_type(), cmd_ver(), cmd_verify(), cmd_vol(), CommandAlias(), CommandAssoc(), CommandChoice(), CommandColor(), CommandDelay(), CommandDelete(), CommandDir(), CommandDirs(), CommandExit(), CommandScreen(), CommandTimer(), copy(), DeleteFiles(), DoDelayedExpansion(), DoTypeFile(), error_bad_command(), error_file_not_found(), error_invalid_drive(), error_invalid_parameter_format(), error_invalid_switch(), error_no_pipe(), error_out_of_memory(), error_parameter_format(), error_path_not_found(), error_req_param_missing(), error_sfile_not_found(), error_syntax(), error_too_many_parameters(), Execute(), ExecuteCommand(), ExecuteIf(), ExecutePipeline(), GetEnvVarOrSpecial(), Initialize(), PushDirectory(), replace(), seta_bitAndTerm(), seta_eval(), seta_unaryTerm(), SetRootPath(), SubstituteVar(), and SubstituteVars().

NtQueryInformationProcessPtr

NtQueryInformationProcessProc NtQueryInformationProcessPtr = NULL

static

Definition at line 170 of file cmd.c.

Referenced by Initialize(), and IsConsoleProcess().

NtReadVirtualMemoryPtr

NtReadVirtualMemoryProc NtReadVirtualMemoryPtr = NULL

static

Definition at line 171 of file cmd.c.

Referenced by Initialize(), and IsConsoleProcess().

OutputStreamMode

CON_STREAM_MODE OutputStreamMode = UTF8Text

Definition at line 177 of file cmd.c.

Referenced by _tmain(), and Initialize().

szCurTitle

TCHAR szCurTitle[MAX_PATH]

Definition at line 168 of file cmd.c.

Referenced by ResetConTitle(), and SetConTitle().

wDefColor

WORD wDefColor = 0

Definition at line 180 of file cmd.c.

Referenced by CommandColor(), Initialize(), and LoadRegistrySettings().