Sweden-Number/programs/cmd/batch.c

622 lines
19 KiB
C
Raw Normal View History

1999-06-06 17:24:04 +02:00
/*
2006-09-04 06:13:08 +02:00
* CMD - Wine-compatible command line interface - batch interface.
1999-06-06 17:24:04 +02:00
*
* Copyright (C) 1999 D A Pickles
1999-06-06 17:24:04 +02:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
1999-06-06 17:24:04 +02:00
*/
#include "wcmd.h"
extern int echo_mode;
2007-06-03 23:07:42 +02:00
extern WCHAR quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
extern BATCH_CONTEXT *context;
extern DWORD errorlevel;
1999-06-06 17:24:04 +02:00
/****************************************************************************
* WCMD_batch
*
* Open and execute a batch file.
* On entry *command includes the complete command line beginning with the name
* of the batch file (if a CALL command was entered the CALL has been removed).
* *file is the name of the file, which might not exist and may not have the
* .BAT suffix on. Called is 1 for a CALL, 0 otherwise.
1999-06-06 17:24:04 +02:00
*
* We need to handle recursion correctly, since one batch program might call another.
* So parameters for this batch file are held in a BATCH_CONTEXT structure.
*
* To support call within the same batch program, another input parameter is
* a label to goto once opened.
1999-06-06 17:24:04 +02:00
*/
2007-06-03 23:07:42 +02:00
void WCMD_batch (WCHAR *file, WCHAR *command, int called, WCHAR *startLabel, HANDLE pgmHandle) {
1999-06-06 17:24:04 +02:00
#define WCMD_BATCH_EXT_SIZE 5
HANDLE h = INVALID_HANDLE_VALUE;
2007-06-03 23:07:42 +02:00
WCHAR string[MAXSTRING];
static const WCHAR extension_batch[][WCMD_BATCH_EXT_SIZE] = {{'.','b','a','t','\0'},
{'.','c','m','d','\0'}};
static const WCHAR extension_exe[WCMD_BATCH_EXT_SIZE] = {'.','e','x','e','\0'};
unsigned int i;
BATCH_CONTEXT *prev_context;
1999-06-06 17:24:04 +02:00
if (startLabel == NULL) {
2007-06-03 23:07:42 +02:00
for(i=0; (i<((sizeof(extension_batch) * sizeof(WCHAR))/WCMD_BATCH_EXT_SIZE)) &&
(h == INVALID_HANDLE_VALUE); i++) {
2007-06-03 23:07:42 +02:00
strcpyW (string, file);
CharLower (string);
if (strstrW (string, extension_batch[i]) == NULL) strcatW (string, extension_batch[i]);
h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}
if (h == INVALID_HANDLE_VALUE) {
2007-06-03 23:07:42 +02:00
strcpyW (string, file);
CharLower (string);
2007-06-03 23:07:42 +02:00
if (strstrW (string, extension_exe) == NULL) strcatW (string, extension_exe);
h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (h != INVALID_HANDLE_VALUE) {
WCMD_run_program (command, 0);
} else {
SetLastError (ERROR_FILE_NOT_FOUND);
WCMD_print_error ();
}
return;
}
} else {
DuplicateHandle(GetCurrentProcess(), pgmHandle,
GetCurrentProcess(), &h,
0, FALSE, DUPLICATE_SAME_ACCESS);
1999-06-06 17:24:04 +02:00
}
/*
* Create a context structure for this batch file.
*/
prev_context = context;
context = (BATCH_CONTEXT *)LocalAlloc (LMEM_FIXED, sizeof (BATCH_CONTEXT));
context -> h = h;
context -> command = command;
2007-03-08 01:50:37 +01:00
memset(context -> shift_count, 0x00, sizeof(context -> shift_count));
context -> prev_context = prev_context;
2007-02-20 18:49:08 +01:00
context -> skip_rest = FALSE;
/* If processing a call :label, 'goto' the label in question */
if (startLabel) {
2007-06-03 23:07:42 +02:00
strcpyW(param1, startLabel);
WCMD_goto();
}
1999-06-06 17:24:04 +02:00
/*
* Work through the file line by line. Specific batch commands are processed here,
* the rest are handled by the main command processor.
*/
2007-02-20 18:49:08 +01:00
while (context -> skip_rest == FALSE && WCMD_fgets (string, sizeof(string), h)) {
2007-06-03 23:07:42 +02:00
if (strlenW(string) == MAXSTRING -1) {
WCMD_output_asis( WCMD_LoadMessage(WCMD_TRUNCATEDLINE));
WCMD_output_asis( string);
WCMD_output_asis( newline);
}
if (string[0] != ':') { /* Skip over labels */
2007-02-23 23:21:27 +01:00
WCMD_process_command (string);
}
1999-06-06 17:24:04 +02:00
}
CloseHandle (h);
/*
* If invoked by a CALL, we return to the context of our caller. Otherwise return
* to the caller's caller.
*/
LocalFree ((HANDLE)context);
if ((prev_context != NULL) && (!called)) {
CloseHandle (prev_context -> h);
context = prev_context -> prev_context;
LocalFree ((HANDLE)prev_context);
}
else {
context = prev_context;
}
1999-06-06 17:24:04 +02:00
}
/*******************************************************************
* WCMD_parameter - extract a parameter from a command line.
*
* Returns the 'n'th space-delimited parameter on the command line (zero-based).
1999-06-06 17:24:04 +02:00
* Parameter is in static storage overwritten on the next call.
* Parameters in quotes (and brackets) are handled.
* Also returns a pointer to the location of the parameter in the command line.
1999-06-06 17:24:04 +02:00
*/
2007-06-03 23:07:42 +02:00
WCHAR *WCMD_parameter (WCHAR *s, int n, WCHAR **where) {
1999-06-06 17:24:04 +02:00
int i = 0;
2007-06-03 23:07:42 +02:00
static WCHAR param[MAX_PATH];
WCHAR *p;
1999-06-06 17:24:04 +02:00
if (where != NULL) *where = NULL;
1999-06-06 17:24:04 +02:00
p = param;
while (TRUE) {
switch (*s) {
case ' ':
s++;
break;
case '"':
if (where != NULL && i==n) *where = s;
1999-06-06 17:24:04 +02:00
s++;
while ((*s != '\0') && (*s != '"')) {
*p++ = *s++;
}
if (i == n) {
*p = '\0';
return param;
}
if (*s == '"') s++;
1999-06-06 17:24:04 +02:00
param[0] = '\0';
i++;
p = param;
1999-06-06 17:24:04 +02:00
break;
case '(':
if (where != NULL && i==n) *where = s;
s++;
while ((*s != '\0') && (*s != ')')) {
*p++ = *s++;
}
if (i == n) {
*p = '\0';
return param;
}
if (*s == ')') s++;
param[0] = '\0';
i++;
p = param;
break;
1999-06-06 17:24:04 +02:00
case '\0':
return param;
default:
2007-02-20 19:02:29 +01:00
/* Only return where if it is for the right parameter */
if (where != NULL && i==n) *where = s;
1999-06-06 17:24:04 +02:00
while ((*s != '\0') && (*s != ' ')) {
*p++ = *s++;
}
if (i == n) {
*p = '\0';
return param;
}
param[0] = '\0';
i++;
p = param;
1999-06-06 17:24:04 +02:00
}
}
}
/****************************************************************************
1999-06-06 17:24:04 +02:00
* WCMD_fgets
*
* Get one line from a batch file. We can't use the native f* functions because
* of the filename syntax differences between DOS and Unix. Also need to lose
* the LF (or CRLF) from the line.
1999-06-06 17:24:04 +02:00
*/
2007-06-03 23:07:42 +02:00
WCHAR *WCMD_fgets (WCHAR *s, int noChars, HANDLE h) {
1999-06-06 17:24:04 +02:00
DWORD bytes;
BOOL status;
2007-06-03 23:07:42 +02:00
WCHAR *p;
1999-06-06 17:24:04 +02:00
p = s;
do {
2007-06-03 23:07:42 +02:00
status = WCMD_ReadFile (h, s, 1, &bytes, NULL);
if ((status == 0) || ((bytes == 0) && (s == p))) return NULL;
1999-06-06 17:24:04 +02:00
if (*s == '\n') bytes = 0;
else if (*s != '\r') {
s++;
2007-06-03 23:07:42 +02:00
noChars--;
}
*s = '\0';
2007-06-03 23:07:42 +02:00
} while ((bytes == 1) && (noChars > 1));
1999-06-06 17:24:04 +02:00
return p;
}
2007-02-20 18:49:43 +01:00
/* WCMD_splitpath - copied from winefile as no obvious way to use it otherwise */
2007-06-03 23:07:42 +02:00
void WCMD_splitpath(const WCHAR* path, WCHAR* drv, WCHAR* dir, WCHAR* name, WCHAR* ext)
2007-02-20 18:49:43 +01:00
{
2007-06-03 23:07:42 +02:00
const WCHAR* end; /* end of processed string */
const WCHAR* p; /* search pointer */
const WCHAR* s; /* copy pointer */
2007-02-20 18:49:43 +01:00
/* extract drive name */
if (path[0] && path[1]==':') {
if (drv) {
*drv++ = *path++;
*drv++ = *path++;
*drv = '\0';
}
} else if (drv)
*drv = '\0';
/* search for end of string or stream separator */
for(end=path; *end && *end!=':'; )
end++;
/* search for begin of file extension */
for(p=end; p>path && *--p!='\\' && *p!='/'; )
if (*p == '.') {
end = p;
break;
}
if (ext)
for(s=end; (*ext=*s++); )
ext++;
/* search for end of directory name */
for(p=end; p>path; )
if (*--p=='\\' || *p=='/') {
p++;
break;
}
if (name) {
for(s=p; s<end; )
*name++ = *s++;
*name = '\0';
}
if (dir) {
for(s=path; s<p; )
*dir++ = *s++;
*dir = '\0';
}
}
/****************************************************************************
* WCMD_HandleTildaModifiers
*
* Handle the ~ modifiers when expanding %0-9 or (%a-z in for command)
* %~xxxxxV (V=0-9 or A-Z)
* Where xxxx is any combination of:
* ~ - Removes quotes
* f - Fully qualified path (assumes current dir if not drive\dir)
* d - drive letter
* p - path
* n - filename
* x - file extension
* s - path with shortnames
* a - attributes
* t - date/time
* z - size
* $ENVVAR: - Searches ENVVAR for (contents of V) and expands to fully
* qualified path
*
* To work out the length of the modifier:
*
* Note: In the case of %0-9 knowing the end of the modifier is easy,
2007-06-03 23:07:42 +02:00
* but in a for loop, the for end WCHARacter may also be a modifier
2007-02-20 18:49:43 +01:00
* eg. for %a in (c:\a.a) do echo XXX
* where XXX = %~a (just ~)
* %~aa (~ and attributes)
* %~aaxa (~, attributes and extension)
* BUT %~aax (~ and attributes followed by 'x')
*
* Hence search forwards until find an invalid modifier, and then
* backwards until find for variable or 0-9
*/
2007-06-03 23:07:42 +02:00
void WCMD_HandleTildaModifiers(WCHAR **start, WCHAR *forVariable) {
2007-02-20 18:49:43 +01:00
#define NUMMODIFIERS 11
2007-06-03 23:07:42 +02:00
static const WCHAR validmodifiers[NUMMODIFIERS] = {
2007-02-20 18:49:43 +01:00
'~', 'f', 'd', 'p', 'n', 'x', 's', 'a', 't', 'z', '$'
};
2007-06-03 23:07:42 +02:00
static const WCHAR space[] = {' ', '\0'};
2007-02-20 18:49:43 +01:00
WIN32_FILE_ATTRIBUTE_DATA fileInfo;
2007-06-03 23:07:42 +02:00
WCHAR outputparam[MAX_PATH];
WCHAR finaloutput[MAX_PATH];
WCHAR fullfilename[MAX_PATH];
WCHAR thisoutput[MAX_PATH];
WCHAR *pos = *start+1;
WCHAR *firstModifier = pos;
WCHAR *lastModifier = NULL;
2007-02-20 18:49:43 +01:00
int modifierLen = 0;
BOOL finished = FALSE;
int i = 0;
BOOL exists = TRUE;
BOOL skipFileParsing = FALSE;
BOOL doneModifier = FALSE;
2007-06-03 23:07:42 +02:00
/* Search forwards until find invalid WCHARacter modifier */
2007-02-20 18:49:43 +01:00
while (!finished) {
2007-06-03 23:07:42 +02:00
/* Work on the previous WCHARacter */
2007-02-20 18:49:43 +01:00
if (lastModifier != NULL) {
for (i=0; i<NUMMODIFIERS; i++) {
if (validmodifiers[i] == *lastModifier) {
/* Special case '$' to skip until : found */
if (*lastModifier == '$') {
while (*pos != ':' && *pos) pos++;
if (*pos == 0x00) return; /* Invalid syntax */
pos++; /* Skip ':' */
}
break;
}
}
if (i==NUMMODIFIERS) {
finished = TRUE;
}
}
/* Save this one away */
if (!finished) {
lastModifier = pos;
pos++;
}
}
/* Now make sure the position we stopped at is a valid parameter */
if (!(*lastModifier >= '0' || *lastModifier <= '9') &&
(forVariable != NULL) &&
2007-06-03 23:07:42 +02:00
(toupperW(*lastModifier) != toupperW(*forVariable))) {
2007-02-20 18:49:43 +01:00
/* Its not... Step backwards until it matches or we get to the start */
2007-06-03 23:07:42 +02:00
while (toupperW(*lastModifier) != toupperW(*forVariable) &&
2007-02-20 18:49:43 +01:00
lastModifier > firstModifier) {
lastModifier--;
}
if (lastModifier == firstModifier) return; /* Invalid syntax */
}
/* Extract the parameter to play with */
if ((*lastModifier >= '0' && *lastModifier <= '9')) {
2007-06-03 23:07:42 +02:00
strcpyW(outputparam, WCMD_parameter (context -> command,
2007-03-08 01:50:37 +01:00
*lastModifier-'0' + context -> shift_count[*lastModifier-'0'], NULL));
2007-02-20 18:49:43 +01:00
} else {
/* FIXME: Retrieve 'for' variable %c\n", *lastModifier); */
/* Need to get 'for' loop variable into outputparam */
return;
}
/* So now, firstModifier points to beginning of modifiers, lastModifier
points to the variable just after the modifiers. Process modifiers
in a specific order, remembering there could be duplicates */
modifierLen = lastModifier - firstModifier;
finaloutput[0] = 0x00;
/* Useful for debugging purposes: */
/*printf("Modifier string '%*.*s' and variable is %c\n Param starts as '%s'\n",
(modifierLen), (modifierLen), firstModifier, *lastModifier,
outputparam);*/
/* 1. Handle '~' : Strip surrounding quotes */
if (outputparam[0]=='"' &&
2007-06-03 23:07:42 +02:00
memchrW(firstModifier, '~', modifierLen) != NULL) {
int len = strlenW(outputparam);
2007-02-20 18:49:43 +01:00
if (outputparam[len-1] == '"') {
outputparam[len-1]=0x00;
len = len - 1;
}
2007-06-03 23:07:42 +02:00
memmove(outputparam, &outputparam[1], (len * sizeof(WCHAR))-1);
2007-02-20 18:49:43 +01:00
}
/* 2. Handle the special case of a $ */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, '$', modifierLen) != NULL) {
2007-02-20 18:49:43 +01:00
/* Special Case: Search envar specified in $[envvar] for outputparam
Note both $ and : are guaranteed otherwise check above would fail */
2007-06-03 23:07:42 +02:00
WCHAR *start = strchrW(firstModifier, '$') + 1;
WCHAR *end = strchrW(firstModifier, ':');
WCHAR env[MAX_PATH];
WCHAR fullpath[MAX_PATH];
2007-02-20 18:49:43 +01:00
/* Extract the env var */
2007-06-03 23:07:42 +02:00
memcpy(env, start, (end-start) * sizeof(WCHAR));
2007-02-20 18:49:43 +01:00
env[(end-start)] = 0x00;
/* If env var not found, return emptry string */
if ((GetEnvironmentVariable(env, fullpath, MAX_PATH) == 0) ||
(SearchPath(fullpath, outputparam, NULL,
MAX_PATH, outputparam, NULL) == 0)) {
finaloutput[0] = 0x00;
outputparam[0] = 0x00;
skipFileParsing = TRUE;
}
}
/* After this, we need full information on the file,
which is valid not to exist. */
if (!skipFileParsing) {
if (GetFullPathName(outputparam, MAX_PATH, fullfilename, NULL) == 0)
return;
2007-06-03 23:07:42 +02:00
exists = GetFileAttributesExW(fullfilename, GetFileExInfoStandard,
2007-02-20 18:49:43 +01:00
&fileInfo);
/* 2. Handle 'a' : Output attributes */
if (exists &&
2007-06-03 23:07:42 +02:00
memchrW(firstModifier, 'a', modifierLen) != NULL) {
2007-02-20 18:49:43 +01:00
2007-06-03 23:07:42 +02:00
WCHAR defaults[] = {'-','-','-','-','-','-','-','-','-','\0'};
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
2007-06-03 23:07:42 +02:00
strcpyW(thisoutput, defaults);
2007-02-20 18:49:43 +01:00
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
thisoutput[0]='d';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
thisoutput[1]='r';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
thisoutput[2]='a';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
thisoutput[3]='h';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
thisoutput[4]='s';
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED)
thisoutput[5]='c';
/* FIXME: What are 6 and 7? */
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
thisoutput[8]='l';
2007-06-03 23:07:42 +02:00
strcatW(finaloutput, thisoutput);
2007-02-20 18:49:43 +01:00
}
/* 3. Handle 't' : Date+time */
if (exists &&
2007-06-03 23:07:42 +02:00
memchrW(firstModifier, 't', modifierLen) != NULL) {
2007-02-20 18:49:43 +01:00
SYSTEMTIME systime;
int datelen;
doneModifier = TRUE;
2007-06-03 23:07:42 +02:00
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
2007-02-20 18:49:43 +01:00
/* Format the time */
FileTimeToSystemTime(&fileInfo.ftLastWriteTime, &systime);
GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime,
NULL, thisoutput, MAX_PATH);
2007-06-03 23:07:42 +02:00
strcatW(thisoutput, space);
datelen = strlenW(thisoutput);
2007-02-20 18:49:43 +01:00
GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &systime,
NULL, (thisoutput+datelen), MAX_PATH-datelen);
2007-06-03 23:07:42 +02:00
strcatW(finaloutput, thisoutput);
2007-02-20 18:49:43 +01:00
}
/* 4. Handle 'z' : File length */
if (exists &&
2007-06-03 23:07:42 +02:00
memchrW(firstModifier, 'z', modifierLen) != NULL) {
2007-03-06 14:26:24 +01:00
/* FIXME: Output full 64 bit size (sprintf does not support I64 here) */
2007-02-20 18:49:43 +01:00
ULONG/*64*/ fullsize = /*(fileInfo.nFileSizeHigh << 32) +*/
fileInfo.nFileSizeLow;
2007-06-03 23:07:42 +02:00
static const WCHAR fmt[] = {'%','u','\0'};
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
2007-06-03 23:07:42 +02:00
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
wsprintf(thisoutput, fmt, fullsize);
strcatW(finaloutput, thisoutput);
2007-02-20 18:49:43 +01:00
}
2007-03-06 14:26:24 +01:00
/* 4. Handle 's' : Use short paths (File doesn't have to exist) */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, 's', modifierLen) != NULL) {
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
2007-03-06 14:26:24 +01:00
/* Don't flag as doneModifier - %~s on its own is processed later */
2007-02-20 18:49:43 +01:00
GetShortPathName(outputparam, outputparam, sizeof(outputparam));
}
2007-03-06 14:26:24 +01:00
/* 5. Handle 'f' : Fully qualified path (File doesn't have to exist) */
2007-02-20 18:49:43 +01:00
/* Note this overrides d,p,n,x */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, 'f', modifierLen) != NULL) {
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
2007-06-03 23:07:42 +02:00
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
strcatW(finaloutput, fullfilename);
2007-02-20 18:49:43 +01:00
} else {
2007-06-03 23:07:42 +02:00
WCHAR drive[10];
WCHAR dir[MAX_PATH];
WCHAR fname[MAX_PATH];
WCHAR ext[MAX_PATH];
2007-02-20 18:49:43 +01:00
BOOL doneFileModifier = FALSE;
2007-06-03 23:07:42 +02:00
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
2007-02-20 18:49:43 +01:00
/* Split into components */
WCMD_splitpath(fullfilename, drive, dir, fname, ext);
2007-02-20 18:49:43 +01:00
/* 5. Handle 'd' : Drive Letter */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, 'd', modifierLen) != NULL) {
strcatW(finaloutput, drive);
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* 6. Handle 'p' : Path */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, 'p', modifierLen) != NULL) {
strcatW(finaloutput, dir);
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* 7. Handle 'n' : Name */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, 'n', modifierLen) != NULL) {
strcatW(finaloutput, fname);
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* 8. Handle 'x' : Ext */
2007-06-03 23:07:42 +02:00
if (memchrW(firstModifier, 'x', modifierLen) != NULL) {
strcatW(finaloutput, ext);
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
doneFileModifier = TRUE;
}
/* If 's' but no other parameter, dump the whole thing */
if (!doneFileModifier &&
2007-06-03 23:07:42 +02:00
memchrW(firstModifier, 's', modifierLen) != NULL) {
2007-02-20 18:49:43 +01:00
doneModifier = TRUE;
2007-06-03 23:07:42 +02:00
if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
strcatW(finaloutput, outputparam);
2007-02-20 18:49:43 +01:00
}
}
}
/* If No other modifier processed, just add in parameter */
2007-06-03 23:07:42 +02:00
if (!doneModifier) strcpyW(finaloutput, outputparam);
2007-02-20 18:49:43 +01:00
/* Finish by inserting the replacement into the string */
2007-06-03 23:07:42 +02:00
pos = WCMD_strdupW(lastModifier+1);
strcpyW(*start, finaloutput);
strcatW(*start, pos);
2007-02-20 18:49:43 +01:00
free(pos);
}
/*******************************************************************
* WCMD_call - processes a batch call statement
*
* If there is a leading ':', calls within this batch program
* otherwise launches another program.
*/
2007-06-03 23:07:42 +02:00
void WCMD_call (WCHAR *command) {
/* Run other program if no leading ':' */
if (*command != ':') {
WCMD_run_program(command, 1);
} else {
2007-06-03 23:07:42 +02:00
WCHAR gotoLabel[MAX_PATH];
2007-06-03 23:07:42 +02:00
strcpyW(gotoLabel, param1);
if (context) {
LARGE_INTEGER li;
/* Save the current file position, call the same file,
restore position */
li.QuadPart = 0;
li.u.LowPart = SetFilePointer(context -> h, li.u.LowPart,
&li.u.HighPart, FILE_CURRENT);
WCMD_batch (param1, command, 1, gotoLabel, context->h);
SetFilePointer(context -> h, li.u.LowPart,
&li.u.HighPart, FILE_BEGIN);
} else {
WCMD_output_asis( WCMD_LoadMessage(WCMD_CALLINSCRIPT));
}
}
}