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 ** )

Definition at line 506 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	,
		LPTSTR	,
		LPTSTR	,
		PARSED_COMMAND *
	)

Definition at line 300 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)
     {
         /* Default the top-level batch context type to .BAT */
         BatType = BAT_TYPE;
 
         /* If this is a .CMD file, adjust the type */
         TCHAR *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 526 of file batch.c.

 {
     LPSTR lpString;
     INT len = 0;
 #ifdef _UNICODE
     lpString = cmd_alloc(nBufferLength);
     if (!lpString)
     {
         WARN("Cannot allocate memory for lpString\n");
         error_out_of_memory();
         return FALSE;
     }
 #else
     lpString = lpBuffer;
 #endif
     /* read all chars from memory until a '\n' is encountered */
     if (bc->mem)
     {
         for (; (bc->mempos < bc->memsize  &&  len < (nBufferLength-1)); len++)
         { 
             lpString[len] = bc->mem[bc->mempos++];
             if (lpString[len] == '\n' )
             {
                 len++;
                 break;
             }
         }
     }
 
     if (!len)
     {
 #ifdef _UNICODE
         cmd_free(lpString);
 #endif
         return FALSE;
     }
 
     lpString[len++] = '\0';
 #ifdef _UNICODE
     MultiByteToWideChar(OutputCodePage, 0, lpString, -1, lpBuffer, len);
     cmd_free(lpString);
 #endif
     return TRUE;
 }

Referenced by cmd_goto(), and ReadBatchLine().

◆ ExitAllBatches()

VOID ExitAllBatches ( VOID )

Definition at line 262 of file batch.c.

 {
     while (bc)
         ExitBatch();
 }

Referenced by Batch(), and ReadBatchLine().

◆ ExitBatch()

VOID ExitBatch ( VOID )

Definition at line 223 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 85 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 579 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;
 }