#include <config.h>
#include "cmdver.h"
#include "cmddbg.h"
#include "console.h"

Include dependency graph for cmd.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	tagCOMMAND

struct	_PARSED_COMMAND

struct	_REDIRECTION

Macros
#define	CMDEXTVERSION 2

#define	BREAK_BATCHFILE 1

#define	BREAK_OUTOFBATCH 2 /* aka. BREAK_ENDOFBATCHFILES */

#define	BREAK_INPUT 3

#define	BREAK_IGNORE 4

#define	D_ON _T("on")

#define	D_OFF _T("off")

#define	CMDLINE_LENGTH 8192

#define	BUFF_SIZE 16384

#define	IS_COMPLETION_DISABLED(CompletionCtrl) ((CompletionCtrl) == 0x00 \|\| (CompletionCtrl) == 0x0D \|\| (CompletionCtrl) >= 0x20)

#define	CMD_SPECIAL 1

#define	CMD_BATCHONLY 2

#define	CMD_HIDE 4

#define	FOR_DIRS 1 /* /D */

#define	FOR_F 2 /* /F */

#define	FOR_LOOP 4 /* /L */

#define	FOR_RECURSIVE 8 /* /R */

#define	IFFLAG_NEGATE 1 /* NOT */

#define	IFFLAG_IGNORECASE 2 /* /I - Extended */

#define	PROMPT_NO 0

#define	PROMPT_YES 1

#define	PROMPT_ALL 2

#define	PROMPT_BREAK 3

#define	STANDARD_SEPS _T(",;=")

Typedefs
typedef struct tagCOMMAND	COMMAND

typedef struct tagCOMMAND *	LPCOMMAND

typedef enum _IF_OPERATOR	IF_OPERATOR

typedef enum _COMMAND_TYPE	COMMAND_TYPE

typedef struct _PARSED_COMMAND	PARSED_COMMAND

typedef enum _REDIR_MODE	REDIR_MODE

typedef struct _REDIRECTION	REDIRECTION

Enumerations
enum	_IF_OPERATOR { IF_ERRORLEVEL , IF_EXIST , IF_CMDEXTVERSION , IF_DEFINED , IF_STRINGEQ , IF_EQU , IF_NEQ , IF_LSS , IF_LEQ , IF_GTR , IF_GEQ }

enum	_COMMAND_TYPE { C_COMMAND , C_QUIET , C_BLOCK , C_MULTI , C_OR , C_AND , C_PIPE , C_FOR , C_IF , C_REM }

enum	_REDIR_MODE { REDIR_READ = 0 , REDIR_WRITE = 1 , REDIR_APPEND = 2 }

Functions
VOID	ExpandAlias (LPTSTR, INT)

INT	CommandAlias (LPTSTR)

INT	CommandAssoc (LPTSTR)

INT	cmd_beep (LPTSTR)

INT	cmd_call (LPTSTR)

INT	CommandChoice (LPTSTR)

INT	cmd_cls (LPTSTR)

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

HANDLE	RunFile (DWORD, LPTSTR, LPTSTR, LPTSTR, INT)

INT	ParseCommandLine (LPTSTR)

INT	ExecuteCommand (IN struct _PARSED_COMMAND *Cmd)

INT	ExecuteCommandWithEcho (IN struct _PARSED_COMMAND *Cmd)

LPCTSTR	GetEnvVarOrSpecial (LPCTSTR varName)

VOID	AddBreakHandler (VOID)

VOID	RemoveBreakHandler (VOID)

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)

BOOL	SubstituteForVars (IN PCTSTR Src, OUT PTSTR Dest)

PTSTR	DoDelayedExpansion (IN PCTSTR Line)

INT	DoCommand (LPTSTR first, LPTSTR rest, struct _PARSED_COMMAND *Cmd)

BOOL	ReadLine (TCHAR *commandline, BOOL bMore)

BOOL	ReadCommand (LPTSTR, INT)

VOID	PrintCommandList (VOID)

LPCTSTR	GetParsedEnvVar (LPCTSTR varName, UINT *varNameLen, BOOL ModeSetA)

INT	CommandColor (LPTSTR)

INT	cmd_copy (LPTSTR)

INT	cmd_date (LPTSTR)

INT	CommandDelete (LPTSTR)

INT	CommandDelay (LPTSTR)

INT	FormatDate (TCHAR *, LPSYSTEMTIME, BOOL)

INT	FormatTime (TCHAR *, LPSYSTEMTIME)

INT	CommandDir (LPTSTR)

VOID	InitDirectoryStack (VOID)

VOID	DestroyDirectoryStack (VOID)

INT	GetDirectoryStackDepth (VOID)

INT	CommandPushd (LPTSTR)

INT	CommandPopd (LPTSTR)

INT	CommandDirs (LPTSTR)

BOOL	OnOffCommand (LPTSTR param, LPBOOL flag, INT message)

INT	CommandEcho (LPTSTR)

INT	CommandEchos (LPTSTR)

INT	CommandEchoerr (LPTSTR)

INT	CommandEchoserr (LPTSTR)

VOID	ErrorMessage (IN DWORD dwErrorCode, IN PCTSTR szFormat OPTIONAL,...)

VOID	error_no_pipe (VOID)

VOID	error_bad_command (PCTSTR s)

VOID	error_invalid_drive (VOID)

VOID	error_req_param_missing (VOID)

VOID	error_sfile_not_found (PCTSTR s)

VOID	error_file_not_found (VOID)

VOID	error_path_not_found (VOID)

VOID	error_too_many_parameters (PCTSTR s)

VOID	error_parameter_format (TCHAR ch)

VOID	error_invalid_switch (TCHAR ch)

VOID	error_invalid_parameter_format (PCTSTR s)

VOID	error_out_of_memory (VOID)

VOID	error_syntax (PCTSTR s)

VOID	msg_pause (VOID)

INT	cmd_for (LPTSTR)

INT	ExecuteFor (struct _PARSED_COMMAND *Cmd)

INT	CommandFree (LPTSTR)

INT	cmd_goto (LPTSTR)

INT	ExecuteIf (struct _PARSED_COMMAND *Cmd)

VOID	InitLastPath (VOID)

VOID	FreeLastPath (VOID)

INT	cmd_chdir (LPTSTR)

INT	cmd_mkdir (LPTSTR)

INT	cmd_rmdir (LPTSTR)

INT	CommandExit (LPTSTR)

INT	CommandRem (LPTSTR)

INT	CommandShowCommands (LPTSTR)

VOID	InitLocale (VOID)

LPTSTR	GetDateString (VOID)

LPTSTR	GetTimeString (VOID)

INT	CommandMemory (LPTSTR)

INT	cmd_mklink (LPTSTR)

INT	GetRootPath (IN LPCTSTR InPath, OUT LPTSTR OutPath, IN INT size)

BOOL	SetRootPath (TCHAR oldpath, TCHAR InPath)

TCHAR	cgetchar (VOID)

BOOL	CheckCtrlBreak (INT)

BOOL	add_entry (LPINT ac, LPTSTR **arg, LPCTSTR entry)

LPTSTR *	split (LPTSTR, LPINT, BOOL, BOOL)

LPTSTR *	splitspace (LPTSTR, LPINT)

VOID	freep (LPTSTR *)

LPTSTR	_stpcpy (LPTSTR, LPCTSTR)

VOID	StripQuotes (LPTSTR)

BOOL	IsValidPathName (IN LPCTSTR pszPath)

BOOL	IsExistingFile (IN LPCTSTR pszPath)

BOOL	IsExistingDirectory (IN LPCTSTR pszPath)

VOID	GetPathCase (IN LPCTSTR Path, OUT LPTSTR OutPath)

BOOL __stdcall	PagePrompt (PCON_PAGER Pager, DWORD Done, DWORD Total)

INT	FilePromptYN (UINT)

INT	FilePromptYNA (UINT)

INT	cmd_move (LPTSTR)

INT	CommandMsgbox (LPTSTR)

PARSED_COMMAND *	ParseCommand (IN PCTSTR Line)

VOID	DumpCommand (IN PARSED_COMMAND *Cmd, IN ULONG SpacePad)

VOID	EchoCommand (IN PARSED_COMMAND *Cmd)

PTCHAR	UnparseCommand (IN PARSED_COMMAND *Cmd, OUT PTCHAR Out, IN PTCHAR OutEnd)

VOID	FreeCommand (IN OUT PARSED_COMMAND *Cmd)

VOID	ParseErrorEx (IN PCTSTR s)

INT	cmd_path (LPTSTR)

VOID	InitPrompt (VOID)

VOID	PrintPrompt (VOID)

INT	cmd_prompt (LPTSTR)

BOOL	HasInfoLine (VOID)

HANDLE	GetHandle (UINT Number)

VOID	SetHandle (UINT Number, HANDLE Handle)

BOOL	PerformRedirection (REDIRECTION *)

VOID	UndoRedirection (REDIRECTION , REDIRECTION End)

INT	GetRedirection (LPTSTR, REDIRECTION **)

VOID	FreeRedirection (REDIRECTION *)

INT	cmd_rename (LPTSTR)

INT	cmd_replace (LPTSTR)

INT	CommandScreen (LPTSTR)

INT	cmd_set (LPTSTR)

LPTSTR	DuplicateEnvironment (VOID)

INT	cmd_setlocal (LPTSTR)

INT	cmd_endlocal (LPTSTR)

INT	cmd_start (LPTSTR)

BOOL	StringToColor (LPWORD, LPTSTR *)

INT	cmd_time (LPTSTR)

INT	CommandTimer (LPTSTR param)

INT	cmd_title (LPTSTR)

INT	cmd_type (LPTSTR)

VOID	InitOSVersion (VOID)

VOID	PrintOSVersion (VOID)

INT	cmd_ver (LPTSTR)

INT	cmd_verify (LPTSTR)

INT	cmd_vol (LPTSTR)

BOOL	SearchForExecutable (LPCTSTR, LPTSTR)

INT	CommandActivate (LPTSTR)

INT	CommandWindow (LPTSTR)

int	cmd_if (TCHAR *)

int	cmd_pause (TCHAR *)

int	cmd_shift (TCHAR *)

Macro Definition Documentation

◆ BREAK_BATCHFILE

#define BREAK_BATCHFILE 1

Definition at line 34 of file cmd.h.

◆ BREAK_IGNORE

#define BREAK_IGNORE 4

Definition at line 37 of file cmd.h.

◆ BREAK_INPUT

#define BREAK_INPUT 3

Definition at line 36 of file cmd.h.

◆ BREAK_OUTOFBATCH

#define BREAK_OUTOFBATCH 2 /* aka. BREAK_ENDOFBATCHFILES */

Definition at line 35 of file cmd.h.

◆ BUFF_SIZE

#define BUFF_SIZE 16384

Definition at line 47 of file cmd.h.

◆ CMD_BATCHONLY

#define CMD_BATCHONLY 2

Definition at line 141 of file cmd.h.

◆ CMD_HIDE

#define CMD_HIDE 4

Definition at line 142 of file cmd.h.

◆ CMD_SPECIAL

#define CMD_SPECIAL 1

Definition at line 140 of file cmd.h.

◆ CMDEXTVERSION

#define CMDEXTVERSION 2

Definition at line 32 of file cmd.h.

◆ CMDLINE_LENGTH

#define CMDLINE_LENGTH 8192

Definition at line 44 of file cmd.h.

◆ D_OFF

#define D_OFF _T("off")

Definition at line 41 of file cmd.h.

◆ D_ON

#define D_ON _T("on")

Definition at line 40 of file cmd.h.

◆ FOR_DIRS

#define FOR_DIRS 1 /* /D */

Definition at line 234 of file cmd.h.

◆ FOR_F

#define FOR_F 2 /* /F */

Definition at line 235 of file cmd.h.

◆ FOR_LOOP

#define FOR_LOOP 4 /* /L */

Definition at line 236 of file cmd.h.

◆ FOR_RECURSIVE

#define FOR_RECURSIVE 8 /* /R */

Definition at line 237 of file cmd.h.

◆ IFFLAG_IGNORECASE

#define IFFLAG_IGNORECASE 2 /* /I - Extended */

Definition at line 261 of file cmd.h.

◆ IFFLAG_NEGATE

#define IFFLAG_NEGATE 1 /* NOT */

Definition at line 260 of file cmd.h.

◆ IS_COMPLETION_DISABLED

#define IS_COMPLETION_DISABLED ( CompletionCtrl ) ((CompletionCtrl) == 0x00 || (CompletionCtrl) == 0x0D || (CompletionCtrl) >= 0x20)

Definition at line 135 of file cmd.h.

◆ PROMPT_ALL

#define PROMPT_ALL 2

Definition at line 332 of file cmd.h.

◆ PROMPT_BREAK

#define PROMPT_BREAK 3

Definition at line 333 of file cmd.h.

◆ PROMPT_NO

#define PROMPT_NO 0

Definition at line 330 of file cmd.h.

◆ PROMPT_YES

#define PROMPT_YES 1

Definition at line 331 of file cmd.h.

◆ STANDARD_SEPS

#define STANDARD_SEPS _T(",;=")

Definition at line 348 of file cmd.h.

Typedef Documentation

◆ COMMAND

typedef struct tagCOMMAND COMMAND

◆ COMMAND_TYPE

typedef enum _COMMAND_TYPE COMMAND_TYPE

◆ IF_OPERATOR

typedef enum _IF_OPERATOR IF_OPERATOR

◆ LPCOMMAND

typedef struct tagCOMMAND * LPCOMMAND

◆ PARSED_COMMAND

typedef struct _PARSED_COMMAND PARSED_COMMAND

◆ REDIR_MODE

typedef enum _REDIR_MODE REDIR_MODE

◆ REDIRECTION

typedef struct _REDIRECTION REDIRECTION

Enumeration Type Documentation

◆ _COMMAND_TYPE

enum _COMMAND_TYPE

Enumerator
C_COMMAND
C_QUIET
C_BLOCK
C_MULTI
C_OR
C_AND
C_PIPE
C_FOR
C_IF
C_REM

Definition at line 350 of file cmd.h.

{
    /* Standard command */
    C_COMMAND,
    /* Quiet operator */
    C_QUIET,
    /* Parenthesized block */
    C_BLOCK,
    /* Operators */
    C_MULTI, C_OR, C_AND, C_PIPE,
    /* Special parsed commands */
    C_FOR, C_IF, C_REM
} COMMAND_TYPE;

◆ _IF_OPERATOR

enum _IF_OPERATOR

Enumerator
IF_ERRORLEVEL	Unary operators
IF_EXIST
IF_CMDEXTVERSION
IF_DEFINED
IF_STRINGEQ	Binary operators
IF_EQU
IF_NEQ
IF_LSS
IF_LEQ
IF_GTR
IF_GEQ

Definition at line 262 of file cmd.h.

{
    /* Standard */
    IF_ERRORLEVEL, IF_EXIST,
    /* Extended */
    IF_CMDEXTVERSION, IF_DEFINED,
 
    /* Standard */
    IF_STRINGEQ,    /* == */
    /* Extended */
    IF_EQU, IF_NEQ, IF_LSS, IF_LEQ, IF_GTR, IF_GEQ
} IF_OPERATOR;

◆ _REDIR_MODE

enum _REDIR_MODE

Enumerator
REDIR_READ
REDIR_WRITE
REDIR_APPEND

Definition at line 443 of file cmd.h.

{
    REDIR_READ   = 0,
    REDIR_WRITE  = 1,
    REDIR_APPEND = 2
} REDIR_MODE;

Function Documentation

◆ _stpcpy()

LPTSTR _stpcpy	(	LPTSTR	dest,
		LPCTSTR	src
	)

Definition at line 474 of file misc.c.

{
    _tcscpy (dest, src);
    return (dest + _tcslen (src));
}

Referenced by BatchParams(), ExecuteAsync(), ForRecursive(), GetEnhancedVar(), ParseCommandPart(), ParseFor(), ParseRem(), and SubstituteForVars().

◆ add_entry()

BOOL add_entry	(	LPINT	ac,
		LPTSTR **	arg,
		LPCTSTR	entry
	)

Definition at line 198 of file misc.c.

{
    LPTSTR q;
    LPTSTR *oldarg;
 
    q = cmd_alloc ((_tcslen(entry) + 1) * sizeof (TCHAR));
    if (!q)
    {
        WARN("Cannot allocate memory for q!\n");
        return FALSE;
    }
 
    _tcscpy (q, entry);
    oldarg = *arg;
    *arg = cmd_realloc (oldarg, (*ac + 2) * sizeof (LPTSTR));
    if (!*arg)
    {
        WARN("Cannot reallocate memory for arg!\n");
        *arg = oldarg;
        cmd_free (q);
        return FALSE;
    }
 
    /* save new entry */
    (*arg)[*ac] = q;
    (*arg)[++(*ac)] = NULL;
 
    return TRUE;
}

Referenced by expand(), split(), and splitspace().

◆ AddBreakHandler()

VOID AddBreakHandler ( VOID )

Definition at line 1844 of file cmd.c.

{
    SetConsoleCtrlHandler(BreakHandler, TRUE);
}

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

◆ cgetchar()

TCHAR cgetchar ( VOID )

Definition at line 242 of file util.c.

{
    HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
    INPUT_RECORD irBuffer;
    DWORD  dwRead;
 
    do
    {
        ReadConsoleInput (hInput, &irBuffer, 1, &dwRead);
        if ((irBuffer.EventType == KEY_EVENT) &&
            (irBuffer.Event.KeyEvent.bKeyDown != FALSE))
        {
            if (irBuffer.Event.KeyEvent.dwControlKeyState &
                 (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
            {
                if (irBuffer.Event.KeyEvent.wVirtualKeyCode == 'C')
                {
                    bCtrlBreak = TRUE;
                    break;
                }
            }
            else if ((irBuffer.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
                     (irBuffer.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
                     (irBuffer.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL))
            {
                // Nothing to do
            }
            else
            {
                break;
            }
        }
    }
    while (TRUE);
 
#ifndef _UNICODE
    return irBuffer.Event.KeyEvent.uChar.AsciiChar;
#else
    return irBuffer.Event.KeyEvent.uChar.UnicodeChar;
#endif /* _UNICODE */
}

Referenced by CheckCtrlBreak().

◆ CheckCtrlBreak()

BOOL CheckCtrlBreak ( INT mode )

Definition at line 146 of file misc.c.

{
    static BOOL bLeaveAll = FALSE; /* leave all batch files */
    TCHAR options[4]; /* Yes, No, All */
    TCHAR c;
 
    switch (mode)
    {
        case BREAK_OUTOFBATCH:
            bLeaveAll = FALSE;
            return FALSE;
 
        case BREAK_BATCHFILE:
        {
            if (bLeaveAll)
                return TRUE;
 
            if (!bCtrlBreak)
                return FALSE;
 
            LoadString(CMD_ModuleHandle, STRING_COPY_OPTION, options, ARRAYSIZE(options));
 
            ConOutResPuts(STRING_CANCEL_BATCH_FILE);
            do
            {
                c = _totupper(cgetchar());
            } while (!(_tcschr(options, c) || c == _T('\3')) || !c);
 
            ConOutChar(_T('\n'));
 
            if (c == options[1])
            {
                bCtrlBreak = FALSE; /* ignore */
                return FALSE;
            }
 
            /* leave all batch files */
            bLeaveAll = ((c == options[2]) || (c == _T('\3')));
            break;
        }
 
        case BREAK_INPUT:
            if (!bCtrlBreak)
                return FALSE;
            break;
    }
 
    /* state processed */
    return TRUE;
}

Referenced by cmd_copy(), CommandDir(), copy(), DirList(), DirPrintBareList(), DirPrintNewList(), DirPrintOldList(), DirPrintWideList(), ExitBatch(), ReadBatchLine(), ReadLine(), and RemoveFile().

◆ cmd_beep()

INT cmd_beep ( LPTSTR param )

Definition at line 31 of file beep.c.

{
    if (_tcsncmp(param, _T("/?"), 2) == 0)
    {
        ConOutResPaging(TRUE, STRING_BEEP_HELP);
        return 0;
    }
 
#if 0
    /* check if run in batch mode */
    if (bc == NULL)
        return 1;
#endif
 
    ConRingBell(ConStreamGetOSHandle(StdOut));
    return 0;
}

◆ cmd_call()

INT cmd_call ( LPTSTR param )

Definition at line 40 of file call.c.

{
    PARSED_COMMAND* Cmd = NULL;
    BOOL bOldIgnoreParserComments;
#ifndef MSCMD_CALL_QUIRKS
    BOOL bOldHandleContinuations;
#else
    SIZE_T nNumCarets;
#endif
    PTSTR first;
 
    TRACE("cmd_call(\'%s\')\n", debugstr_aw(param));
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_CALL_HELP);
        return 0;
    }
 
    /* Fail if no command or label has been provided */
    if (*param == _T('\0'))
        return (nErrorLevel = 1);
 
    /* Ignore parser comments (starting with a colon) */
    bOldIgnoreParserComments = bIgnoreParserComments;
    bIgnoreParserComments = FALSE;
 
#ifndef MSCMD_CALL_QUIRKS
    /* Disable parsing of escape carets */
    bOldHandleContinuations = bHandleContinuations;
    bHandleContinuations = FALSE;
    first = param;
#else
    /*
     * As the original escape carets have been dealt with during the first
     * command parsing step, the remaining ones need to be doubled so that
     * they can again survive the new parsing step done below.
     * But do it the Windows' CMD "buggy" way: **all** carets are doubled,
     * even those inside quotes. However, this causes carets inside quotes
     * to remain doubled after the parsing step...
     */
 
    /* Count all the carets */
    nNumCarets = 0;
    first = param;
    while (first)
    {
        first = _tcschr(first, _T('^'));
        if (first)
        {
            ++nNumCarets;
            ++first;
        }
    }
 
    /* Re-allocate a large enough parameter string if needed */
    if (nNumCarets > 0)
    {
        PTCHAR Src, Dest, End;
 
        // TODO: Improvement: Use the scratch TempBuf if the string is not too long.
        first = cmd_alloc((_tcslen(param) + nNumCarets + 1) * sizeof(TCHAR));
        if (!first)
        {
            WARN("Cannot allocate memory for new CALL parameter string!\n");
            error_out_of_memory();
            return (nErrorLevel = 1);
        }
 
        /* Copy the parameter string and double the escape carets */
        Src = param;
        Dest = first;
        while (*Src)
        {
            if (*Src != _T('^'))
            {
                /* Copy everything before the next caret (or the end of the string) */
                End = _tcschr(Src, _T('^'));
                if (!End)
                    End = Src + _tcslen(Src);
                memcpy(Dest, Src, (End - Src) * sizeof(TCHAR));
                Dest += End - Src;
                Src = End;
                continue;
            }
 
            /* Copy the original caret and double it */
            *Dest++ = *Src;
            *Dest++ = *Src++;
        }
        *Dest = _T('\0');
    }
    else
    {
        first = param;
    }
#endif
 
    /*
     * Reparse the CALL parameter string as a command.
     * Note that this will trigger a second round of %-variable substitutions.
     */
    Cmd = ParseCommand(first);
 
    /* Restore the global parsing state */
#ifndef MSCMD_CALL_QUIRKS
    bHandleContinuations = bOldHandleContinuations;
#endif
    bIgnoreParserComments = bOldIgnoreParserComments;
 
    /*
     * If no command is there, yet no error occurred, this means that
     * a whitespace label was given. Do not consider this as a failure.
     */
    if (!Cmd && !bParseError)
    {
#ifdef MSCMD_CALL_QUIRKS
        if (first != param)
            cmd_free(first);
#endif
        return (nErrorLevel = 0);
    }
 
    /* Reset bParseError so as to continue running afterwards */
    bParseError = FALSE;
 
    /*
     * Otherwise, if no command is there because a parse error occurred,
     * or if this an unsupported command: not a standard one, including
     * FOR and IF, fail and bail out.
     */
    if (!Cmd || (Cmd->Type == C_FOR) || (Cmd->Type == C_IF) ||
        ((Cmd->Type != C_COMMAND) && (Cmd->Type != C_REM)))
    {
        ConErrResPrintf(STRING_ERROR_UNEXPECTED, first);
 
#ifdef MSCMD_CALL_QUIRKS
        if (first != param)
            cmd_free(first);
#endif
        if (Cmd) FreeCommand(Cmd);
        return (nErrorLevel = 1);
    }
 
#ifdef MSCMD_CALL_QUIRKS
    if (first != param)
        cmd_free(first);
#endif
 
    first = Cmd->Command.First;
    param = Cmd->Command.Rest;
 
    /* "CALL :label args ..." - Call a subroutine of the current batch file, only if extensions are enabled */
    if (bEnableExtensions && (*first == _T(':')))
    {
        INT ret;
 
        /* A batch context must be present */
        if (!bc)
        {
            ConErrResPuts(STRING_ERROR_CALL_BAD_LABEL);
            FreeCommand(Cmd);
            return (nErrorLevel = 1);
        }
 
        ret = Batch(bc->BatchFilePath, first, param, NULL);
        nErrorLevel = (ret != 0 ? ret : nErrorLevel);
    }
    else
    {
        nErrorLevel = DoCommand(first, param, NULL);
    }
 
    FreeCommand(Cmd);
    return nErrorLevel;
}

◆ cmd_chdir()

INT cmd_chdir ( LPTSTR param )

Definition at line 240 of file internal.c.

{
    BOOL bChangeDrive = FALSE;
    LPTSTR tmp;
    TCHAR szCurrent[MAX_PATH];
 
    /* Filter out special cases first */
 
    /* Print help */
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_CD_HELP);
        return 0;
    }
 
    //
    // FIXME: Use the split() tokenizer if bEnableExtensions == FALSE,
    // so as to cut the parameter at the first separator (space, ',', ';'):
    // - When bEnableExtensions == FALSE, doing
    //   CD system32;winsxs
    //   will go into system32, (but: CD "system32;winsxs" will fail as below), while
    // - When bEnableExtensions == TRUE, it will fail because the "system32;winsxs"
    //   directory does not exist.
    //
 
    /* Remove extra quotes */
    StripQuotes(param);
 
    if (bEnableExtensions)
    {
        /* Strip trailing whitespace */
        tmp = param + _tcslen(param) - 1;
        while (tmp > param && _istspace(*tmp))
            --tmp;
        *(tmp + 1) = _T('\0');
    }
 
    /* Reset the error level */
    nErrorLevel = 0;
 
    /* Print the current directory on a disk */
    if (_tcslen(param) == 2 && param[1] == _T(':'))
    {
        if (GetRootPath(param, szCurrent, ARRAYSIZE(szCurrent)))
        {
            error_invalid_drive();
            return 1;
        }
        ConOutPrintf(_T("%s\n"), szCurrent);
        return 0;
    }
 
    /* Get the current directory */
    GetCurrentDirectory(ARRAYSIZE(szCurrent), szCurrent);
    if (param[0] == _T('\0'))
    {
        ConOutPrintf(_T("%s\n"), szCurrent);
        return 0;
    }
 
    /* If the input string is prefixed with the /D switch, change the drive */
    if (!_tcsncicmp(param, _T("/D"), 2))
    {
        bChangeDrive = TRUE;
        param += 2;
        while (_istspace(*param))
            ++param;
    }
 
    if (!SetRootPath(bChangeDrive ? NULL : szCurrent, param))
    {
        nErrorLevel = 1;
        return 1;
    }
 
    return 0;
}

◆ cmd_cls()

INT cmd_cls ( LPTSTR param )

Definition at line 33 of file cls.c.

{
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_CLS_HELP);
        return 0;
    }
 
    ConClearScreen(&StdOutScreen);
    return 0;
}

◆ cmd_copy()

INT cmd_copy ( LPTSTR param )

Definition at line 332 of file copy.c.

{
    LPTSTR *arg;
    INT argc, i, nFiles, nOverwrite = 0, nSrc = -1, nDes = -1;
    /* this is the path up to the folder of the src and dest ie C:\windows\ */
    TCHAR szDestPath[MAX_PATH];
    TCHAR szSrcPath[MAX_PATH];
    DWORD dwFlags = 0;
    /* If this is the type of copy where we are adding files */
    BOOL bAppend = FALSE;
    WIN32_FIND_DATA findBuffer;
    HANDLE hFile = NULL;
    BOOL bTouch = FALSE;
    /* Pointer to keep track of how far through the append input(file1+file2+file3) we are */
    TCHAR  * appendPointer = _T("\0");
    /* The full path to src and dest.  This has drive letter, folders, and filename */
    TCHAR tmpDestPath[MAX_PATH];
    TCHAR tmpSrcPath[MAX_PATH];
    /* A bool to know whether or not the destination name will be taken from the input */
    BOOL bSrcName = FALSE;
    /* Seems like a waste but it is a pointer used to copy from input to PreserveName */
    TCHAR * UseThisName;
    /* for CMDCOPY env */
    TCHAR *evar;
    int size;
    TCHAR * szTouch;
    BOOL bHasWildcard, bDone = FALSE, bMoreFiles = FALSE;
    /* Used for something like "copy c*.exe d*.exe" */
    BOOL bMultipleSource = FALSE, bMultipleDest = FALSE;
 
 
    /* Show help/usage info */
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_COPY_HELP2);
        return 0;
    }
 
    nErrorLevel = 0;
 
    /* Get the env variable value if it exists */
    evar = cmd_alloc(512 * sizeof(TCHAR));
    if (evar == NULL)
        size = 0;
    else
        size = GetEnvironmentVariable (_T("COPYCMD"), evar, 512);
 
    if (size > 512)
    {
        TCHAR *old_evar = evar;
        evar = cmd_realloc(evar,size * sizeof(TCHAR) );
        if (evar!=NULL)
            size = GetEnvironmentVariable (_T("COPYCMD"), evar, size);
        else
        {
            size=0;
            evar = old_evar;
        }
    }
 
    /* check see if we did get any env variable */
    if (size != 0)
    {
        int t = 0;
 
        /* scan and set the flags */
        for (t = 0; t < size; t++)
        {
            if (_tcsncicmp(_T("/A"),&evar[t],2) == 0)
            {
                dwFlags |=COPY_ASCII;
                t++;
            }
            else if (_tcsncicmp(_T("/B"),&evar[t],2) == 0)
            {
                dwFlags |= COPY_BINARY;
                t++;
            }
            else if (_tcsncicmp(_T("/D"),&evar[t],2) == 0)
            {
                dwFlags |= COPY_DECRYPT;
                t++;
            }
            else if (_tcsncicmp(_T("/V"),&evar[t],2) == 0)
            {
                dwFlags |= COPY_VERIFY;
                t++;
            }
            else if (_tcsncicmp(_T("/N"),&evar[t],2) == 0)
            {
                dwFlags |= COPY_SHORTNAME;
                t++;
            }
            else if (_tcsncicmp(_T("/Y"),&evar[t],2) == 0)
            {
                dwFlags |= COPY_NO_PROMPT;
                t++;
            }
            else if (_tcsncicmp(_T("/-Y"),&evar[t],3) == 0)
            {
                dwFlags |= COPY_PROMPT;
                t+=2;
            }
            else if (_tcsncicmp(_T("/Z"),&evar[t],2) == 0)
            {
                dwFlags |= COPY_PROMPT;
                t++;
            }
        }
    }
    cmd_free(evar);
 
 
    /* Split the user input into array */
    arg = split(param, &argc, FALSE, TRUE);
    nFiles = argc;
 
    /* Read switches and count files */
    for (i = 0; i < argc; i++)
    {
        if (*arg[i] == _T('/'))
        {
            if (_tcslen(arg[i]) >= 2)
            {
                switch (_totupper(arg[i][1]))
                {
                    case _T('A'):
                        dwFlags |= COPY_ASCII;
                        break;
 
                    case _T('B'):
                        dwFlags |= COPY_BINARY;
                        break;
 
                    case _T('D'):
                        dwFlags |= COPY_DECRYPT;
                        break;
 
                    case _T('V'):
                        dwFlags |= COPY_VERIFY;
                        break;
 
                    case _T('N'):
                        dwFlags |= COPY_SHORTNAME;
                        break;
 
                    case _T('Y'):
                        dwFlags |= COPY_NO_PROMPT;
                        dwFlags &= ~COPY_PROMPT;
                        break;
 
                    case _T('-'):
                        if (_tcslen(arg[i]) >= 3)
                        {
                            if (_totupper(arg[i][2]) == _T('Y'))
                            {
                                dwFlags &= ~COPY_NO_PROMPT;
                                dwFlags |= COPY_PROMPT;
                            }
                        }
 
                        break;
 
                    case _T('Z'):
                        dwFlags |= COPY_RESTART;
                        break;
 
                    default:
                        /* Invalid switch */
                        ConOutResPrintf(STRING_ERROR_INVALID_SWITCH, _totupper(arg[i][1]));
                        nErrorLevel = 1;
                        freep (arg);
                        return 1;
                        break;
                }
            }
            /* If it was a switch, subtract from total arguments */
            nFiles--;
        }
        else
        {
            /* If it isn't a switch then it is the source or destination */
            if (nSrc == -1)
            {
                nSrc = i;
            }
            else if (*arg[i] == _T('+'))
            {
                /* Next file should be appended */
                bMoreFiles = TRUE;
                nFiles -= 1;
            }
            else if (bMoreFiles)
            {
                /* Add this file to the source string
                   this way we can do all checks
                    directly on source string later on */
                TCHAR * ptr;
                int length = (_tcslen(arg[nSrc]) + _tcslen(arg[i]) + 2) * sizeof(TCHAR);
                ptr = cmd_alloc(length);
                if (ptr)
                {
                    _tcscpy(ptr, arg[nSrc]);
                    _tcscat(ptr, _T("|"));
                    _tcscat(ptr, arg[i]);
                    cmd_free(arg[nSrc]);
                    arg[nSrc] = ptr;
                    nFiles -= 1;
                }
 
                bMoreFiles = FALSE;
            }
            else if (nDes == -1)
            {
                nDes = i;
            }
        }
    }
 
    /* keep quiet within batch files */
    if (bc != NULL)
    {
        dwFlags |= COPY_NO_PROMPT;
        dwFlags &= ~COPY_PROMPT;
    }
 
    if (nFiles < 1)
    {
        /* There are not enough files, there has to be at least 1 */
        ConOutResPuts(STRING_ERROR_REQ_PARAM_MISSING);
        freep(arg);
        return 1;
    }
 
    if (nFiles > 2)
    {
        /* There are too many file names in command */
        ConErrResPrintf(STRING_ERROR_TOO_MANY_PARAMETERS,_T(""));
        nErrorLevel = 1;
        freep(arg);
        return 1;
    }
 
    if ((_tcschr(arg[nSrc], _T('|')) != NULL) ||
        (_tcschr(arg[nSrc], _T('*')) != NULL) ||
        (_tcschr(arg[nSrc], _T('?')) != NULL) ||
        IsExistingDirectory(arg[nSrc]))
    {
        bMultipleSource = TRUE;
    }
 
    /* Reuse the number of files variable */
    nFiles = 0;
 
    /* Check if no destination argument is passed */
    if (nDes == -1)
    {
        /* If no destination was entered then just use
        the current directory as the destination */
        GetCurrentDirectory(ARRAYSIZE(szDestPath), szDestPath);
    }
    else
    {
        /* Check if the destination is 'x:' */
        if ((arg[nDes][1] == _T(':')) && (arg[nDes][2] == _T('\0')))
        {
            GetRootPath(arg[nDes], szDestPath, ARRAYSIZE(szDestPath));
        }
        else
        {
            /* If the user entered two file names then form the full string path */
            GetFullPathName(arg[nDes], ARRAYSIZE(szDestPath), szDestPath, NULL);
        }
 
        /* Make sure there is an ending slash to the path if the dest is a folder */
        if ((_tcschr(szDestPath, _T('*')) == NULL) &&
            IsExistingDirectory(szDestPath))
        {
            bMultipleDest = TRUE;
            if (szDestPath[_tcslen(szDestPath) -  1] != _T('\\'))
                _tcscat(szDestPath, _T("\\"));
        }
 
        /* Check if the destination uses wildcards */
        if ((_tcschr(arg[nDes], _T('*')) != NULL) ||
            (_tcschr(arg[nDes], _T('?')) != NULL))
        {
            bMultipleDest = TRUE;
        }
    }
 
    if (nDes != -1) /* Append files only when there is a destination */
    {
        if (bMultipleSource && !bMultipleDest)
        {
            /* We have multiple source files, but not multiple destination
               files. This means we are appending the source files. */
            bAppend = TRUE;
            if (_tcschr(arg[nSrc], _T('|')) != NULL)
                appendPointer = arg[nSrc];
        }
    }
 
    /* Save the name the user entered */
    UseThisName = _tcsrchr(szDestPath,_T('\\'));
    if (UseThisName)
    {
        /* Split the name from the path */
        *UseThisName++ = _T('\0');
 
        /* Check if the dest path ends with '\*' or '\' */
        if (((UseThisName[0] == _T('*')) && (UseThisName[1] == _T('\0'))) ||
            (UseThisName[0] == _T('\0')))
        {
            /* In this case we will be using the same name as the source file
            for the destination file because destination is a folder */
            bSrcName = TRUE;
            UseThisName = NULL;
        }
    }
    else
    {
        /* Something's seriously wrong! */
        UseThisName = szDestPath;
    }
 
    do
    {
        /* Get the full string of the path to the source file */
        if (_tcschr(arg[nSrc], _T('|')) != NULL)
        {
            /* Reset the source path */
            szSrcPath[0] = _T('\0');
 
            /* Loop through the source file name and copy all
               the chars one at a time until we reach the separator */
            while(TRUE)
            {
                if (appendPointer[0] == _T('|'))
                {
                    /* Skip the | and go to the next file name */
                    appendPointer++;
                    break;
                }
                else if (appendPointer[0] == _T('\0'))
                {
                    bDone = TRUE;
                    break;
                }
 
                _tcsncat(szSrcPath, appendPointer, 1);
                appendPointer++;
            }
 
            if (_tcschr(arg[nSrc], _T(',')) != NULL)
            {
                /* Only time there is a , in the source is when they are using touch
                   Cant have a destination and can only have on ,, at the end of the string
                   Cant have more than one file name */
                szTouch = _tcsstr(arg[nSrc], _T("|"));
                if (_tcsncmp(szTouch,_T("|,,\0"), 4) || (nDes != -1))
                {
                    ConErrResPrintf(STRING_ERROR_INVALID_PARAM_FORMAT,arg[nSrc]);
                    nErrorLevel = 1;
                    freep (arg);
                    return 1;
                }
                bTouch = TRUE;
                bDone = TRUE;
            }
        }
        else
        {
            bDone = TRUE;
            _tcscpy(szSrcPath, arg[nSrc]);
        }
 
        /* "x:" is not a valid source path format. */
        if ((szSrcPath[1] == _T(':')) && (szSrcPath[2] == _T('\0')))
        {
            ConOutPrintf(_T("%s\n"), szSrcPath);
            ConOutFormatMessage(ERROR_FILE_NOT_FOUND, szSrcPath);
            nErrorLevel = 1;
            break;
        }
 
 
        /* From this point on, we can assume that the shortest path is
           3 letters long and that would be [DriveLetter]:\ */
 
        /* Check if the path has a wildcard */
        bHasWildcard = (_tcschr(szSrcPath, _T('*')) != NULL);
 
        /* If there is no * in the path name and it is a folder then we will
           need to add a wildcard to the pathname so FindFirstFile comes up
           with all the files in that folder */
        if (!bHasWildcard && IsExistingDirectory(szSrcPath))
        {
            /* If it doesnt have a \ at the end already then on needs to be added */
            if (szSrcPath[_tcslen(szSrcPath) -  1] != _T('\\'))
                _tcscat(szSrcPath, _T("\\"));
            _tcscat(szSrcPath, _T("*"));
            bHasWildcard = TRUE;
        }
 
        /* If the path ends with '\' add a wildcard at the end */
        if (szSrcPath[_tcslen(szSrcPath) -  1] == _T('\\'))
        {
            _tcscat(szSrcPath, _T("*"));
            bHasWildcard = TRUE;
        }
 
        /* Get a list of all the files */
        hFile = FindFirstFile(szSrcPath, &findBuffer);
 
        /* If we could not open the file handle, print out the error */
        if (hFile == INVALID_HANDLE_VALUE)
        {
            /* only print source name when more than one file */
            if (bMultipleSource)
                ConOutPrintf(_T("%s\n"), szSrcPath);
 
            ConOutFormatMessage(GetLastError(), szSrcPath);
            freep(arg);
            nErrorLevel = 1;
            return 1;
        }
 
        /* Strip the paths back to the folder they are in */
        for (i = (_tcslen(szSrcPath) -  1); i > -1; i--)
        {
            if (szSrcPath[i] != _T('\\'))
                szSrcPath[i] = _T('\0');
            else
                break;
        }
 
        do
        {
            /* Check Breaker */
            if (CheckCtrlBreak(BREAK_INPUT))
            {
                FindClose(hFile);
                freep(arg);
                return 1;
            }
 
            /* Set the override to yes each new file */
            nOverwrite = 1;
 
            /* Ignore the . and .. files */
            if (!_tcscmp(findBuffer.cFileName, _T("."))  ||
                !_tcscmp(findBuffer.cFileName, _T("..")) ||
                findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
                continue;
            }
 
            /* Copy the base folder over to a tmp string */
            _tcscpy(tmpDestPath, szDestPath);
            _tcscat(tmpDestPath, _T("\\"));
 
            /* Can't put a file into a folder that isn't there */
            if (_tcscmp(tmpDestPath, _T("\\\\.\\")) &&
                !IsExistingDirectory(tmpDestPath))
            {
                FindClose(hFile);
                ConOutFormatMessage(GetLastError(), szSrcPath);
                freep(arg);
                nErrorLevel = 1;
                return 1;
            }
 
            /* Copy over the destination path name */
            if (bSrcName)
                _tcscat(tmpDestPath, findBuffer.cFileName);
            else
            {
                /* If there is no wildcard, use the name the user entered */
                if ((_tcschr(UseThisName, _T('*')) == NULL) &&
                    (_tcschr(UseThisName, _T('?')) == NULL))
                {
                    _tcscat(tmpDestPath, UseThisName);
                }
                else
                {
                    TCHAR DoneFile[MAX_PATH];
 
                    BuildFileName(findBuffer.cFileName,
                                  UseThisName,
                                  DoneFile);
 
 
                    /* Add the filename to the tmp string path */
                    _tcscat(tmpDestPath, DoneFile);
                }
            }
 
            /* Build the string path to the source file */
            _tcscpy(tmpSrcPath,szSrcPath);
            _tcscat (tmpSrcPath, findBuffer.cFileName);
 
            /* Check to see if the file is the same file */
            if (!bTouch && !_tcscmp(tmpSrcPath, tmpDestPath))
            {
                ConOutResPrintf(STRING_COPY_ERROR2);
 
                nErrorLevel = 1;
                break;
            }
 
            /* only print source name when more than one file */
            if (bMultipleSource)
                ConOutPrintf(_T("%s\n"), tmpSrcPath);
 
            /* Handle any overriding / prompting that needs to be done */
            if (((!(dwFlags & COPY_NO_PROMPT) && IsExistingFile (tmpDestPath)) || dwFlags & COPY_PROMPT) && !bTouch)
                nOverwrite = CopyOverwrite(tmpDestPath);
            if (nOverwrite == PROMPT_NO || nOverwrite == PROMPT_BREAK)
                continue;
            if (nOverwrite == PROMPT_ALL || (nOverwrite == PROMPT_YES && bAppend))
                dwFlags |= COPY_NO_PROMPT;
 
            /* Tell whether the copy was successful or not */
            if (copy(tmpSrcPath,tmpDestPath, bAppend, dwFlags, bTouch))
            {
                nFiles++;
            }
            else
            {
                /* print out the error message */
                ConOutResPrintf(STRING_COPY_ERROR3);
                ConOutFormatMessage (GetLastError(), szSrcPath);
                nErrorLevel = 1;
            }
 
        /* Loop through all wildcard files */
        } while (FindNextFile(hFile, &findBuffer));
 
        FindClose(hFile);
 
    /* Loop through all files in src string with a + */
    } while (!bDone);
 
    /* print out the number of files copied */
    ConOutResPrintf(STRING_COPY_FILE, bAppend ? 1 : nFiles);
 
    if (arg != NULL)
        freep(arg);
 
    return 0;
}

◆ cmd_date()

INT cmd_date ( LPTSTR param )

Definition at line 176 of file date.c.

{
    LPTSTR* arg;
    INT argc;
    INT i;
    BOOL bPrompt = TRUE;
    INT nDateString = -1;
    TCHAR szDate[40];
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_DATE_HELP4);
        return 0;
    }
 
    nErrorLevel = 0;
 
    /* Build the parameter array */
    arg = split(param, &argc, FALSE, FALSE);
 
    /* Check for options */
    for (i = 0; i < argc; i++)
    {
        if (bEnableExtensions && (_tcsicmp(arg[i], _T("/T")) == 0))
            bPrompt = FALSE;
 
        if ((*arg[i] != _T('/')) && (nDateString == -1))
            nDateString = i;
    }
 
    if (nDateString == -1)
    {
        ConOutResPuts(STRING_DATE_NOW);
        ConOutPrintf(_T("%s\n"), GetDateString());
    }
 
    if (!bPrompt)
    {
        freep(arg);
        return 0;
    }
 
    while (TRUE)
    {
        if (nDateString == -1)
        {
            PromptDateString();
            ConInString(szDate, ARRAYSIZE(szDate));
 
            TRACE("\'%s\'\n", debugstr_aw(szDate));
 
            while (*szDate && szDate[_tcslen(szDate) - 1] < _T(' '))
                szDate[_tcslen(szDate) - 1] = _T('\0');
 
            if (ParseDate(szDate))
            {
                freep(arg);
                return 0;
            }
        }
        else
        {
            if (ParseDate(arg[nDateString]))
            {
                freep(arg);
                return 0;
            }
 
            /* Force input the next time around */
            nDateString = -1;
        }
 
        ConErrResPuts(STRING_DATE_ERROR);
        nErrorLevel = 1;
    }
 
    freep(arg);
    return 0;
}

Referenced by Initialize().

◆ cmd_endlocal()

INT cmd_endlocal ( LPTSTR param )

Definition at line 110 of file setlocal.c.

{
    LPTSTR Environ, Name, Value;
    PSETLOCAL Saved;
    TCHAR drvEnvVar[] = _T("=?:");
    TCHAR szCurrent[MAX_PATH];
 
    if (!_tcscmp(param, _T("/?")))
    {
        // FIXME
        ConOutPuts(_T("ENDLOCAL help not implemented yet!\n"));
        return 0;
    }
 
    /* Pop a SETLOCAL struct off of this batch context's stack */
    if (!bc || !(Saved = bc->setlocal))
        return 0;
    bc->setlocal = Saved->Prev;
 
    bEnableExtensions = Saved->EnableExtensions;
    bDelayedExpansion = Saved->DelayedExpansion;
 
    /* First, clear out the environment. Since making any changes to the
     * environment invalidates pointers obtained from GetEnvironmentStrings(),
     * we must make a copy of it and get the variable names from that. */
    Environ = DuplicateEnvironment();
    if (Environ)
    {
        for (Name = Environ; *Name; Name += _tcslen(Name) + 1)
        {
            if (!(Value = _tcschr(Name + 1, _T('='))))
                continue;
            *Value++ = _T('\0');
            SetEnvironmentVariable(Name, NULL);
            Name = Value;
        }
        cmd_free(Environ);
    }
 
    /* Now, restore variables from the copy saved by cmd_setlocal() */
    for (Name = Saved->Environment; *Name; Name += _tcslen(Name) + 1)
    {
        if (!(Value = _tcschr(Name + 1, _T('='))))
            continue;
        *Value++ = _T('\0');
        SetEnvironmentVariable(Name, Value);
        Name = Value;
    }
 
    /* Restore the current drive and its current directory from the environment */
    drvEnvVar[1] = _T('A') + Saved->CurDrive - 1;
    if (!GetEnvironmentVariable(drvEnvVar, szCurrent, ARRAYSIZE(szCurrent)))
    {
        _stprintf(szCurrent, _T("%C:\\"), _T('A') + Saved->CurDrive - 1);
    }
    _tchdir(szCurrent); // SetRootPath(NULL, szCurrent);
 
    cmd_free(Saved->Environment);
    cmd_free(Saved);
    return 0;
}

Referenced by ExitBatch().

◆ cmd_for()

INT cmd_for ( LPTSTR param )

Definition at line 41 of file for.c.

{
    TRACE("cmd_for(\'%s\')\n", debugstr_aw(param));
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_FOR_HELP1);
        return 0;
    }
 
    ParseErrorEx(param);
    return 1;
}

◆ cmd_goto()

INT cmd_goto ( LPTSTR param )

Definition at line 36 of file goto.c.

{
    LPTSTR label, tmp;
    DWORD dwCurrPos;
    BOOL bRetry;
 
    TRACE("cmd_goto(\'%s\')\n", debugstr_aw(param));
 
    /*
     * Keep the help message handling here too.
     * This allows us to reproduce the Windows' CMD "bug"
     * (from a batch script):
     *
     * SET label=/?
     * CALL :%%label%%
     *
     * calls GOTO help, due to how CALL :label functionality
     * is internally implemented.
     *
     * See https://stackoverflow.com/q/31987023/13530036
     * for more details.
     *
     * Note that the choice of help parsing forbids
     * any label containing '/?' in it.
     */
    if (_tcsstr(param, _T("/?")))
    {
        ConOutResPaging(TRUE, STRING_GOTO_HELP1);
        return 0;
    }
 
    /* If not in batch, fail */
    if (bc == NULL)
        return 1;
 
    /* Fail if no label has been provided */
    if (*param == _T('\0'))
    {
        ConErrResPrintf(STRING_GOTO_ERROR1);
        ExitBatch();
        return 1;
    }
 
    /* Strip leading whitespace */
    while (_istspace(*param))
        ++param;
 
    /* Support jumping to the end of the file, only if extensions are enabled */
    if (bEnableExtensions &&
        (_tcsnicmp(param, _T(":EOF"), 4) == 0) &&
        (!param[4] || _istspace(param[4])))
    {
        /* Position at the end of the batch file */
        bc->mempos = bc->memsize;
 
        /* Do not process any more parts of a compound command */
        bc->current = NULL;
        return 0;
    }
 
    /* Skip the first colon or plus sign */
    if (*param == _T(':') || *param == _T('+'))
        ++param;
    /* Terminate the label at the first delimiter character */
    tmp = param;
    while (!_istcntrl(*tmp) && !_istspace(*tmp) &&
           !_tcschr(_T(":+"), *tmp) && !_tcschr(STANDARD_SEPS, *tmp) /* &&
           !_tcschr(_T("&|<>"), *tmp) */)
    {
        ++tmp;
    }
    *tmp = _T('\0');
 
    /* If we don't have any label, bail out */
    if (!*param)
        goto NotFound;
 
    /*
     * Search the next label starting our position, until the end of the file.
     * If none has been found, restart at the beginning of the file, and continue
     * until reaching back our old current position.
     */
    bRetry = FALSE;
    dwCurrPos = bc->mempos;
 
retry:
    while (BatchGetString(textline, ARRAYSIZE(textline)))
    {
        if (bRetry && (bc->mempos >= dwCurrPos))
            break;
 
#if 0
        /* If this is not a label, continue searching */
        if (!_tcschr(textline, _T(':')))
            continue;
#endif
 
        label = textline;
 
        /* A bug in Windows' CMD makes it always ignore the
         * first character of the line, unless it's a colon. */
        if (*label != _T(':'))
            ++label;
 
        /* Strip any leading whitespace */
        while (_istspace(*label))
            ++label;
 
        /* If this is not a label, continue searching */
        if (*label != _T(':'))
            continue;
 
        /* Skip the first colon or plus sign */
#if 0
        if (*label == _T(':') || *label == _T('+'))
            ++label;
#endif
        ++label;
        /* Strip any whitespace between the colon and the label */
        while (_istspace(*label))
            ++label;
        /* Terminate the label at the first delimiter character */
        tmp = label;
        while (!_istcntrl(*tmp) && !_istspace(*tmp) &&
               !_tcschr(_T(":+"), *tmp) && !_tcschr(STANDARD_SEPS, *tmp) &&
               !_tcschr(_T("&|<>"), *tmp))
        {
            /* Support the escape caret */
            if (*tmp == _T('^'))
            {
                /* Move the buffer back one character */
                memmove(tmp, tmp + 1, (_tcslen(tmp + 1) + 1) * sizeof(TCHAR));
                /* We will ignore the new character */
            }
 
            ++tmp;
        }
        *tmp = _T('\0');
 
        /* Jump if the labels are identical */
        if (_tcsicmp(label, param) == 0)
        {
            /* Do not process any more parts of a compound command */
            bc->current = NULL;
            return 0;
        }
    }
    if (!bRetry && (bc->mempos >= bc->memsize))
    {
        bRetry = TRUE;
        bc->mempos = 0;
        goto retry;
    }
 
NotFound:
    ConErrResPrintf(STRING_GOTO_ERROR2, param);
    ExitBatch();
    return 1;
}

Referenced by Batch(), and CommandExit().

◆ cmd_if()

int cmd_if ( TCHAR * )

◆ cmd_mkdir()

INT cmd_mkdir ( LPTSTR param )

Definition at line 360 of file internal.c.

{
    LPTSTR *p;
    INT argc, i;
    DWORD dwLastError;
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_MKDIR_HELP);
        return 0;
    }
 
    p = split (param, &argc, FALSE, FALSE);
    if (argc == 0)
    {
        ConErrResPuts(STRING_ERROR_REQ_PARAM_MISSING);
        freep(p);
        nErrorLevel = 1;
        return 1;
    }
 
    nErrorLevel = 0;
    for (i = 0; i < argc; i++)
    {
        if (!MakeFullPath(p[i]))
        {
            dwLastError = GetLastError();
            switch (dwLastError)
            {
            case ERROR_PATH_NOT_FOUND:
                ConErrResPuts(STRING_MD_ERROR2);
                break;
 
            case ERROR_FILE_EXISTS:
            case ERROR_ALREADY_EXISTS:
                ConErrResPrintf(STRING_MD_ERROR, p[i]);
                break;
 
            default:
                ErrorMessage(GetLastError(), NULL);
            }
            nErrorLevel = 1;
        }
    }
 
    freep (p);
    return nErrorLevel;
}

◆ cmd_mklink()

INT cmd_mklink ( LPTSTR param )

Definition at line 124 of file mklink.c.

{
    HMODULE hKernel32 = GetModuleHandle(_T("KERNEL32"));
    DWORD Flags = 0;
    enum { SYMBOLIC, HARD, JUNCTION } LinkType = SYMBOLIC;
    INT NumFiles = 0;
    LPTSTR Name[2];
    INT argc, i;
    LPTSTR *arg;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPuts(STRING_MKLINK_HELP);
        return 0;
    }
 
    arg = split(param, &argc, FALSE, FALSE);
    for (i = 0; i < argc; i++)
    {
        if (arg[i][0] == _T('/'))
        {
            if (!_tcsicmp(arg[i], _T("/D")))
                Flags |= 1; /* SYMBOLIC_LINK_FLAG_DIRECTORY */
            else if (!_tcsicmp(arg[i], _T("/H")))
                LinkType = HARD;
            else if (!_tcsicmp(arg[i], _T("/J")))
                LinkType = JUNCTION;
            else
            {
                error_invalid_switch(arg[i][1]);
                freep(arg);
                return 1;
            }
        }
        else
        {
            if (NumFiles == 2)
            {
                error_too_many_parameters(arg[i]);
                freep(arg);
                return 1;
            }
            Name[NumFiles++] = arg[i];
        }
    }
    freep(arg);
 
    if (NumFiles != 2)
    {
        error_req_param_missing();
        return 1;
    }
 
    nErrorLevel = 0;
 
    if (LinkType == SYMBOLIC)
    {
        /* CreateSymbolicLink doesn't exist in old versions of Windows,
         * so load dynamically */
        BOOL (WINAPI *CreateSymbolicLink)(LPCTSTR, LPCTSTR, DWORD)
#ifdef UNICODE
            = (BOOL (WINAPI *)(LPCTSTR, LPCTSTR, DWORD))GetProcAddress(hKernel32, "CreateSymbolicLinkW");
#else
            = (BOOL (WINAPI *)(LPCTSTR, LPCTSTR, DWORD))GetProcAddress(hKernel32, "CreateSymbolicLinkA");
#endif
        if (CreateSymbolicLink && CreateSymbolicLink(Name[0], Name[1], Flags))
        {
            ConOutResPrintf(STRING_MKLINK_CREATED_SYMBOLIC, Name[0], Name[1]);
            return 0;
        }
    }
    else if (LinkType == HARD)
    {
        /* CreateHardLink doesn't exist in old versions of Windows,
         * so load dynamically */
        BOOL (WINAPI *CreateHardLink)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES)
#ifdef UNICODE
            = (BOOL (WINAPI *)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES))GetProcAddress(hKernel32, "CreateHardLinkW");
#else
            = (BOOL (WINAPI *)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES))GetProcAddress(hKernel32, "CreateHardLinkA");
#endif
        if (CreateHardLink && CreateHardLink(Name[0], Name[1], NULL))
        {
            ConOutResPrintf(STRING_MKLINK_CREATED_HARD, Name[0], Name[1]);
            return 0;
        }
    }
    else
    {
        if (CreateJunction(Name[0], Name[1]))
        {
            ConOutResPrintf(STRING_MKLINK_CREATED_JUNCTION, Name[0], Name[1]);
            return 0;
        }
    }
 
    ErrorMessage(GetLastError(), _T("MKLINK"));
    return 1;
}

◆ cmd_move()

INT cmd_move ( LPTSTR param )

Definition at line 87 of file move.c.

{
    LPTSTR *arg;
    INT argc, i, nFiles;
    LPTSTR pszDest;
    TCHAR szDestPath[MAX_PATH];
    TCHAR szFullDestPath[MAX_PATH];
    TCHAR szSrcDirPath[MAX_PATH];
    TCHAR szSrcPath[MAX_PATH];
    TCHAR szFullSrcPath[MAX_PATH];
    DWORD dwFlags = 0;
    INT nOverwrite = 0;
    WIN32_FIND_DATA findBuffer;
    HANDLE hFile;
 
    /* used only when source and destination  directories are on different volume */
    HANDLE hDestFile = NULL;
    WIN32_FIND_DATA findDestBuffer;
    TCHAR szMoveDest[MAX_PATH];
    TCHAR szMoveSrc[MAX_PATH];
    LPTSTR pszDestDirPointer;
    LPTSTR pszSrcDirPointer;
    INT nDirLevel = 0;
 
    LPTSTR pszFile;
    BOOL OnlyOneFile;
    BOOL FoundFile;
    BOOL MoveStatus;
    DWORD dwMoveFlags = 0;
    DWORD dwMoveStatusFlags = 0;
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
#if 0
        ConOutPuts (_T("Moves files and renames files and directories.\n\n"
            "To move one or more files:\n"
            "MOVE [/N][/Y|/-Y][drive:][path]filename1[,...] destination\n"
            "\n"
            "To rename a directory:\n"
            "MOVE [/N][/Y|/-Y][drive:][path]dirname1 dirname2\n"
            "\n"
            "  [drive:][path]filename1  Specifies the location and name of the file\n"
            "                           or files you want to move.\n"
            "  /N                       Nothing. Don everthing but move files or directories.\n"
            "  /Y\n"
            "  /-Y\n"
            "..."));
#else
        ConOutResPaging(TRUE,STRING_MOVE_HELP2);
#endif
        return 0;
    }
 
    nErrorLevel = 0;
    arg = splitspace(param, &argc);
 
    /* read options */
    for (i = 0; i < argc; i++)
    {
        if (!_tcsicmp(arg[i], _T("/N")))
            dwFlags |= MOVE_NOTHING;
        else if (!_tcsicmp(arg[i], _T("/Y")))
            dwFlags |= MOVE_OVER_YES;
        else if (!_tcsicmp(arg[i], _T("/-Y")))
            dwFlags |= MOVE_OVER_NO;
        else
            break;
    }
    nFiles = argc - i;
 
    if (nFiles < 1)
    {
        /* there must be at least one pathspec */
        error_req_param_missing();
        nErrorLevel = 1;
        goto Quit;
    }
 
    if (nFiles > 2)
    {
        /* there are more than two pathspecs */
        error_too_many_parameters(param);
        nErrorLevel = 1;
        goto Quit;
    }
 
    /* If no destination is given, default to current directory */
    pszDest = (nFiles == 1) ? _T(".") : arg[i + 1];
 
    /* check for wildcards in source and destination */
    if (_tcschr(pszDest, _T('*')) != NULL || _tcschr(pszDest, _T('?')) != NULL)
    {
        /* '*'/'?' in dest, this doesnt happen.  give folder name instead*/
        error_invalid_parameter_format(pszDest);
        nErrorLevel = 1;
        goto Quit;
    }
    if (_tcschr(arg[i], _T('*')) != NULL || _tcschr(arg[i], _T('?')) != NULL)
    {
        dwMoveStatusFlags |= MOVE_SOURCE_HAS_WILD;
    }
 
    /* get destination */
    GetFullPathName (pszDest, MAX_PATH, szDestPath, NULL);
    TRACE ("Destination: %s\n", debugstr_aw(szDestPath));
 
    /* get source folder */
    GetFullPathName(arg[i], MAX_PATH, szSrcDirPath, &pszFile);
    if (pszFile != NULL)
        *pszFile = _T('\0');
    TRACE ("Source Folder: %s\n", debugstr_aw(szSrcDirPath));
 
    hFile = FindFirstFile (arg[i], &findBuffer);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        ErrorMessage(GetLastError(), arg[i]);
        nErrorLevel = 1;
        goto Quit;
    }
 
    /* check for special cases "." and ".." and if found skip them */
    FoundFile = TRUE;
    while(FoundFile &&
          (_tcscmp(findBuffer.cFileName,_T(".")) == 0 ||
           _tcscmp(findBuffer.cFileName,_T("..")) == 0))
        FoundFile = FindNextFile (hFile, &findBuffer);
 
    if (!FoundFile)
    {
        /* what? we don't have anything to move? */
        error_file_not_found();
        FindClose(hFile);
        nErrorLevel = 1;
        goto Quit;
    }
 
    OnlyOneFile = TRUE;
    /* check if there can be found files as files have first priority */
    if (findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        dwMoveStatusFlags |= MOVE_SOURCE_IS_DIR;
    else
        dwMoveStatusFlags |= MOVE_SOURCE_IS_FILE;
    while(OnlyOneFile && FindNextFile(hFile,&findBuffer))
    {
        if (!(findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            ConOutPrintf(_T(""));
            if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE) OnlyOneFile = FALSE;
            else
            {   /* this has been done this way so that we don't disturb other settings if they have been set before this */
                dwMoveStatusFlags |= MOVE_SOURCE_IS_FILE;
                dwMoveStatusFlags &= ~MOVE_SOURCE_IS_DIR;
            }
        }
    }
    FindClose(hFile);
 
    TRACE ("Do we have only one file: %s\n", OnlyOneFile ? "TRUE" : "FALSE");
 
    /* we have to start again to be sure we don't miss any files or folders*/
    hFile = FindFirstFile (arg[i], &findBuffer);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        ErrorMessage(GetLastError(), arg[i]);
        nErrorLevel = 1;
        goto Quit;
    }
 
    /* check for special cases "." and ".." and if found skip them */
    FoundFile = TRUE;
    while(FoundFile &&
          (_tcscmp(findBuffer.cFileName,_T(".")) == 0 ||
           _tcscmp(findBuffer.cFileName,_T("..")) == 0))
        FoundFile = FindNextFile (hFile, &findBuffer);
 
    if (!FoundFile)
    {
        /* huh? somebody removed files and/or folders which were there */
        error_file_not_found();
        FindClose(hFile);
        nErrorLevel = 1;
        goto Quit;
    }
 
    /* check if source and destination paths are on different volumes */
    if (szSrcDirPath[0] != szDestPath[0])
        dwMoveStatusFlags |= MOVE_PATHS_ON_DIF_VOL;
 
    /* move it */
    do
    {
        TRACE ("Found file/directory: %s\n", debugstr_aw(findBuffer.cFileName));
        nOverwrite = 1;
        dwMoveFlags = 0;
        dwMoveStatusFlags &= ~MOVE_DEST_IS_FILE &
                            ~MOVE_DEST_IS_DIR &
                            ~MOVE_SRC_CURRENT_IS_DIR &
                            ~MOVE_DEST_EXISTS;
        _tcscpy(szFullSrcPath,szSrcDirPath);
        if (szFullSrcPath[_tcslen(szFullSrcPath) -  1] != _T('\\'))
            _tcscat (szFullSrcPath, _T("\\"));
        _tcscat(szFullSrcPath,findBuffer.cFileName);
        _tcscpy(szSrcPath, szFullSrcPath);
 
        if (IsExistingDirectory(szSrcPath))
        {
            /* source is directory */
            if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE)
            {
                dwMoveStatusFlags |= MOVE_SRC_CURRENT_IS_DIR; /* source is file but at the current round we found a directory */
                continue;
            }
            TRACE ("Source is dir: %s\n", debugstr_aw(szSrcPath));
            dwMoveFlags = MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
        }
 
        /* if source is file we don't need to do anything special */
        if (IsExistingDirectory(szDestPath))
        {
            /* destination is existing directory */
            TRACE ("Destination is directory: %s\n", debugstr_aw(szDestPath));
 
            dwMoveStatusFlags |= MOVE_DEST_IS_DIR;
 
            /*build the dest string(accounts for *)*/
            _tcscpy (szFullDestPath, szDestPath);
            /*check to see if there is an ending slash, if not add one*/
            if (szFullDestPath[_tcslen(szFullDestPath) -  1] != _T('\\'))
                _tcscat (szFullDestPath, _T("\\"));
            _tcscat (szFullDestPath, findBuffer.cFileName);
 
            if (IsExistingFile(szFullDestPath) || IsExistingDirectory(szFullDestPath))
                dwMoveStatusFlags |= MOVE_DEST_EXISTS;
 
            dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
        }
        if (IsExistingFile(szDestPath))
        {
            /* destination is a file */
            TRACE ("Destination is file: %s\n", debugstr_aw(szDestPath));
 
            dwMoveStatusFlags |= MOVE_DEST_IS_FILE | MOVE_DEST_EXISTS;
            _tcscpy (szFullDestPath, szDestPath);
 
            dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
        }
 
        TRACE ("Move Status Flags: 0x%X\n",dwMoveStatusFlags);
 
        if (dwMoveStatusFlags & MOVE_SOURCE_IS_DIR &&
            dwMoveStatusFlags & MOVE_DEST_IS_DIR &&
            dwMoveStatusFlags & MOVE_SOURCE_HAS_WILD)
        {
            /* We are not allowed to have existing source and destination dir when there is wildcard in source */
            error_syntax(NULL);
            FindClose(hFile);
            nErrorLevel = 1;
            goto Quit;
        }
        if (!(dwMoveStatusFlags & (MOVE_DEST_IS_FILE | MOVE_DEST_IS_DIR)))
        {
            /* destination doesn't exist */
            _tcscpy (szFullDestPath, szDestPath);
            if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE) dwMoveStatusFlags |= MOVE_DEST_IS_FILE;
            if (dwMoveStatusFlags & MOVE_SOURCE_IS_DIR) dwMoveStatusFlags |= MOVE_DEST_IS_DIR;
 
            dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
        }
 
        if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE &&
            dwMoveStatusFlags & MOVE_DEST_IS_FILE &&
            !OnlyOneFile)
        {
            /*source has many files but there is only one destination file*/
            error_invalid_parameter_format(pszDest);
            FindClose(hFile);
            nErrorLevel = 1;
            goto Quit;
        }
 
        /*checks to make sure user wanted/wants the override*/
        if ((dwFlags & MOVE_OVER_NO) &&
           (dwMoveStatusFlags & MOVE_DEST_EXISTS))
            continue;
        if (!(dwFlags & MOVE_OVER_YES) &&
            (dwMoveStatusFlags & MOVE_DEST_EXISTS))
            nOverwrite = MoveOverwrite (szFullDestPath);
        if (nOverwrite == PROMPT_NO || nOverwrite == PROMPT_BREAK)
            continue;
        if (nOverwrite == PROMPT_ALL)
            dwFlags |= MOVE_OVER_YES;
 
        ConOutPrintf (_T("%s => %s "), szSrcPath, szFullDestPath);
 
        /* are we really supposed to do something */
        if (dwFlags & MOVE_NOTHING)
            continue;
 
        /*move the file*/
        if (!(dwMoveStatusFlags & MOVE_SOURCE_IS_DIR &&
            dwMoveStatusFlags & MOVE_PATHS_ON_DIF_VOL))
            /* we aren't moving source folder to different drive */
            MoveStatus = MoveFileEx (szSrcPath, szFullDestPath, dwMoveFlags);
        else
        {   /* we are moving source folder to different drive */
            _tcscpy(szMoveDest, szFullDestPath);
            _tcscpy(szMoveSrc, szSrcPath);
            DeleteFile(szMoveDest);
            MoveStatus = CreateDirectory(szMoveDest, NULL); /* we use default security settings */
            if (MoveStatus)
            {
                _tcscat(szMoveDest,_T("\\"));
                _tcscat(szMoveSrc,_T("\\"));
                nDirLevel = 0;
                pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
                pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
                _tcscpy(pszSrcDirPointer,_T("*.*"));
                hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
                if (hDestFile == INVALID_HANDLE_VALUE)
                    MoveStatus = FALSE;
                else
                {
                    BOOL FirstTime = TRUE;
                    FoundFile = TRUE;
                    MoveStatus = FALSE;
                    while(FoundFile)
                    {
                        if (FirstTime)
                            FirstTime = FALSE;
                        else
                            FoundFile = FindNextFile (hDestFile, &findDestBuffer);
 
                        if (!FoundFile)
                        {
                            /* Nothing to do in this folder so we stop working on it */
                            FindClose(hDestFile);
                            (pszSrcDirPointer)--;
                            (pszDestDirPointer)--;
                            _tcscpy(pszSrcDirPointer,_T(""));
                            _tcscpy(pszDestDirPointer,_T(""));
                            if (nDirLevel > 0)
                            {
                                TCHAR szTempPath[MAX_PATH];
                                INT_PTR nDiff;
 
                                FoundFile = TRUE; /* we need to continue our seek for files */
                                nDirLevel--;
                                RemoveDirectory(szMoveSrc);
                                GetDirectory(szMoveSrc,szTempPath,0);
                                nDiff = _tcslen(szMoveSrc) - _tcslen(szTempPath);
                                pszSrcDirPointer = pszSrcDirPointer - nDiff;
                                _tcscpy(pszSrcDirPointer,_T(""));
                                GetDirectory(szMoveDest,szTempPath,0);
                                nDiff = _tcslen(szMoveDest) - _tcslen(szTempPath);
                                pszDestDirPointer = pszDestDirPointer - nDiff;
                                _tcscpy(pszDestDirPointer,_T(""));
                                if (szMoveSrc[_tcslen(szMoveSrc) -  1] != _T('\\'))
                                    _tcscat (szMoveSrc, _T("\\"));
                                if (szMoveDest[_tcslen(szMoveDest) -  1] != _T('\\'))
                                    _tcscat (szMoveDest, _T("\\"));
                                pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
                                pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
                                _tcscpy(pszSrcDirPointer,_T("*.*"));
                                hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
                                if (hDestFile == INVALID_HANDLE_VALUE)
                                    continue;
                                FirstTime = TRUE;
                            }
                            else
                            {
                                MoveStatus = TRUE; /* we moved everything so lets tell user about it */
                                RemoveDirectory(szMoveSrc);
                            }
                            continue;
                        }
 
                        /* if we find "." or ".." we'll skip them */
                        if (_tcscmp(findDestBuffer.cFileName,_T(".")) == 0 ||
                            _tcscmp(findDestBuffer.cFileName,_T("..")) == 0)
                            continue;
 
                        _tcscpy(pszSrcDirPointer, findDestBuffer.cFileName);
                        _tcscpy(pszDestDirPointer, findDestBuffer.cFileName);
                        if (IsExistingFile(szMoveSrc))
                        {
                            FoundFile = CopyFile(szMoveSrc, szMoveDest, FALSE);
                            if (!FoundFile) continue;
                            DeleteFile(szMoveSrc);
                        }
                        else
                        {
                            FindClose(hDestFile);
                            CreateDirectory(szMoveDest, NULL);
                            _tcscat(szMoveDest,_T("\\"));
                            _tcscat(szMoveSrc,_T("\\"));
                            nDirLevel++;
                            pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
                            pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
                            _tcscpy(pszSrcDirPointer,_T("*.*"));
                            hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
                            if (hDestFile == INVALID_HANDLE_VALUE)
                            {
                                FoundFile = FALSE;
                                continue;
                            }
                            FirstTime = TRUE;
                        }
                    }
                }
            }
        }
 
        if (MoveStatus)
        {
            ConOutResPrintf(STRING_MOVE_ERROR1);
        }
        else
        {
            ConOutResPrintf(STRING_MOVE_ERROR2);
            nErrorLevel = 1;
        }
    }
    while ((!OnlyOneFile || dwMoveStatusFlags & MOVE_SRC_CURRENT_IS_DIR ) &&
            !(dwMoveStatusFlags & MOVE_SOURCE_IS_DIR) &&
            FindNextFile (hFile, &findBuffer));
    FindClose (hFile);
 
    if(hDestFile && hDestFile != INVALID_HANDLE_VALUE)
        FindClose(hDestFile);
 
Quit:
    freep(arg);
    return nErrorLevel;
}

◆ cmd_path()

INT cmd_path ( LPTSTR param )

Definition at line 36 of file path.c.

{
    INT retval = 0;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_PATH_HELP1);
        return 0;
    }
 
    /* If param is empty, display the PATH environment variable */
    if (!param || !*param)
    {
        DWORD  dwBuffer;
        LPTSTR pszBuffer;
 
        pszBuffer = (LPTSTR)cmd_alloc(ENV_BUFFER_SIZE * sizeof(TCHAR));
        if (!pszBuffer)
        {
            WARN("Cannot allocate memory for pszBuffer!\n");
            error_out_of_memory();
            retval = 1;
            goto Quit;
        }
 
        dwBuffer = GetEnvironmentVariable(_T("PATH"), pszBuffer, ENV_BUFFER_SIZE);
        if (dwBuffer == 0)
        {
            cmd_free(pszBuffer);
            ConErrResPrintf(STRING_SET_ENV_ERROR, _T("PATH"));
            retval = 0;
            goto Quit;
        }
        else if (dwBuffer > ENV_BUFFER_SIZE)
        {
            LPTSTR pszOldBuffer = pszBuffer;
            pszBuffer = (LPTSTR)cmd_realloc(pszBuffer, dwBuffer * sizeof (TCHAR));
            if (!pszBuffer)
            {
                WARN("Cannot reallocate memory for pszBuffer!\n");
                error_out_of_memory();
                cmd_free(pszOldBuffer);
                retval = 1;
                goto Quit;
            }
            GetEnvironmentVariable(_T("PATH"), pszBuffer, dwBuffer);
        }
 
        ConOutPrintf(_T("PATH=%s\n"), pszBuffer);
        cmd_free(pszBuffer);
 
        retval = 0;
        goto Quit;
    }
 
    /* Skip leading '=' */
    if (*param == _T('='))
        param++;
 
    /* Set PATH environment variable */
    if (!SetEnvironmentVariable(_T("PATH"), param))
    {
        retval = 1;
    }
 
Quit:
    if (BatType != CMD_TYPE)
    {
        if (retval != 0)
            nErrorLevel = retval;
    }
    else
    {
        nErrorLevel = retval;
    }
 
    return retval;
}

Referenced by RunShell().

◆ cmd_pause()

int cmd_pause ( TCHAR * )

◆ cmd_prompt()

INT cmd_prompt ( LPTSTR param )

Definition at line 260 of file prompt.c.

{
    INT retval = 0;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_PROMPT_HELP1);
#ifdef FEATURE_DIRECTORY_STACK
        ConOutResPaging(FALSE, STRING_PROMPT_HELP2);
#endif
        ConOutResPaging(FALSE, STRING_PROMPT_HELP3);
        return 0;
    }
 
    /*
     * Set the PROMPT environment variable. If 'param' is NULL or is
     * an empty string (the user entered "prompt" only), then remove
     * the environment variable and therefore use the default prompt.
     * Otherwise, use the new prompt.
     */
    if (!SetEnvironmentVariable(_T("PROMPT"),
                                (param && param[0] != _T('\0') ? param : NULL)))
    {
        retval = 1;
    }
 
    if (BatType != CMD_TYPE)
    {
        if (retval != 0)
            nErrorLevel = retval;
    }
    else
    {
        nErrorLevel = retval;
    }
 
    return retval;
}

◆ cmd_rename()

INT cmd_rename ( LPTSTR param )

Definition at line 53 of file ren.c.

{
    LPTSTR *arg = NULL;
    INT args = 0;
    INT nSlash = 0;
    INT nEvalArgs = 0; /* number of evaluated arguments */
    DWORD dwFlags = 0;
    DWORD dwFiles = 0; /* number of renamed files */
    INT i;
 
    LPTSTR srcPattern = NULL; /* Source Argument*/
    TCHAR srcPath[MAX_PATH]; /*Source Path Directories*/
    LPTSTR srcFILE = NULL;  /*Contains the files name(s)*/
    TCHAR srcFinal[MAX_PATH];
 
    LPTSTR dstPattern = NULL; /*Destiny Argument*/
    TCHAR dstPath[MAX_PATH]; /*Source Path Directories*/
    LPTSTR dstFILE = NULL; /*Contains the files name(s)*/
 
    TCHAR dstLast[MAX_PATH]; /*It saves the File name after unmasked with wildcards*/
    TCHAR dstFinal[MAX_PATH]; /*It saves the Final destiny Path*/
 
    BOOL bDstWildcard = FALSE;
    BOOL bPath = FALSE;
 
    LPTSTR p,q,r;
 
    HANDLE hFile;
    WIN32_FIND_DATA f;
    /*If the PARAM=/? then show the help*/
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_REN_HELP1);
        return 0;
    }
 
    nErrorLevel = 0;
 
    /* Split the argument list.Args will be saved in arg vector*/
    arg = split(param, &args, FALSE, FALSE);
 
    if (args < 2)
    {
        if (!(dwFlags & REN_ERROR))
            error_req_param_missing();
        freep(arg);
        return 1;
    }
 
    /* Read options */
    for (i = 0; i < args; i++)
    {
        /* Lets check if we have a special option chosen and set the flag(s)*/
        if (*arg[i] == _T('/'))
        {
            if (_tcslen(arg[i]) >= 2)
            {
                switch (_totupper(arg[i][1]))
                {
                    case _T('E'):
                    dwFlags |= REN_ERROR;
                    break;
 
                    case _T('N'):
                    dwFlags |= REN_NOTHING;
                    break;
 
                    case _T('P'):
                    dwFlags |= REN_PROMPT;
                    break;
 
                    case _T('Q'):
                    dwFlags |= REN_QUIET;
                    break;
 
                    case _T('S'):
                    dwFlags |= REN_SUBDIR;
                    break;
 
                    case _T('T'):
                    dwFlags |= REN_TOTAL;
                    break;
                }
            }
            nEvalArgs++;//Save the number of the options.
        }
    }
 
    /* keep quiet within batch files */
    if (bc != NULL)
        dwFlags |= REN_QUIET;
 
    /* there are only options on the command line --> error!!! */
    if (args < nEvalArgs + 2)
    {
        if (!(dwFlags & REN_ERROR))
            error_req_param_missing();
        freep(arg);
        return 1;
    }
 
    /* Get destination pattern and source pattern*/
    for (i = 0; i < args; i++)
    {
        if (*arg[i] == _T('/'))//We have find an Option.Jump it.
            continue;
        dstPattern = arg[i]; //we save the Last argument as dstPattern
        srcPattern = arg[i-1];
    }
 
    if (_tcschr(srcPattern, _T('\\')))  //Checking if the Source (srcPattern) is a Path to the file
    {
        bPath= TRUE;
 
        //Splitting srcPath and srcFile.
 
        srcFILE = _tcschr(srcPattern, _T('\\'));
        nSlash++;
        while(_tcschr(srcFILE, _T('\\')))
        {
            srcFILE++;
            if (*srcFILE==_T('\\')) nSlash++ ;
            if (!_tcschr(srcFILE, _T('\\'))) break;
        }
        _tcsncpy(srcPath,srcPattern,_tcslen(srcPattern)-_tcslen(srcFILE));
 
        if (_tcschr(dstPattern, _T('\\'))) //Checking if the Destiny (dstPattern)is also a Path.And splitting dstPattern in dstPath and srcPath.
        {
            dstFILE = _tcschr(dstPattern, _T('\\'));
            nSlash=0;
            while(_tcschr(dstFILE, _T('\\')))
            {
                dstFILE++;
                if (*dstFILE==_T('\\')) nSlash++ ;
                if (!_tcschr(dstFILE, _T('\\'))) break;
            }
            _tcsncpy(dstPath,dstPattern,_tcslen(dstPattern)-_tcslen(dstFILE));
 
            if ((_tcslen(dstPath)!=_tcslen(srcPath))||(_tcsncmp(srcPath,dstPath,_tcslen(srcPath))!=0)) //If it has a Path,then MUST be equal than srcPath
            {
                error_syntax(dstPath);
                freep(arg);
                return 1;
            }
        }
        else
        { //If Destiny hasnt a Path,then (MSDN says) srcPath is its Path.
            _tcscpy(dstPath,srcPath);
            dstFILE=dstPattern;
        }
    }
 
    if (!_tcschr(srcPattern, _T('\\'))) //If srcPattern isn't a Path but a name:
    {
        srcFILE=srcPattern;
        if (_tcschr(dstPattern, _T('\\')))
        {
            error_syntax(dstPattern);
            freep(arg);
            return 1;
        }
        else
        {
            dstFILE=dstPattern;
        }
    }
 
    //Checking Wildcards.
    if (_tcschr(dstFILE, _T('*')) || _tcschr(dstFILE, _T('?')))
        bDstWildcard = TRUE;
 
    TRACE("\n\nSourcePattern: %s SourcePath: %s SourceFile: %s", debugstr_aw(srcPattern),debugstr_aw(srcPath),debugstr_aw(srcFILE));
    TRACE("\n\nDestinationPattern: %s Destination Path:%s Destination File: %s\n", debugstr_aw(dstPattern),debugstr_aw(dstPath),debugstr_aw(dstFILE));
 
    hFile = FindFirstFile(srcPattern, &f);
 
    if (hFile == INVALID_HANDLE_VALUE)
    {
        if (!(dwFlags & REN_ERROR)) error_file_not_found();
    }
    do
    {
        /* ignore "." and ".." */
        if (!_tcscmp (f.cFileName, _T(".")) || !_tcscmp (f.cFileName, _T("..")))
            continue;
 
        /* do not rename hidden or system files */
        if (f.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM))
            continue;
 
        /* do not rename directories when the destination pattern contains
         * wildcards, unless option /S is used */
        if ((f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
            bDstWildcard && !(dwFlags & REN_SUBDIR))
        {
            continue;
        }
 
        TRACE("Found source name: %s\n", debugstr_aw(f.cFileName));
        /* So here we have splitted the dstFILE and we have find a f.cFileName(thanks to srcPattern)
         * Now we have to use the mask (dstFILE) (which can have Wildcards) with f.cFileName to find destination file name(dstLast) */
        p = f.cFileName;
        q = dstFILE;
        r = dstLast;
        while(*q != 0)
        {
            if (*q == '*')
            {
                q++;
                while (*p != 0 && *p != *q)
                {
                    *r = *p;
                    p++;
                    r++;
                }
            }
            else if (*q == '?')
            {
                q++;
                if (*p != 0)
                {
                    *r = *p;
                    p++;
                    r++;
                }
            }
            else
            {
                *r = *q;
                if (*p != 0) p++;
                q++;
                r++;
            }
        }
        *r = 0;
        //Well we have splitted the Paths,so now we have to paste them again(if needed),thanks bPath.
        if (bPath != FALSE)
        {
            _tcscpy(srcFinal,srcPath);
            _tcscat(srcFinal,f.cFileName);
            _tcscpy(dstFinal,dstPath);
            _tcscat(dstFinal,dstLast);
        }
        else
        {
            _tcscpy(srcFinal,f.cFileName);
            _tcscpy(dstFinal,dstLast);
        }
 
        TRACE("DestinationPath: %s\n", debugstr_aw(dstFinal));
 
        if (!(dwFlags & REN_QUIET) && !(dwFlags & REN_TOTAL))
            ConOutPrintf(_T("%s -> %s\n"),srcFinal , dstFinal);
 
        /* Rename the file */
        if (!(dwFlags & REN_NOTHING))
        {
            if (MoveFile(srcFinal, dstFinal))
            {
                dwFiles++;
            }
            else
            {
                if (!(dwFlags & REN_ERROR))
                    ConErrResPrintf(STRING_REN_ERROR, GetLastError());
            }
        }
    }
    while (FindNextFile(hFile, &f));
 
    //Closing and Printing errors.
    FindClose(hFile);
 
    if (!(dwFlags & REN_QUIET))
    {
        if (dwFiles == 1)
            ConOutResPrintf(STRING_REN_HELP2, dwFiles);
        else
            ConOutResPrintf(STRING_REN_HELP3, dwFiles);
    }
 
    freep(arg);
    return 0;
}

◆ cmd_replace()

INT cmd_replace ( LPTSTR )

◆ cmd_rmdir()

INT cmd_rmdir ( LPTSTR param )

Definition at line 521 of file internal.c.

{
    INT nError = 0;
    INT res;
    LPTSTR *arg;
    INT args;
    INT dirCount;
    INT i;
    TCHAR ch;
    BOOL bRecurseDir = FALSE;
    BOOL bQuiet = FALSE;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_RMDIR_HELP);
        return 0;
    }
 
    arg = split(param, &args, FALSE, FALSE);
    dirCount = 0;
 
    /* Check for options anywhere in command line */
    for (i = 0; i < args; i++)
    {
        if (*arg[i] == _T('/'))
        {
            /* Found an option, but check to make sure it has something after it */
            if (_tcslen(arg[i]) == 2)
            {
                ch = _totupper(arg[i][1]);
 
                if (ch == _T('S'))
                    bRecurseDir = TRUE;
                else if (ch == _T('Q'))
                    bQuiet = TRUE;
            }
        }
        else
        {
            dirCount++;
        }
    }
 
    if (dirCount == 0)
    {
        /* No folder to remove */
        error_req_param_missing();
        freep(arg);
        return 1;
    }
 
    for (i = 0; i < args; i++)
    {
        if (*arg[i] == _T('/'))
            continue;
 
        if (bRecurseDir)
        {
            /* Ask the user whether to delete everything in the folder */
            if (!bQuiet)
            {
                res = FilePromptYNA(STRING_DEL_HELP2);
                if (res == PROMPT_NO || res == PROMPT_BREAK)
                {
                    nError = 1;
                    continue;
                }
                if (res == PROMPT_ALL)
                    bQuiet = TRUE;
            }
 
            res = DeleteFolder(arg[i]);
        }
        else
        {
            /* Without /S, do not force directory deletion even if it's read-only */
            res = RemoveDirectory(arg[i]);
        }
 
        if (!res)
        {
            /* Couldn't delete the folder, print out the error */
            nError = GetLastError();
            ErrorMessage(nError, NULL);
        }
    }
 
    freep(arg);
    return nError;
}

◆ cmd_set()

INT cmd_set ( LPTSTR param )

Definition at line 72 of file set.c.

{
    INT retval = 0;
    LPTSTR p;
    LPTSTR lpEnv;
    LPTSTR lpOutput;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_SET_HELP);
        return 0;
    }
 
    param = (LPTSTR)skip_ws(param);
 
    /* If no parameters, show the environment */
    if (param[0] == _T('\0'))
    {
        lpEnv = (LPTSTR)GetEnvironmentStrings();
        if (lpEnv)
        {
            lpOutput = lpEnv;
            while (*lpOutput)
            {
                /* Do not display the special '=X:' environment variables */
                if (*lpOutput != _T('='))
                {
                    ConOutPuts(lpOutput);
                    ConOutChar(_T('\n'));
                }
                lpOutput += _tcslen(lpOutput) + 1;
            }
            FreeEnvironmentStrings(lpEnv);
        }
 
        retval = 0;
        goto Quit;
    }
 
    /* The /A does *NOT* have to be followed by a whitespace */
    if (!_tcsnicmp(param, _T("/A"), 2))
    {
        BOOL Success;
 
        /* Save error level since seta_eval() modifies it, as
         * we need to set it later according to specific rules. */
        INT nOldErrorLevel = nErrorLevel;
 
        StripQuotes(param);
        Success = seta_eval(skip_ws(param + 2));
        if (!Success)
        {
#if 0
            /* Might seem random but this is what windows xp does -- This is a message ID */
            retval = 9165;
#endif
            retval = nErrorLevel;
            nErrorLevel = nOldErrorLevel;
        }
        else
        {
            retval = 0;
        }
        goto Quit;
    }
 
    if (!_tcsnicmp(param, _T("/P"), 2))
    {
        TCHAR value[1023];
        param = GetQuotedString((LPTSTR)skip_ws(param + 2));
        p = _tcschr(param, _T('='));
        if (!p)
        {
            ConErrResPuts(STRING_SYNTAX_COMMAND_INCORRECT);
            retval = 1;
            goto Quit;
        }
 
        *p++ = _T('\0');
        ConOutPrintf(_T("%s"), GetQuotedString(p));
        ConInString(value, ARRAYSIZE(value));
 
        if (!*value || !SetEnvironmentVariable(param, value))
        {
            retval = 1;
            goto Quit;
        }
        retval = 0;
        goto Quit;
    }
 
    param = GetQuotedString(param);
 
    p = _tcschr(param, _T('='));
    if (p)
    {
        /* Set or remove the environment variable */
        if (p == param)
        {
            /* Handle set =val case */
            ConErrResPuts(STRING_SYNTAX_COMMAND_INCORRECT);
            retval = 1;
            goto Quit;
        }
 
        *p++ = _T('\0');
 
#ifdef FEATURE_DYNAMIC_TRACE
        /* Check for dynamic TRACE ON/OFF */
        if (!_tcsicmp(param, _T("CMDTRACE")))
            g_bDynamicTrace = !_tcsicmp(p, _T("ON"));
#endif
 
        if (!SetEnvironmentVariable(param, *p ? p : NULL))
        {
            retval = 1;
            goto Quit;
        }
    }
    else
    {
        /* Display all the environment variables with the given prefix */
        LPTSTR pOrgParam = param;
        BOOLEAN bFound = FALSE;
        BOOLEAN bRestoreSpace;
 
        /*
         * Trim the prefix from "special" characters (only when displaying the
         * environment variables), so that e.g. "SET ,; ,;FOO" will display all
         * the variables starting by "FOO".
         * The SET command allows as well to set an environment variable whose name
         * actually contains these characters (e.g. "SET ,; ,;FOO=42"); however,
         * by trimming the characters, doing "SET ,; ,;FOO" would not allow seeing
         * such variables.
         * Thus, we also save a pointer to the original variable name prefix, that
         * we will look it up as well below.
         */
        while (_istspace(*param) || *param == _T(',') || *param == _T(';'))
            ++param;
 
        /* Just remove the very last space, if present */
        p = _tcsrchr(param, _T(' '));
        bRestoreSpace = (p != NULL);
        if (!p)
            p = param + _tcslen(param);
        *p = _T('\0');
 
        lpEnv = GetEnvironmentStrings();
        if (lpEnv)
        {
            lpOutput = lpEnv;
            while (*lpOutput)
            {
                /* Look up for both the original and truncated variable name prefix */
                if (!_tcsnicmp(lpOutput, pOrgParam, p - pOrgParam) ||
                    !_tcsnicmp(lpOutput, param, p - param))
                {
                    ConOutPuts(lpOutput);
                    ConOutChar(_T('\n'));
                    bFound = TRUE;
                }
                lpOutput += _tcslen(lpOutput) + 1;
            }
            FreeEnvironmentStrings(lpEnv);
        }
 
        /* Restore the truncated space for correctly
         * displaying the error message, if any. */
        if (bRestoreSpace)
            *p = _T(' ');
 
        if (!bFound)
        {
            ConErrResPrintf(STRING_SET_ENV_ERROR, param);
            retval = 1;
            goto Quit;
        }
    }
 
Quit:
    if (BatType != CMD_TYPE)
    {
        if (retval != 0)
            nErrorLevel = retval;
    }
    else
    {
        nErrorLevel = retval;
    }
 
    return retval;
}

◆ cmd_setlocal()

INT cmd_setlocal ( LPTSTR param )

Definition at line 42 of file setlocal.c.

{
    PSETLOCAL Saved;
    LPTSTR* arg;
    INT argc, i;
 
    if (!_tcscmp(param, _T("/?")))
    {
        // FIXME
        ConOutPuts(_T("SETLOCAL help not implemented yet!\n"));
        return 0;
    }
 
    /* SETLOCAL only works inside a batch context */
    if (!bc)
        return 0;
 
    Saved = cmd_alloc(sizeof(SETLOCAL));
    if (!Saved)
    {
        WARN("Cannot allocate memory for Saved!\n");
        error_out_of_memory();
        return 1;
    }
 
    Saved->Environment = DuplicateEnvironment();
    if (!Saved->Environment)
    {
        error_out_of_memory();
        cmd_free(Saved);
        return 1;
    }
    /*
     * Save the current drive; the duplicated environment
     * contains the corresponding current directory.
     */
    Saved->CurDrive = _getdrive();
 
    Saved->EnableExtensions = bEnableExtensions;
    Saved->DelayedExpansion = bDelayedExpansion;
 
    Saved->Prev = bc->setlocal;
    bc->setlocal = Saved;
 
    nErrorLevel = 0;
 
    arg = splitspace(param, &argc);
    for (i = 0; i < argc; i++)
    {
        if (!_tcsicmp(arg[i], _T("ENABLEEXTENSIONS")))
            bEnableExtensions = TRUE;
        else if (!_tcsicmp(arg[i], _T("DISABLEEXTENSIONS")))
            bEnableExtensions = FALSE;
        else if (!_tcsicmp(arg[i], _T("ENABLEDELAYEDEXPANSION")))
            bDelayedExpansion = TRUE;
        else if (!_tcsicmp(arg[i], _T("DISABLEDELAYEDEXPANSION")))
            bDelayedExpansion = FALSE;
        else
        {
            error_invalid_parameter_format(arg[i]);
            break;
        }
    }
    freep(arg);
 
    return nErrorLevel;
}

◆ cmd_shift()

int cmd_shift ( TCHAR * )

◆ cmd_start()

INT cmd_start ( LPTSTR Rest )

Definition at line 37 of file start.c.

{
    TCHAR szFullName[CMDLINE_LENGTH];
    TCHAR szUnquotedName[CMDLINE_LENGTH];
    TCHAR *param = NULL;
    TCHAR *dot;
    INT size;
    LPTSTR comspec;
    BOOL bWait = FALSE;
    BOOL bBat  = FALSE;
    BOOL bCreate = FALSE;
    TCHAR szFullCmdLine[CMDLINE_LENGTH];
    PROCESS_INFORMATION prci;
    STARTUPINFO stui;
#ifdef UNICODE
    DWORD dwCreationFlags = CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT;
#else
    DWORD dwCreationFlags = CREATE_NEW_CONSOLE;
#endif
    DWORD dwAffinityMask = 0;
    LPTSTR lpTitle = NULL;
    LPTSTR lpDirectory = NULL;
    LPTSTR lpEnvironment = NULL;
    WORD wShowWindow = SW_SHOWNORMAL;
 
    while (1)
    {
        if (_istspace(*Rest))
        {
            Rest++;
        }
        else if (*Rest == _T('"') && !lpTitle)
        {
            lpTitle = GetParameter(&Rest);
            StripQuotes(lpTitle);
        }
        else if (*Rest == _T('/'))
        {
            LPTSTR option;
            Rest++;
            option = GetParameter(&Rest);
            if (*option == _T('?'))
            {
                ConOutResPaging(TRUE,STRING_START_HELP1);
                return 0;
            }
            else if (_totupper(*option) == _T('D'))
            {
                lpDirectory = option + 1;
                if (!*lpDirectory)
                {
                    while (_istspace(*Rest))
                        Rest++;
                    lpDirectory = GetParameter(&Rest);
                }
                StripQuotes(lpDirectory);
            }
            else if (_totupper(*option) == _T('I'))
            {
                /* rest of the option is apparently ignored */
                lpEnvironment = lpOriginalEnvironment;
            }
            else if (!_tcsicmp(option, _T("MIN")))
            {
                wShowWindow = SW_MINIMIZE;
            }
            else if (!_tcsicmp(option, _T("MAX")))
            {
                wShowWindow = SW_MAXIMIZE;
            }
            else if (!_tcsicmp(option, _T("AFFINITY")))
            {
                TCHAR *end;
                while (_istspace(*Rest))
                    Rest++;
                option = GetParameter(&Rest);
                /* Affinity mask is given in hexadecimal */
                dwAffinityMask = _tcstoul(option, &end, 16);
                if (*end != _T('\0') || dwAffinityMask == 0 ||
                    dwAffinityMask == (DWORD)-1)
                {
                    ConErrResPrintf(STRING_ERROR_INVALID_PARAM_FORMAT, option);
                    return 1;
                }
                dwCreationFlags |= CREATE_SUSPENDED;
            }
            else if (!_tcsicmp(option, _T("B")))
            {
                dwCreationFlags &= ~CREATE_NEW_CONSOLE;
                dwCreationFlags |= CREATE_NEW_PROCESS_GROUP;
            }
            else if (!_tcsicmp(option, _T("LOW")))
            {
                dwCreationFlags |= IDLE_PRIORITY_CLASS;
            }
            else if (!_tcsicmp(option, _T("NORMAL")))
            {
                dwCreationFlags |= NORMAL_PRIORITY_CLASS;
            }
            else if (!_tcsicmp(option, _T("HIGH")))
            {
                dwCreationFlags |= HIGH_PRIORITY_CLASS;
            }
            else if (!_tcsicmp(option, _T("REALTIME")))
            {
                dwCreationFlags |= REALTIME_PRIORITY_CLASS;
            }
            else if (!_tcsicmp(option, _T("ABOVENORMAL")))
            {
                dwCreationFlags |= ABOVE_NORMAL_PRIORITY_CLASS;
            }
            else if (!_tcsicmp(option, _T("BELOWNORMAL")))
            {
                dwCreationFlags |= BELOW_NORMAL_PRIORITY_CLASS;
            }
            else if (!_tcsicmp(option, _T("SEPARATE")))
            {
                dwCreationFlags |= CREATE_SEPARATE_WOW_VDM;
            }
            else if (!_tcsicmp(option, _T("SHARED")))
            {
                dwCreationFlags |= CREATE_SHARED_WOW_VDM;
            }
            else if (!_tcsicmp(option, _T("W")) ||
                     !_tcsicmp(option, _T("WAIT")))
            {
                bWait = TRUE;
            }
            else
            {
                ConErrResPrintf(STRING_TYPE_ERROR, option);
                return 0;
            }
        }
        else
        {
            /* It's not an option - must be the beginning of
             * the actual command. Leave the loop. */
            break;
        }
    }
 
    /* get comspec */
    comspec = cmd_alloc ( MAX_PATH * sizeof(TCHAR));
    if (!comspec)
    {
        WARN("Cannot allocate memory for start comspec!\n");
        error_out_of_memory();
        return 1;
    }
    SetLastError(0);
    size = GetEnvironmentVariable (_T("COMSPEC"), comspec, MAX_PATH);
    if (GetLastError() == ERROR_ENVVAR_NOT_FOUND)
    {
        _tcscpy(comspec, _T("cmd"));
    }
    else
    {
        if (size > MAX_PATH)
        {
            LPTSTR Oldcomspec = comspec;
            comspec = cmd_realloc(comspec,size * sizeof(TCHAR) );
            if (comspec==NULL)
            {
                cmd_free(Oldcomspec);
                return 1;
            }
            size = GetEnvironmentVariable (_T("COMSPEC"), comspec, size);
        }
    }
 
    nErrorLevel = 0;
 
    if (!*Rest)
    {
        Rest = _T("cmd.exe");
    }
    else
    /* Parsing the command that gets called by start, and it's parameters */
    {
        BOOL bInside = FALSE;
        INT i;
        /* find the end of the command and put the arguments in param */
        for (i = 0; Rest[i]; i++)
        {
            if (Rest[i] == _T('\"'))
                bInside = !bInside;
            if (_istspace(Rest[i]) && !bInside)
            {
                param = &Rest[i+1];
                Rest[i] = _T('\0');
                break;
            }
        }
    }
 
    _tcscpy(szUnquotedName, Rest);
    StripQuotes(szUnquotedName);
 
    /* get the PATH environment variable and parse it */
    /* search the PATH environment variable for the binary */
    if (SearchForExecutable(szUnquotedName, szFullName))
    {
        /* check if this is a .BAT or .CMD file */
        dot = _tcsrchr(szFullName, _T('.'));
        if (dot && (!_tcsicmp(dot, _T(".bat")) || !_tcsicmp(dot, _T(".cmd"))))
        {
            bBat = TRUE;
            _stprintf(szFullCmdLine, _T("\"%s\" /K %s"), comspec, Rest);
            TRACE ("[BATCH: %s %s]\n", debugstr_aw(szFullName), debugstr_aw(Rest));
        }
        else
        {
            TRACE ("[EXEC: %s %s]\n", debugstr_aw(szFullName), debugstr_aw(Rest));
            _tcscpy(szFullCmdLine, szFullName);
        }
 
        /* build command line for CreateProcess() */
        if (param != NULL)
        {
            _tcsncat(szFullCmdLine, _T(" "), CMDLINE_LENGTH - _tcslen(szFullCmdLine));
            _tcsncat(szFullCmdLine, param, CMDLINE_LENGTH - _tcslen(szFullCmdLine));
        }
 
        /* fill startup info */
        memset (&stui, 0, sizeof (STARTUPINFO));
        stui.cb = sizeof (STARTUPINFO);
        stui.dwFlags = STARTF_USESHOWWINDOW;
        stui.lpTitle = lpTitle;
        stui.wShowWindow = wShowWindow;
 
        bCreate = CreateProcess(bBat ? comspec : szFullName,
                                szFullCmdLine, NULL, NULL, TRUE, dwCreationFlags,
                                lpEnvironment, lpDirectory, &stui, &prci);
        if (bCreate)
        {
            if (dwAffinityMask)
            {
                SetProcessAffinityMask(prci.hProcess, dwAffinityMask);
                ResumeThread(prci.hThread);
            }
            CloseHandle(prci.hThread);
        }
    }
    else
    {
        /* The file name did not seem to be valid, but maybe it's actually a
         * directory or URL, so we still want to pass it to ShellExecute. */
        _tcscpy(szFullName, szUnquotedName);
    }
 
    if (!bCreate)
    {
        /* CreateProcess didn't work; try ShellExecute */
        DWORD flags = SEE_MASK_NOCLOSEPROCESS;
        if (!(dwCreationFlags & CREATE_NEW_CONSOLE))
            flags |= SEE_MASK_NO_CONSOLE;
        prci.hProcess = RunFile(flags, szFullName, param, lpDirectory, wShowWindow);
    }
 
    if (prci.hProcess != NULL)
    {
        if (bWait)
        {
            DWORD dwExitCode;
            WaitForSingleObject (prci.hProcess, INFINITE);
            GetExitCodeProcess (prci.hProcess, &dwExitCode);
            nErrorLevel = (INT)dwExitCode;
        }
        CloseHandle (prci.hProcess);
 
        /* Update the local code page cache */
        {
            UINT uNewInputCodePage  = GetConsoleCP();
            UINT uNewOutputCodePage = GetConsoleOutputCP();
 
            if ((InputCodePage  != uNewInputCodePage) ||
                (OutputCodePage != uNewOutputCodePage))
            {
                InputCodePage  = uNewInputCodePage;
                OutputCodePage = uNewOutputCodePage;
 
                /* Reset the current thread UI language */
                if (IsConsoleHandle(ConStreamGetOSHandle(StdOut)) ||
                    IsConsoleHandle(ConStreamGetOSHandle(StdErr)))
                {
                    ConSetThreadUILanguage(0);
                }
                /* Update the streams cached code page */
                ConStdStreamsSetCacheCodePage(InputCodePage, OutputCodePage);
 
                /* Update the locale as well */
                InitLocale();
            }
        }
    }
    else
    {
        ErrorMessage(GetLastError (),
                      _T("Error executing CreateProcess()!!\n"));
    }
 
    cmd_free(comspec);
    return 0;
}

◆ cmd_time()

INT cmd_time ( LPTSTR param )

Definition at line 132 of file time.c.

{
    LPTSTR* arg;
    INT argc;
    INT i;
    INT nTimeString = -1;
    TCHAR szTime[40];
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_TIME_HELP1);
        return 0;
    }
 
    nErrorLevel = 0;
 
    /* Build the parameter array */
    arg = split(param, &argc, FALSE, FALSE);
 
    /* Check for options */
    for (i = 0; i < argc; i++)
    {
        if (bEnableExtensions && (_tcsicmp(arg[i], _T("/T")) == 0))
        {
            /* Display current time in short format */
            SYSTEMTIME st;
            GetLocalTime(&st);
            FormatTime(szTime, &st);
            ConOutPrintf(_T("%s\n"), szTime);
            freep(arg);
            return 0;
        }
 
        if ((*arg[i] != _T('/')) && (nTimeString == -1))
            nTimeString = i;
    }
 
    if (nTimeString == -1)
    {
        ConOutResPuts(STRING_TIME_NOW);
        ConOutPrintf(_T("%s\n"), GetTimeString());
    }
 
    while (TRUE)
    {
        if (nTimeString == -1)
        {
            ConOutResPuts(STRING_TIME_HELP2);
            ConInString(szTime, ARRAYSIZE(szTime));
 
            TRACE("\'%s\'\n", debugstr_aw(szTime));
 
            while (*szTime && szTime[_tcslen(szTime) - 1] < _T(' '))
                szTime[_tcslen(szTime) - 1] = _T('\0');
 
            if (ParseTime(szTime))
            {
                freep(arg);
                return 0;
            }
        }
        else
        {
            if (ParseTime(arg[nTimeString]))
            {
                freep(arg);
                return 0;
            }
 
            /* Force input the next time around */
            nTimeString = -1;
        }
 
        ConErrResPuts(STRING_TIME_ERROR);
        nErrorLevel = 1;
    }
 
    freep(arg);
    return 0;
}

Referenced by Initialize().

◆ cmd_title()

INT cmd_title ( LPTSTR param )

Definition at line 18 of file title.c.

{
    /* Do nothing if no args */
    if (*param == _T('\0'))
        return 0;
 
    /* Asking help? */
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_TITLE_HELP);
        return 0;
    }
 
    /* Set the new console title, and tell CMD to not reset it */
    bTitleSet = FALSE;
    return ConSetTitle(param);
}

◆ cmd_type()

INT cmd_type ( LPTSTR param )

Definition at line 221 of file type.c.

{
    INT argc, i;
    LPTSTR* argv;
    LPTSTR errmsg;
    HANDLE hConsoleOut;
    BOOL bNoFileName = FALSE;
    BOOL bPaging = FALSE;
    BOOL bFileFound;
    DWORD dwLastError;
    UINT nFileSpecs = 0;
    HANDLE hFind;
    WIN32_FIND_DATA FindData;
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_TYPE_HELP1);
        return 0;
    }
 
    if (!*param)
    {
        error_req_param_missing();
        return 1;
    }
 
    /* Parse the command line. We will manually expand any file specification present. */
    argv = split(param, &argc, FALSE, FALSE);
 
    /* Loop through the options, count also the specified number of file specifications */
    for (i = 0; i < argc; ++i)
    {
        if (argv[i][0] == _T('/'))
        {
            if (_tcslen(argv[i]) == 2)
            {
                switch (_totupper(argv[i][1]))
                {
                case _T('N'):
                    bNoFileName = TRUE;
                    continue;
 
                case _T('P'):
                    bPaging = TRUE;
                    continue;
                }
            }
 
            // error_invalid_switch(argv[i] + 1);
            ConErrResPrintf(STRING_TYPE_ERROR, argv[i] + 1);
            nErrorLevel = 1;
            goto Quit;
        }
 
        /* This should be a file specification */
        ++nFileSpecs;
    }
 
    nErrorLevel = 0;
 
    hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
 
    /* Reset paging state */
    if (bPaging)
        ConOutPrintfPaging(TRUE, _T(""));
 
    /* Now loop through the files */
    for (i = 0; i < argc; ++i)
    {
        /* Skip the options */
        if (argv[i][0] == _T('/'))
            continue;
 
        /* If wildcards are present in this file specification, perform a file enumeration */
        if (_tcschr(argv[i], _T('*')) || _tcschr(argv[i], _T('?')))
        {
            dwLastError = ERROR_SUCCESS;
            bFileFound = FALSE;
 
            hFind = FindFirstFile(argv[i], &FindData);
 
            if (hFind != INVALID_HANDLE_VALUE)
            {
                /* Loop through all the files */
                do
                {
                    /* Ignore any directory silently */
                    if (!_tcscmp(FindData.cFileName, _T("."))  ||
                        !_tcscmp(FindData.cFileName, _T("..")) ||
                        (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
                    {
                        continue;
                    }
 
                    bFileFound = TRUE;
                    if (!DoTypeFile(FindData.cFileName, hConsoleOut, bNoFileName, bPaging))
                    {
                        FindClose(hFind);
                        goto Quit;
                    }
 
                } while (FindNextFile(hFind, &FindData));
 
                FindClose(hFind);
            }
 
            /*
             * Return an error if the file specification could not be resolved,
             * or no actual files were encountered (but only directories).
             */
            if (hFind == INVALID_HANDLE_VALUE)
                dwLastError = GetLastError();
            else if (!bFileFound)
                dwLastError = ERROR_FILE_NOT_FOUND;
 
            if (dwLastError != ERROR_SUCCESS)
            {
                // FIXME: Use ErrorMessage() ?
                FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                              FORMAT_MESSAGE_IGNORE_INSERTS |
                              FORMAT_MESSAGE_FROM_SYSTEM,
                              NULL,
                              dwLastError,
                              MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                              (LPTSTR)&errmsg,
                              0,
                              NULL);
                ConErrPrintf(_T("%s - %s"), argv[i], errmsg);
                LocalFree(errmsg);
                nErrorLevel = 1;
            }
        }
        else
        {
            if (!DoTypeFile(argv[i], hConsoleOut, (bNoFileName || (nFileSpecs <= 1)), bPaging))
                goto Quit;
        }
 
        /* Continue with the next file specification */
    }
 
Quit:
    freep(argv);
    return nErrorLevel;
}

Referenced by client_dde_callback().

◆ cmd_ver()

INT cmd_ver ( LPTSTR param )

Definition at line 126 of file ver.c.

{
    INT i;
 
    nErrorLevel = 0;
 
    if (_tcsstr(param, _T("/?")) != NULL)
    {
        ConOutResPaging(TRUE,STRING_VERSION_HELP1);
        return 0;
    }
 
    ConOutResPrintf(STRING_CMD_SHELLINFO, _T(KERNEL_VERSION_STR), _T(KERNEL_VERSION_BUILD_STR));
    ConOutChar(_T('\n'));
    ConOutResPuts(STRING_VERSION_RUNNING_ON);
    PrintOSVersion();
 
    /* Basic copyright notice */
    if (param[0] != _T('\0'))
    {
        ConOutPuts(_T("\n\n"));
        ConOutPuts(_T("Copyright (C) 1994-1998 Tim Norman and others.\n"));
        ConOutResPrintf(STRING_CMD_COPYRIGHT, _T(COPYRIGHT_YEAR));
 
        for (i = 0; param[i]; i++)
        {
            /* Skip spaces */
            if (param[i] == _T(' '))
                continue;
 
            if (param[i] == _T('/'))
            {
                /* Is this a lone '/' ? */
                if (param[i + 1] == 0)
                {
                    error_invalid_switch(_T(' '));
                    return 1;
                }
                continue;
            }
 
            if (_totupper(param[i]) == _T('W'))
            {
                /* Warranty notice */
                ConOutResPuts(STRING_VERSION_HELP3);
            }
            else if (_totupper(param[i]) == _T('R'))
            {
                /* Redistribution notice */
                ConOutResPuts(STRING_VERSION_HELP4);
            }
            else if (_totupper(param[i]) == _T('C'))
            {
                /* Developer listing */
                ConOutResPuts(STRING_VERSION_HELP6);
                ConOutResPuts(STRING_FREEDOS_DEV);
                ConOutResPuts(STRING_VERSION_HELP7);
                ConOutResPuts(STRING_REACTOS_DEV);
            }
            else
            {
                error_invalid_switch(_totupper(param[i]));
                return 1;
            }
        }
 
        /* Bug report notice */
        ConOutResPuts(STRING_VERSION_HELP5);
    }
 
    ConOutChar(_T('\n'));
 
    return 0;
}

◆ cmd_verify()

INT cmd_verify ( LPTSTR param )

Definition at line 30 of file verify.c.

{
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_VERIFY_HELP1);
        return 0;
    }
 
    if (!OnOffCommand(param, &bVerify, STRING_VERIFY_HELP2))
    {
        ConErrResPuts(STRING_VERIFY_HELP3);
        return nErrorLevel = 1;
    }
 
    return nErrorLevel = 0;
}

◆ cmd_vol()

INT cmd_vol ( LPTSTR param )

Definition at line 64 of file vol.c.

{
    TCHAR szRootPath[] = _T("A:\\");
    TCHAR szPath[MAX_PATH];
 
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_VOL_HELP4);
        return 0;
    }
 
    nErrorLevel = 0;
 
    if (param[0] == _T('\0'))
    {
        GetCurrentDirectory(MAX_PATH, szPath);
        szRootPath[0] = szPath[0];
    }
    else
    {
        _tcsupr (param);
        if (param[1] == _T(':'))
        {
            szRootPath[0] = param[0];
        }
        else
        {
            error_invalid_drive ();
            nErrorLevel = 1;
            return 1;
        }
    }
 
    if (!IsValidPathName (szRootPath))
    {
        error_invalid_drive ();
        nErrorLevel = 1;
        return 1;
    }
 
    /* print the header */
    if (!PrintVolumeHeader (szRootPath))
    {
        nErrorLevel = 1;
        return 1;
    }
 
    return 0;
}

◆ CommandActivate()

INT CommandActivate ( LPTSTR )

◆ CommandAlias()

INT CommandAlias ( LPTSTR param )

Definition at line 174 of file alias.c.

{
    LPTSTR ptr;
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_ALIAS_HELP);
        return 0;
    }
 
    nErrorLevel = 0;
 
    if (param[0] == _T('\0'))
    {
        PrintAlias ();
        return 0;
    }
 
    nErrorLevel = 0;
 
    /* error if no '=' found */
    if ((ptr = _tcschr (param, _T('='))) == 0)
    {
        nErrorLevel = 1;
        return 1;
    }
 
    /* Split rest into name and substitute */
    *ptr++ = _T('\0');
 
    partstrlwr (param);
 
    if (ptr[0] == _T('\0'))
        AddConsoleAlias(param, NULL, _T("cmd.exe"));
    else
        AddConsoleAlias(param, ptr, _T("cmd.exe"));
 
    return 0;
}

◆ CommandAssoc()

INT CommandAssoc ( LPTSTR param )

Definition at line 238 of file assoc.c.

{
    INT retval = 0;
    PTCHAR pEqualSign;
 
    /* Print help */
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_ASSOC_HELP);
        return 0;
    }
 
    /* Print all associations if no parameter has been specified */
    if (!*param)
    {
        PrintAllAssociations();
        goto Quit;
    }
 
    pEqualSign = _tcschr(param, _T('='));
    if (pEqualSign != NULL)
    {
        PTSTR pszFileType = pEqualSign + 1;
 
        /* NULL-terminate at the equals sign */
        *pEqualSign = 0;
 
        /* If the equals sign is the last character
         * in the string, delete the association. */
        if (*pszFileType == 0)
        {
            retval = RemoveAssociation(param);
        }
        else
        /* Otherwise, add the association and print it out */
        {
            retval = AddAssociation(param, pszFileType);
            PrintAssociation(param);
        }
 
        if (retval != ERROR_SUCCESS)
        {
            if (retval != ERROR_FILE_NOT_FOUND)
            {
                ConErrResPrintf(STRING_ERROR_WHILE_PROCESSING, param);
            }
            // retval = 1; /* Fixup the error value */
        }
    }
    else
    {
        /* No equals sign, print the association */
        retval = PrintAssociation(param);
        if (retval != ERROR_SUCCESS)
        {
            ConErrResPrintf(STRING_ASSOC_ERROR, param);
            retval = 1; /* Fixup the error value */
        }
    }
 
Quit:
    if (BatType != CMD_TYPE)
    {
        if (retval != 0)
            nErrorLevel = retval;
    }
    else
    {
        nErrorLevel = retval;
    }
 
    return retval;
}

◆ CommandChoice()

INT CommandChoice ( LPTSTR param )

Definition at line 102 of file choice.c.

{
    LPTSTR lpOptions;
    TCHAR Options[6];
    LPTSTR lpText    = NULL;
    BOOL   bNoPrompt = FALSE;
    BOOL   bCaseSensitive = FALSE;
    BOOL   bTimeout = FALSE;
    INT    nTimeout = 0;
    TCHAR  cDefault = _T('\0');
    INPUT_RECORD ir;
    LPTSTR p, np;
    LPTSTR *arg;
    INT    argc;
    INT    i;
    INT    val;
 
    INT GCret;
    TCHAR Ch;
    DWORD amount,clk;
 
    LoadString(CMD_ModuleHandle, STRING_CHOICE_OPTION, Options, 4);
    lpOptions = Options;
 
    if (_tcsncmp (param, _T("/?"), 2) == 0)
    {
        ConOutResPaging(TRUE,STRING_CHOICE_HELP);
        return 0;
    }
 
    /* retrieve text */
    p = param;
 
    while (TRUE)
    {
        if (*p == _T('\0'))
            break;
 
        if (*p != _T('/'))
        {
            lpText = p;
                break;
        }
        np = _tcschr (p, _T(' '));
        if (!np)
            break;
        p = np + 1;
    }
 
    /* build parameter array */
    arg = split (param, &argc, FALSE, FALSE);
 
    /* evaluate arguments */
    if (argc > 0)
    {
        for (i = 0; i < argc; i++)
        {
            if (_tcsnicmp (arg[i], _T("/c"), 2) == 0)
            {
                if (arg[i][2] == _T(':'))
                    lpOptions = &arg[i][3];
                else
                    lpOptions = &arg[i][2];
 
                if (_tcslen (lpOptions) == 0)
                {
                    ConErrResPuts(STRING_CHOICE_ERROR);
                    freep (arg);
                    return 1;
                }
            }
            else if (_tcsnicmp (arg[i], _T("/n"), 2) == 0)
            {
                bNoPrompt = TRUE;
            }
            else if (_tcsnicmp (arg[i], _T("/s"), 2) == 0)
            {
                bCaseSensitive = TRUE;
            }
            else if (_tcsnicmp (arg[i], _T("/t"), 2) == 0)
            {
                LPTSTR s;
 
                if (arg[i][2] == _T(':'))
                {
                    cDefault = arg[i][3];
                    s = &arg[i][4];
                }
                else
                {
                    cDefault = arg[i][2];
                    s = &arg[i][3];
                }
 
                if (*s != _T(','))
                {
                    ConErrResPuts(STRING_CHOICE_ERROR_TXT);
                    freep (arg);
                    return 1;
                }
 
                s++;
                nTimeout = _ttoi(s);
                bTimeout = TRUE;
            }
            else if (arg[i][0] == _T('/'))
            {
                ConErrResPrintf(STRING_CHOICE_ERROR_OPTION, arg[i]);
                freep (arg);
                return 1;
            }
        }
    }
 
    /* print text */
    if (lpText)
        ConOutPrintf (_T("%s"), lpText);
 
    /* print options */
    if (bNoPrompt == FALSE)
    {
        ConOutPrintf (_T("[%c"), lpOptions[0]);
 
        for (i = 1; (unsigned)i < _tcslen (lpOptions); i++)
            ConOutPrintf (_T(",%c"), lpOptions[i]);
 
        ConOutPrintf (_T("]?"));
    }
 
    ConInFlush ();
 
    if (!bTimeout)
    {
        while (TRUE)
        {
            ConInKey (&ir);
 
            val = IsKeyInString (lpOptions,
#ifdef _UNICODE
                                 ir.Event.KeyEvent.uChar.UnicodeChar,
#else
                                 ir.Event.KeyEvent.uChar.AsciiChar,
#endif
                                 bCaseSensitive);
 
            if (val >= 0)
            {
                ConOutPrintf (_T("%c\n"), lpOptions[val]);
 
                nErrorLevel = val + 1;
 
                break;
            }
 
            Beep (440, 50);
        }
 
        freep (arg);
        TRACE ("ErrorLevel: %d\n", nErrorLevel);
        return 0;
    }
 
    clk = GetTickCount ();
    amount = nTimeout*1000;
 
loop:
    GCret = GetCharacterTimeout (&Ch, amount - (GetTickCount () - clk));
 
    switch (GCret)
    {
        case GC_TIMEOUT:
            TRACE ("GC_TIMEOUT\n");
            TRACE ("elapsed %d msecs\n", GetTickCount () - clk);
            break;
 
        case GC_NOKEY:
            TRACE ("GC_NOKEY\n");
            TRACE ("elapsed %d msecs\n", GetTickCount () - clk);
            goto loop;
 
        case GC_KEYREAD:
            TRACE ("GC_KEYREAD\n");
            TRACE ("elapsed %d msecs\n", GetTickCount () - clk);
            TRACE ("read %c\n", Ch);
            if ((val=IsKeyInString(lpOptions,Ch,bCaseSensitive))==-1)
            {
                Beep (440, 50);
                goto loop;
            }
            cDefault=Ch;
            break;
    }
 
    TRACE ("exiting wait loop after %d msecs\n",
                GetTickCount () - clk);
 
    val = IsKeyInString (lpOptions, cDefault, bCaseSensitive);
    ConOutPrintf(_T("%c\n"), lpOptions[val]);
 
    nErrorLevel = val + 1;
 
    freep (arg);
 
    TRACE ("ErrorLevel: %d\n", nErrorLevel);
 
    return 0;
}

◆ CommandColor()

INT CommandColor ( LPTSTR rest )

Definition at line 32 of file color.c.

{
    WORD wColor = 0x00;
 
    /* The user asked for help */
    if (_tcsncmp(rest, _T("/?"), 2) == 0)
    {
        ConOutResPaging(TRUE, STRING_COLOR_HELP1);
        return 0;
    }
 
    /* Let's prepare %ERRORLEVEL% */
    nErrorLevel = 0;
 
    /* No parameter: Set the default colors */
    if (rest[0] == _T('\0'))
    {
        ConSetScreenColor(ConStreamGetOSHandle(StdOut), wDefColor, TRUE);
        return 0;
    }
 
    /* The parameter is just one character: Set color text */
    if (_tcslen(rest) == 1)
    {
        if ((rest[0] >= _T('0')) && (rest[0] <= _T('9')))
        {
            wColor = (WORD)_ttoi(rest);
        }
        else if ((rest[0] >= _T('a')) && (rest[0] <= _T('f')))
        {
            wColor = (WORD)(rest[0] + 10 - _T('a'));
        }
        else if ((rest[0] >= _T('A')) && (rest[0] <= _T('F')))
        {
            wColor = (WORD)(rest[0] + 10 - _T('A'));
        }
        else /* Invalid character */
        {
            ConOutResPaging(TRUE, STRING_COLOR_HELP1);
            nErrorLevel = 1;
            return 1;
        }
    }
    /* Color string: advanced choice: two-digits, "Color ON Color", "Foreground ON Background" */
    else if (StringToColor(&wColor, &rest) == FALSE)
    {
        /* Invalid color string */
        ConOutResPaging(TRUE, STRING_COLOR_HELP1);
        nErrorLevel = 1;
        return 1;
    }
 
    TRACE("Color %02x\n", wColor);
 
    /*
     * Set the chosen color. Use also the following advanced flag:
     * /-F to avoid changing already buffered foreground/background.
     */
    if (ConSetScreenColor(ConStreamGetOSHandle(StdOut), wColor,
                          !_tcsstr(rest, _T("/-F")) && !_tcsstr(rest, _T("/-f"))) == FALSE)
    {
        /* Failed because foreground and background colors were the same */
        ConErrResPuts(STRING_COLOR_ERROR1);
        nErrorLevel = 1;
        return 1;
    }
 
    /* Return success */
    return 0;
}

◆ CommandDelay()

INT CommandDelay ( LPTSTR param )

Definition at line 17 of file delay.c.

{
    DWORD val;
    DWORD mul=1000;
 
    if (_tcsncmp (param, _T("/?"), 2) == 0)
    {
        ConOutResPaging(TRUE,STRING_DELAY_HELP);
        return 0;
    }
 
    nErrorLevel = 0;
 
    if (*param==0)
    {
        error_req_param_missing ();
        return 1;
    }
 
    if (_tcsnicmp(param,_T("/m"),2) == 0)
    {
        mul = 1;
        param += 2;
    }
 
    val = _ttoi(param);
    Sleep(val * mul);
 
    return 0;
}

◆ CommandDelete()

INT CommandDelete ( LPTSTR param )

Definition at line 358 of file del.c.

{
    /*cmd is the command that was given, in this case it will always be "del" or "delete"
    param is whatever is given after the command*/
 
    LPTSTR *arg = NULL;
    INT args;
    INT i;
    INT   nEvalArgs = 0; /* number of evaluated arguments */
    DWORD dwFlags = 0;
    DWORD dwAttrFlags = 0;
    DWORD dwFiles = 0;
    LONG ch;
    TCHAR szOriginalArg[MAX_PATH];
 
    /*checks the first two chars of param to see if it is /?
    this however allows the following command to not show help
    "del frog.txt /?" */
 
    if (!StringsLoaded)
    {
        LoadStrings();
    }
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_DEL_HELP1);
        return 0;
    }
 
    nErrorLevel = 0;
 
    arg = split (param, &args, FALSE, FALSE);
 
    if (args == 0)
    {
        /* only command given */
        error_req_param_missing ();
        freep (arg);
        return 1;
    }
    /* check for options anywhere in command line */
    for (i = 0; i < args; i++)
    {
        if (*arg[i] == _T('/'))
        {
            /*found a command, but check to make sure it has something after it*/
            if (_tcslen (arg[i]) >= 2)
            {
                ch = _totupper (arg[i][1]);
                if (ch == _T('N'))
                {
                    dwFlags |= DEL_NOTHING;
                }
                else if (ch == _T('P'))
                {
                    dwFlags |= DEL_PROMPT;
                }
                else if (ch == _T('Q'))
                {
                    dwFlags |= DEL_QUIET;
                }
                else if (ch == _T('F'))
                {
                    dwFlags |= DEL_FORCE;
                }
                else if (ch == _T('S'))
                {
                    dwFlags |= DEL_SUBDIR;
                }
                else if (ch == _T('T'))
                {
                    dwFlags |= DEL_TOTAL;
                }
                else if (ch == _T('W'))
                {
                    dwFlags |= DEL_WIPE;
                }
                else if (ch == _T('Y'))
                {
                    dwFlags |= DEL_YES;
                }
                else if (ch == _T('A'))
                {
                    dwFlags |= DEL_ATTRIBUTES;
                    /*the proper syntax for /A has a min of 4 chars
                    i.e. /A:R or /A:-H */
                    if (_tcslen (arg[i]) < 4)
                    {
                        error_invalid_parameter_format(arg[i]);
                        return 0;
                    }
                    ch = _totupper (arg[i][3]);
                    if (_tcslen (arg[i]) == 4)
                    {
                        if (ch == _T('A'))
                        {
                            dwAttrFlags |= ATTR_ARCHIVE;
                        }
                        if (ch == _T('H'))
                        {
                            dwAttrFlags |= ATTR_HIDDEN;
                        }
                        if (ch == _T('S'))
                        {
                            dwAttrFlags |= ATTR_SYSTEM;
                        }
                        if (ch == _T('R'))
                        {
                            dwAttrFlags |= ATTR_READ_ONLY;
                        }
                    }
                    if (_tcslen (arg[i]) == 5)
                    {
                        if (ch == _T('-'))
                        {
                            ch = _totupper (arg[i][4]);
                            if (ch == _T('A'))
                            {
                                dwAttrFlags |= ATTR_N_ARCHIVE;
                            }
                            if (ch == _T('H'))
                            {
                                dwAttrFlags |= ATTR_N_HIDDEN;
                            }
                            if (ch == _T('S'))
                            {
                                dwAttrFlags |= ATTR_N_SYSTEM;
                            }
                            if (ch == _T('R'))
                            {
                                dwAttrFlags |= ATTR_N_READ_ONLY;
                            }
                        }
                    }
                }
            }
 
            nEvalArgs++;
        }
    }
 
    /* there are only options on the command line --> error!!!
    there is the same number of args as there is flags, so none of the args were filenames*/
    if (args == nEvalArgs)
    {
        error_req_param_missing ();
        freep (arg);
        return 1;
    }
 
    /* keep quiet within batch files */
    if (bc != NULL) dwFlags |= DEL_QUIET;
 
    /* check for filenames anywhere in command line */
    for (i = 0; i < args && !(dwFiles & 0x80000000); i++)
    {
        /*this checks to see if it is a flag; if it isn't, we assume it is a file name*/
        if ((*arg[i] == _T('/')) || (*arg[i] == _T('-')))
            continue;
 
        /* We want to make a copies of the argument */
        if (_tcslen(arg[i]) == 2 && arg[i][1] == _T(':'))
        {
            /* Check for C: D: ... */
            GetRootPath(arg[i], szOriginalArg, MAX_PATH);
        }
        else
        {
            _tcscpy(szOriginalArg,arg[i]);
        }
        dwFiles += ProcessDirectory(szOriginalArg, &dwFlags, dwAttrFlags);
    }
 
    freep (arg);
 
    /*Based on MS cmd, we only tell what files are being deleted when /S is used */
    if (dwFlags & DEL_TOTAL)
    {
        dwFiles &= 0x7fffffff;
        if (dwFiles < 2)
        {
            ConOutResPrintf(STRING_DEL_HELP3, dwFiles);
        }
        else
        {
            ConOutResPrintf(STRING_DEL_HELP4, dwFiles);
        }
    }
 
    return 0;
}

◆ CommandDir()

INT CommandDir ( LPTSTR rest )

Definition at line 1843 of file dir.c.

{
    TCHAR   dircmd[MAX_PATH];   /* A variable to store the DIRCMD environment variable */
    TCHAR   prev_volume[MAX_PATH];
    TCHAR   szFullPath[MAX_PATH];
    LPTSTR* params = NULL;
    LPTSTR  pszFilePart;
    TCHAR   cPathSep;
    INT     entries = 0;
    UINT    loop = 0;
    DIRSWITCHFLAGS stFlags;
    INT ret = 1;
    BOOL ChangedVolume;
 
    /* Initialize Switch Flags < Default switches are set here! > */
    stFlags.b4Digit = TRUE;
    stFlags.bBareFormat = FALSE;
    stFlags.bDataStreams = FALSE;
    stFlags.bLowerCase = FALSE;
    stFlags.bNewLongList = TRUE;
    stFlags.bPause = FALSE;
    stFlags.bRecursive = FALSE;
    stFlags.bShortName = FALSE;
    stFlags.bTSeparator = TRUE;
    stFlags.bUser = FALSE;
    stFlags.bWideList = FALSE;
    stFlags.bWideListColSort = FALSE;
    stFlags.stTimeField.eTimeField = TF_MODIFIEDDATE;
    stFlags.stAttribs.dwAttribMask = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
    stFlags.stAttribs.dwAttribVal = 0L;
    stFlags.stOrderBy.sCriteriaCount = 0;
 
    nErrorLevel = 0;
 
    /* Read the parameters from the DIRCMD environment variable */
    if (GetEnvironmentVariable (_T("DIRCMD"), dircmd, ARRAYSIZE(dircmd)))
    {
        if (!DirReadParam(dircmd, &params, &entries, &stFlags))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
    }
 
    /* Read the parameters */
    if (!DirReadParam(rest, &params, &entries, &stFlags) || CheckCtrlBreak(BREAK_INPUT))
    {
        nErrorLevel = 1;
        goto cleanup;
    }
 
    /* Default to current directory */
    if (entries == 0)
    {
        if (!add_entry(&entries, &params, _T("*")))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
    }
 
    prev_volume[0] = _T('\0');
 
    /* Reset paging state */
    if (stFlags.bPause)
        ConOutPrintfPaging(TRUE, _T(""));
 
    for (loop = 0; loop < (UINT)entries; loop++)
    {
        if (CheckCtrlBreak(BREAK_INPUT))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
 
        recurse_dir_cnt = 0L;
        recurse_file_cnt = 0L;
        recurse_bytes = 0;
 
        /* <Debug :>
           Uncomment this to show the final state of switch flags*/
        {
            int i;
            TRACE("Attributes mask/value %x/%x\n",stFlags.stAttribs.dwAttribMask,stFlags.stAttribs.dwAttribVal);
            TRACE("(B) Bare format : %i\n", stFlags.bBareFormat);
            TRACE("(C) Thousand : %i\n", stFlags.bTSeparator);
            TRACE("(W) Wide list : %i\n", stFlags.bWideList);
            TRACE("(D) Wide list sort by column : %i\n", stFlags.bWideListColSort);
            TRACE("(L) Lowercase : %i\n", stFlags.bLowerCase);
            TRACE("(N) New : %i\n", stFlags.bNewLongList);
            TRACE("(O) Order : %i\n", stFlags.stOrderBy.sCriteriaCount);
            for (i =0;i<stFlags.stOrderBy.sCriteriaCount;i++)
                TRACE(" Order Criteria [%i]: %i (Reversed: %i)\n",i, stFlags.stOrderBy.eCriteria[i], stFlags.stOrderBy.bCriteriaRev[i]);
            TRACE("(P) Pause : %i\n", stFlags.bPause);
            TRACE("(Q) Owner : %i\n", stFlags.bUser);
            TRACE("(R) Data stream : %i\n", stFlags.bDataStreams);
            TRACE("(S) Recursive : %i\n", stFlags.bRecursive);
            TRACE("(T) Time field : %i\n", stFlags.stTimeField.eTimeField);
            TRACE("(X) Short names : %i\n", stFlags.bShortName);
            TRACE("Parameter : %s\n", debugstr_aw(params[loop]));
        }
 
        /* Print the drive header if the volume changed */
        ChangedVolume = TRUE;
 
        if (!stFlags.bBareFormat &&
            GetVolumePathName(params[loop], szFullPath, ARRAYSIZE(szFullPath)))
        {
            if (!_tcscmp(szFullPath, prev_volume))
                ChangedVolume = FALSE;
            else
                _tcscpy(prev_volume, szFullPath);
        }
 
        /* Resolve the pattern */
        ResolvePattern(params[loop], ARRAYSIZE(szFullPath), szFullPath, &pszFilePart);
 
        /* Print the header */
        cPathSep = pszFilePart[-1];
        pszFilePart[-1] = _T('\0'); /* Truncate to directory name only */
        if (ChangedVolume && !stFlags.bBareFormat &&
            !PrintDirectoryHeader(szFullPath, &stFlags))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
        pszFilePart[-1] = cPathSep;
 
        /* Perform the actual directory listing */
        if (DirList(szFullPath, pszFilePart, &stFlags) != 0)
        {
            nErrorLevel = 1;
            goto cleanup;
        }
 
        /* Print the footer */
        pszFilePart[-1] = _T('\0'); /* Truncate to directory name only */
        PrintSummary(szFullPath,
                     recurse_file_cnt,
                     recurse_dir_cnt,
                     recurse_bytes,
                     &stFlags,
                     TRUE);
    }
 
    ret = 0;
 
cleanup:
    freep(params);
 
    return ret;
}

◆ CommandDirs()

INT CommandDirs ( LPTSTR rest )

Definition at line 154 of file dirstack.c.

{
    LPDIRENTRY lpDir;
 
    if (!_tcsncmp(rest, _T("/?"), 2))
    {
        ConOutResPuts(STRING_DIRSTACK_HELP3);
        return 0;
    }
 
    nErrorLevel = 0;
 
    lpDir = lpStackBottom;
 
    if (lpDir == NULL)
    {
        ConOutResPuts(STRING_DIRSTACK_HELP4);
        return 0;
    }
 
    while (lpDir != NULL)
    {
        ConOutPuts(lpDir->szPath);
        lpDir = lpDir->prev;
    }
 
    return 0;
}

◆ CommandEcho()

INT CommandEcho ( LPTSTR param )

Definition at line 65 of file echo.c.

{
    LPTSTR p1;
 
    TRACE ("CommandEcho: '%s'\n", debugstr_aw(param));
 
    /* skip all spaces for the check of '/?', 'ON' and 'OFF' */
    p1 = param;
    while(_istspace(*p1))
            p1++;
 
    if (!_tcsncmp (p1, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_ECHO_HELP4);
        return 0;
    }
 
    if (!OnOffCommand(p1, &bEcho, STRING_ECHO_HELP5))
    {
        /* skip the first character */
        ConOutPuts(param + 1);
        ConOutChar(_T('\n'));
    }
    return 0;
}

◆ CommandEchoerr()

INT CommandEchoerr ( LPTSTR param )

Definition at line 106 of file echo.c.

{
    TRACE ("CommandEchoerr: '%s'\n", debugstr_aw(param));
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPuts(STRING_ECHO_HELP2);
        return 0;
    }
 
    ConErrPuts (param);
    return 0;
}

◆ CommandEchos()

INT CommandEchos ( LPTSTR param )

Definition at line 91 of file echo.c.

{
    TRACE ("CommandEchos: '%s'\n", debugstr_aw(param));
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPuts(STRING_ECHO_HELP1);
        return 0;
    }
 
    ConOutPrintf (_T("%s"), param);
    return 0;
}

◆ CommandEchoserr()

INT CommandEchoserr ( LPTSTR param )

Definition at line 121 of file echo.c.

{
    TRACE ("CommandEchoserr: '%s'\n", debugstr_aw(param));
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPuts(STRING_ECHO_HELP3);
        return 0;
    }
 
    ConErrPrintf (_T("%s"), param);
    return 0;
}

◆ CommandExit()

INT CommandExit ( LPTSTR param )

Definition at line 621 of file internal.c.

{
    if (!_tcsncmp(param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE, STRING_EXIT_HELP);
 
        /* Just make sure we don't exit */
        bExit = FALSE;
        return 0;
    }
 
    if (_tcsnicmp(param, _T("/B"), 2) == 0)
    {
        param += 2;
 
        /*
         * If a current batch file is running, exit it,
         * otherwise exit this command interpreter instance.
         */
        if (bc)
        {
            /* Windows' CMD compatibility: Use GOTO :EOF */
            TCHAR EofLabel[] = _T(":EOF");
 
#ifdef SUPPORT_EXIT_B_NO_EXTENSIONS
            /*
             * Temporarily enable extensions so as to support :EOF.
             *
             * Our GOTO implementation ensures that, when extensions are
             * enabled and the label is ':EOF', no immediate change of batch
             * context (done e.g. via ExitBatch() calls) is performed.
             * This will therefore ensure that we do not spoil the extensions
             * state when we restore it below.
             */
            BOOL bOldEnableExtensions = bEnableExtensions;
            bEnableExtensions = TRUE;
#endif
 
            cmd_goto(EofLabel);
 
#ifdef SUPPORT_EXIT_B_NO_EXTENSIONS
            /* Restore the original state of the extensions */
            bEnableExtensions = bOldEnableExtensions;
#endif
        }
        else
        {
            bExit = TRUE;
        }
    }
    else
    {
        /* Exit this command interpreter instance */
        bExit = TRUE;
    }
 
    /* Search for an optional exit code */
    while (_istspace(*param))
        ++param;
 
    /* Set the errorlevel to the exit code */
    if (_istdigit(*param))
    {
        nErrorLevel = _ttoi(param);
        // if (fSingleCommand == 1) return nErrorLevel;
    }
 
    return (bExit ? nErrorLevel : 0);
}

◆ CommandFree()

INT CommandFree ( LPTSTR param )

Definition at line 86 of file free.c.

{
    LPTSTR szParam;
    TCHAR  szDefPath[MAX_PATH];
    INT argc, i;
    LPTSTR *arg;
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_FREE_HELP2);
        return 0;
    }
 
    if (!param || *param == _T('\0'))
    {
        GetCurrentDirectory (MAX_PATH, szDefPath);
        szDefPath[2] = _T('\0');
        szParam = szDefPath;
    }
    else
        szParam = param;
 
    arg = split (szParam, &argc, FALSE, FALSE);
 
    for (i = 0; i < argc; i++)
        PrintDiskInfo (arg[i]);
 
    freep (arg);
 
    return 0;
}

◆ CommandMemory()

INT CommandMemory ( LPTSTR param )

Definition at line 18 of file memory.c.

{
    MEMORYSTATUSEX msex;
    TCHAR szMemoryLoad[20];
    TCHAR szTotalPhys[40];
    TCHAR szAvailPhys[40];
    TCHAR szTotalPageFile[40];
    TCHAR szAvailPageFile[40];
    TCHAR szTotalVirtual[40];
    TCHAR szAvailVirtual[40];
    BOOL (WINAPI *GlobalMemoryStatusEx)(LPMEMORYSTATUSEX);
 
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_MEMORY_HELP1);
        return 0;
    }
 
    GlobalMemoryStatusEx
        = (BOOL (WINAPI *)(LPMEMORYSTATUSEX))GetProcAddress(GetModuleHandle(_T("KERNEL32")), "GlobalMemoryStatusEx");
    if (GlobalMemoryStatusEx)
    {
        msex.dwLength = sizeof(MEMORYSTATUSEX);
        GlobalMemoryStatusEx(&msex);
    }
    else
    {
        MEMORYSTATUS ms;
        ms.dwLength = sizeof(MEMORYSTATUS);
        GlobalMemoryStatus(&ms);
        msex.dwMemoryLoad = ms.dwMemoryLoad;
        msex.ullTotalPhys = ms.dwTotalPhys;
        msex.ullAvailPhys = ms.dwAvailPhys;
        msex.ullTotalPageFile = ms.dwTotalPageFile;
        msex.ullAvailPageFile = ms.dwAvailPageFile;
        msex.ullTotalVirtual = ms.dwTotalVirtual;
        msex.ullAvailVirtual = ms.dwAvailVirtual;
    }
 
    ConvertULargeInteger(msex.dwMemoryLoad, szMemoryLoad, 20, FALSE);
    ConvertULargeInteger(msex.ullTotalPhys, szTotalPhys, 40, TRUE);
    ConvertULargeInteger(msex.ullAvailPhys, szAvailPhys, 40, TRUE);
    ConvertULargeInteger(msex.ullTotalPageFile, szTotalPageFile, 40, TRUE);
    ConvertULargeInteger(msex.ullAvailPageFile, szAvailPageFile, 40, TRUE);
    ConvertULargeInteger(msex.ullTotalVirtual, szTotalVirtual, 40, TRUE);
    ConvertULargeInteger(msex.ullAvailVirtual, szAvailVirtual, 40, TRUE);
 
    ConOutResPrintf(STRING_MEMORY_HELP2,
                    szMemoryLoad, szTotalPhys, szAvailPhys, szTotalPageFile,
                    szAvailPageFile, szTotalVirtual, szAvailVirtual);
 
    return 0;
}

◆ CommandMsgbox()

INT CommandMsgbox ( LPTSTR )

◆ CommandPopd()

INT CommandPopd ( LPTSTR rest )

Definition at line 132 of file dirstack.c.

{
    INT ret = 0;
    if (!_tcsncmp(rest, _T("/?"), 2))
    {
        ConOutResPuts(STRING_DIRSTACK_HELP2);
        return 0;
    }
 
    if (nStackDepth == 0)
        return 1;
 
    ret = _tchdir(lpStackTop->szPath) != 0;
    PopDirectory ();
 
    return ret;
}

◆ CommandPushd()

INT CommandPushd ( LPTSTR rest )

Definition at line 107 of file dirstack.c.

{
    TCHAR curPath[MAX_PATH];
 
    if (!_tcsncmp (rest, _T("/?"), 2))
    {
        ConOutResPuts(STRING_DIRSTACK_HELP1);
        return 0;
    }
 
    GetCurrentDirectory (MAX_PATH, curPath);
 
    if (rest[0] != _T('\0'))
    {
        if (!SetRootPath(NULL, rest))
            return 1;
    }
 
    return PushDirectory(curPath);
}

◆ CommandRem()

INT CommandRem ( LPTSTR param )

Definition at line 695 of file internal.c.

{
    if (_tcsstr(param, _T("/?")) == param)
    {
        ConOutResPaging(TRUE,STRING_REM_HELP);
    }
 
    return 0;
}

◆ CommandScreen()

INT CommandScreen ( LPTSTR param )

Definition at line 18 of file screen.c.

{
    SHORT x, y;
    SHORT maxx, maxy;
    BOOL bSkipText = FALSE;
 
    if (_tcsncmp(param, _T("/?"), 2) == 0)
    {
        ConOutResPaging(TRUE,STRING_SCREEN_HELP);
        return 0;
    }
 
    nErrorLevel = 0;
 
    /* Retrieve the screen dimensions */
    GetScreenSize(&maxx, &maxy);
 
    /* Get row */
    while (_istspace(*param))
        param++;
 
    if (!*param)
    {
        error_req_param_missing();
        return 1;
    }
 
    y = _ttoi(param);
    if (y < 0 || y > (maxy-1))
    {
        ConOutResPuts(STRING_SCREEN_ROW);
        return 1;
    }
 
    /* Get column */
    if (!(param = _tcschr(param, _T(' '))))
    {
        error_req_param_missing();
        return 1;
    }
 
    while (_istspace(*param))
        param++;
 
    if (!*param)
    {
        error_req_param_missing();
        return 1;
    }
 
    x = _ttoi(param);
    if (x < 0 || x > (maxx-1))
    {
        ConErrResPuts(STRING_SCREEN_COL);
        return 1;
    }
 
    /* Get text */
    if (!(param = _tcschr(param, _T(' '))))
    {
        bSkipText = TRUE;
    }
    else
    {
        while (_istspace(*param))
            param++;
 
        if (!*param)
            bSkipText = TRUE;
    }
 
    bIgnoreEcho = TRUE;
 
    if (bSkipText)
        x = 0;
 
    SetCursorXY(x, y);
 
    if (!bSkipText)
        ConOutPuts(param);
 
    return 0;
}

◆ CommandShowCommands()

INT CommandShowCommands ( LPTSTR param )

Definition at line 707 of file internal.c.

{
    PrintCommandList();
    return 0;
}

◆ CommandTimer()

INT CommandTimer ( LPTSTR param )

Definition at line 59 of file timer.c.

{
    // all timers are kept
    static DWORD clksT[10];
 
    // timers status
    // set all the clocks off by default
    static BOOL clksS[10]={FALSE,FALSE,FALSE,FALSE,
        FALSE,FALSE,FALSE,FALSE,FALSE,FALSE};
 
    // TRUE if /S in command line
    BOOL bS = FALSE;
 
    // avoid to set clk_n more than once
    BOOL bCanNSet = TRUE;
 
    INT NewClkStatus = NCS_NOT_SPECIFIED;
 
    // the clock number specified on the command line
    // 1 by default
    INT clk_n=1;
 
    // output format
    INT iFormat=1;
 
 
    // command line parsing variables
    INT argc;
    LPTSTR *p;
 
    INT i;
 
    if (_tcsncmp (param, _T("/?"), 2) == 0)
    {
        ConOutResPrintf(STRING_TIMER_HELP3, cTimeSeparator, cTimeSeparator, cDecimalSeparator);
        return 0;
    }
 
    nErrorLevel = 0;
 
    p = split (param, &argc, FALSE, FALSE);
 
    //read options
    for (i = 0; i < argc; i++)
    {
        //set timer on
        if (!(_tcsicmp(&p[i][0],_T("on")))  && NewClkStatus == NCS_NOT_SPECIFIED)
        {
            NewClkStatus = NCS_ON;
            continue;
        }
 
        //set timer off
        if (!(_tcsicmp(&p[i][0],_T("off"))) && NewClkStatus == NCS_NOT_SPECIFIED)
        {
            NewClkStatus = NCS_OFF;
            continue;
        }
 
        // other options
        if (p[i][0] == _T('/'))
        {
            // set timer number
            if (_istdigit(p[i][1]) && bCanNSet)
            {
                clk_n = p[i][1] - _T('0');
                bCanNSet = FALSE;
                continue;
            }
 
            // set s(plit) option
            if (_totupper(p[i][1]) == _T('S'))
            {
                bS = TRUE;
                continue;
            }
 
            // specify format
            if (_totupper(p[i][1]) == _T('F'))
            {
                iFormat = p[i][2] - _T('0');
                continue;
            }
        }
    }
 
    // do stuff (start/stop/read timer)
    if (NewClkStatus == NCS_ON)
    {
        cT=GetTickCount();
        cS=TRUE;
 
        ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
        ConOutPuts(GetTimeString());
        freep(p);
        return 0;
    }
 
    if (bS)
    {
        if (cS)
        {
            ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
            ConOutPrintf(_T("%s\n"), GetTimeString());
            PrintElapsedTime(GetTickCount()-cT, iFormat);
            freep(p);
            return 0;
        }
 
        cT=GetTickCount();
        cS=TRUE;
        ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
        ConOutPuts(GetTimeString());
        freep(p);
        return 0;
    }
 
    if (NewClkStatus == NCS_NOT_SPECIFIED)
    {
        if (cS)
        {
            cS=FALSE;
            ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
            ConOutPrintf(_T("%s\n"), GetTimeString());
            PrintElapsedTime(GetTickCount()-cT, iFormat);
            freep(p);
            return 0;
        }
 
        cT=GetTickCount();
        cS=TRUE;
        ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
        ConOutPuts(GetTimeString());
        freep(p);
        return 0;
    }
 
 
    if (NewClkStatus == NCS_OFF)
    {
        if (cS)
        {
            cS=FALSE;
            ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
            ConOutPrintf(_T("%s\n"), GetTimeString());
            PrintElapsedTime(GetTickCount()-cT, iFormat);
            freep(p);
            return 0;
        }
        ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
        ConOutPuts(GetTimeString());
        freep(p);
        return 0;
    }
 
    freep(p);
    return 0;
}

◆ CommandWindow()

INT CommandWindow ( LPTSTR )

◆ 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().

◆ DestroyDirectoryStack()

VOID DestroyDirectoryStack ( VOID )

Definition at line 91 of file dirstack.c.

{
    while (nStackDepth)
        PopDirectory ();
}

Referenced by Cleanup().

◆ DoCommand()

INT DoCommand	(	LPTSTR	first,
		LPTSTR	rest,
		struct _PARSED_COMMAND *	Cmd
	)

Definition at line 557 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 1640 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().

◆ DumpCommand()

VOID DumpCommand	(	IN PARSED_COMMAND *	Cmd,
		IN ULONG	SpacePad
	)

Definition at line 1533 of file parser.c.

{
/*
 * This macro is like DumpCommand(Cmd, Pad);
 * but avoids an extra recursive level.
 * Note that it can be used ONLY for terminating commands!
 */
#define DUMP(Command, Pad) \
do { \
    Cmd = (Command); \
    SpacePad = (Pad); \
    goto dump; \
} while (0)
 
    PARSED_COMMAND* Sub;
 
dump:
    if (!Cmd)
        return;
 
    /* Space padding */
    ConOutPrintf(_T("%*s"), SpacePad, _T(""));
 
    switch (Cmd->Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        /* Generic command name, and Type */
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T("Cmd: %s  Type: %x"),
                     Cmd->Command.First, Cmd->Type);
#else
        ConOutPrintf(_T("Cmd: %s  Type: %x "),
                     Cmd->Command.First, Cmd->Type);
#endif
        /* Arguments */
        if (Cmd->Command.Rest && *(Cmd->Command.Rest))
#ifndef MSCMD_ECHO_COMMAND_COMPAT
            ConOutPrintf(_T(" Args: `%s'"), Cmd->Command.Rest);
#else
            ConOutPrintf(_T("Args: `%s' "), Cmd->Command.Rest);
#endif
        /* Redirections */
        DumpRedir(Cmd->Redirections);
 
        ConOutChar(_T('\n'));
        return;
    }
 
    case C_QUIET:
    {
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutChar(_T('@'));
#else
        ConOutPuts(_T("@ "));
#endif
        DumpRedir(Cmd->Redirections); // FIXME: Can we have leading redirections??
        ConOutChar(_T('\n'));
 
        /*DumpCommand*/DUMP(Cmd->Subcommands, SpacePad + 2);
        return;
    }
 
    case C_BLOCK:
    {
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutChar(_T('('));
#else
        ConOutPuts(_T("( "));
#endif
        DumpRedir(Cmd->Redirections);
        ConOutChar(_T('\n'));
 
        SpacePad += 2;
 
        for (Sub = Cmd->Subcommands; Sub; Sub = Sub->Next)
        {
#if defined(MSCMD_ECHO_COMMAND_COMPAT) && defined(MSCMD_PARSER_BUGS)
            /*
             * We will emulate Windows' CMD handling of "CRLF" and "&" multi-command
             * enumeration within parenthesized command blocks.
             */
 
            if (!Sub->Next)
            {
                DumpCommand(Sub, SpacePad);
                continue;
            }
 
            if (Sub->Type != C_MULTI)
            {
                ConOutPrintf(_T("%*s"), SpacePad, _T(""));
                ConOutPuts(_T("CRLF \n"));
                DumpCommand(Sub, SpacePad);
                continue;
            }
 
            /* Now, Sub->Type == C_MULTI */
 
            Cmd = Sub;
 
            ConOutPrintf(_T("%*s"), SpacePad, _T(""));
            ConOutPrintf(_T("%s \n"), OpString[Cmd->Type - C_OP_LOWEST]);
            // FIXME: Can we have redirections on these operator-type commands?
 
            SpacePad += 2;
 
            Cmd = Cmd->Subcommands;
            DumpCommand(Cmd, SpacePad);
            ConOutPrintf(_T("%*s"), SpacePad, _T(""));
            ConOutPuts(_T("CRLF \n"));
            DumpCommand(Cmd->Next, SpacePad);
 
            // NOTE: Next commands will remain indented.
 
#else
 
            /*
             * If this command is followed by another one, first display "CRLF".
             * This also emulates the CRLF placement "bug" of Windows' CMD
             * for the last two commands.
             */
            if (Sub->Next)
            {
                ConOutPrintf(_T("%*s"), SpacePad, _T(""));
#ifndef MSCMD_ECHO_COMMAND_COMPAT
                ConOutPuts(_T("CRLF\n"));
#else
                ConOutPuts(_T("CRLF \n"));
#endif
            }
            DumpCommand(Sub, SpacePad);
 
#endif // defined(MSCMD_ECHO_COMMAND_COMPAT) && defined(MSCMD_PARSER_BUGS)
        }
 
        return;
    }
 
    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T("%s\n"), OpString[Cmd->Type - C_OP_LOWEST]);
#else
        ConOutPrintf(_T("%s \n"), OpString[Cmd->Type - C_OP_LOWEST]);
#endif
        // FIXME: Can we have redirections on these operator-type commands?
 
        SpacePad += 2;
 
        Sub = Cmd->Subcommands;
        DumpCommand(Sub, SpacePad);
        /*DumpCommand*/DUMP(Sub->Next, SpacePad);
        return;
    }
 
    case C_FOR:
    {
        ConOutPuts(_T("for"));
        /* NOTE: FOR cannot have leading redirections */
 
        if (Cmd->For.Switches & FOR_DIRS)      ConOutPuts(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         ConOutPuts(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      ConOutPuts(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) ConOutPuts(_T(" /R"));
        if (Cmd->For.Params)
            ConOutPrintf(_T(" %s"), Cmd->For.Params);
        ConOutPrintf(_T(" %%%c in (%s) do\n"), Cmd->For.Variable, Cmd->For.List);
        /*DumpCommand*/DUMP(Cmd->Subcommands, SpacePad + 2);
        return;
    }
 
    case C_IF:
    {
        ConOutPuts(_T("if"));
        /* NOTE: IF cannot have leading redirections */
 
        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            ConOutPuts(_T(" /I"));
 
        ConOutChar(_T('\n'));
 
        SpacePad += 2;
 
        /*
         * Show the IF command condition as a command.
         * If it is negated, indent the command more.
         */
        if (Cmd->If.Flags & IFFLAG_NEGATE)
        {
            ConOutPrintf(_T("%*s"), SpacePad, _T(""));
            ConOutPuts(_T("not\n"));
            SpacePad += 2;
        }
 
        ConOutPrintf(_T("%*s"), SpacePad, _T(""));
 
        /*
         * Command name:
         * - Unary operator: its name is the command name, and its argument is the command argument.
         * - Binary operator: its LHS is the command name, its RHS is the command argument.
         *
         * Type:
         * Windows' CMD (Win2k3 / Win7-10) values are as follows:
         *   CMDEXTVERSION  Type: 0x32 / 0x34
         *   ERRORLEVEL     Type: 0x33 / 0x35
         *   DEFINED        Type: 0x34 / 0x36
         *   EXIST          Type: 0x35 / 0x37
         *   ==             Type: 0x37 / 0x39 (String Comparison)
         *
         * For the following command:
         *   NOT            Type: 0x36 / 0x38
         * Windows only prints it without any type / redirection.
         *
         * For the following command:
         *   EQU, NEQ, etc. Type: 0x38 / 0x3a (Generic Comparison)
         * Windows displays it as command of unknown type.
         */
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T("Cmd: %s  Type: %x"),
                     (Cmd->If.Operator <= IF_MAX_UNARY) ?
                        IfOperatorString[Cmd->If.Operator] :
                        Cmd->If.LeftArg,
                     Cmd->If.Operator);
#else
        ConOutPrintf(_T("Cmd: %s  Type: %x "),
                     (Cmd->If.Operator <= IF_MAX_UNARY) ?
                        IfOperatorString[Cmd->If.Operator] :
                        Cmd->If.LeftArg,
                     Cmd->If.Operator);
#endif
        /* Arguments */
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T(" Args: `%s'"), Cmd->If.RightArg);
#else
        ConOutPrintf(_T("Args: `%s' "), Cmd->If.RightArg);
#endif
 
        ConOutChar(_T('\n'));
 
        if (Cmd->If.Flags & IFFLAG_NEGATE)
        {
            SpacePad -= 2;
        }
 
        Sub = Cmd->Subcommands;
        DumpCommand(Sub, SpacePad);
        if (Sub->Next)
        {
            ConOutPrintf(_T("%*s"), SpacePad - 2, _T(""));
            ConOutPuts(_T("else\n"));
            DumpCommand(Sub->Next, SpacePad);
        }
        return;
    }
 
    default:
        ConOutPrintf(_T("*** Unknown type: %x\n"), Cmd->Type);
        break;
    }
 
#undef DUMP
}

Referenced by DumpCommand(), and ParseCommand().

◆ DuplicateEnvironment()

LPTSTR DuplicateEnvironment ( VOID )

Definition at line 25 of file setlocal.c.

{
    LPTSTR Environ = GetEnvironmentStrings();
    LPTSTR End, EnvironCopy;
 
    if (!Environ) return NULL;
 
    for (End = Environ; *End; End += _tcslen(End) + 1) ;
    EnvironCopy = cmd_alloc((End + 1 - Environ) * sizeof(TCHAR));
 
    if (EnvironCopy)
        memcpy(EnvironCopy, Environ, (End + 1 - Environ) * sizeof(TCHAR));
 
    FreeEnvironmentStrings(Environ);
    return EnvironCopy;
}

Referenced by _tmain(), cmd_endlocal(), and cmd_setlocal().

◆ EchoCommand()

VOID EchoCommand ( IN PARSED_COMMAND * Cmd )

Definition at line 1808 of file parser.c.

{
    PARSED_COMMAND* Sub;
    REDIRECTION* Redir;
 
    if (!Cmd)
        return;
 
    switch (Cmd->Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        if (SubstituteForVars(Cmd->Command.First, TempBuf))
            ConOutPrintf(_T("%s"), TempBuf);
        if (SubstituteForVars(Cmd->Command.Rest, TempBuf))
        {
            ConOutPrintf(_T("%s"), TempBuf);
#ifdef MSCMD_ECHO_COMMAND_COMPAT
            /* NOTE: For Windows compatibility, add a trailing space after printing the command parameter, if present */
            if (*TempBuf) ConOutChar(_T(' '));
#endif
        }
        break;
    }
 
    case C_QUIET:
        return;
 
    case C_BLOCK:
    {
        BOOLEAN bIsFirstCmdCRLF;
 
        ConOutChar(_T('('));
 
        Sub = Cmd->Subcommands;
 
        bIsFirstCmdCRLF = (Sub && Sub->Next);
 
#if defined(MSCMD_ECHO_COMMAND_COMPAT) && defined(MSCMD_PARSER_BUGS)
        /*
         * We will emulate Windows' CMD handling of "CRLF" and "&" multi-command
         * enumeration within parenthesized command blocks.
         */
        bIsFirstCmdCRLF = bIsFirstCmdCRLF && (Sub->Type != C_MULTI);
#endif
 
        /*
         * Single-command block: display all on one line.
         * Multi-command block: display commands on separate lines.
         */
        if (bIsFirstCmdCRLF)
            ConOutChar(_T('\n'));
 
        for (; Sub; Sub = Sub->Next)
        {
            EchoCommand(Sub);
            if (Sub->Next)
#ifdef MSCMD_ECHO_COMMAND_COMPAT
                ConOutPuts(_T(" \n "));
#else
                ConOutChar(_T('\n'));
#endif
        }
 
        if (bIsFirstCmdCRLF)
            ConOutChar(_T('\n'));
 
#ifdef MSCMD_ECHO_COMMAND_COMPAT
        /* NOTE: For Windows compatibility, add a trailing space after printing the closing parenthesis */
        ConOutPuts(_T(") "));
#else
        ConOutChar(_T(')'));
#endif
        break;
    }
 
    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
        Sub = Cmd->Subcommands;
        EchoCommand(Sub);
        ConOutPrintf(_T(" %s "), OpString[Cmd->Type - C_OP_LOWEST]);
        EchoCommand(Sub->Next);
        break;
    }
 
    case C_FOR:
    {
        ConOutPuts(_T("for"));
        if (Cmd->For.Switches & FOR_DIRS)      ConOutPuts(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         ConOutPuts(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      ConOutPuts(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) ConOutPuts(_T(" /R"));
        if (Cmd->For.Params)
            ConOutPrintf(_T(" %s"), Cmd->For.Params);
        if (Cmd->For.List && SubstituteForVars(Cmd->For.List, TempBuf))
            ConOutPrintf(_T(" %%%c in (%s) do "), Cmd->For.Variable, TempBuf);
        else
            ConOutPrintf(_T(" %%%c in (%s) do "), Cmd->For.Variable, Cmd->For.List);
        EchoCommand(Cmd->Subcommands);
        break;
    }
 
    case C_IF:
    {
        ConOutPuts(_T("if"));
        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            ConOutPuts(_T(" /I"));
        if (Cmd->If.Flags & IFFLAG_NEGATE)
            ConOutPuts(_T(" not"));
        if (Cmd->If.LeftArg && SubstituteForVars(Cmd->If.LeftArg, TempBuf))
            ConOutPrintf(_T(" %s"), TempBuf);
        ConOutPrintf(_T(" %s"), IfOperatorString[Cmd->If.Operator]);
        if (SubstituteForVars(Cmd->If.RightArg, TempBuf))
            ConOutPrintf(_T(" %s "), TempBuf);
        Sub = Cmd->Subcommands;
        EchoCommand(Sub);
        if (Sub->Next)
        {
            ConOutPuts(_T(" else "));
            EchoCommand(Sub->Next);
        }
        break;
    }
 
    default:
        ASSERT(FALSE);
        break;
    }
 
    for (Redir = Cmd->Redirections; Redir; Redir = Redir->Next)
    {
        if (SubstituteForVars(Redir->Filename, TempBuf))
        {
#ifdef MSCMD_ECHO_COMMAND_COMPAT
            ConOutPrintf(_T("%c%s%s "),
                         _T('0') + Redir->Number,
                         RedirString[Redir->Mode], TempBuf);
#else
            ConOutPrintf(_T(" %c%s%s"),
                         _T('0') + Redir->Number,
                         RedirString[Redir->Mode], TempBuf);
#endif
        }
    }
}

Referenced by EchoCommand(), and ExecuteCommandWithEcho().

◆ error_bad_command()

VOID error_bad_command ( PCTSTR s )

Referenced by Execute(), and ForF().

◆ error_file_not_found()

VOID error_file_not_found ( VOID )

Definition at line 93 of file error.c.

{
    ConErrResPuts(STRING_ERROR_FILE_NOT_FOUND);
    nErrorLevel = 1;
}

Referenced by cmd_move(), cmd_rename(), and PrintSummary().

◆ error_invalid_drive()

VOID error_invalid_drive ( VOID )

Definition at line 117 of file error.c.

{
    ConErrResPuts(STRING_ERROR_INVALID_DRIVE);
    nErrorLevel = 1;
}

Referenced by cmd_chdir(), and cmd_vol().

◆ error_invalid_parameter_format()

VOID error_invalid_parameter_format ( PCTSTR s )

Referenced by cmd_move(), cmd_setlocal(), and CommandDelete().

◆ error_invalid_switch()

VOID error_invalid_switch ( TCHAR ch )

Referenced by cmd_mklink(), cmd_shift(), cmd_ver(), and DirReadParam().

◆ error_no_pipe()

VOID error_no_pipe ( VOID )

Definition at line 131 of file error.c.

{
    ConErrResPuts(STRING_ERROR_CANNOTPIPE);
    nErrorLevel = 1;
}

Referenced by ExecutePipeline().

◆ error_out_of_memory()

VOID error_out_of_memory ( VOID )

Definition at line 138 of file error.c.

{
    ConErrResPuts(STRING_ERROR_OUT_OF_MEMORY);
    nErrorLevel = 1;
}

Referenced by BatchParams(), cmd_call(), cmd_path(), cmd_setlocal(), cmd_start(), DoCommand(), ExecuteAsync(), ForF(), and PushDirectory().

◆ error_parameter_format()

VOID error_parameter_format ( TCHAR ch )

Referenced by DirReadParam().

◆ error_path_not_found()

VOID error_path_not_found ( VOID )

Definition at line 86 of file error.c.

{
    ConErrResPuts(STRING_ERROR_PATH_NOT_FOUND);
    nErrorLevel = 1;
}

◆ error_req_param_missing()

VOID error_req_param_missing ( VOID )

Definition at line 110 of file error.c.

{
    ConErrResPuts(STRING_ERROR_REQ_PARAM_MISSING);
    nErrorLevel = 1;
}

Referenced by cmd_ctty(), cmd_mklink(), cmd_move(), cmd_rename(), cmd_rmdir(), cmd_type(), CommandDelay(), CommandDelete(), and CommandScreen().

◆ error_sfile_not_found()

VOID error_sfile_not_found ( PCTSTR s )

Referenced by DeleteFiles(), and ForF().

◆ error_syntax()

VOID error_syntax ( PCTSTR s )

Referenced by cmd_move(), cmd_rename(), ExecuteIf(), ForF(), and ParseErrorEx().

◆ error_too_many_parameters()

VOID error_too_many_parameters ( PCTSTR s )

Referenced by cmd_mklink(), cmd_move(), and ExecutePipeline().

◆ ErrorMessage()

VOID ErrorMessage	(	IN DWORD	dwErrorCode,
		IN PCTSTR szFormat	OPTIONAL,
			...
	)

◆ ExecuteCommand()

INT ExecuteCommand ( IN struct _PARSED_COMMAND * Cmd )

◆ ExecuteCommandWithEcho()

INT ExecuteCommandWithEcho ( IN struct _PARSED_COMMAND * Cmd )

◆ ExecuteFor()

INT ExecuteFor ( struct _PARSED_COMMAND * Cmd )

Definition at line 604 of file for.c.

{
    INT Ret;
    LPTSTR List;
    PFOR_CONTEXT lpNew;
    TCHAR Buffer[CMDLINE_LENGTH]; /* Buffer to hold the variable value */
    LPTSTR BufferPtr = Buffer;
 
    List = DoDelayedExpansion(Cmd->For.List);
    if (!List)
        return 1;
 
    /* Create our FOR context */
    lpNew = cmd_alloc(sizeof(FOR_CONTEXT));
    if (!lpNew)
    {
        WARN("Cannot allocate memory for lpNew!\n");
        cmd_free(List);
        return 1;
    }
    lpNew->prev = fc;
    lpNew->firstvar = Cmd->For.Variable;
    lpNew->varcount = 1;
    lpNew->values = &BufferPtr;
 
    Cmd->For.Context = lpNew;
    fc = lpNew;
 
    /* Run the extended FOR syntax only if extensions are enabled */
    if (bEnableExtensions)
    {
        if (Cmd->For.Switches & FOR_F)
        {
            Ret = ForF(Cmd, List, Buffer);
        }
        else if (Cmd->For.Switches & FOR_LOOP)
        {
            Ret = ForLoop(Cmd, List, Buffer);
        }
        else if (Cmd->For.Switches & FOR_RECURSIVE)
        {
            DWORD Len = GetFullPathName(Cmd->For.Params ? Cmd->For.Params : _T("."),
                                        MAX_PATH, Buffer, NULL);
            Ret = ForRecursive(Cmd, List, Buffer, &Buffer[Len]);
        }
        else
        {
            Ret = ForDir(Cmd, List, Buffer, Buffer);
        }
    }
    else
    {
        Ret = ForDir(Cmd, List, Buffer, Buffer);
    }
 
    /* Remove our context, unless someone already did that */
    if (fc == lpNew)
        fc = lpNew->prev;
 
    cmd_free(lpNew);
    cmd_free(List);
    return Ret;
}

Referenced by ExecuteCommand().

◆ ExecuteIf()

INT ExecuteIf ( struct _PARSED_COMMAND * Cmd )

Definition at line 66 of file if.c.

{
    INT result = FALSE; /* when set cause 'then' clause to be executed */
    LPTSTR param;
    LPTSTR Left = NULL, Right;
 
    if (Cmd->If.LeftArg)
    {
        Left = DoDelayedExpansion(Cmd->If.LeftArg);
        if (!Left)
            return 1;
    }
    Right = DoDelayedExpansion(Cmd->If.RightArg);
    if (!Right)
    {
        if (Left) cmd_free(Left);
        return 1;
    }
 
    if (bEnableExtensions && (Cmd->If.Operator == IF_CMDEXTVERSION))
    {
        /* IF CMDEXTVERSION n: check if Command Extensions
         * version is greater or equal to n. */
        DWORD n = _tcstoul(Right, &param, 10);
        if (*param != _T('\0'))
        {
            error_syntax(Right);
            goto fail;
        }
        result = (CMDEXTVERSION >= n);
    }
    else if (bEnableExtensions && (Cmd->If.Operator == IF_DEFINED))
    {
        /* IF DEFINED var: check if environment variable exists */
        result = (GetEnvVarOrSpecial(Right) != NULL);
    }
    else if (Cmd->If.Operator == IF_ERRORLEVEL)
    {
        /* IF ERRORLEVEL n: check if last exit code is greater or equal to n */
        INT n = _tcstol(Right, &param, 10);
        if (*param != _T('\0'))
        {
            error_syntax(Right);
            goto fail;
        }
        result = (nErrorLevel >= n);
    }
    else if (Cmd->If.Operator == IF_EXIST)
    {
        BOOL IsDir;
        SIZE_T Size;
        WIN32_FIND_DATA f;
        HANDLE hFind;
        DWORD attrs;
 
        /* IF EXIST filename: check if file exists (wildcards allowed) */
        StripQuotes(Right);
 
        Size = _tcslen(Right);
        IsDir = (Right[Size - 1] == '\\');
        if (IsDir)
            Right[Size - 1] = 0;
 
        hFind = FindFirstFile(Right, &f);
        if (hFind != INVALID_HANDLE_VALUE)
        {
            attrs = f.dwFileAttributes;
            FindClose(hFind);
        }
        else
        {
            /* FindFirstFile fails at the root directory. */
            attrs = GetFileAttributes(Right);
        }
 
        if (attrs == INVALID_FILE_ATTRIBUTES)
            result = FALSE;
        else if (IsDir)
            result = ((attrs & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
        else
            result = TRUE;
 
        if (IsDir)
            Right[Size - 1] = '\\';
    }
    else
    {
        /*
         * Do case-insensitive string comparisons if /I specified.
         *
         * Since both strings are user-specific, use kernel32!lstrcmp(i)
         * instead of CRT!_tcs(i)cmp, so as to use the correct
         * current thread locale information.
         */
        INT (WINAPI *StringCmp)(LPCTSTR, LPCTSTR) =
            (Cmd->If.Flags & IFFLAG_IGNORECASE) ? lstrcmpi : lstrcmp;
 
        if (Cmd->If.Operator == IF_STRINGEQ)
        {
            /* IF str1 == str2 */
            result = (StringCmp(Left, Right) == 0);
        }
        else if (bEnableExtensions)
        {
            result = GenericCmp(StringCmp, Left, Right);
            switch (Cmd->If.Operator)
            {
            case IF_EQU: result = (result == 0); break;
            case IF_NEQ: result = (result != 0); break;
            case IF_LSS: result = (result <  0); break;
            case IF_LEQ: result = (result <= 0); break;
            case IF_GTR: result = (result >  0); break;
            case IF_GEQ: result = (result >= 0); break;
            default: goto unknownOp;
            }
        }
        else
        {
unknownOp:
            ERR("Unknown IF operator 0x%x\n", Cmd->If.Operator);
            ASSERT(FALSE);
            goto fail;
        }
    }
 
    if (Left) cmd_free(Left);
    cmd_free(Right);
 
    if (result ^ ((Cmd->If.Flags & IFFLAG_NEGATE) != 0))
    {
        /* Full condition was true, do the command */
        return ExecuteCommand(Cmd->Subcommands);
    }
    else
    {
        /* Full condition was false, do the "else" command if there is one */
        return ExecuteCommand(Cmd->Subcommands->Next);
    }
 
fail:
    if (Left) cmd_free(Left);
    cmd_free(Right);
    return 1;
}

Referenced by ExecuteCommand().

◆ ExpandAlias()

VOID ExpandAlias	(	LPTSTR	cmd,
		INT	maxlen
	)

Definition at line 89 of file alias.c.

{
    LPTSTR buffer;
    TCHAR *position, *in, *out;
    LPTSTR Token;
    LPTSTR tmp;
 
    tmp = cmd_dup(cmd);
    if (!tmp)
        return;
 
    /* first part is the macro name */
    position = tmp + _tcscspn(tmp, _T(" \n"));
    if (position == tmp)
    {
        cmd_free(tmp);
        return;
    }
    *position++ = _T('\0');
    position += _tcsspn(position, _T(" "));
 
    buffer = cmd_alloc(maxlen);
    if (!buffer)
    {
        WARN("Cannot allocate memory for alias buffer!\n");
        cmd_free(tmp);
        return;
    }
 
    if (GetConsoleAlias(tmp, buffer, maxlen, _T("cmd.exe")) == 0)
    {
        cmd_free(tmp);
        cmd_free(buffer);
        return;
    }
 
    in = buffer;
    out = cmd;
    while (*in)
    {
        if (*in == _T('$'))
        {
            Token = position;
            if (in[1] >= _T('1') && in[1] <= _T('9'))
            {
                /* Copy a single space-delimited token from the input line */
                INT num;
                for (num = in[1] - _T('1'); num > 0; num--)
                {
                    Token += _tcscspn(Token, _T(" \n"));
                    Token += _tcsspn(Token, _T(" "));
                }
                while (!_tcschr(_T(" \n"), *Token))
                {
                    if (out >= &cmd[maxlen - 1])
                        break;
                    *out++ = *Token++;
                }
                in += 2;
                continue;
            }
            else if (in[1] == _T('*'))
            {
                /* Copy the entire remainder of the line */
                while (*Token && *Token != _T('\n'))
                {
                    if (out >= &cmd[maxlen - 1])
                        break;
                    *out++ = *Token++;
                }
                in += 2;
                continue;
            }
        }
        if (out >= &cmd[maxlen - 1])
            break;
        *out++ = *in++;
    }
    *out++ = _T('\n');
    *out = _T('\0');
 
    cmd_free(buffer);
    cmd_free(tmp);
}

Referenced by ReadCommand().

◆ FilePromptYN()

INT FilePromptYN ( UINT resID )

Definition at line 573 of file misc.c.

{
    TCHAR szMsg[RC_STRING_MAX_SIZE];
//  TCHAR cKey = 0;
//  LPTSTR szKeys = _T("yna");
 
    TCHAR szIn[10];
    LPTSTR p;
 
    if (resID != 0)
        ConOutResPrintf (resID);
 
    /* preliminary fix */
    ConInString(szIn, 10);
 
    _tcsupr (szIn);
    for (p = szIn; _istspace (*p); p++)
        ;
 
    LoadString(CMD_ModuleHandle, STRING_CHOICE_OPTION, szMsg, ARRAYSIZE(szMsg));
 
    if (_tcsncmp(p, &szMsg[0], 1) == 0)
        return PROMPT_YES;
    else if (_tcsncmp(p, &szMsg[1], 1) == 0)
        return PROMPT_NO;
#if 0
    else if (*p == _T('\03'))
        return PROMPT_BREAK;
#endif
 
    return PROMPT_NO;
 
    /* unfinished solution */
#if 0
    RemoveBreakHandler();
    ConInDisable();
 
    do
    {
        ConInKey (&ir);
        cKey = _totlower (ir.Event.KeyEvent.uChar.AsciiChar);
        if (_tcschr (szKeys, cKey[0]) == NULL)
            cKey = 0;
 
 
    }
    while ((ir.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
           (ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
           (ir.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL));
 
    AddBreakHandler();
    ConInEnable();
 
    if ((ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
        ((ir.Event.KeyEvent.wVirtualKeyCode == 'C') &&
         (ir.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))))
        return PROMPT_BREAK;
 
    return PROMPT_YES;
#endif
}

Referenced by DeleteFiles().

◆ FilePromptYNA()

INT FilePromptYNA ( UINT resID )

Definition at line 110 of file util.c.

{
    TCHAR szMsg[RC_STRING_MAX_SIZE];
//  TCHAR cKey = 0;
//  LPTSTR szKeys = _T("yna");
 
    TCHAR szIn[10];
    LPTSTR p;
 
    if (resID != 0)
        ConOutResPrintf (resID);
 
    /* preliminary fix */
    ConInString(szIn, 10);
 
    _tcsupr (szIn);
    for (p = szIn; _istspace (*p); p++)
        ;
 
    LoadString(NULL, STRING_COPY_OPTION, szMsg, ARRAYSIZE(szMsg));
 
    if (_tcsncmp(p, &szMsg[0], 1) == 0)
        return PROMPT_YES;
    else if (_tcsncmp(p, &szMsg[1], 1) == 0)
        return PROMPT_NO;
    else if (_tcsncmp(p, &szMsg[2], 1) == 0)
        return PROMPT_ALL;
#if 0
    else if (*p == _T('\03'))
        return PROMPT_BREAK;
#endif
 
    return PROMPT_NO;
 
    /* unfinished solution */
#if 0
    RemoveBreakHandler();
    ConInDisable();
 
    do
    {
        ConInKey (&ir);
        cKey = _totlower (ir.Event.KeyEvent.uChar.AsciiChar);
        if (_tcschr (szKeys, cKey[0]) == NULL)
            cKey = 0;
    }
    while ((ir.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
           (ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
           (ir.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL));
 
    AddBreakHandler();
    ConInEnable();
 
    if ((ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
        ((ir.Event.KeyEvent.wVirtualKeyCode == _T('C')) &&
         (ir.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))))
        return PROMPT_BREAK;
 
    return PROMPT_YES;
#endif
}

◆ FormatDate()

INT FormatDate	(	TCHAR *	lpDate,
		LPSYSTEMTIME	dt,
		BOOL	b4Digit
	)

Definition at line 675 of file dir.c.

{
    /* Format date */
    WORD wYear = b4Digit ? dt->wYear : dt->wYear%100;
    switch (nDateFormat)
    {
        case 0: /* mmddyy */
        default:
            return _stprintf(lpDate, _T("%02d%c%02d%c%0*d"),
                    dt->wMonth, cDateSeparator,
                    dt->wDay, cDateSeparator,
                    b4Digit?4:2, wYear);
            break;
 
        case 1: /* ddmmyy */
            return _stprintf(lpDate, _T("%02d%c%02d%c%0*d"),
                    dt->wDay, cDateSeparator, dt->wMonth,
                    cDateSeparator, b4Digit?4:2, wYear);
            break;
 
        case 2: /* yymmdd */
            return _stprintf(lpDate, _T("%0*d%c%02d%c%02d"),
                    b4Digit?4:2, wYear, cDateSeparator,
                    dt->wMonth, cDateSeparator, dt->wDay);
            break;
    }
}

Referenced by DirPrintFileDateTime(), and GetEnhancedVar().

◆ FormatTime()

INT FormatTime	(	TCHAR *	lpTime,
		LPSYSTEMTIME	dt
	)

Definition at line 704 of file dir.c.

{
    /* Format Time */
    switch (nTimeFormat)
    {
        case 0: /* 12 hour format */
        default:
            return _stprintf(lpTime,_T("%02d%c%02u %cM"),
                    (dt->wHour == 0 ? 12 : (dt->wHour <= 12 ? dt->wHour : dt->wHour - 12)),
                    cTimeSeparator,
                     dt->wMinute, (dt->wHour <= 11 ? _T('A') : _T('P')));
            break;
 
        case 1: /* 24 hour format */
            return _stprintf(lpTime, _T("%02d%c%02u"),
                    dt->wHour, cTimeSeparator, dt->wMinute);
            break;
    }
}

Referenced by cmd_time(), DirPrintFileDateTime(), and GetEnhancedVar().

◆ FreeCommand()

VOID FreeCommand ( IN OUT PARSED_COMMAND * Cmd )

Definition at line 527 of file parser.c.

{
    if (Cmd->Subcommands)
        FreeCommand(Cmd->Subcommands);
    if (Cmd->Next)
        FreeCommand(Cmd->Next);
    FreeRedirection(Cmd->Redirections);
    if (Cmd->Type == C_FOR)
    {
        cmd_free(Cmd->For.Params);
        cmd_free(Cmd->For.List);
    }
    else if (Cmd->Type == C_IF)
    {
        cmd_free(Cmd->If.LeftArg);
        cmd_free(Cmd->If.RightArg);
    }
    cmd_free(Cmd);
}

Referenced by Batch(), cmd_call(), FreeCommand(), ParseBlock(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandLine(), ParseFor(), ParseIf(), and ProcessInput().

◆ FreeLastPath()

VOID FreeLastPath ( VOID )

◆ freep()

VOID freep ( LPTSTR * p )

Definition at line 460 of file misc.c.

{
    LPTSTR *q;
 
    if (!p)
        return;
 
    q = p;
    while (*q)
        cmd_free(*q++);
 
    cmd_free(p);
}

Referenced by split(), and splitspace().

◆ FreeRedirection()

VOID FreeRedirection ( REDIRECTION * Redir )

Definition at line 153 of file redir.c.

{
    REDIRECTION *Next;
    for (; Redir; Redir = Next)
    {
        Next = Redir->Next;
        ASSERT(Redir->OldHandle == INVALID_HANDLE_VALUE);
        cmd_free(Redir);
    }
}

Referenced by ExitBatch(), FreeCommand(), ParsePrimary(), and ParseRedirection().

◆ GetDateString()

LPTSTR GetDateString ( VOID )

Definition at line 58 of file locale.c.

{
    static TCHAR szDate[32];
    SYSTEMTIME t;
 
    GetLocalTime(&t);
    GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &t, NULL, szDate, ARRAYSIZE(szDate));
    return szDate;
}

Referenced by cmd_date(), GetEnvVarOrSpecial(), and PrintPrompt().

◆ GetDirectoryStackDepth()

INT GetDirectoryStackDepth ( VOID )

Definition at line 98 of file dirstack.c.

{
    return nStackDepth;
}

Referenced by PrintPrompt().

◆ GetEnvVarOrSpecial()

LPCTSTR GetEnvVarOrSpecial ( LPCTSTR varName )

Definition at line 904 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().

◆ GetHandle()

HANDLE GetHandle ( UINT Number )

Definition at line 39 of file redir.c.

{
    if (Number < 3)
        return ConStreamGetOSHandle(StdStreams[Number]);
        // return GetStdHandle(STD_INPUT_HANDLE - Number);
    else if (Number < ARRAYSIZE(ExtraHandles) + 3)
        return ExtraHandles[Number - 3];
    else
        return INVALID_HANDLE_VALUE;
}

◆ GetParsedEnvVar()

LPCTSTR GetParsedEnvVar	(	LPCTSTR	varName,
		UINT *	varNameLen,
		BOOL	ModeSetA
	)

◆ GetPathCase()

VOID GetPathCase	(	IN LPCTSTR	Path,
		OUT LPTSTR	OutPath
	)

Definition at line 86 of file misc.c.

{
    SIZE_T i;
    SIZE_T cchPath = _tcslen(Path);
    TCHAR TempPath[MAX_PATH];
    LPTSTR pchTemp = TempPath;
    LPTSTR pchTempEnd = TempPath + _countof(TempPath);
    WIN32_FIND_DATA FindFileData;
    HANDLE hFind;
 
    *pchTemp = OutPath[0] = 0;
 
    for (i = 0; i < cchPath; ++i)
    {
        if (pchTemp + 1 >= pchTempEnd)
        {
            // On failure, copy the original path for an error message
            StringCchCopy(OutPath, MAX_PATH, Path);
            return;
        }
 
        if (Path[i] != _T('\\') && Path[i] != _T('/'))
        {
            *pchTemp++ = Path[i];
            *pchTemp = 0;
            if (i != cchPath - 1)
                continue;
        }
 
        /* Handle the base part of the path different.
           Because if you put it into findfirstfile, it will
           return your current folder */
        if (TempPath[0] && TempPath[1] == _T(':') && !TempPath[2]) /* "C:", "D:" etc. */
        {
            StringCchCat(OutPath, MAX_PATH, TempPath);
            StringCchCat(OutPath, MAX_PATH, _T("\\"));
            StringCchCat(TempPath, _countof(TempPath), _T("\\"));
        }
        else
        {
            hFind = FindFirstFile(TempPath, &FindFileData);
            if (hFind == INVALID_HANDLE_VALUE)
            {
                StringCchCopy(OutPath, MAX_PATH, Path);
                return;
            }
            FindClose(hFind);
            StringCchCat(OutPath, MAX_PATH, _T("\\"));
            StringCchCat(OutPath, MAX_PATH, FindFileData.cFileName);
            StringCchCat(OutPath, MAX_PATH, _T("\\"));
            StringCchCopy(TempPath, _countof(TempPath), OutPath);
        }
        pchTemp = TempPath + _tcslen(TempPath);
    }
}

◆ GetRedirection()

INT GetRedirection	(	LPTSTR	,
		REDIRECTION **
	)

◆ GetRootPath()

INT GetRootPath	(	IN LPCTSTR	InPath,
		OUT LPTSTR	OutPath,
		IN INT	size
	)

Definition at line 21 of file util.c.

{
    if (InPath[0] && InPath[1] == _T(':'))
    {
        INT t = 0;
 
        if ((InPath[0] >= _T('0')) && (InPath[0] <= _T('9')))
        {
            t = (InPath[0] - _T('0')) + 28;
        }
        else if ((InPath[0] >= _T('a')) && (InPath[0] <= _T('z')))
        {
            t = (InPath[0] - _T('a')) + 1;
        }
        else if ((InPath[0] >= _T('A')) && (InPath[0] <= _T('Z')))
        {
            t = (InPath[0] - _T('A')) + 1;
        }
 
        return (_tgetdcwd(t, OutPath, size) == NULL);
    }
 
    /* Get current directory */
    return !GetCurrentDirectory(size, OutPath);
}

Referenced by cmd_chdir().

◆ GetTimeString()

LPTSTR GetTimeString ( VOID )

Definition at line 70 of file locale.c.

{
    static TCHAR szTime[12];
    SYSTEMTIME t;
    GetLocalTime(&t);
    _stprintf(szTime, _T("%2d%c%02d%c%02d%c%02d"),
        t.wHour, cTimeSeparator, t.wMinute, cTimeSeparator,
        t.wSecond, cDecimalSeparator, t.wMilliseconds / 10);
    return szTime;
}

Referenced by cmd_time(), CommandTimer(), GetEnvVarOrSpecial(), and PrintPrompt().

◆ HasInfoLine()

BOOL HasInfoLine ( VOID )

Definition at line 72 of file prompt.c.

{
    LPTSTR pr;
    TCHAR szPrompt[256];
 
    if (GetEnvironmentVariable(_T("PROMPT"), szPrompt, _countof(szPrompt)))
    {
        pr = szPrompt;
        while (*pr)
        {
            if (*pr++ != _T('$'))
                continue;
            if (!*pr || _totupper(*pr++) != _T('I'))
                continue;
 
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by Initialize(), and PrintPrompt().

◆ InitDirectoryStack()

VOID InitDirectoryStack ( VOID )

Definition at line 80 of file dirstack.c.

{
    nStackDepth = 0;
    lpStackTop = NULL;
    lpStackBottom = NULL;
}

Referenced by Initialize().

◆ InitLastPath()

VOID InitLastPath ( VOID )

◆ InitLocale()

VOID InitLocale ( VOID )

Definition at line 25 of file locale.c.

{
    TCHAR szBuffer[256];
 
    /* date settings */
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDATE, szBuffer, ARRAYSIZE(szBuffer));
    cDateSeparator = szBuffer[0];
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDATE | LOCALE_RETURN_NUMBER, (LPTSTR)&nDateFormat, sizeof(nDateFormat) / sizeof(TCHAR));
 
    /* time settings */
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STIME, szBuffer, ARRAYSIZE(szBuffer));
    cTimeSeparator = szBuffer[0];
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITIME | LOCALE_RETURN_NUMBER, (LPTSTR)&nTimeFormat, sizeof(nTimeFormat) / sizeof(TCHAR));
 
    /* number settings */
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, szBuffer, ARRAYSIZE(szBuffer));
    cThousandSeparator = szBuffer[0];
    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, szBuffer, ARRAYSIZE(szBuffer));
    cDecimalSeparator  = szBuffer[0];
        GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, szBuffer, ARRAYSIZE(szBuffer));
        nNumberGroups = _ttoi(szBuffer);
#if 0
    /* days of week */
    for (i = 0; i < 7; i++)
    {
        GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1 + i, szBuffer, ARRAYSIZE(szBuffer));
        _tcscpy(aszDayNames[(i+1)%7], szBuffer); /* little hack */
    }
#endif
}

Referenced by cmd_start(), Execute(), and Initialize().

◆ InitOSVersion()

VOID InitOSVersion ( VOID )

Definition at line 32 of file ver.c.

{
    LONG lResult;
    HKEY hKey;
 
    /* Get version information */
    ZeroMemory(&osvi, sizeof(osvi));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    GetVersionEx(&osvi);
 
    /* Build OS version string */
 
    /* Open registry key */
    lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                           _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"),
                           0,
                           KEY_QUERY_VALUE,
                           &hKey);
    if (lResult == ERROR_SUCCESS)
    {
        DWORD dwSize, dwType;
 
        /* Retrieve the ProductName value */
        dwSize = sizeof(szOSName);
        lResult = RegQueryValueEx(hKey,
                                  _T("ProductName"),
                                  NULL,
                                  &dwType,
                                  (LPBYTE)szOSName,
                                  &dwSize);
 
        /* If we have failed or the data type is unsupported... */
        if (lResult != ERROR_SUCCESS || dwType != REG_SZ)
        {
            /* ... reserve size for one NULL character only! */
            dwSize = sizeof(TCHAR);
 
            /* Set an error code (anything != ERROR_SUCCESS) */
            lResult = ERROR_INVALID_PARAMETER;
        }
 
        /* NULL-terminate the string */
        szOSName[(dwSize / sizeof(TCHAR)) - 1] = _T('\0');
 
        /* Close the key */
        RegCloseKey(hKey);
    }
 
    /*
     * If the registry key somehow doesn't exist or cannot be loaded, then
     * determine at least whether the version of Windows is either 9x or NT.
     */
    if (lResult != ERROR_SUCCESS)
    {
        switch (osvi.dwPlatformId)
        {
            case VER_PLATFORM_WIN32_WINDOWS:
            {
                if (osvi.dwMajorVersion == 4)
                {
                    if (osvi.dwMinorVersion == 0)
                        _tcscpy(szOSName, _T("Windows 95"));
                    else if (osvi.dwMinorVersion == 1)
                        _tcscpy(szOSName, _T("Windows 98"));
                    else if (osvi.dwMinorVersion == 9)
                        _tcscpy(szOSName, _T("Windows ME"));
                    else
                        _tcscpy(szOSName, _T("Windows 9x"));
                }
                break;
            }
 
            case VER_PLATFORM_WIN32_NT:
            {
                _tcscpy(szOSName, _T("Windows NT"));
                break;
            }
        }
    }
}

Referenced by Initialize().

◆ InitPrompt()

VOID InitPrompt ( VOID )

Definition at line 57 of file prompt.c.

{
    TCHAR Buffer[2];
 
    /*
     * Set the PROMPT environment variable if it doesn't exist already.
     * You can change the PROMPT environment variable before cmd starts.
     */
    if (GetEnvironmentVariable(_T("PROMPT"), Buffer, _countof(Buffer)) == 0)
        SetEnvironmentVariable(_T("PROMPT"), DefaultPrompt);
}

Referenced by Initialize().

◆ IsExistingDirectory()

BOOL IsExistingDirectory ( IN LPCTSTR pszPath )

Definition at line 104 of file util.c.

{
    DWORD attr = GetFileAttributes(pszPath);
    return ((attr != INVALID_FILE_ATTRIBUTES) && (attr & FILE_ATTRIBUTE_DIRECTORY));
}

◆ IsExistingFile()

BOOL IsExistingFile ( IN LPCTSTR pszPath )

Definition at line 98 of file util.c.

{
    DWORD attr = GetFileAttributes(pszPath);
    return ((attr != INVALID_FILE_ATTRIBUTES) && !(attr & FILE_ATTRIBUTE_DIRECTORY));
}

◆ IsValidPathName()

BOOL IsValidPathName ( IN LPCTSTR pszPath )

Definition at line 496 of file misc.c.

{
    BOOL  bResult;
    TCHAR szOldPath[MAX_PATH];
 
    GetCurrentDirectory(ARRAYSIZE(szOldPath), szOldPath);
    bResult = SetCurrentDirectory(pszPath);
 
    SetCurrentDirectory(szOldPath);
 
    return bResult;
}

◆ msg_pause()

VOID msg_pause ( VOID )

Definition at line 210 of file util.c.

{
    ConOutResPuts(STRING_ERROR_D_PAUSEMSG);
}

◆ OnOffCommand()

BOOL OnOffCommand	(	LPTSTR	param,
		LPBOOL	flag,
		INT	message
	)

Definition at line 32 of file echo.c.

{
    TCHAR *p2;
    if (_tcsnicmp(param, D_OFF, sizeof(D_OFF)/sizeof(TCHAR) - 1) == 0)
    {
        p2 = param + sizeof(D_OFF)/sizeof(TCHAR) - 1;
        while (_istspace(*p2))
            p2++;
        if (*p2 == _T('\0'))
        {
            *flag = FALSE;
            return TRUE;
        }
    }
    else if (_tcsnicmp(param, D_ON, sizeof(D_ON)/sizeof(TCHAR) - 1) == 0)
    {
        p2 = param + sizeof(D_ON)/sizeof(TCHAR) - 1;
        while (_istspace(*p2))
            p2++;
        if (*p2 == _T('\0'))
        {
            *flag = TRUE;
            return TRUE;
        }
    }
    else if (*param == _T('\0'))
    {
        ConOutResPrintf(message, *flag ? D_ON : D_OFF);
        return TRUE;
    }
    return FALSE;
}

Referenced by cmd_verify(), and CommandEcho().

◆ PagePrompt()

BOOL __stdcall PagePrompt	(	PCON_PAGER	Pager,
		DWORD	Done,
		DWORD	Total
	)

Definition at line 526 of file misc.c.

{
    SHORT iScreenWidth, iCursorY;
    INPUT_RECORD ir;
 
    ConOutResPuts(STRING_MISC_HELP1);
 
    RemoveBreakHandler();
    ConInDisable();
 
    do
    {
        ConInKey(&ir);
    }
    while ((ir.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
           (ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
           (ir.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL));
 
    AddBreakHandler();
    ConInEnable();
 
    /*
     * Get the screen width, erase the full line where the cursor is,
     * and move the cursor back to the beginning of the line.
     */
    GetScreenSize(&iScreenWidth, NULL);
    iCursorY = GetCursorY();
    SetCursorXY(0, iCursorY);
    while (iScreenWidth-- > 0) // Or call FillConsoleOutputCharacter ?
        ConOutChar(_T(' '));
    SetCursorXY(0, iCursorY);
 
    if ((ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
        ((ir.Event.KeyEvent.wVirtualKeyCode == _T('C')) &&
         (ir.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))))
    {
        /* We break, output a newline */
        ConOutChar(_T('\n'));
 
        bCtrlBreak = TRUE;
        return FALSE;
    }
 
    return TRUE;
}

◆ ParseCommand()

PARSED_COMMAND * ParseCommand ( IN PCTSTR Line )

Definition at line 1461 of file parser.c.

{
    PARSED_COMMAND* Cmd;
 
    if (Line)
    {
        if (!SubstituteVars(Line, ParseLine, _T('%')))
            return NULL;
        bLineContinuations = FALSE;
    }
    else
    {
        if (!ReadLine(ParseLine, FALSE))
            return NULL;
        bLineContinuations = TRUE;
    }
 
    InitParser();
 
    Cmd = ParseCommandOp(C_OP_LOWEST);
    if (Cmd)
    {
        bIgnoreEcho = FALSE;
 
        if ((CurrentTokenType != TOK_END) &&
            (_tcscmp(CurrentToken, _T("\n")) != 0))
        {
            ParseError();
        }
        if (bParseError)
        {
            FreeCommand(Cmd);
            return NULL;
        }
 
        /* Debugging support */
        if (fDumpParse)
            DumpCommand(Cmd, 0);
    }
    else
    {
        bIgnoreEcho = TRUE;
    }
    return Cmd;
}

Referenced by Batch(), cmd_call(), ParseCommandLine(), and ProcessInput().

◆ ParseCommandLine()

INT ParseCommandLine ( LPTSTR cmd )

Definition at line 636 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().

◆ ParseErrorEx()

VOID ParseErrorEx ( IN PCTSTR s )

Definition at line 227 of file parser.c.

{
    /* Only display the first error we encounter */
    if (!bParseError)
        error_syntax(s);
    bParseError = TRUE;
}

Referenced by cmd_for(), cmd_if(), GetBatchVar(), ParseCommandPart(), and ParseError().

◆ PerformRedirection()

BOOL PerformRedirection ( REDIRECTION * RedirList )

Definition at line 63 of file redir.c.

{
    REDIRECTION *Redir;
    LPTSTR Filename;
    HANDLE hNew;
    UINT DupNumber;
 
    static SECURITY_ATTRIBUTES SecAttr = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
 
    /* Some parameters used for read, write, and append, respectively */
    static struct REDIR_PARAMS
    {
        DWORD dwDesiredAccess;
        DWORD dwShareMode;
        DWORD dwCreationDisposition;
    } RedirParams[] =
    {
        {GENERIC_READ , FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING}, // REDIR_READ
        {GENERIC_WRITE, FILE_SHARE_READ                   , CREATE_ALWAYS}, // REDIR_WRITE
        {GENERIC_WRITE, FILE_SHARE_READ                   , OPEN_ALWAYS  }  // REDIR_APPEND
    };
 
    for (Redir = RedirList; Redir; Redir = Redir->Next)
    {
        Filename = DoDelayedExpansion(Redir->Filename);
        if (!Filename)
            goto redir_error;
        StripQuotes(Filename);
 
        if (*Filename == _T('&'))
        {
            DupNumber = Filename[1] - _T('0');
            if (DupNumber >= 10 ||
                !DuplicateHandle(GetCurrentProcess(),
                                 GetHandle(DupNumber),
                                 GetCurrentProcess(),
                                 &hNew,
                                 0,
                                 TRUE,
                                 DUPLICATE_SAME_ACCESS))
            {
                hNew = INVALID_HANDLE_VALUE;
            }
        }
        else
        {
            hNew = CreateFile(Filename,
                              RedirParams[Redir->Mode].dwDesiredAccess,
                              RedirParams[Redir->Mode].dwShareMode,
                              &SecAttr,
                              RedirParams[Redir->Mode].dwCreationDisposition,
                              0,
                              NULL);
        }
 
        if (hNew == INVALID_HANDLE_VALUE)
        {
            /* TODO: Print a more detailed message */
            ConErrResPrintf(Redir->Mode == REDIR_READ ? STRING_CMD_ERROR1 : STRING_CMD_ERROR3,
                            Filename);
            cmd_free(Filename);
redir_error:
            /* Undo all the redirections before this one */
            UndoRedirection(RedirList, Redir);
            return FALSE;
        }
 
        if (Redir->Mode == REDIR_APPEND)
            SetFilePointer(hNew, 0, NULL, FILE_END);
        Redir->OldHandle = GetHandle(Redir->Number);
        SetHandle(Redir->Number, hNew);
 
        TRACE("%d redirected to: %s\n", Redir->Number, debugstr_aw(Filename));
        cmd_free(Filename);
    }
    return TRUE;
}

Referenced by ExecuteCommand().

◆ PrintCommandList()

VOID PrintCommandList ( VOID )

Definition at line 230 of file cmdtable.c.

{
    LPCOMMAND cmdptr;
    INT y;
 
    y = 0;
    cmdptr = cmds;
    while (cmdptr->name)
    {
        if (!(cmdptr->flags & CMD_HIDE))
        {
            if (++y == 8)
            {
                ConOutPuts(cmdptr->name);
                ConOutChar(_T('\n'));
                y = 0;
            }
            else
            {
                ConOutPrintf (_T("%-10s"), cmdptr->name);
            }
        }
 
        cmdptr++;
    }
 
    if (y != 0)
        ConOutChar(_T('\n'));
}

Referenced by CommandShowCommands().

◆ PrintOSVersion()

VOID PrintOSVersion ( VOID )

Definition at line 114 of file ver.c.

{
    ConOutResPrintf(STRING_VERSION_RUNVER, szOSName,
                    osvi.dwMajorVersion, osvi.dwMinorVersion,
                    osvi.dwBuildNumber, osvi.szCSDVersion);
}

◆ PrintPrompt()

VOID PrintPrompt ( VOID )

Definition at line 134 of file prompt.c.

{
    LPTSTR pr, Prompt;
    TCHAR szPrompt[256];
    TCHAR szPath[MAX_PATH];
 
    if (GetEnvironmentVariable(_T("PROMPT"), szPrompt, _countof(szPrompt)))
        Prompt = szPrompt;
    else
        Prompt = DefaultPrompt;
 
    /*
     * Special pre-handling for $I: If the information line is displayed
     * on top of the screen, ensure that the prompt won't be hidden below it.
     */
    if (HasInfoLine() && GetCursorY() == 0)
        ConOutChar(_T('\n'));
 
    /* Parse the prompt string */
    for (pr = Prompt; *pr; ++pr)
    {
        if (*pr != _T('$'))
        {
            ConOutChar(*pr);
        }
        else
        {
            ++pr;
            if (!*pr) break;
            switch (_totupper(*pr))
            {
                case _T('A'):
                    ConOutChar(_T('&'));
                    break;
 
                case _T('B'):
                    ConOutChar(_T('|'));
                    break;
 
                case _T('C'):
                    ConOutChar(_T('('));
                    break;
 
                case _T('D'):
                    ConOutPrintf(_T("%s"), GetDateString());
                    break;
 
                case _T('E'):
                    ConOutChar(_T('\x1B'));
                    break;
 
                case _T('F'):
                    ConOutChar(_T(')'));
                    break;
 
                case _T('G'):
                    ConOutChar(_T('>'));
                    break;
 
                case _T('H'):
                    ConOutPuts(_T("\x08 \x08"));
                    break;
 
                case _T('I'):
                    PrintInfoLine();
                    break;
 
                case _T('L'):
                    ConOutChar(_T('<'));
                    break;
 
                case _T('N'):
                {
                    GetCurrentDirectory(_countof(szPath), szPath);
                    ConOutChar(szPath[0]);
                    break;
                }
 
                case _T('P'):
                {
                    GetCurrentDirectory(_countof(szPath), szPath);
                    ConOutPrintf(_T("%s"), szPath);
                    break;
                }
 
                case _T('Q'):
                    ConOutChar(_T('='));
                    break;
 
                case _T('S'):
                    ConOutChar(_T(' '));
                    break;
 
                case _T('T'):
                    ConOutPrintf(_T("%s"), GetTimeString());
                    break;
 
                case _T('V'):
                    PrintOSVersion();
                    break;
 
                case _T('_'):
                    ConOutChar(_T('\n'));
                    break;
 
                case _T('$'):
                    ConOutChar(_T('$'));
                    break;
 
#ifdef FEATURE_DIRECTORY_STACK
                case _T('+'):
                {
                    INT i;
                    for (i = 0; i < GetDirectoryStackDepth(); i++)
                        ConOutChar(_T('+'));
                    break;
                }
#endif
            }
        }
    }
}

Referenced by Batch(), ExecuteCommandWithEcho(), ReadCommand(), and ReadLine().

◆ ReadCommand()

BOOL ReadCommand	(	LPTSTR	str,
		INT	maxlen
	)

Definition at line 138 of file cmdinput.c.

{
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    SHORT orgx;     /* origin x/y */
    SHORT orgy;
    SHORT curx;     /*current x/y cursor position*/
    SHORT cury;
    SIZE_T tempscreen;
    INT   count;    /*used in some for loops*/
    INT   current = 0;  /*the position of the cursor in the string (str)*/
    INT   charcount = 0;/*chars in the string (str)*/
    INPUT_RECORD ir;
    DWORD dwControlKeyState;
#ifdef FEATURE_UNIX_FILENAME_COMPLETION
    WORD   wLastKey = 0;
#endif
    TCHAR  ch;
    BOOL bReturn = FALSE;
    BOOL bCharInput;
#ifdef FEATURE_4NT_FILENAME_COMPLETION
    TCHAR szPath[MAX_PATH];
#endif
#ifdef FEATURE_HISTORY
    //BOOL bContinue=FALSE;/*is TRUE the second case will not be executed*/
    TCHAR PreviousChar;
#endif
 
    if (!GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
    {
        /* No console */
        HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
        DWORD dwRead;
        CHAR chr;
        do
        {
            if (!ReadFile(hStdin, &chr, 1, &dwRead, NULL) || !dwRead)
                return FALSE;
#ifdef _UNICODE
            MultiByteToWideChar(InputCodePage, 0, &chr, 1, &str[charcount++], 1);
#endif
        } while (chr != '\n' && charcount < maxlen);
        str[charcount] = _T('\0');
        return TRUE;
    }
 
    /* get screen size */
    maxx = csbi.dwSize.X;
    maxy = csbi.dwSize.Y;
 
    curx = orgx = csbi.dwCursorPosition.X;
    cury = orgy = csbi.dwCursorPosition.Y;
 
    memset (str, 0, maxlen * sizeof (TCHAR));
 
    SetCursorType (bInsert, TRUE);
 
    do
    {
        bReturn = FALSE;
        ConInKey (&ir);
 
        dwControlKeyState = ir.Event.KeyEvent.dwControlKeyState;
 
        if (dwControlKeyState &
            (RIGHT_ALT_PRESSED |LEFT_ALT_PRESSED|
             RIGHT_CTRL_PRESSED|LEFT_CTRL_PRESSED) )
        {
            switch (ir.Event.KeyEvent.wVirtualKeyCode)
            {
#ifdef FEATURE_HISTORY
                case _T('K'):
                    /* add the current command line to the history */
                    if (dwControlKeyState &
                        (LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED))
                    {
                        if (str[0])
                            History(0,str);
 
                        ClearCommandLine (str, maxlen, orgx, orgy);
                        current = charcount = 0;
                        curx = orgx;
                        cury = orgy;
                        //bContinue=TRUE;
                    }
                    break;
 
                case _T('D'):
                    /* delete current history entry */
                    if (dwControlKeyState &
                        (LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED))
                    {
                        ClearCommandLine (str, maxlen, orgx, orgy);
                        History_del_current_entry(str);
                        current = charcount = _tcslen (str);
                        ConOutPrintf (_T("%s"), str);
                        GetCursorXY (&curx, &cury);
                        //bContinue=TRUE;
                    }
                    break;
#endif /*FEATURE_HISTORY*/
 
                case _T('M'):
                    /* ^M does the same as return */
                    if (dwControlKeyState &
                        (LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED))
                    {
                        /* end input, return to main */
#ifdef FEATURE_HISTORY
                        /* add to the history */
                        if (str[0])
                            History(0, str);
#endif /*FEATURE_HISTORY*/
                        str[charcount++] = _T('\n');
                        str[charcount] = _T('\0');
                        ConOutChar (_T('\n'));
                        bReturn = TRUE;
                    }
                    break;
 
                case _T('H'): /* ^H does the same as VK_BACK */
                    if (dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
                    {
                        bCharInput = FALSE;
                        goto DoBackSpace;
                    }
                    break;
            }
        }
 
        bCharInput = FALSE;
 
        switch (ir.Event.KeyEvent.wVirtualKeyCode)
        {
            case VK_BACK:
            DoBackSpace:
                /* <BACKSPACE> - delete character to left of cursor */
                if (current > 0 && charcount > 0)
                {
                    if (current == charcount)
                    {
                        /* if at end of line */
                        str[current - 1] = _T('\0');
                        if (GetCursorX () != 0)
                        {
                            ConOutPrintf (_T("\b \b"));
                            curx--;
                        }
                        else
                        {
                            SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
                            ConOutChar (_T(' '));
                            SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
                            cury--;
                            curx = maxx - 1;
                        }
                    }
                    else
                    {
                        for (count = current - 1; count < charcount; count++)
                            str[count] = str[count + 1];
                        if (GetCursorX () != 0)
                        {
                            SetCursorXY ((SHORT)(GetCursorX () - 1), GetCursorY ());
                            curx--;
                        }
                        else
                        {
                            SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
                            cury--;
                            curx = maxx - 1;
                        }
                        GetCursorXY (&curx, &cury);
                        ConOutPrintf (_T("%s "), &str[current - 1]);
                        SetCursorXY (curx, cury);
                    }
                    charcount--;
                    current--;
                }
                break;
 
            case VK_INSERT:
                /* toggle insert/overstrike mode */
                bInsert ^= TRUE;
                SetCursorType (bInsert, TRUE);
                break;
 
            case VK_DELETE:
                /* delete character under cursor */
                if (current != charcount && charcount > 0)
                {
                    for (count = current; count < charcount; count++)
                        str[count] = str[count + 1];
                    charcount--;
                    GetCursorXY (&curx, &cury);
                    ConOutPrintf (_T("%s "), &str[current]);
                    SetCursorXY (curx, cury);
                }
                break;
 
            case VK_HOME:
                /* goto beginning of string */
                if (current != 0)
                {
                    SetCursorXY (orgx, orgy);
                    curx = orgx;
                    cury = orgy;
                    current = 0;
                }
                break;
 
            case VK_END:
                /* goto end of string */
                if (current != charcount)
                {
                    SetCursorXY (orgx, orgy);
                    ConOutPrintf (_T("%s"), str);
                    GetCursorXY (&curx, &cury);
                    current = charcount;
                }
                break;
 
            case VK_TAB:
#ifdef FEATURE_UNIX_FILENAME_COMPLETION
                /* expand current file name */
                if ((current == charcount) ||
                    (current == charcount - 1 &&
                     str[current] == _T('"'))) /* only works at end of line*/
                {
                    if (wLastKey != VK_TAB)
                    {
                        /* if first TAB, complete filename*/
                        tempscreen = charcount;
                        CompleteFilename (str, charcount);
                        charcount = _tcslen (str);
                        current = charcount;
 
                        SetCursorXY (orgx, orgy);
                        ConOutPrintf (_T("%s"), str);
 
                        if (tempscreen > charcount)
                        {
                            GetCursorXY (&curx, &cury);
                            for (count = tempscreen - charcount; count--; )
                                ConOutChar (_T(' '));
                            SetCursorXY (curx, cury);
                        }
                        else
                        {
                            if (((charcount + orgx) / maxx) + orgy > maxy - 1)
                                orgy += maxy - ((charcount + orgx) / maxx + orgy + 1);
                        }
 
                        /* set cursor position */
                        SetCursorXY ((orgx + current) % maxx,
                                 orgy + (orgx + current) / maxx);
                        GetCursorXY (&curx, &cury);
                    }
                    else
                    {
                        /*if second TAB, list matches*/
                        if (ShowCompletionMatches (str, charcount))
                        {
                            PrintPrompt();
                            GetCursorXY(&orgx, &orgy);
                            ConOutPrintf(_T("%s"), str);
 
                            /* set cursor position */
                            SetCursorXY((orgx + current) % maxx,
                                         orgy + (orgx + current) / maxx);
                            GetCursorXY(&curx, &cury);
                        }
 
                    }
                }
                else
                {
                    MessageBeep(-1);
                }
#endif
#ifdef FEATURE_4NT_FILENAME_COMPLETION
                /* used to later see if we went down to the next line */
                tempscreen = charcount;
                szPath[0]=_T('\0');
 
                /* str is the whole things that is on the current line
                   that is and and out.  arg 2 is weather it goes back
                    one file or forward one file */
                CompleteFilename(str, !(ir.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED), szPath, current);
                /* Attempt to clear the line */
                ClearCommandLine (str, maxlen, orgx, orgy);
                curx = orgx;
                cury = orgy;
                current = charcount = 0;
 
                /* Everything is deleted, lets add it back in */
                _tcscpy(str,szPath);
 
                /* Figure out where cusor is going to be after we print it */
                charcount = _tcslen(str);
                current = charcount;
 
                SetCursorXY(orgx, orgy);
                /* Print out what we have now */
                ConOutPrintf(_T("%s"), str);
 
                /* Move cursor accordingly */
                if (tempscreen > charcount)
                {
                    GetCursorXY(&curx, &cury);
                    for(count = tempscreen - charcount; count--; )
                        ConOutChar(_T(' '));
                    SetCursorXY(curx, cury);
                }
                else
                {
                    if (((charcount + orgx) / maxx) + orgy > maxy - 1)
                        orgy += maxy - ((charcount + orgx) / maxx + orgy + 1);
                }
                SetCursorXY((short)(((int)orgx + current) % maxx), (short)((int)orgy + ((int)orgx + current) / maxx));
                GetCursorXY(&curx, &cury);
#endif
                break;
 
            case _T('C'):
                if ((ir.Event.KeyEvent.dwControlKeyState &
                    (RIGHT_CTRL_PRESSED|LEFT_CTRL_PRESSED)))
                {
                    /* Ignore the Ctrl-C key event if it has already been handled */
                    if (!bCtrlBreak)
                        break;
 
                    /*
                     * Fully print the entered string
                     * so the command prompt would not overwrite it.
                     */
                    SetCursorXY(orgx, orgy);
                    ConOutPrintf(_T("%s"), str);
 
                    /*
                     * A Ctrl-C. Do not clear the command line,
                     * but return an empty string in str.
                     */
                    str[0] = _T('\0');
                    curx = orgx;
                    cury = orgy;
                    current = charcount = 0;
                    bReturn = TRUE;
                }
                else
                {
                    /* Just a normal 'C' character */
                    bCharInput = TRUE;
                }
                break;
 
            case VK_RETURN:
                /* end input, return to main */
#ifdef FEATURE_HISTORY
                /* add to the history */
                if (str[0])
                    History(0, str);
#endif
                str[charcount++] = _T('\n');
                str[charcount] = _T('\0');
                ConOutChar(_T('\n'));
                bReturn = TRUE;
                break;
 
            case VK_ESCAPE:
                /* clear str  Make this callable! */
                ClearCommandLine (str, maxlen, orgx, orgy);
                curx = orgx;
                cury = orgy;
                current = charcount = 0;
                break;
 
#ifdef FEATURE_HISTORY
            case VK_F3:
                History_move_to_bottom();
#endif
            case VK_UP:
#ifdef FEATURE_HISTORY
                /* get previous command from buffer */
                ClearCommandLine (str, maxlen, orgx, orgy);
                History(-1, str);
                current = charcount = _tcslen (str);
                if (((charcount + orgx) / maxx) + orgy > maxy - 1)
                    orgy += maxy - ((charcount + orgx) / maxx + orgy + 1);
                ConOutPrintf (_T("%s"), str);
                GetCursorXY (&curx, &cury);
#endif
                break;
 
            case VK_DOWN:
#ifdef FEATURE_HISTORY
                /* get next command from buffer */
                ClearCommandLine (str, maxlen, orgx, orgy);
                History(1, str);
                current = charcount = _tcslen (str);
                if (((charcount + orgx) / maxx) + orgy > maxy - 1)
                    orgy += maxy - ((charcount + orgx) / maxx + orgy + 1);
                ConOutPrintf (_T("%s"), str);
                GetCursorXY (&curx, &cury);
#endif
                break;
 
            case VK_LEFT:
                if (dwControlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
                {
                    /* move cursor to the previous word */
                    if (current > 0)
                    {
                        while (current > 0 && str[current - 1] == _T(' '))
                        {
                            current--;
                            if (curx == 0)
                            {
                                cury--;
                                curx = maxx -1;
                            }
                            else
                            {
                                curx--;
                            }
                        }
 
                        while (current > 0 && str[current -1] != _T(' '))
                        {
                            current--;
                            if (curx == 0)
                            {
                                cury--;
                                curx = maxx -1;
                            }
                            else
                            {
                                curx--;
                            }
                        }
 
                        SetCursorXY(curx, cury);
                    }
                }
                else
                {
                    /* move cursor left */
                    if (current > 0)
                    {
                        current--;
                        if (GetCursorX () == 0)
                        {
                            SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
                            curx = maxx - 1;
                            cury--;
                        }
                        else
                        {
                            SetCursorXY ((SHORT)(GetCursorX () - 1), GetCursorY ());
                            curx--;
                        }
                    }
                    else
                    {
                        MessageBeep (-1);
                    }
                }
                break;
 
            case VK_RIGHT:
                if (dwControlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
                {
                    /* move cursor to the next word */
                    if (current != charcount)
                    {
                        while (current != charcount && str[current] != _T(' '))
                        {
                            current++;
                            if (curx == maxx - 1)
                            {
                                cury++;
                                curx = 0;
                            }
                            else
                            {
                                curx++;
                            }
                        }
 
                        while (current != charcount && str[current] == _T(' '))
                        {
                            current++;
                            if (curx == maxx - 1)
                            {
                                cury++;
                                curx = 0;
                            }
                            else
                            {
                                curx++;
                            }
                        }
 
                        SetCursorXY(curx, cury);
                    }
                }
                else
                {
                    /* move cursor right */
                    if (current != charcount)
                    {
                        current++;
                        if (GetCursorX () == maxx - 1)
                        {
                            SetCursorXY (0, (SHORT)(GetCursorY () + 1));
                            curx = 0;
                            cury++;
                        }
                        else
                        {
                            SetCursorXY ((SHORT)(GetCursorX () + 1), GetCursorY ());
                            curx++;
                        }
                    }
#ifdef FEATURE_HISTORY
                    else
                    {
                        LPCTSTR last = PeekHistory(-1);
                        if (last && charcount < (INT)_tcslen (last))
                        {
                            PreviousChar = last[current];
                            ConOutChar(PreviousChar);
                            GetCursorXY(&curx, &cury);
                            str[current++] = PreviousChar;
                            charcount++;
                        }
                    }
#endif
                }
                break;
 
            default:
                /* This input is just a normal char */
                bCharInput = TRUE;
 
            }
#ifdef _UNICODE
            ch = ir.Event.KeyEvent.uChar.UnicodeChar;
            if (ch >= 32 && (charcount != (maxlen - 2)) && bCharInput)
#else
            ch = ir.Event.KeyEvent.uChar.AsciiChar;
            if ((UCHAR)ch >= 32 && (charcount != (maxlen - 2)) && bCharInput)
#endif /* _UNICODE */
            {
                /* insert character into string... */
                if (bInsert && current != charcount)
                {
                    /* If this character insertion will cause screen scrolling,
                     * adjust the saved origin of the command prompt. */
                    tempscreen = _tcslen(str + current) + curx;
                    if ((tempscreen % maxx) == (maxx - 1) &&
                        (tempscreen / maxx) + cury == (maxy - 1))
                    {
                        orgy--;
                        cury--;
                    }
 
                    for (count = charcount; count > current; count--)
                        str[count] = str[count - 1];
                    str[current++] = ch;
                    if (curx == maxx - 1)
                        curx = 0, cury++;
                    else
                        curx++;
                    ConOutPrintf (_T("%s"), &str[current - 1]);
                    SetCursorXY (curx, cury);
                    charcount++;
                }
                else
                {
                    if (current == charcount)
                        charcount++;
                    str[current++] = ch;
                    if (GetCursorX () == maxx - 1 && GetCursorY () == maxy - 1)
                        orgy--, cury--;
                    if (GetCursorX () == maxx - 1)
                        curx = 0, cury++;
                    else
                        curx++;
                    ConOutChar (ch);
                }
            }
 
        //wLastKey = ir.Event.KeyEvent.wVirtualKeyCode;
    }
    while (!bReturn);
 
    SetCursorType (bInsert, TRUE);
 
#ifdef FEATURE_ALIASES
    /* expand all aliases */
    ExpandAlias (str, maxlen);
#endif /* FEATURE_ALIAS */
    return TRUE;
}

◆ ReadLine()

BOOL ReadLine	(	TCHAR *	commandline,
		BOOL	bMore
	)

Definition at line 1721 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 1850 of file cmd.c.

{
    SetConsoleCtrlHandler(BreakHandler, FALSE);
}

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

◆ 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().

◆ SearchForExecutable()

BOOL SearchForExecutable	(	LPCTSTR	pFileName,
		LPTSTR	pFullName
	)

Definition at line 142 of file where.c.

{
    static TCHAR pszDefaultPathExt[] = _T(".com;.exe;.bat;.cmd");
    LPTSTR pszPathExt, pszPath;
    LPTSTR pCh;
    DWORD  dwBuffer;
    TRACE ("SearchForExecutable: \'%s\'\n", debugstr_aw(pFileName));
 
    /* load environment variable PATHEXT */
    pszPathExt = (LPTSTR)cmd_alloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
    if (!pszPathExt)
    {
        WARN("Cannot allocate memory for pszPathExt!\n");
        return FALSE;
    }
 
    dwBuffer = GetEnvironmentVariable (_T("PATHEXT"), pszPathExt, ENV_BUFFER_SIZE);
    if (dwBuffer > ENV_BUFFER_SIZE)
    {
        LPTSTR pszOldPathExt = pszPathExt;
        pszPathExt = (LPTSTR)cmd_realloc (pszPathExt, dwBuffer * sizeof (TCHAR));
        if (!pszPathExt)
        {
            WARN("Cannot reallocate memory for pszPathExt!\n");
            cmd_free(pszOldPathExt);
            return FALSE;
        }
        GetEnvironmentVariable (_T("PATHEXT"), pszPathExt, dwBuffer);
        _tcslwr(pszPathExt);
    }
    else if (0 == dwBuffer)
    {
        _tcscpy(pszPathExt, pszDefaultPathExt);
    }
    else
    {
        _tcslwr(pszPathExt);
    }
 
    /* Check if valid directly on specified path */
    if (SearchForExecutableSingle(pFileName, pFullName, pszPathExt, NULL))
    {
        cmd_free(pszPathExt);
        return TRUE;
    }
 
    /* If an explicit directory was given, stop here - no need to search PATH. */
    if (pFileName[1] == _T(':') || _tcschr(pFileName, _T('\\')))
    {
        cmd_free(pszPathExt);
        return FALSE;
    }
 
    /* load environment variable PATH into buffer */
    pszPath = (LPTSTR)cmd_alloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
    if (!pszPath)
    {
        WARN("Cannot allocate memory for pszPath!\n");
        return FALSE;
    }
 
    dwBuffer = GetEnvironmentVariable (_T("PATH"), pszPath, ENV_BUFFER_SIZE);
    if (dwBuffer > ENV_BUFFER_SIZE)
    {
        LPTSTR pszOldPath = pszPath;
        pszPath = (LPTSTR)cmd_realloc (pszPath, dwBuffer * sizeof (TCHAR));
        if (!pszPath)
        {
            WARN("Cannot reallocate memory for pszPath!\n");
            cmd_free(pszOldPath);
            cmd_free(pszPathExt);
            return FALSE;
        }
        GetEnvironmentVariable (_T("PATH"), pszPath, dwBuffer);
    }
 
    TRACE ("SearchForExecutable(): Loaded PATH: %s\n", debugstr_aw(pszPath));
 
    /* search in PATH */
    pCh = _tcstok(pszPath, _T(";"));
    while (pCh)
    {
        if (SearchForExecutableSingle(pFileName, pFullName, pszPathExt, pCh))
        {
            cmd_free(pszPath);
            cmd_free(pszPathExt);
            return TRUE;
        }
        pCh = _tcstok(NULL, _T(";"));
    }
 
    cmd_free(pszPath);
    cmd_free(pszPathExt);
    return FALSE;
}

Referenced by cmd_start(), Execute(), and GetCmdLineCommand().

◆ SetHandle()

VOID SetHandle	(	UINT	Number,
		HANDLE	Handle
	)

Definition at line 50 of file redir.c.

{
    if (Number < 3)
    {
        ConStreamSetOSHandle(StdStreams[Number], Handle);
        /* Synchronize the associated Win32 handle */
        SetStdHandle(STD_INPUT_HANDLE - Number, Handle);
    }
    else if (Number < ARRAYSIZE(ExtraHandles) + 3)
        ExtraHandles[Number - 3] = Handle;
}

Referenced by cmd_ctty(), PerformRedirection(), and UndoRedirection().

◆ SetRootPath()

BOOL SetRootPath	(	TCHAR *	oldpath,
		TCHAR *	InPath
	)

Definition at line 182 of file internal.c.

{
    DWORD dwLastError;
    TCHAR OutPath[MAX_PATH];
    TCHAR OutPathTemp[MAX_PATH];
 
    StripQuotes(InPath);
 
    /* Retrieve the full path name from the (possibly relative) InPath */
    if (GetFullPathName(InPath, ARRAYSIZE(OutPathTemp), OutPathTemp, NULL) == 0)
    {
        dwLastError = GetLastError();
        goto Fail;
    }
 
    if (bEnableExtensions)
    {
        /*
         * Convert the full path to its correct case, and
         * resolve any wilcard present as well in the path
         * and retrieve the first result.
         * Example: c:\windows\SYSTEM32 => C:\WINDOWS\System32
         * Example: C:\WINDOWS\S* => C:\WINDOWS\System,
         * or C:\WINDOWS\System32, depending on the user's OS.
         */
        GetPathCase(OutPathTemp, OutPath);
    }
    else
    {
        _tcscpy(OutPath, OutPathTemp);
    }
 
    /* Use _tchdir(), since unlike SetCurrentDirectory() it updates
     * the current-directory-on-drive environment variables. */
    if (_tchdir(OutPath) != 0)
    {
        dwLastError = GetLastError();
        if (dwLastError == ERROR_FILE_NOT_FOUND)
            dwLastError = ERROR_PATH_NOT_FOUND;
        goto Fail;
    }
 
    /* Keep the original drive in ordinary CD/CHDIR (without /D switch) */
    if (oldpath != NULL && _tcsncicmp(OutPath, oldpath, 2) != 0)
        SetCurrentDirectory(oldpath);
 
    return TRUE;
 
Fail:
    ConErrFormatMessage(dwLastError);
    nErrorLevel = 1;
    return FALSE;
}

Referenced by cmd_chdir(), and CommandPushd().

◆ split()

LPTSTR * split	(	LPTSTR	s,
		LPINT	args,
		BOOL	expand_wildcards,
		BOOL	handle_plus
	)

Definition at line 296 of file misc.c.

{
    LPTSTR *arg;
    LPTSTR start;
    LPTSTR q;
    INT  ac;
    INT_PTR  len;
 
    arg = cmd_alloc (sizeof (LPTSTR));
    if (!arg)
    {
        WARN("Cannot allocate memory for arg!\n");
        return NULL;
    }
    *arg = NULL;
 
    ac = 0;
    while (*s)
    {
        BOOL bQuoted = FALSE;
 
        /* skip leading spaces */
        while (*s && (_istspace(*s) || _istcntrl(*s)))
            ++s;
 
        start = s;
 
        /* the first character can be '/' */
        if (*s == _T('/'))
            ++s;
 
        /* skip to next word delimiter or start of next option */
        while (_istprint(*s))
        {
            /* if quote (") then set bQuoted */
            bQuoted ^= (*s == _T('\"'));
 
            /* Check if we have unquoted text */
            if (!bQuoted)
            {
                /* check for separators */
                if (_istspace(*s) ||
                    (*s == _T('/')) ||
                    (handle_plus && (*s == _T('+'))))
                {
                    /* Make length at least one character */
                    if (s == start) s++;
                    break;
                }
            }
 
            ++s;
        }
 
        /* a word was found */
        if (s != start)
        {
            q = cmd_alloc (((len = s - start) + 1) * sizeof (TCHAR));
            if (!q)
            {
                WARN("Cannot allocate memory for q!\n");
                return NULL;
            }
            memcpy (q, start, len * sizeof (TCHAR));
            q[len] = _T('\0');
            StripQuotes(q);
            if (expand_wildcards && (_T('/') != *start) &&
                (NULL != _tcschr(q, _T('*')) || NULL != _tcschr(q, _T('?'))))
            {
                if (! expand(&ac, &arg, q))
                {
                    cmd_free (q);
                    freep (arg);
                    return NULL;
                }
            }
            else
            {
                if (! add_entry(&ac, &arg, q))
                {
                    cmd_free (q);
                    freep (arg);
                    return NULL;
                }
            }
            cmd_free (q);
        }
    }
 
    *args = ac;
 
    return arg;
}

◆ splitspace()

LPTSTR * splitspace	(	LPTSTR	s,
		LPINT	args
	)

Definition at line 395 of file misc.c.

{
    LPTSTR *arg;
    LPTSTR start;
    LPTSTR q;
    INT  ac;
    INT_PTR  len;
 
    arg = cmd_alloc (sizeof (LPTSTR));
    if (!arg)
    {
        WARN("Cannot allocate memory for arg!\n");
        return NULL;
    }
    *arg = NULL;
 
    ac = 0;
    while (*s)
    {
        BOOL bQuoted = FALSE;
 
        /* skip leading spaces */
        while (*s && (_istspace (*s) || _istcntrl (*s)))
            ++s;
 
        start = s;
 
        /* skip to next word delimiter or start of next option */
        while (_istprint(*s) && (bQuoted || !_istspace(*s)))
        {
            /* if quote (") then set bQuoted */
            bQuoted ^= (*s == _T('\"'));
            ++s;
        }
 
        /* a word was found */
        if (s != start)
        {
            q = cmd_alloc (((len = s - start) + 1) * sizeof (TCHAR));
            if (!q)
            {
                WARN("Cannot allocate memory for q!\n");
                return NULL;
            }
            memcpy (q, start, len * sizeof (TCHAR));
            q[len] = _T('\0');
            StripQuotes(q);
            if (! add_entry(&ac, &arg, q))
            {
                cmd_free (q);
                freep (arg);
                return NULL;
            }
            cmd_free (q);
        }
    }
 
    *args = ac;
 
    return arg;
}

Referenced by cmd_move(), and cmd_setlocal().

◆ StringToColor()

BOOL StringToColor	(	LPWORD	lpColor,
		LPTSTR *	str
	)

Definition at line 255 of file strtoclr.c.

{
    WORD wRet;
 
    wRet = str_to_color (str);
    if (wRet == (WORD)-1)
    {
        wRet=hex_clr (*str);
        chop_blank (str);
        if (wRet == (WORD)-1)
            return FALSE;
    }
 
    *lpColor = wRet;
 
    return TRUE;
}

Referenced by CommandColor().

◆ StripQuotes()

VOID StripQuotes ( LPTSTR )

◆ SubstituteForVars()

BOOL SubstituteForVars	(	IN PCTSTR	Src,
		OUT PTSTR	Dest
	)

Definition at line 1596 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 1326 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 1514 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().

◆ UndoRedirection()

VOID UndoRedirection	(	REDIRECTION *	Redir,
		REDIRECTION *	End
	)

Definition at line 142 of file redir.c.

{
    for (; Redir != End; Redir = Redir->Next)
    {
        CloseHandle(GetHandle(Redir->Number));
        SetHandle(Redir->Number, Redir->OldHandle);
        Redir->OldHandle = INVALID_HANDLE_VALUE;
    }
}

Referenced by ExecuteCommand(), ExitBatch(), and PerformRedirection().

◆ UnparseCommand()

PTCHAR UnparseCommand	(	IN PARSED_COMMAND *	Cmd,
		OUT PTCHAR	Out,
		IN PTCHAR	OutEnd
	)

Definition at line 1965 of file parser.c.

{
/*
 * Since this function has the annoying requirement that it must avoid
 * overflowing the supplied buffer, define some helper macros to make
 * this less painful.
 */
#define CHAR(Char) \
do { \
    if (Out == OutEnd) return NULL; \
    *Out++ = Char; \
} while (0)
#define STRING(String) \
do { \
    if (Out + _tcslen(String) > OutEnd) return NULL; \
    Out = _stpcpy(Out, String); \
} while (0)
#define PRINTF(Format, ...) \
do { \
    UINT Len = _sntprintf(Out, OutEnd - Out, Format, __VA_ARGS__); \
    if (Len > (UINT)(OutEnd - Out)) return NULL; \
    Out += Len; \
} while (0)
#define RECURSE(Subcommand) \
do { \
    Out = UnparseCommand(Subcommand, Out, OutEnd); \
    if (!Out) return NULL; \
} while (0)
 
    PARSED_COMMAND* Sub;
    REDIRECTION* Redir;
 
    if (!Cmd)
        return Out;
 
    switch (Cmd->Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        /* This is fragile since there could be special characters, but
         * Windows doesn't bother escaping them, so for compatibility
         * we probably shouldn't do it either */
        if (!SubstituteForVars(Cmd->Command.First, TempBuf)) return NULL;
        STRING(TempBuf);
        if (!SubstituteForVars(Cmd->Command.Rest, TempBuf)) return NULL;
        STRING(TempBuf);
        break;
    }
 
    case C_QUIET:
    {
        CHAR(_T('@'));
        RECURSE(Cmd->Subcommands);
        break;
    }
 
    case C_BLOCK:
    {
        CHAR(_T('('));
        for (Sub = Cmd->Subcommands; Sub; Sub = Sub->Next)
        {
            RECURSE(Sub);
            if (Sub->Next)
                CHAR(_T('&'));
        }
        CHAR(_T(')'));
        break;
    }
 
    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
        Sub = Cmd->Subcommands;
        RECURSE(Sub);
        PRINTF(_T(" %s "), OpString[Cmd->Type - C_OP_LOWEST]);
        RECURSE(Sub->Next);
        break;
    }
 
    case C_FOR:
    {
        STRING(_T("for"));
        if (Cmd->For.Switches & FOR_DIRS)      STRING(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         STRING(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      STRING(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) STRING(_T(" /R"));
        if (Cmd->For.Params)
            PRINTF(_T(" %s"), Cmd->For.Params);
        if (Cmd->For.List && SubstituteForVars(Cmd->For.List, TempBuf))
            PRINTF(_T(" %%%c in (%s) do "), Cmd->For.Variable, TempBuf);
        else
            PRINTF(_T(" %%%c in (%s) do "), Cmd->For.Variable, Cmd->For.List);
        RECURSE(Cmd->Subcommands);
        break;
    }
 
    case C_IF:
    {
        STRING(_T("if"));
        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            STRING(_T(" /I"));
        if (Cmd->If.Flags & IFFLAG_NEGATE)
            STRING(_T(" not"));
        if (Cmd->If.LeftArg && SubstituteForVars(Cmd->If.LeftArg, TempBuf))
            PRINTF(_T(" %s"), TempBuf);
        PRINTF(_T(" %s"), IfOperatorString[Cmd->If.Operator]);
        if (!SubstituteForVars(Cmd->If.RightArg, TempBuf)) return NULL;
        PRINTF(_T(" %s "), TempBuf);
        Sub = Cmd->Subcommands;
        RECURSE(Sub);
        if (Sub->Next)
        {
            STRING(_T(" else "));
            RECURSE(Sub->Next);
        }
        break;
    }
 
    default:
        ASSERT(FALSE);
        break;
    }
 
    for (Redir = Cmd->Redirections; Redir; Redir = Redir->Next)
    {
        if (!SubstituteForVars(Redir->Filename, TempBuf))
            return NULL;
        PRINTF(_T(" %c%s%s"), _T('0') + Redir->Number,
               RedirString[Redir->Mode], TempBuf);
    }
    return Out;
 
#undef CHAR
#undef STRING
#undef PRINTF
#undef RECURSE
}

Referenced by ExecuteAsync().

Variable Documentation

◆ AutoCompletionChar

TCHAR AutoCompletionChar

extern

Definition at line 111 of file cmdinput.c.

Referenced by Initialize(), and LoadRegistrySettings().

◆ bCtrlBreak

BOOL bCtrlBreak

extern

Definition at line 11 of file util.c.

Referenced by BreakHandler(), cgetchar(), and ProcessInput().

◆ bDelayedExpansion

BOOL bDelayedExpansion

extern

Definition at line 162 of file cmd.c.

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

◆ bDisableBatchEcho

BOOL bDisableBatchEcho

extern

Definition at line 160 of file cmd.c.

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

◆ bEnableExtensions

BOOL bEnableExtensions

extern

Definition at line 53 of file more.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(), SetRootPath(), and wmain().

◆ bExit

BOOL bExit

extern

Definition at line 152 of file cmd.c.

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

◆ bHandleContinuations

BOOL bHandleContinuations

extern

Definition at line 97 of file parser.c.

Referenced by cmd_call(), ParseCommandOp(), ParseToken(), and ParseTokenEx().

◆ bIgnoreEcho

BOOL bIgnoreEcho

extern

Definition at line 155 of file cmd.c.

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

◆ bIgnoreParserComments

BOOL bIgnoreParserComments

extern

Definition at line 96 of file parser.c.

Referenced by cmd_call(), and ParseCommandBinaryOp().

◆ bParseError

BOOL bParseError

extern

Definition at line 90 of file parser.c.

Referenced by Batch(), cmd_call(), ParseBlock(), ParseChar(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandLine(), ParseCommandPart(), ParseErrorEx(), ParsePrimary(), ResetParser(), and SubstituteVar().

◆ cDateSeparator

TCHAR cDateSeparator

extern

Definition at line 16 of file locale.c.

Referenced by FormatDate(), InitLocale(), PromptDateString(), and ReadSeparator().

◆ cDecimalSeparator

TCHAR cDecimalSeparator

extern

Definition at line 19 of file locale.c.

Referenced by CommandTimer(), GetTimeString(), InitLocale(), ParseTime(), and PrintElapsedTime().

◆ CMD_ModuleHandle

HANDLE CMD_ModuleHandle

extern

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().

◆ cmds

COMMAND cmds[]

extern

Definition at line 21 of file main.c.

◆ cThousandSeparator

TCHAR cThousandSeparator

extern

Definition at line 18 of file locale.c.

Referenced by ConvertULargeInteger(), and InitLocale().

◆ cTimeSeparator

TCHAR cTimeSeparator

extern

Definition at line 17 of file locale.c.

Referenced by CommandTimer(), FormatTime(), GetTimeString(), InitLocale(), ParseTime(), and PrintElapsedTime().

◆ lpOriginalEnvironment

LPTSTR lpOriginalEnvironment

extern

Definition at line 164 of file cmd.c.

Referenced by _tmain(), and cmd_start().

◆ nDateFormat

INT nDateFormat

extern

Definition at line 20 of file locale.c.

Referenced by FormatDate(), InitLocale(), ParseDate(), and PromptDateString().

◆ nErrorLevel

INT nErrorLevel

extern

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(), seta_bitAndTerm(), seta_eval(), seta_unaryTerm(), SetRootPath(), SubstituteVar(), and SubstituteVars().

◆ nNumberGroups

INT nNumberGroups

extern

Definition at line 22 of file locale.c.

Referenced by ConvertULargeInteger(), and InitLocale().

◆ nTimeFormat

INT nTimeFormat

extern

Definition at line 21 of file locale.c.

Referenced by FormatTime(), InitLocale(), and ParseTime().

◆ ParseLine

TCHAR ParseLine[CMDLINE_LENGTH]

extern

Definition at line 92 of file parser.c.

Referenced by Batch(), InitParser(), ParseChar(), and ParseCommand().

◆ PathCompletionChar

TCHAR PathCompletionChar

extern

Definition at line 112 of file cmdinput.c.

Referenced by Initialize(), and LoadRegistrySettings().

◆ wColor

WORD wColor

extern

Referenced by CommandColor(), ConSetScreenColor(), DisplayScreen(), MainLoop(), and WriteStringAt().

◆ wDefColor

WORD wDefColor

extern

Definition at line 180 of file cmd.c.

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

Variables
LPTSTR	lpOriginalEnvironment

WORD	wColor

WORD	wDefColor

BOOL	bCtrlBreak

BOOL	bIgnoreEcho

BOOL	bExit

BOOL	bDisableBatchEcho

BOOL	bEnableExtensions

BOOL	bDelayedExpansion

INT	nErrorLevel

HANDLE	CMD_ModuleHandle

TCHAR	AutoCompletionChar

TCHAR	PathCompletionChar

COMMAND	cmds []

TCHAR	cDateSeparator

INT	nDateFormat

TCHAR	cTimeSeparator

INT	nTimeFormat

TCHAR	cThousandSeparator

TCHAR	cDecimalSeparator

INT	nNumberGroups

BOOL	bParseError

TCHAR	ParseLine [CMDLINE_LENGTH]

BOOL	bIgnoreParserComments

BOOL	bHandleContinuations

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BREAK_BATCHFILE

◆ BREAK_IGNORE

◆ BREAK_INPUT

◆ BREAK_OUTOFBATCH

◆ BUFF_SIZE

◆ CMD_BATCHONLY

◆ CMD_HIDE

◆ CMD_SPECIAL

◆ CMDEXTVERSION

◆ CMDLINE_LENGTH

◆ D_OFF

◆ D_ON

◆ FOR_DIRS

◆ FOR_F

◆ FOR_LOOP

◆ FOR_RECURSIVE

◆ IFFLAG_IGNORECASE

◆ IFFLAG_NEGATE

◆ IS_COMPLETION_DISABLED

◆ PROMPT_ALL

◆ PROMPT_BREAK

◆ PROMPT_NO

◆ PROMPT_YES

◆ STANDARD_SEPS

Typedef Documentation

◆ COMMAND

◆ COMMAND_TYPE

◆ IF_OPERATOR

◆ LPCOMMAND

◆ PARSED_COMMAND

◆ REDIR_MODE

◆ REDIRECTION

Enumeration Type Documentation

◆ _COMMAND_TYPE

◆ _IF_OPERATOR

◆ _REDIR_MODE

Function Documentation

◆ _stpcpy()

◆ add_entry()

◆ AddBreakHandler()

◆ cgetchar()

◆ CheckCtrlBreak()

◆ cmd_beep()

◆ cmd_call()

◆ cmd_chdir()

◆ cmd_cls()

◆ cmd_copy()

◆ cmd_date()

◆ cmd_endlocal()

◆ cmd_for()

◆ cmd_goto()

◆ cmd_if()

◆ cmd_mkdir()

◆ cmd_mklink()

◆ cmd_move()

◆ cmd_path()

◆ cmd_pause()

◆ cmd_prompt()

◆ cmd_rename()

◆ cmd_replace()

◆ cmd_rmdir()

◆ cmd_set()

◆ cmd_setlocal()

◆ cmd_shift()

◆ cmd_start()

◆ cmd_time()

◆ cmd_title()

◆ cmd_type()

◆ cmd_ver()

◆ cmd_verify()

◆ cmd_vol()

◆ CommandActivate()

◆ CommandAlias()