#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 (TCHAR , TCHAR )

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)

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 442 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 460 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 184 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 1846 of file cmd.c.

{
    SetConsoleCtrlHandler(BreakHandler, TRUE);
}

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

◆ cgetchar()

TCHAR cgetchar ( VOID )

Definition at line 41 of file misc.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(), cmd_pause(), and cmd_replace().

◆ CheckCtrlBreak()

BOOL CheckCtrlBreak ( INT mode )

Definition at line 132 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(), recReplace(), RemoveFile(), and replace().

◆ 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)))
    {
        // FIXME: Localize
        ConErrPrintf(_T("%s was unexpected.\n"), 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)
        {
            // FIXME: Localize
            ConErrPuts(_T("Invalid attempt to call batch label outside of batch script.\n"));
            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)
        ConOutPrintf(_T("%s"), GetDateString());
 
    if (!bPrompt)
    {
        freep(arg);
        return 0;
    }
 
    while (TRUE)
    {
        if (nDateString == -1)
        {
            PrintDateString();
            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 244 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_ERROR1, 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 param )

Definition at line 392 of file replace.c.

{
    LPTSTR *arg;
    INT argc, i,filesReplaced = 0, nFiles, srcIndex = -1, destIndex = -1;
    DWORD dwFlags = 0;
    TCHAR szDestPath[MAX_PATH], szSrcPath[MAX_PATH], tmpSrcPath[MAX_PATH];
    BOOL doMore = TRUE;
 
    /* Help wanted? */
    if (!_tcsncmp (param, _T("/?"), 2))
    {
        ConOutResPaging(TRUE,STRING_REPLACE_HELP1);
        return 0;
    }
 
    /* Divide the argument in to an array of c-strings */
    arg = split (param, &argc, FALSE, FALSE);
    nFiles = argc;
 
    /* Read options */
    for (i = 0; i < argc; i++)
    {
        if (arg[i][0] == _T('/'))
        {
            if (_tcslen(arg[i]) == 2)
            {
                switch (_totupper(arg[i][1]))
                {
                case _T('A'):
                    dwFlags |= REPLACE_ADD;
                    break;
                case _T('P'):
                    dwFlags |= REPLACE_CONFIRM;
                    break;
                case _T('R'):
                    dwFlags |= REPLACE_READ_ONLY;
                    break;
                case _T('S'):
                    dwFlags |= REPLACE_SUBDIR;
                    break;
                case _T('W'):
                    dwFlags |= REPLACE_DISK;
                    break;
                case _T('U'):
                    dwFlags |= REPLACE_UPDATE;
                    break;
                default:
                    invalid_switch(arg[i]);
                    freep(arg);
                    return 0;
                }
            }
            else
            {
                invalid_switch(arg[i]);
                freep(arg);
                return 0;
            }
            nFiles--;
        }
        else
        {
            if (srcIndex == -1)
            {
                srcIndex = i;
            }
            else if (destIndex == -1)
            {
                destIndex = i;
            }
            else
            {
                invalid_switch(arg[i]);
                freep(arg);
                return 0;
            }
        }
    }
 
    /* See so that at least source is there */
    if (nFiles < 1)
    {
        ConOutResPaging(TRUE,STRING_REPLACE_HELP2);
        ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
        freep(arg);
        return 1;
    }
    /* Check so that not both update and add switch is added and subdir */
    if ((dwFlags & REPLACE_UPDATE || dwFlags & REPLACE_SUBDIR) && (dwFlags & REPLACE_ADD))
    {
        ConOutResPaging(TRUE,STRING_REPLACE_ERROR4);
        ConOutResPaging(TRUE,STRING_REPLACE_HELP7);
        freep(arg);
        return 1;
    }
 
    /* If we have a destination get the full path */
    if (destIndex != -1)
    {
        if (_tcslen(arg[destIndex]) == 2 && arg[destIndex][1] == ':')
            GetRootPath(arg[destIndex],szDestPath,MAX_PATH);
        else
        {
            /* Check for wildcards in destination directory */
            if (_tcschr (arg[destIndex], _T('*')) != NULL ||
                _tcschr (arg[destIndex], _T('?')) != NULL)
            {
                ConOutResPrintf(STRING_REPLACE_ERROR2,arg[destIndex]);
                ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
                freep(arg);
                return 1;
            }
            getPath(szDestPath, arg[destIndex]);
            /* Make sure that destination exists */
            if (!IsExistingDirectory(szDestPath))
            {
                ConOutResPrintf(STRING_REPLACE_ERROR2, szDestPath);
                ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
                freep(arg);
                return 1;
            }
        }
    }
    else
    {
        /* Dest is current dir */
        GetCurrentDirectory(MAX_PATH,szDestPath);
    }
 
    /* Get the full source path */
    if (!(_tcslen(arg[srcIndex]) == 2 && arg[srcIndex][1] == ':'))
        getPath(szSrcPath, arg[srcIndex]);
    else
        _tcscpy(szSrcPath,arg[srcIndex]);
 
    /* Source does not have wildcards */
    if (_tcschr (arg[srcIndex], _T('*')) == NULL &&
        _tcschr (arg[srcIndex], _T('?')) == NULL)
    {
        /* Check so that source is not a directory, because that is not allowed */
        if (IsExistingDirectory(szSrcPath))
        {
            ConOutResPrintf(STRING_REPLACE_ERROR6, szSrcPath);
            ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
            freep(arg);
            return 1;
        }
        /* Check if the file exists */
        if (!IsExistingFile(szSrcPath))
        {
            ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
            freep(arg);
            return 1;
        }
    }
    /* /w switch is set so wait for any key to be pressed */
    if (dwFlags & REPLACE_DISK)
    {
        msg_pause();
        cgetchar();
    }
 
    /* Add an extra \ to the destination path if needed */
    if (szDestPath[_tcslen(szDestPath) -  1] != _T('\\'))
        _tcscat(szDestPath, _T("\\"));
 
    /* Save source path */
    _tcscpy(tmpSrcPath,szSrcPath);
    /* Replace in dest dir */
    filesReplaced += recReplace(dwFlags, tmpSrcPath, szDestPath, &doMore);
    /* If subdir switch is set replace in the subdirs to */
    if (dwFlags & REPLACE_SUBDIR && doMore)
    {
        filesReplaced += recFindSubDirs(dwFlags, szSrcPath,  szDestPath, &doMore);
    }
 
    /* If source == dest write no more */
    if (filesReplaced != -1)
    {
        /* No files replaced */
        if (filesReplaced==0)
        {
            /* Add switch dependent output */
            if (dwFlags & REPLACE_ADD)
                ConOutResPaging(TRUE,STRING_REPLACE_HELP7);
            else
                ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
        }
        /* Some files replaced */
        else
        {
            /* Add switch dependent output */
            if (dwFlags & REPLACE_ADD)
                ConOutResPrintf(STRING_REPLACE_HELP8, filesReplaced);
            else
                ConOutResPrintf(STRING_REPLACE_HELP4, filesReplaced);
        }
    }
    /* Return memory */
    freep(arg);
    return 1;
}

◆ 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');
        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_ERROR1, 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);
            ConOutPuts(szTime);
            freep(arg);
            return 0;
        }
 
        if ((*arg[i] != _T('/')) && (nTimeString == -1))
            nTimeString = i;
    }
 
    if (nTimeString == -1)
    {
        ConOutResPrintf(STRING_LOCALE_HELP1);
        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_ERROR1);
        nErrorLevel = 1;
    }
 
    freep(arg);
    return 0;
}