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

Classes
struct	tagBATCHCONTEXT

struct	tagFORCONTEXT

Macros
#define	BATCH_BUFFSIZE 8192

Typedefs
typedef struct tagBATCHCONTEXT	BATCH_CONTEXT

typedef struct tagBATCHCONTEXT *	LPBATCH_CONTEXT

typedef struct tagFORCONTEXT	FOR_CONTEXT

typedef struct tagFORCONTEXT *	LPFOR_CONTEXT

Functions
LPTSTR	FindArg (TCHAR, BOOL *)

LPTSTR	BatchParams (LPTSTR, LPTSTR)

VOID	ExitBatch (VOID)

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

BOOL	BatchGetString (LPTSTR lpBuffer, INT nBufferLength)

LPTSTR	ReadBatchLine (VOID)

VOID	AddBatchRedirection (REDIRECTION **)

Variables
LPBATCH_CONTEXT	bc

LPFOR_CONTEXT	fc

BOOL	bEcho

TCHAR	textline [BATCH_BUFFSIZE]

Macro Definition Documentation

◆ BATCH_BUFFSIZE

#define BATCH_BUFFSIZE 8192

Definition at line 43 of file batch.h.

Typedef Documentation

◆ BATCH_CONTEXT

typedef struct tagBATCHCONTEXT BATCH_CONTEXT

◆ FOR_CONTEXT

typedef struct tagFORCONTEXT FOR_CONTEXT

◆ LPBATCH_CONTEXT

typedef struct tagBATCHCONTEXT * LPBATCH_CONTEXT

◆ LPFOR_CONTEXT

typedef struct tagFORCONTEXT * LPFOR_CONTEXT

Function Documentation

◆ AddBatchRedirection()

VOID AddBatchRedirection ( REDIRECTION ** )

Definition at line 371 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 238 of file batch.c.

 {
     BATCH_CONTEXT new;
     LPFOR_CONTEXT saved_fc;
     INT i;
     INT ret = 0;
     BOOL same_fn = FALSE;
 
     HANDLE hFile = 0;
     SetLastError(0);
     if (bc && bc->mem)
     {
         TCHAR fpname[MAX_PATH];
         GetFullPathName(fullname, sizeof(fpname) / sizeof(TCHAR), fpname, NULL);
         if (_tcsicmp(bc->BatchFilePath,fpname)==0)
             same_fn=TRUE;
     }
     TRACE ("Batch: (\'%s\', \'%s\', \'%s\')  same_fn = %d\n",
         debugstr_aw(fullname), debugstr_aw(firstword), debugstr_aw(param), same_fn);
 
     if (!same_fn)
     {
         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;
         }
     }
 
     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 (same_fn)
         {
             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, sizeof(bc->BatchFilePath) / sizeof(TCHAR), bc->BatchFilePath, NULL);
     /*  if a new batch file, load it into memory and close the file */
     if (!same_fn)
     {
         BatchFile2Mem(hFile);
         CloseHandle(hFile);
     }
 
     bc->mempos = 0;    /* goto begin of batch file */
     bc->bEcho = bEcho; /* Preserve echo across batch calls */
     for (i = 0; i < 10; i++)
         bc->shiftlevel[i] = i;
 
     bc->params = BatchParams (firstword, param);
     //
     // Allocate enough memory to hold the params and copy them over without modifications
     //
     bc->raw_params = cmd_dup(param);
     if (bc->raw_params == NULL)
     {
         error_out_of_memory();
         return 1;
     }
 
     /* Check if this is a "CALL :label" */
     if (*firstword == _T(':'))
         cmd_goto(firstword);
 
     /* If we are calling from inside a FOR, hide the FOR variables */
     saved_fc = fc;
     fc = NULL;
 
     /* 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)
             continue;
 
         /* JPP 19980807 */
         /* Echo the command and execute it */
         bc->current = Cmd;
         ret = ExecuteCommandWithEcho(Cmd);
         FreeCommand(Cmd);
     }
 
     /* Always return the current errorlevel */
     ret = nErrorLevel;
 
     TRACE ("Batch: returns TRUE\n");
 
     fc = saved_fc;
     return ret;
 }

◆ BatchGetString()

BOOL BatchGetString	(	LPTSTR	lpBuffer,
		INT	nBufferLength
	)

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

◆ BatchParams()

LPTSTR BatchParams	(	LPTSTR	,
		LPTSTR
	)

Definition at line 113 of file batch.c.

 {
     LPTSTR dp = (LPTSTR)cmd_alloc ((_tcslen(s1) + _tcslen(s2) + 3) * sizeof (TCHAR));
 
     /* JPP 20-Jul-1998 added error checking */
     if (dp == NULL)
     {
         WARN("Cannot allocate memory for dp!\n");
         error_out_of_memory();
         return NULL;
     }
 
     if (s1 && *s1)
     {
         s1 = _stpcpy (dp, s1);
         *s1++ = _T('\0');
     }
     else
         s1 = dp;
 
     while (*s2)
     {
         BOOL inquotes = FALSE;
 
         /* Find next parameter */
         while (_istspace(*s2) || (*s2 && _tcschr(_T(",;="), *s2)))
             s2++;
         if (!*s2)
             break;
 
         /* Copy it */
         do
         {
             if (!inquotes && (_istspace(*s2) || _tcschr(_T(",;="), *s2)))
                 break;
             inquotes ^= (*s2 == _T('"'));
             *s1++ = *s2++;
         } while (*s2);
         *s1++ = _T('\0');
     }
 
     *s1 = _T('\0');
 
     return dp;
 }

Referenced by Batch().

◆ ExitBatch()

VOID ExitBatch ( VOID )

Definition at line 186 of file batch.c.

 {
     ClearBatch();
 
     TRACE ("ExitBatch\n");
 
     UndoRedirection(bc->RedirList, NULL);
     FreeRedirection(bc->RedirList);
 
     /* Preserve echo state across batch calls */
     bEcho = bc->bEcho;
 
     while (bc->setlocal)
         cmd_endlocal(_T(""));
 
     bc = bc->prev;
 }

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

◆ FindArg()

LPTSTR FindArg	(	TCHAR	,
		BOOL *
	)

Definition at line 83 of file batch.c.

 {
     LPTSTR pp;
     INT n = Char - _T('0');
 
     TRACE ("FindArg: (%d)\n", n);
 
     if (n < 0 || n > 9)
         return NULL;
 
     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;
 
     return pp;
 }

Referenced by GetBatchVar().

◆ ReadBatchLine()

LPTSTR ReadBatchLine ( VOID )

Definition at line 444 of file batch.c.

 {
     TRACE ("ReadBatchLine ()\n");
 
     /* User halt */
     if (CheckCtrlBreak (BREAK_BATCHFILE))
     {
         while (bc)
             ExitBatch();
         return NULL;
     }
 
     if (!BatchGetString (textline, sizeof (textline) / sizeof (textline[0]) - 1))
     {
         TRACE ("ReadBatchLine(): Reached EOF!\n");
         /* End of file.... */
         ExitBatch();
         return NULL;
     }
 
     TRACE ("ReadBatchLine(): textline: \'%s\'\n", debugstr_aw(textline));
 
     if (textline[_tcslen(textline) - 1] != _T('\n'))
         _tcscat(textline, _T("\n"));
 
     return textline;
 }