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

Classes
struct	_BATCH_CONTEXT

struct	_FOR_CONTEXT

Macros
#define	MSCMD_BATCH_ECHO

#define	BATCH_BUFFSIZE 8192

Typedefs
typedef enum _BATCH_TYPE	BATCH_TYPE

typedef struct _BATCH_CONTEXT	BATCH_CONTEXT

typedef struct _BATCH_CONTEXT *	PBATCH_CONTEXT

typedef struct _FOR_CONTEXT	FOR_CONTEXT

typedef struct _FOR_CONTEXT *	PFOR_CONTEXT

Enumerations
enum	_BATCH_TYPE { NONE , BAT_TYPE , CMD_TYPE }

Functions
BOOL	FindArg (IN TCHAR Char, OUT PCTSTR ArgPtr, OUT BOOL IsParam0)

VOID	ExitBatch (VOID)

VOID	ExitAllBatches (VOID)

INT	Batch (LPTSTR, LPTSTR, LPTSTR, PARSED_COMMAND *)

BOOL	BatchGetString (LPTSTR lpBuffer, INT nBufferLength)

LPTSTR	ReadBatchLine (VOID)

VOID	AddBatchRedirection (REDIRECTION **)

Variables
BATCH_TYPE	BatType

PBATCH_CONTEXT	bc

PFOR_CONTEXT	fc

BOOL	bBcEcho

BOOL	bEcho

TCHAR	textline [BATCH_BUFFSIZE]

Macro Definition Documentation

◆ BATCH_BUFFSIZE

#define BATCH_BUFFSIZE 8192

Definition at line 68 of file batch.h.

◆ MSCMD_BATCH_ECHO

#define MSCMD_BATCH_ECHO

Definition at line 24 of file batch.h.

Typedef Documentation

◆ BATCH_CONTEXT

typedef struct _BATCH_CONTEXT BATCH_CONTEXT

◆ BATCH_TYPE

typedef enum _BATCH_TYPE BATCH_TYPE

◆ FOR_CONTEXT

typedef struct _FOR_CONTEXT FOR_CONTEXT

◆ PBATCH_CONTEXT

typedef struct _BATCH_CONTEXT * PBATCH_CONTEXT

◆ PFOR_CONTEXT

typedef struct _FOR_CONTEXT * PFOR_CONTEXT

Enumeration Type Documentation

◆ _BATCH_TYPE

enum _BATCH_TYPE

Enumerator
NONE
BAT_TYPE
CMD_TYPE

Definition at line 15 of file batch.h.

{
    NONE,
    BAT_TYPE,   /* Old-style DOS batch file */
    CMD_TYPE    /* New-style NT OS/2 batch file */
} BATCH_TYPE;

Function Documentation

◆ AddBatchRedirection()

VOID AddBatchRedirection ( REDIRECTION ** RedirList )

Definition at line 507 of file batch.c.

{
    REDIRECTION **ListEnd;
 
    /* Prepend the list to the batch context's list */
    ListEnd = RedirList;
    while (*ListEnd)
        ListEnd = &(*ListEnd)->Next;
    *ListEnd = bc->RedirList;
    bc->RedirList = *RedirList;
 
    /* Null out the pointer so that the list will not be cleared prematurely.
     * These redirections should persist until the batch file exits. */
    *RedirList = NULL;
}

Referenced by Batch().

◆ Batch()

INT Batch	(	LPTSTR	fullname,
		LPTSTR	firstword,
		LPTSTR	param,
		PARSED_COMMAND *	Cmd
	)

Definition at line 299 of file batch.c.

{
    INT ret = 0;
    INT i;
    HANDLE hFile = NULL;
    BOOLEAN bSameFn = FALSE;
    BOOLEAN bTopLevel;
    BATCH_CONTEXT new;
    PFOR_CONTEXT saved_fc;
 
    SetLastError(0);
    if (bc && bc->mem)
    {
        TCHAR fpname[MAX_PATH];
        GetFullPathName(fullname, ARRAYSIZE(fpname), fpname, NULL);
        if (_tcsicmp(bc->BatchFilePath, fpname) == 0)
            bSameFn = TRUE;
    }
    TRACE("Batch(\'%s\', \'%s\', \'%s\')  bSameFn = %d\n",
        debugstr_aw(fullname), debugstr_aw(firstword), debugstr_aw(param), bSameFn);
 
    if (!bSameFn)
    {
        hFile = CreateFile(fullname, GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE, NULL,
                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL |
                           FILE_FLAG_SEQUENTIAL_SCAN, NULL);
 
        if (hFile == INVALID_HANDLE_VALUE)
        {
            ConErrResPuts(STRING_BATCH_ERROR);
            return 1;
        }
    }
 
    /*
     * Remember whether this is a top-level batch context, i.e. if there is
     * no batch context existing prior (bc == NULL originally), and we are
     * going to create one below.
     */
    bTopLevel = !bc;
 
    if (bc != NULL && Cmd == bc->current)
    {
        /* Then we are transferring to another batch */
        ClearBatch();
        AddBatchRedirection(&Cmd->Redirections);
    }
    else
    {
        struct _SETLOCAL *setlocal = NULL;
 
        if (Cmd == NULL)
        {
            /* This is a CALL. CALL will set errorlevel to our return value, so
             * in order to keep the value of errorlevel unchanged in the case
             * of calling an empty batch file, we must return that same value. */
            ret = nErrorLevel;
        }
        else if (bc)
        {
            /* If a batch file runs another batch file as part of a compound command
             * (e.g. "x.bat & somethingelse") then the first file gets terminated. */
 
            /* Get its SETLOCAL stack so it can be migrated to the new context */
            setlocal = bc->setlocal;
            bc->setlocal = NULL;
            ExitBatch();
        }
 
        /* Create a new context. This function will not
         * return until this context has been exited */
        new.prev = bc;
        /* copy some fields in the new structure if it is the same file */
        if (bSameFn)
        {
            new.mem     = bc->mem;
            new.memsize = bc->memsize;
            new.mempos  = 0;
            new.memfree = FALSE;    /* don't free this, being used before this */
        }
        bc = &new;
        bc->RedirList = NULL;
        bc->setlocal = setlocal;
    }
 
    GetFullPathName(fullname, ARRAYSIZE(bc->BatchFilePath), bc->BatchFilePath, NULL);
 
    /* If a new batch file, load it into memory and close the file */
    if (!bSameFn)
    {
        BatchFile2Mem(hFile);
        CloseHandle(hFile);
    }
 
    bc->mempos = 0;    /* Go to the beginning of the batch file */
#ifndef MSCMD_BATCH_ECHO
    bc->bEcho = bEcho; /* Preserve echo across batch calls */
#endif
    for (i = 0; i < 10; i++)
        bc->shiftlevel[i] = i;
 
    /* Parse the batch parameters */
    if (!BatchParams(firstword, param, &bc->raw_params, &bc->params))
        return 1;
 
    /* If we are calling from inside a FOR, hide the FOR variables */
    saved_fc = fc;
    fc = NULL;
 
    /* Perform top-level batch initialization */
    if (bTopLevel)
    {
        TCHAR *dot;
 
        /* Default the top-level batch context type to .BAT */
        BatType = BAT_TYPE;
 
        /* If this is a .CMD file, adjust the type */
        dot = _tcsrchr(bc->BatchFilePath, _T('.'));
        if (dot && (!_tcsicmp(dot, _T(".cmd"))))
        {
            BatType = CMD_TYPE;
        }
 
#ifdef MSCMD_BATCH_ECHO
        bBcEcho = bEcho;
#endif
    }
 
    /* If this is a "CALL :label args ...", call a subroutine of
     * the current batch file, only if extensions are enabled. */
    if (bEnableExtensions && (*firstword == _T(':')))
    {
        LPTSTR expLabel;
 
        /* Position at the place of the parent file (which is the same as the caller) */
        bc->mempos = (bc->prev ? bc->prev->mempos : 0);
 
        /*
         * Jump to the label. Strip the label's colon; as a side-effect
         * this will forbid "CALL :EOF"; however "CALL ::EOF" will work!
         */
        bc->current = Cmd;
        ++firstword;
 
        /* Expand the label only! (simulate a GOTO command as in Windows' CMD) */
        expLabel = DoDelayedExpansion(firstword);
        ret = cmd_goto(expLabel ? expLabel : firstword);
        if (expLabel)
            cmd_free(expLabel);
    }
 
    /* If we have created a new context, don't return
     * until this batch file has completed. */
    while (bc == &new && !bExit)
    {
        Cmd = ParseCommand(NULL);
        if (!Cmd)
        {
            if (!bParseError)
                continue;
 
            /* Echo the pre-parsed batch file line on error */
            if (bEcho && !bDisableBatchEcho)
            {
                if (!bIgnoreEcho)
                    ConOutChar(_T('\n'));
                PrintPrompt();
                ConOutPuts(ParseLine);
                ConOutChar(_T('\n'));
            }
            /* Stop all execution */
            ExitAllBatches();
            ret = 1;
            break;
        }
 
        /* JPP 19980807 */
        /* Echo the command and execute it */
        bc->current = Cmd;
        ret = ExecuteCommandWithEcho(Cmd);
        FreeCommand(Cmd);
    }
    if (bExit)
    {
        /* Stop all execution */
        ExitAllBatches();
    }
 
    /* Perform top-level batch cleanup */
    if (!bc || bTopLevel)
    {
        /* Reset the top-level batch context type */
        BatType = NONE;
 
#ifdef MSCMD_BATCH_ECHO
        bEcho = bBcEcho;
#endif
    }
 
    /* Restore the FOR variables */
    fc = saved_fc;
 
    /* Always return the last command's return code */
    TRACE("Batch: returns %d\n", ret);
    return ret;
}

◆ BatchGetString()

BOOL BatchGetString	(	LPTSTR	lpBuffer,
		INT	nBufferLength
	)

Definition at line 527 of file batch.c.

{
    INT len = 0;
 
    /* read all chars from memory until a '\n' is encountered */
    if (bc->mem)
    {
        for (; ((bc->mempos + len) < bc->memsize  &&  len < (nBufferLength-1)); len++)
        {
#ifndef _UNICODE
            lpBuffer[len] = bc->mem[bc->mempos + len];
#endif
            if (bc->mem[bc->mempos + len] == '\n')
            {
                len++;
                break;
            }
        }
#ifdef _UNICODE
        nBufferLength = MultiByteToWideChar(OutputCodePage, 0, &bc->mem[bc->mempos], len, lpBuffer, nBufferLength);
        lpBuffer[nBufferLength] = L'\0';
        lpBuffer[len] = '\0';
#endif
        bc->mempos += len;
    }
 
    return len != 0;
}

Referenced by cmd_goto(), and ReadBatchLine().

◆ ExitAllBatches()

VOID ExitAllBatches ( VOID )

Definition at line 261 of file batch.c.

{
    while (bc)
        ExitBatch();
}

Referenced by Batch(), and ReadBatchLine().

◆ ExitBatch()

VOID ExitBatch ( VOID )

Definition at line 222 of file batch.c.

{
    ClearBatch();
 
    TRACE("ExitBatch\n");
 
    UndoRedirection(bc->RedirList, NULL);
    FreeRedirection(bc->RedirList);
 
#ifndef MSCMD_BATCH_ECHO
    /* Preserve echo state across batch calls */
    bEcho = bc->bEcho;
#endif
 
    while (bc->setlocal)
        cmd_endlocal(_T(""));
 
    bc = bc->prev;
 
#if 0
    /* Do not process any more parts of a compound command */
    bc->current = NULL;
#endif
 
    /* If there is no more batch contexts, notify the signal handler */
    if (!bc)
    {
        CheckCtrlBreak(BREAK_OUTOFBATCH);
        BatType = NONE;
 
#ifdef MSCMD_BATCH_ECHO
        bEcho = bBcEcho;
#endif
    }
}

Referenced by Batch(), cmd_goto(), ExitAllBatches(), and ReadBatchLine().

◆ FindArg()

BOOL FindArg	(	IN TCHAR	Char,
		OUT PCTSTR *	ArgPtr,
		OUT BOOL *	IsParam0
	)

Definition at line 84 of file batch.c.

{
    PCTSTR pp;
    INT n = Char - _T('0');
 
    TRACE("FindArg: (%d)\n", n);
 
    *ArgPtr = NULL;
 
    if (n < 0 || n > 9)
        return FALSE;
 
    n = bc->shiftlevel[n];
    *IsParam0 = (n == 0);
    pp = bc->params;
 
    /* Step up the strings till we reach
     * the end or the one we want. */
    while (*pp && n--)
        pp += _tcslen(pp) + 1;
 
    *ArgPtr = pp;
    return TRUE;
}

Referenced by GetBatchVar().

◆ ReadBatchLine()

LPTSTR ReadBatchLine ( VOID )

Definition at line 564 of file batch.c.

{
    TRACE("ReadBatchLine()\n");
 
    /* User halt */
    if (CheckCtrlBreak(BREAK_BATCHFILE))
    {
        ExitAllBatches();
        return NULL;
    }
 
    if (!BatchGetString(textline, ARRAYSIZE(textline) - 1))
    {
        TRACE("ReadBatchLine(): Reached EOF!\n");
        /* End of file */
        ExitBatch();
        return NULL;
    }
 
    TRACE("ReadBatchLine(): textline: \'%s\'\n", debugstr_aw(textline));
 
#if 1
    //
    // FIXME: This is redundant, but keep it for the moment until we correctly
    // hande the end-of-file situation here, in ReadLine() and in the parser.
    // (In an EOF, the previous BatchGetString() call will return FALSE but
    // we want not to run the ExitBatch() at first, but wait later to do it.)
    //
    if (textline[_tcslen(textline) - 1] != _T('\n'))
        _tcscat(textline, _T("\n"));
#endif
 
    return textline;
}