cmd: Adjust CMD_LIST to a tree-like structure and implement command chains
Flávio J. Saraiva
flaviojs2005 at gmail.com
Tue Mar 21 12:57:12 CDT 2017
Fixes chaining of commands (most commands are untested)
This commit also makes changes targetted at 'IF', 'FOR', 'CALL', 'TYPE',
brackets, labels and pipes. These changes are the minimum required
changes to make the tree-like structure work with the current tests,
and need to be reworked.
Signed-off-by: Flávio J. Saraiva <flaviojs2005 at gmail.com>
---
programs/cmd/batch.c | 6 +-
programs/cmd/builtins.c | 226 ++------
programs/cmd/tests/test_builtins.cmd | 38 --
programs/cmd/tests/test_builtins.cmd.exp | 58 +--
programs/cmd/wcmd.h | 37 +-
programs/cmd/wcmdmain.c | 850 +++++++++++++++++++++++++++----
6 files changed, 865 insertions(+), 350 deletions(-)
diff --git a/programs/cmd/batch.c b/programs/cmd/batch.c
index 1a78b55..754e673 100644
--- a/programs/cmd/batch.c
+++ b/programs/cmd/batch.c
@@ -92,7 +92,7 @@ void WCMD_batch (WCHAR *file, WCHAR *command, BOOL called, WCHAR *startLabel, HA
/* Note: although this batch program itself may be called, we are not retrying
the command as a result of a call failing to find a program, hence the
retryCall parameter below is FALSE */
- WCMD_process_commands(toExecute, FALSE, FALSE);
+ WCMD_process_commands(toExecute, FALSE);
WCMD_free_commands(toExecute);
toExecute = NULL;
}
@@ -691,7 +691,7 @@ void WCMD_HandleTildaModifiers(WCHAR **start, BOOL atExecute)
* If there is a leading ':', calls within this batch program
* otherwise launches another program.
*/
-void WCMD_call (WCHAR *command) {
+BOOL WCMD_call (WCHAR *command) {
/* Run other program if no leading ':' */
if (*command != ':') {
@@ -729,4 +729,6 @@ void WCMD_call (WCHAR *command) {
WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_CALLINSCRIPT));
}
}
+
+ return (errorlevel == 0);
}
diff --git a/programs/cmd/builtins.c b/programs/cmd/builtins.c
index 7301f54..c3b50dc 100644
--- a/programs/cmd/builtins.c
+++ b/programs/cmd/builtins.c
@@ -1531,103 +1531,6 @@ void WCMD_echo (const WCHAR *args)
}
/*****************************************************************************
- * WCMD_part_execute
- *
- * Execute a command, and any && or bracketed follow on to the command. The
- * first command to be executed may not be at the front of the
- * commands->thiscommand string (eg. it may point after a DO or ELSE)
- */
-static void WCMD_part_execute(CMD_LIST **cmdList, const WCHAR *firstcmd,
- BOOL isIF, BOOL executecmds)
-{
- CMD_LIST *curPosition = *cmdList;
- int myDepth = (*cmdList)->bracketDepth;
-
- WINE_TRACE("cmdList(%p), firstCmd(%s), doIt(%d)\n", cmdList, wine_dbgstr_w(firstcmd),
- executecmds);
-
- /* Skip leading whitespace between condition and the command */
- while (firstcmd && *firstcmd && (*firstcmd==' ' || *firstcmd=='\t')) firstcmd++;
-
- /* Process the first command, if there is one */
- if (executecmds && firstcmd && *firstcmd) {
- WCHAR *command = heap_strdupW(firstcmd);
- WCMD_execute (firstcmd, (*cmdList)->redirects, cmdList, FALSE);
- heap_free(command);
- }
-
-
- /* If it didn't move the position, step to next command */
- if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
-
- /* Process any other parts of the command */
- if (*cmdList) {
- BOOL processThese = executecmds;
-
- while (*cmdList) {
- static const WCHAR ifElse[] = {'e','l','s','e'};
-
- /* execute all appropriate commands */
- curPosition = *cmdList;
-
- WINE_TRACE("Processing cmdList(%p) - delim(%d) bd(%d / %d)\n",
- *cmdList,
- (*cmdList)->prevDelim,
- (*cmdList)->bracketDepth, myDepth);
-
- /* Execute any statements appended to the line */
- /* FIXME: Only if previous call worked for && or failed for || */
- if ((*cmdList)->prevDelim == CMD_ONFAILURE ||
- (*cmdList)->prevDelim == CMD_ONSUCCESS) {
- if (processThese && (*cmdList)->command) {
- WCMD_execute ((*cmdList)->command, (*cmdList)->redirects,
- cmdList, FALSE);
- }
- if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
-
- /* Execute any appended to the statement with (...) */
- } else if ((*cmdList)->bracketDepth > myDepth) {
- if (processThese) {
- *cmdList = WCMD_process_commands(*cmdList, TRUE, FALSE);
- WINE_TRACE("Back from processing commands, (next = %p)\n", *cmdList);
- }
- if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
-
- /* End of the command - does 'ELSE ' follow as the next command? */
- } else {
- if (isIF
- && WCMD_keyword_ws_found(ifElse, sizeof(ifElse)/sizeof(ifElse[0]),
- (*cmdList)->command)) {
-
- /* Swap between if and else processing */
- processThese = !executecmds;
-
- /* Process the ELSE part */
- if (processThese) {
- const int keyw_len = sizeof(ifElse)/sizeof(ifElse[0]) + 1;
- WCHAR *cmd = ((*cmdList)->command) + keyw_len;
-
- /* Skip leading whitespace between condition and the command */
- while (*cmd && (*cmd==' ' || *cmd=='\t')) cmd++;
- if (*cmd) {
- WCMD_execute (cmd, (*cmdList)->redirects, cmdList, FALSE);
- }
- }
- if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
- } else if (!processThese) {
- if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
- WINE_TRACE("Ignore the next command as well (next = %p)\n", *cmdList);
- } else {
- WINE_TRACE("Found end of this IF statement (next = %p)\n", *cmdList);
- break;
- }
- }
- }
- }
- return;
-}
-
-/*****************************************************************************
* WCMD_parse_forf_options
*
* Parses the for /f 'options', extracting the values and validating the
@@ -2006,7 +1909,7 @@ static void WCMD_parse_line(CMD_LIST *cmdStart,
if (forloopcontext.variable[varidx] && forloopcontext.variable[varidx][0] != forf_eol) {
CMD_LIST *thisCmdStart = cmdStart;
*doExecuted = TRUE;
- WCMD_part_execute(&thisCmdStart, firstCmd, FALSE, TRUE);
+ thisCmdStart = WCMD_process_commands(thisCmdStart, FALSE);
*cmdEnd = thisCmdStart;
}
@@ -2099,18 +2002,18 @@ static HANDLE WCMD_forf_getinputhandle(BOOL usebackq, WCHAR *itemstr, BOOL iscmd
*/
void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
-
+ CMD_LIST *forInCmd;
+ CMD_LIST *forDoCmd;
WIN32_FIND_DATAW fd;
HANDLE hff;
int i;
static const WCHAR inW[] = {'i','n'};
static const WCHAR doW[] = {'d','o'};
- CMD_LIST *setStart, *thisSet, *cmdStart, *cmdEnd;
+ CMD_LIST *thisSet, *cmdStart, *cmdEnd;
WCHAR variable[4];
int varidx = -1;
WCHAR *oldvariablevalue;
WCHAR *firstCmd;
- int thisDepth;
WCHAR optionsRoot[MAX_PATH];
DIRECTORY_STACK *dirsToWalk = NULL;
BOOL expandDirs = FALSE;
@@ -2127,9 +2030,15 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
WCHAR forf_delims[256];
WCHAR forf_tokens[MAXSTRING];
BOOL forf_usebackq = FALSE;
+ WCHAR *thisArg;
+
+ if (p == NULL || cmdList == NULL) {
+ WINE_FIXME("Invalid argument (%p, %p)\n", p, cmdList);
+ return;
+ }
/* Handle optional qualifiers (multiple are allowed) */
- WCHAR *thisArg = WCMD_parameter(p, parameterNo++, NULL, FALSE, FALSE);
+ thisArg = WCMD_parameter(p, parameterNo++, NULL, FALSE, FALSE);
optionsRoot[0] = 0;
while (thisArg && *thisArg == '/') {
@@ -2201,40 +2110,23 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
varidx = FOR_VAR_IDX(variable[1]);
/* Ensure line continues with IN */
- thisArg = WCMD_parameter(p, parameterNo++, NULL, FALSE, FALSE);
- if (!thisArg
- || !(CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
- thisArg, sizeof(inW)/sizeof(inW[0]), inW,
- sizeof(inW)/sizeof(inW[0])) == CSTR_EQUAL)) {
- WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR));
- return;
- }
-
- /* Save away where the set of data starts and the variable */
- thisDepth = (*cmdList)->bracketDepth;
- *cmdList = (*cmdList)->nextcommand;
- setStart = (*cmdList);
-
- /* Skip until the close bracket */
- WINE_TRACE("Searching %p as the set\n", *cmdList);
- while (*cmdList &&
- (*cmdList)->command != NULL &&
- (*cmdList)->bracketDepth > thisDepth) {
- WINE_TRACE("Skipping %p which is part of the set\n", *cmdList);
- *cmdList = (*cmdList)->nextcommand;
+ forInCmd = (*cmdList != NULL ? (*cmdList)->children : NULL);
+ if (forInCmd == NULL || forInCmd->type != CMD_TYPE_FOR_IN || forInCmd->command == NULL
+ || !WCMD_keyword_ws_found(inW, sizeof(inW)/sizeof(inW[0]), forInCmd->command)) {
+ WINE_TRACE("Expected 'IN' %p:\n", forInCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR));
+ return;
}
- /* Skip the close bracket, if there is one */
- if (*cmdList) *cmdList = (*cmdList)->nextcommand;
-
- /* Syntax error if missing close bracket, or nothing following it
- and once we have the complete set, we expect a DO */
- WINE_TRACE("Looking for 'do ' in %p\n", *cmdList);
- if ((*cmdList == NULL)
- || !WCMD_keyword_ws_found(doW, sizeof(doW)/sizeof(doW[0]), (*cmdList)->command)) {
-
- WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR));
- return;
+ /* Ensure the IN is followed by a DO */
+ forDoCmd = forInCmd->nextcommand;
+ if (forDoCmd == NULL || forDoCmd->type != CMD_TYPE_FOR_DO || forDoCmd->command == NULL
+ || !WCMD_keyword_ws_found(doW, sizeof(doW)/sizeof(doW[0]), forDoCmd->command)) {
+ WINE_TRACE("Expected 'DO' %p:\n", forDoCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR));
+ return;
}
cmdEnd = *cmdList;
@@ -2245,19 +2137,17 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
/* Save away the starting position for the commands (and offset for the
first one) */
- cmdStart = *cmdList;
- firstCmd = (*cmdList)->command + 3; /* Skip 'do ' */
+ cmdStart = forDoCmd->children;
+ firstCmd = (cmdStart != NULL ? cmdStart->command : NULL);
itemNum = 0;
/* If we are recursing directories (ie /R), add all sub directories now, then
prefix the root when searching for the item */
if (dirsToWalk) WCMD_add_dirstowalk(dirsToWalk);
- thisSet = setStart;
+ thisSet = forInCmd->children;
/* Loop through all set entries */
- while (thisSet &&
- thisSet->command != NULL &&
- thisSet->bracketDepth >= thisDepth) {
+ while (thisSet && thisSet->command != NULL) {
/* Loop through all entries on the same line */
WCHAR *item;
@@ -2327,7 +2217,7 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
oldvariablevalue = forloopcontext.variable[varidx];
forloopcontext.variable[varidx] = fullitem;
}
- WCMD_part_execute (&thisCmdStart, firstCmd, FALSE, TRUE);
+ thisCmdStart = WCMD_process_commands(thisCmdStart, FALSE);
if (varidx >= 0) forloopcontext.variable[varidx] = oldvariablevalue;
cmdEnd = thisCmdStart;
@@ -2344,7 +2234,7 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
oldvariablevalue = forloopcontext.variable[varidx];
forloopcontext.variable[varidx] = fullitem;
}
- WCMD_part_execute (&thisCmdStart, firstCmd, FALSE, TRUE);
+ thisCmdStart = WCMD_process_commands(thisCmdStart, FALSE);
if (varidx >= 0) forloopcontext.variable[varidx] = oldvariablevalue;
cmdEnd = thisCmdStart;
@@ -2439,6 +2329,8 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
WCHAR thisNum[20];
static const WCHAR fmt[] = {'%','d','\0'};
+ thisCmdStart = NULL;
+
WINE_TRACE("FOR /L provided range from %d to %d step %d\n",
numbers[0], numbers[2], numbers[1]);
for (i=numbers[0];
@@ -2457,7 +2349,8 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
oldvariablevalue = forloopcontext.variable[varidx];
forloopcontext.variable[varidx] = thisNum;
}
- WCMD_part_execute (&thisCmdStart, firstCmd, FALSE, TRUE);
+ thisCmdStart = WCMD_process_commands(thisCmdStart, FALSE);
+
if (varidx >= 0) forloopcontext.variable[varidx] = oldvariablevalue;
}
cmdEnd = thisCmdStart;
@@ -2475,25 +2368,6 @@ void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
}
} while (dirsToWalk != NULL);
-
- /* Now skip over the do part if we did not perform the for loop so far.
- We store in cmdEnd the next command after the do block, but we only
- know this if something was run. If it has not been, we need to calculate
- it. */
- if (!doExecuted) {
- thisCmdStart = cmdStart;
- WINE_TRACE("Skipping for loop commands due to no valid iterations\n");
- WCMD_part_execute(&thisCmdStart, firstCmd, FALSE, FALSE);
- cmdEnd = thisCmdStart;
- }
-
- /* When the loop ends, either something like a GOTO or EXIT /b has terminated
- all processing, OR it should be pointing to the end of && processing OR
- it should be pointing at the NULL end of bracket for the DO. The return
- value needs to be the NEXT command to execute, which it either is, or
- we need to step over the closing bracket */
- *cmdList = cmdEnd;
- if (cmdEnd && cmdEnd->command == NULL) *cmdList = cmdEnd->nextcommand;
}
/**************************************************************************
@@ -2778,7 +2652,7 @@ static int evaluate_if_comparison(const WCHAR *leftOperand, const WCHAR *operato
*
* FIXME: Much more syntax checking needed!
*/
-void WCMD_if (WCHAR *p, CMD_LIST **cmdList)
+BOOL WCMD_if (WCHAR *p, CMD_LIST **cmdList)
{
int negate; /* Negate condition */
int test; /* Condition evaluation result */
@@ -2789,6 +2663,7 @@ void WCMD_if (WCHAR *p, CMD_LIST **cmdList)
static const WCHAR defdW[] = {'d','e','f','i','n','e','d','\0'};
static const WCHAR parmI[] = {'/','I','\0'};
int caseInsensitive = (strstrW(quals, parmI) != NULL);
+ CMD_LIST *childCmd;
negate = !lstrcmpiW(param1,notW);
strcpyW(condition, (negate ? param2 : param1));
@@ -2845,13 +2720,24 @@ void WCMD_if (WCHAR *p, CMD_LIST **cmdList)
WCMD_parameter(p, 0, &command, FALSE, FALSE);
}
- /* Process rest of IF statement which is on the same line
- Note: This may process all or some of the cmdList (eg a GOTO) */
- WCMD_part_execute(cmdList, command, TRUE, (test != negate));
- return;
+ childCmd = (*cmdList)->children;
+ if (test != negate) {
+ /* IF true */
+ while (childCmd && childCmd->type != CMD_TYPE_IF_TRUE) {
+ childCmd = childCmd->nextcommand;
+ }
+ }
+ else {
+ /* IF false */
+ while (childCmd && childCmd->type != CMD_TYPE_IF_FALSE) {
+ childCmd = childCmd->nextcommand;
+ }
+ }
+ return WCMD_process_command(&childCmd, FALSE);
syntax_err:
WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR));
+ return FALSE;
}
/****************************************************************************
@@ -4361,8 +4247,7 @@ void WCMD_title (const WCHAR *args) {
*
* Copy a file to standard output.
*/
-
-void WCMD_type (WCHAR *args) {
+BOOL WCMD_type (WCHAR *args) {
int argno = 0;
WCHAR *argN = args;
@@ -4370,7 +4255,7 @@ void WCMD_type (WCHAR *args) {
if (param1[0] == 0x00) {
WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG));
- return;
+ return FALSE;
}
if (param2[0] != 0x00) writeHeaders = TRUE;
@@ -4406,6 +4291,7 @@ void WCMD_type (WCHAR *args) {
CloseHandle (h);
}
}
+ return (errorlevel == 0);
}
/****************************************************************************
diff --git a/programs/cmd/tests/test_builtins.cmd b/programs/cmd/tests/test_builtins.cmd
index 62334b1..42e628a 100644
--- a/programs/cmd/tests/test_builtins.cmd
+++ b/programs/cmd/tests/test_builtins.cmd
@@ -179,7 +179,6 @@ if exist foo (type foo) else echo not supported
echo --- redirections within IF statements
if 1==1 echo foo1>bar
type bar & del bar
-echo -----
if 1==1 (echo foo2>bar) else echo baz2>bar
type bar & del bar
if 1==1 (echo foo3) else echo baz3>bar
@@ -271,39 +270,27 @@ echo --- chain success
echo a1&echo a2
echo b1&&echo b2
echo c1||echo c2
-echo ---
echo d1&echo d2&echo d3
echo e1&echo e2&&echo e3
echo f1&echo f2||echo f3
-echo ---
echo g1&&echo g2&echo g3
echo h1&&echo h2&&echo h3
echo i1&&echo i2||echo i3
-echo ---
echo j1||echo j2&echo j3
-echo ---
echo k1||echo k2&&echo k3
-echo ---
echo l1||echo l2||echo l3
-echo ---
echo --- chain failure
call :cfail a1&call :cfail a2
call :cfail b1&&call :cfail b2
-echo ---
call :cfail c1||call :cfail c2
call :cfail d1&call :cfail d2&call :cfail d3
call :cfail e1&call :cfail e2&&call :cfail e3
-echo ---
call :cfail f1&call :cfail f2||call :cfail f3
call :cfail g1&&call :cfail g2&call :cfail g3
-echo ---
call :cfail h1&&call :cfail h2&&call :cfail h3
-echo ---
call :cfail i1&&call :cfail i2||call :cfail i3
-echo ---
call :cfail j1||call :cfail j2&call :cfail j3
call :cfail k1||call :cfail k2&&call :cfail k3
-echo ---
call :cfail l1||call :cfail l2||call :cfail l3
echo --- chain brackets
rem Brackets are like regular commands, they support redirections
@@ -311,30 +298,20 @@ rem and have the same precedence as regular commands.
echo a1&(echo a2&echo a3)
echo b1&(echo b2&&echo b3)
echo c1&(echo c2||echo c3)
-echo ---
echo d1&&(echo d2&echo d3)
echo e1&&(echo e2&&echo e3)
echo f1&&(echo f2||echo f3)
-echo ---
echo g1||(echo g2&echo g3)
-echo ---
echo h1||(echo h2&&echo h3)
-echo ---
echo i1||(echo i2||echo i3)
-echo ---
call :cfail j1&(call :cfail j2&call :cfail j3)
call :cfail k1&(call :cfail k2&&call :cfail k3)
-echo ---
call :cfail l1&(call :cfail l2||call :cfail l3)
call :cfail m1&&(call :cfail m2&call :cfail m3)
-echo ---
call :cfail n1&&(call :cfail n2&&call :cfail n3)
-echo ---
call :cfail o1&&(call :cfail o2||call :cfail o3)
-echo ---
call :cfail p1||(call :cfail p2&call :cfail p3)
call :cfail q1||(call :cfail q2&&call :cfail q3)
-echo ---
call :cfail r1||(call :cfail r2||call :cfail r3)
echo --- chain pipe
rem Piped commands run at the same time, so the print order varies.
@@ -345,11 +322,9 @@ echo ---
echo b1|echo b2
echo c1&&echo c2|echo c3
echo d1||echo d2|echo d3
-echo ---
echo e1&echo e2|echo e3
echo f1|echo f2&&echo f3
echo g1|echo g2||echo g3
-echo ---
echo h1|echo h2&echo h3
echo i1|echo i2|echo i3
echo --- chain pipe input
@@ -383,36 +358,25 @@ rem brackets, which means the 'else' can only be recognized when the
rem 'if true' command chain ends with brackets.
if 1==1 if 2==2 if 3==3 (echo a1) else (echo a2) else echo a3
if 1==1 if 2==2 if 3==0 (echo b1) else (echo b2) else echo b3
-echo ---
if 1==1 if 2==0 if 3==3 (echo c1) else (echo c2) else echo c3
-echo ---
if 1==1 if 2==0 if 3==0 (echo d1) else (echo d2) else echo d3
-echo ---
if 1==0 if 2==2 if 3==3 (echo e1) else (echo e2) else echo e3
-echo ---
if 1==0 if 2==2 if 3==0 (echo f1) else (echo f2) else echo f3
-echo ---
if 1==0 if 2==0 if 3==3 (echo g1) else (echo g2) else echo g3
-echo ---
if 1==0 if 2==0 if 3==0 (echo h1) else (echo h2) else echo h3
-echo ---
echo --- chain else (if true)
if 1==1 echo a1 else echo a2
if 1==1 echo b1|echo b2 else echo b3
if 1==1 echo c1&&echo c2 else echo c3
if 1==1 echo d1||echo d2 else echo d3
-echo ---
if 1==1 echo e1&echo e2 else echo e3
if 1==1 echo f1 else echo f2|echo f3
if 1==1 echo g1 else echo g2&&echo g3
if 1==1 echo h1 else echo h2||echo h3
-echo ---
if 1==1 echo i1 else echo i2&echo i3
if 1==1 echo j1|(echo j2) else echo j3
-echo ---
if 1==1 echo k1&&(echo k2) else echo k3
if 1==1 echo l1||(echo l2) else echo l3
-echo ---
if 1==1 echo m1&(echo m2) else echo m3
if 1==1 (echo n1) else echo n2|echo n3
if 1==1 (echo o1) else echo o2&&echo o3
@@ -429,14 +393,12 @@ if 1==0 echo g1 else echo g2&&echo g3
if 1==0 echo h1 else echo h2||echo h3
if 1==0 echo i1 else echo i2&echo i3
if 1==0 echo j1|(echo j2) else echo j3
-echo ---
if 1==0 echo k1&&(echo k2) else echo k3
if 1==0 echo l1||(echo l2) else echo l3
if 1==0 echo m1&(echo m2) else echo m3
if 1==0 (echo n1) else echo n2|echo n3
if 1==0 (echo o1) else echo o2&&echo o3
if 1==0 (echo p1) else echo p2||echo p3
-echo ---
if 1==0 (echo q1) else echo q2&echo q3
echo ------------ Testing 'set' ------------
call :setError 0
diff --git a/programs/cmd/tests/test_builtins.cmd.exp b/programs/cmd/tests/test_builtins.cmd.exp
index 796550e..6a4f8ab 100644
--- a/programs/cmd/tests/test_builtins.cmd.exp
+++ b/programs/cmd/tests/test_builtins.cmd.exp
@@ -205,8 +205,7 @@ food21
@todo_wine at foo7@space@@space@@or_broken at not supported at space@
@todo_wine at foo@or_broken at not supported
--- redirections within IF statements
- at todo_wine@foo1
------
+foo1
foo2
foo3
file does not exist, ok
@@ -255,7 +254,6 @@ a2
b1
b2
c1
- at todo_wine@---
d1
d2
d3
@@ -264,7 +262,6 @@ e2
e3
f1
f2
- at todo_wine@---
g1
g2
g3
@@ -273,19 +270,14 @@ h2
h3
i1
i2
- at todo_wine@---
j1
- at todo_wine@j3
- at todo_wine@---
+j3
k1
- at todo_wine@---
l1
- at todo_wine@---
--- chain failure
a1
a2
b1
- at todo_wine@---
c1
c2
d1
@@ -293,24 +285,19 @@ d2
d3
e1
e2
- at todo_wine@---
f1
f2
f3
g1
- at todo_wine@g3
- at todo_wine@---
+g3
h1
- at todo_wine@---
i1
- at todo_wine@i3
- at todo_wine@---
+i3
j1
j2
j3
k1
k2
- at todo_wine@---
l1
l2
l3
@@ -323,7 +310,6 @@ b2
b3
c1
c2
- at todo_wine@---
d1
d2
d3
@@ -332,52 +318,41 @@ e2
e3
f1
f2
- at todo_wine@---
g1
- at todo_wine@---
h1
- at todo_wine@---
i1
- at todo_wine@---
j1
j2
j3
k1
k2
- at todo_wine@---
l1
l2
l3
m1
- at todo_wine@---
n1
- at todo_wine@---
o1
- at todo_wine@---
p1
p2
p3
q1
q2
- at todo_wine@---
r1
r2
r3
--- chain pipe
- at todo_wine@a at space@
+a at space@
@todo_wine at a@space@
---
b2
c1
c3
d1
- at todo_wine@---
e1
e3
f2
f3
g2
- at todo_wine@---
h2
h3
i3
@@ -391,37 +366,26 @@ f4:[f3:[f2:[f1,f2],f3],f4]@or_broken at f4:[f3:[f2:,f3],f4]@or_broken at f4:[f3:,f4]
--- chain else
a1
b2
- at todo_wine@---
- at todo_wine@c3
- at todo_wine@---
- at todo_wine@d3
- at todo_wine@---
- at todo_wine@---
- at todo_wine@---
- at todo_wine@---
- at todo_wine@---
+c3
+d3
--- chain else (if true)
a1 else echo a2
b2 else echo b3
c1
c2 else echo c3
d1
- at todo_wine@---
e1
e2 else echo e3
f3
g1 else echo g2
g3
h1 else echo h2
- at todo_wine@---
i1 else echo i2
i3
@todo_wine at j2@space@
- at todo_wine@---
k1
k2
l1
- at todo_wine@---
m1
m2
n1
@@ -429,8 +393,7 @@ o1
p1
q1
--- chain else (if false)
- at todo_wine@j3
----
+j3
k3
l3
m3
@@ -438,7 +401,6 @@ n3
o2
o3
p2
- at todo_wine@---
q2
q3
------------ Testing 'set' ------------
@@ -600,13 +562,13 @@ bar2 at space@
foo2
foobar deleted
--- on success conditional and
- at todo_wine@foo3 not created
+foo3 not created
bar4 at space@
foo4
--- on failure conditional or
foo5
foo6 at space@
- at todo_wine@------------ Testing cd ------------
+------------ Testing cd ------------
singleFile
Current dir: @drive@@path at foobar@or_broken at Current dir:@space@
@drive@@path at foobar
diff --git a/programs/cmd/wcmd.h b/programs/cmd/wcmd.h
index c135621..63f425c 100644
--- a/programs/cmd/wcmd.h
+++ b/programs/cmd/wcmd.h
@@ -42,12 +42,34 @@ typedef enum _CMDdelimiters {
CMD_PIPE /* Single | */
} CMD_DELIMITERS;
+typedef enum _CMD_TYPE {
+ CMD_TYPE_NONE,
+ CMD_TYPE_STRING, /* Command string */
+ CMD_TYPE_CHAIN_EOL, /* Children are separated by '\n' (top) */
+ CMD_TYPE_CHAIN_ALWAYS, /* Children are separated by '&' */
+ CMD_TYPE_CHAIN_FAILURE, /* Children are separated by '||' */
+ CMD_TYPE_CHAIN_SUCCESS, /* Children are separated by '&&' */
+ CMD_TYPE_CHAIN_PIPE, /* Children are separated by '|' (bottom) */
+ CMD_TYPE_BRACKETS, /* Children are inside brackets */
+ CMD_TYPE_BRACKETS_AFTER, /* Pseudo-command to capture the redirect after ')' */
+ CMD_TYPE_IF, /* A child for 'IF' true and an optional child for 'IF' false */
+ CMD_TYPE_IF_TRUE, /* Children are executed when 'IF' tests true */
+ CMD_TYPE_IF_FALSE, /* Children are executed when 'IF' tests false */
+ CMD_TYPE_FOR, /* A child for 'IN' and a child 'DO' */
+ CMD_TYPE_FOR_IN, /* Command string is the 'FOR' IN' list without brackets */
+ CMD_TYPE_FOR_DO, /* Children are executed each 'FOR' loop */
+} CMD_TYPE;
+
+#define IS_CMD_CHAIN(x) ( (x)->type >= CMD_TYPE_CHAIN_EOL && (x)->type <= CMD_TYPE_CHAIN_PIPE )
+
/* Data structure to hold commands to be processed */
typedef struct _CMD_LIST {
+ CMD_TYPE type; /* Type of command */
WCHAR *command; /* Command string to execute */
WCHAR *redirects; /* Redirects in place */
- struct _CMD_LIST *nextcommand; /* Next command string to execute */
+ struct _CMD_LIST *nextcommand; /* Next command to execute */
+ struct _CMD_LIST *children; /* Child commands */
CMD_DELIMITERS prevDelim; /* Previous delimiter */
int bracketDepth;/* How deep bracketing have we got to */
WCHAR pipeFile[MAX_PATH]; /* Where to get input from for pipes */
@@ -55,7 +77,7 @@ typedef struct _CMD_LIST {
void WCMD_assoc (const WCHAR *, BOOL);
void WCMD_batch (WCHAR *, WCHAR *, BOOL, WCHAR *, HANDLE);
-void WCMD_call (WCHAR *command);
+BOOL WCMD_call (WCHAR *command);
void WCMD_change_tty (void);
void WCMD_choice (const WCHAR *);
void WCMD_clear_screen (void);
@@ -71,7 +93,7 @@ void WCMD_exit (CMD_LIST **cmdList);
void WCMD_for (WCHAR *, CMD_LIST **cmdList);
void WCMD_give_help (const WCHAR *args);
void WCMD_goto (CMD_LIST **cmdList);
-void WCMD_if (WCHAR *, CMD_LIST **cmdList);
+BOOL WCMD_if (WCHAR *, CMD_LIST **cmdList);
void WCMD_leave_paged_mode(void);
void WCMD_more (WCHAR *);
void WCMD_move (void);
@@ -97,7 +119,7 @@ void WCMD_setshow_time (void);
void WCMD_shift (const WCHAR *args);
void WCMD_start (const WCHAR *args);
void WCMD_title (const WCHAR *);
-void WCMD_type (WCHAR *);
+BOOL WCMD_type (WCHAR *);
void WCMD_verify (const WCHAR *args);
void WCMD_version (void);
int WCMD_volume (BOOL set_label, const WCHAR *args);
@@ -121,10 +143,13 @@ void WCMD_strsubstW(WCHAR *start, const WCHAR* next, const WCHAR* insert, int le
BOOL WCMD_ReadFile(const HANDLE hIn, WCHAR *intoBuf, const DWORD maxChars, LPDWORD charsRead);
WCHAR *WCMD_ReadAndParseLine(const WCHAR *initialcmd, CMD_LIST **output, HANDLE readFrom);
-CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL oneBracket, BOOL retrycall);
+BOOL WCMD_process_command(CMD_LIST **cmdList, BOOL called);
+CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL called);
void WCMD_free_commands(CMD_LIST *cmds);
-void WCMD_execute (const WCHAR *orig_command, const WCHAR *redirects,
+BOOL WCMD_execute (const WCHAR *orig_command, const WCHAR *redirects,
CMD_LIST **cmdList, BOOL retrycall);
+const char *WCMD_type_string(CMD_TYPE type);
+void WCMD_DumpCommands(CMD_LIST *commands, int level);
void *heap_alloc(size_t);
diff --git a/programs/cmd/wcmdmain.c b/programs/cmd/wcmdmain.c
index 1aa3c1c..e7ee742 100644
--- a/programs/cmd/wcmdmain.c
+++ b/programs/cmd/wcmdmain.c
@@ -1236,9 +1236,17 @@ void WCMD_run_program (WCHAR *command, BOOL called)
/* Parse the command string, without reading any more input */
WCMD_ReadAndParseLine(command, &toExecute, INVALID_HANDLE_VALUE);
- WCMD_process_commands(toExecute, FALSE, called);
- WCMD_free_commands(toExecute);
- toExecute = NULL;
+ if (toExecute) {
+ WCMD_process_commands(toExecute, called);
+ WCMD_free_commands(toExecute);
+ toExecute = NULL;
+ }
+ else {
+ /* FIXME This was added in order to support the 'call for' test.
+ It is likely that this code is setting errorlevel wrongly in untested situations.
+ To fix this we need to figure out where this should happen in the 'call for' test. */
+ errorlevel = 1;
+ }
return;
}
@@ -1259,11 +1267,12 @@ void WCMD_run_program (WCHAR *command, BOOL called)
* try to run it as an internal command. 'retrycall' represents whether
* we are attempting this retry.
*/
-void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
+BOOL WCMD_execute (const WCHAR *command, const WCHAR *redirects,
CMD_LIST **cmdList, BOOL retrycall)
{
WCHAR *cmd, *p, *redir;
- int status, i;
+ int i;
+ BOOL status;
DWORD count, creationDisposition;
HANDLE h;
WCHAR *whichcmd;
@@ -1277,6 +1286,8 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
STD_OUTPUT_HANDLE,
STD_ERROR_HANDLE};
BOOL prev_echo_mode, piped = FALSE;
+ CMD_LIST *origCmd;
+ CMD_LIST *childCmd;
WINE_TRACE("command on entry:%s (%p)\n",
wine_dbgstr_w(command), cmdList);
@@ -1349,7 +1360,7 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
if (!status) WCMD_print_error ();
heap_free(cmd );
heap_free(new_redir);
- return;
+ return status;
}
sa.nLength = sizeof(sa);
@@ -1370,7 +1381,7 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
WCMD_print_error ();
heap_free(cmd);
heap_free(new_redir);
- return;
+ return FALSE;
}
SetStdHandle (STD_INPUT_HANDLE, h);
@@ -1385,7 +1396,7 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
WCMD_print_error ();
heap_free(cmd);
heap_free(new_redir);
- return;
+ return FALSE;
}
SetStdHandle (STD_INPUT_HANDLE, h);
}
@@ -1431,7 +1442,7 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
WCMD_print_error ();
heap_free(cmd);
heap_free(new_redir);
- return;
+ return FALSE;
}
if (SetFilePointer (h, 0, NULL, FILE_END) ==
INVALID_SET_FILE_POINTER) {
@@ -1475,10 +1486,12 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
}
+ /* FIXME for each command that doesn't update status: test when it chains on success/failure and make it update status */
+ status = TRUE;
switch (i) {
case WCMD_CALL:
- WCMD_call (p);
+ status = WCMD_call (p);
break;
case WCMD_CD:
case WCMD_CHDIR:
@@ -1564,7 +1577,7 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
WCMD_title(&whichcmd[count+1]);
break;
case WCMD_TYPE:
- WCMD_type (p);
+ status = WCMD_type (p);
break;
case WCMD_VER:
WCMD_output_asis(newlineW);
@@ -1607,14 +1620,29 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
i.e. 'call if 1==1...' will fail. */
if (!retrycall) {
if (i==WCMD_FOR) WCMD_for (p, cmdList);
- else if (i==WCMD_IF) WCMD_if (p, cmdList);
+ else if (i==WCMD_IF) status = WCMD_if (p, cmdList);
break;
}
/* else: drop through */
default:
prev_echo_mode = echo_mode;
- WCMD_run_program (whichcmd, FALSE);
+ if (whichcmd[0] == '(') {
+ /* brackets */
+ origCmd = childCmd = (*cmdList)->children;
+ while (childCmd) {
+ status = WCMD_process_command(&childCmd, retrycall);
+ if (childCmd == origCmd) origCmd = childCmd = childCmd->nextcommand;
+ }
+ }
+ else if (whichcmd[0] == ':') {
+ /* label */
+ }
+ else {
+ /* external program */
+ WCMD_run_program (whichcmd, FALSE);
+ }
echo_mode = prev_echo_mode;
+ break;
}
heap_free(cmd);
heap_free(new_redir);
@@ -1626,6 +1654,8 @@ void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
SetStdHandle (idx_stdhandles[i], old_stdhandles[i]);
}
}
+
+ return status;
}
/*************************************************************************
@@ -1645,22 +1675,65 @@ WCHAR *WCMD_LoadMessage(UINT id) {
}
/***************************************************************************
+ * WCMD_type_string
+ *
+ * Returns a string representation of the command type.
+ *
+ * For unknown types it uses a global buffer that will be replaced on the next unknown type.
+ */
+const char * WCMD_type_string(CMD_TYPE type)
+{
+ static char unknownType[23]; /* 11 + 11(int) + 1('\0') */
+ switch (type) {
+ case CMD_TYPE_STRING: return "CMD_TYPE_STRING";
+ case CMD_TYPE_CHAIN_EOL: return "CMD_TYPE_CHAIN_EOL";
+ case CMD_TYPE_CHAIN_ALWAYS: return "CMD_TYPE_CHAIN_ALWAYS";
+ case CMD_TYPE_CHAIN_FAILURE: return "CMD_TYPE_CHAIN_FAILURE";
+ case CMD_TYPE_CHAIN_SUCCESS: return "CMD_TYPE_CHAIN_SUCCESS";
+ case CMD_TYPE_CHAIN_PIPE: return "CMD_TYPE_CHAIN_PIPE";
+ case CMD_TYPE_BRACKETS: return "CMD_TYPE_BRACKETS";
+ case CMD_TYPE_BRACKETS_AFTER: return "CMD_TYPE_BRACKETS_AFTER";
+ case CMD_TYPE_IF: return "CMD_TYPE_IF";
+ case CMD_TYPE_IF_TRUE: return "CMD_TYPE_IF_TRUE";
+ case CMD_TYPE_IF_FALSE: return "CMD_TYPE_IF_FALSE";
+ case CMD_TYPE_FOR: return "CMD_TYPE_FOR";
+ case CMD_TYPE_FOR_IN: return "CMD_TYPE_FOR_IN";
+ case CMD_TYPE_FOR_DO: return "CMD_TYPE_FOR_DO";
+ default:
+ sprintf(unknownType, "CMD_TYPE_(%d)", type);
+ return unknownType;
+ }
+}
+
+/***************************************************************************
* WCMD_DumpCommands
*
* Dumps out the parsed command line to ensure syntax is correct
*/
-static void WCMD_DumpCommands(CMD_LIST *commands) {
+void WCMD_DumpCommands(CMD_LIST *commands, int level) {
CMD_LIST *thisCmd = commands;
+ char indent[24];
+ const int maxlen = sizeof(indent)/sizeof(indent[0]);
+
+ if (level >= maxlen) {
+ WINE_FIXME("maximum indent reached\n");
+ level = maxlen - 1;
+ }
+ memset(indent, ' ', sizeof(indent));
+ indent[level] = 0;
- WINE_TRACE("Parsed line:\n");
while (thisCmd != NULL) {
- WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
+ WINE_TRACE("%p %s%s %d %2.2d %p %p %s Redir:%s\n",
thisCmd,
+ indent,
+ WCMD_type_string(thisCmd->type),
thisCmd->prevDelim,
thisCmd->bracketDepth,
thisCmd->nextcommand,
+ thisCmd->children,
wine_dbgstr_w(thisCmd->command),
wine_dbgstr_w(thisCmd->redirects));
+ WCMD_DumpCommands(thisCmd->children, level + 1);
thisCmd = thisCmd->nextcommand;
}
}
@@ -1670,7 +1743,8 @@ static void WCMD_DumpCommands(CMD_LIST *commands) {
*
* Adds a command to the current command list
*/
-static void WCMD_addCommand(WCHAR *command, int *commandLen,
+static void WCMD_addCommand(CMD_TYPE type,
+ WCHAR *command, int *commandLen,
WCHAR *redirs, int *redirLen,
WCHAR **copyTo, int **copyToLen,
CMD_DELIMITERS prevDelim, int curDepth,
@@ -1678,6 +1752,28 @@ static void WCMD_addCommand(WCHAR *command, int *commandLen,
CMD_LIST *thisEntry = NULL;
+ /* Dummy command to capture redirects after the bracket */
+ if (type == CMD_TYPE_BRACKETS_AFTER) {
+ /* Append redirects */
+ if (lastEntry && (*lastEntry)->type == CMD_TYPE_BRACKETS) {
+ thisEntry = *lastEntry;
+ if (redirLen && *redirLen > 0) {
+ const int len = strlenW(thisEntry->redirects);
+ WCHAR *redirects = heap_alloc((len+*redirLen+1) * sizeof(WCHAR));
+ memcpy(redirects, thisEntry->redirects, len * sizeof(WCHAR));
+ memcpy(redirects + len, redirs, *redirLen * sizeof(WCHAR));
+ redirects[len+*redirLen] = '\0';
+ heap_free(thisEntry->redirects);
+ thisEntry->redirects = redirects;
+ }
+ }
+ else {
+ WINE_FIXME("Missing '(' command, ignoring ')' command:\n");
+ WCMD_DumpCommands(*output, 0);
+ }
+ return;
+ }
+
/* Allocate storage for command */
thisEntry = heap_alloc(sizeof(CMD_LIST));
@@ -1706,7 +1802,9 @@ static void WCMD_addCommand(WCHAR *command, int *commandLen,
}
/* Fill in other fields */
+ thisEntry->type = type;
thisEntry->nextcommand = NULL;
+ thisEntry->children = NULL;
thisEntry->prevDelim = prevDelim;
thisEntry->bracketDepth = curDepth;
if (*lastEntry) {
@@ -1772,6 +1870,276 @@ static BOOL WCMD_IsEndQuote(const WCHAR *quote, int quoteIndex)
}
/***************************************************************************
+ * WCMD_chain_commands
+ *
+ * Restructures the command list into a tree by linking chains of "&", "||, "&&" and "|".
+ *
+ * It assumes that the children of the commands have already been chained.
+ *
+ * The current command list is considered an implicit EOL chain.
+ */
+static BOOL WCMD_chain_commands(CMD_LIST **cmdList)
+{
+ CMD_LIST **leftLocation;
+ CMD_LIST *leftCmd;
+ CMD_LIST *thisCmd;
+ CMD_LIST *rightCmd;
+ CMD_LIST **childLocation;
+
+ if (cmdList == NULL)
+ return FALSE; /* invalid argument */
+
+ leftLocation = cmdList;
+ leftCmd = *leftLocation;
+
+ if (leftCmd == NULL)
+ return TRUE; /* empty command list */
+
+ if (leftCmd && IS_CMD_CHAIN(leftCmd) && !leftCmd->children)
+ {
+ /* invalid leftCmd */
+ WINE_TRACE("unlinked command chain operators (%p) should not appear at the start:\n", leftCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return FALSE;
+ }
+
+ thisCmd = leftCmd->nextcommand;
+ while (thisCmd)
+ {
+ rightCmd = thisCmd->nextcommand;
+
+ /* unlinked chain operator */
+ if (IS_CMD_CHAIN(thisCmd) && !thisCmd->children)
+ {
+ /* no rightCmd */
+ if (rightCmd == NULL)
+ {
+ WINE_TRACE("unlinked command chain operators (%p) should not appear at the end:\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return FALSE;
+ }
+ /* consecutive unlinked chain operators */
+ else if (IS_CMD_CHAIN(rightCmd) && !rightCmd->children)
+ {
+ WINE_TRACE("unlinked command chain operators (%p) should have 1 command between them:\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return FALSE;
+ }
+
+ /* leftCmd is not a chain or thisCmd chain is on top of the leftCmd chain, make leftCmd and rightCmd children of thisCmd */
+ if (!IS_CMD_CHAIN(leftCmd) || thisCmd->type < leftCmd->type)
+ {
+ *leftLocation = thisCmd;
+ thisCmd->nextcommand = rightCmd->nextcommand;
+ thisCmd->children = leftCmd;
+ leftCmd->nextcommand = rightCmd;
+ rightCmd->nextcommand = NULL;
+ leftCmd = thisCmd;
+ thisCmd = leftCmd->nextcommand;
+ continue;
+ }
+ /* leftCmd is the same type of chain, make rightCmd a child of leftCmd and remove thisCmd */
+ else if (leftCmd->type == thisCmd->type)
+ {
+ leftCmd->nextcommand = rightCmd->nextcommand;
+ thisCmd->nextcommand = NULL;
+ WCMD_free_commands(thisCmd);
+ childLocation = &leftCmd->children;
+ while (*childLocation) {
+ childLocation = &(*childLocation)->nextcommand;
+ }
+ *childLocation = rightCmd;
+ rightCmd->nextcommand = NULL;
+ thisCmd = leftCmd->nextcommand;
+ continue;
+ }
+ /* leftCmd chain is on top of the thisCmd chain, chain thisCmd with the last child of leftCmd */
+ else
+ {
+ childLocation = &leftCmd->children;
+ if (*childLocation == NULL) {
+ WINE_TRACE("expected leftCmd %p to have children:\n", leftCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return FALSE;
+ }
+ leftCmd->nextcommand = rightCmd->nextcommand;
+ rightCmd->nextcommand = NULL;
+ while ((*childLocation)->nextcommand) {
+ childLocation = &(*childLocation)->nextcommand;
+ }
+ (*childLocation)->nextcommand = thisCmd;
+ if (!WCMD_chain_commands(childLocation)) {
+ WINE_TRACE("failed to chain children of %p (%p):\n", leftCmd, thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return FALSE;
+ }
+
+ thisCmd = leftCmd->nextcommand;
+ continue;
+ }
+ }
+ /* advance */
+ leftLocation = &leftCmd->nextcommand;
+ leftCmd = thisCmd;
+ thisCmd = rightCmd;
+ }
+
+ return TRUE;
+}
+
+/***************************************************************************
+ * WCMD_complete_until
+ *
+ * Continuously completes the last incomplete command until an incomplete
+ * stopType is found or all commands are complete.
+ *
+ * On error it sets error and returns the location of the command that
+ * was being completed.
+ *
+ * On success it either returns the location of the incomplete command with
+ * type stopType or NULL if all commands are complete.
+ */
+static CMD_LIST **WCMD_complete_until(CMD_TYPE stopType, CMD_LIST **cmdList, BOOL *error)
+{
+ CMD_LIST **location;
+ CMD_LIST **incompleteLocation;
+ CMD_LIST **childLocation;
+ CMD_LIST *thisCmd;
+ CMD_LIST *ifTrueCmd;
+ CMD_LIST *forInCmd;
+ CMD_LIST *forDoCmd;
+ CMD_TYPE pairType;
+
+ if (error) *error = TRUE; /* only one return path for success */
+
+ if (cmdList == NULL) {
+ return NULL;
+ }
+
+ while (TRUE) {
+ /* Get last incomplete command */
+ incompleteLocation = NULL;
+ for (location = cmdList; *location; location = &(*location)->nextcommand) {
+ /* Commands that must have children */
+ if ((*location)->children == NULL) {
+ switch ((*location)->type) {
+ case CMD_TYPE_BRACKETS:
+ case CMD_TYPE_IF:
+ case CMD_TYPE_IF_TRUE:
+ case CMD_TYPE_IF_FALSE:
+ case CMD_TYPE_FOR:
+ case CMD_TYPE_FOR_IN:
+ case CMD_TYPE_FOR_DO:
+ incompleteLocation = location;
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+
+ /* Stop if all are complete or if stopType is found */
+ if (incompleteLocation == NULL || (*incompleteLocation)->type == stopType) {
+ if (error) *error = FALSE; /* success */
+ return incompleteLocation;
+ }
+
+ /* Finish the incomplete command */
+ thisCmd = *incompleteLocation;
+
+ /* 'IF' expects an 'IF' true and optionally an 'IF' false */
+ if (thisCmd->type == CMD_TYPE_IF) {
+
+ ifTrueCmd = thisCmd->nextcommand;
+ if (ifTrueCmd == NULL || ifTrueCmd->type != CMD_TYPE_IF_TRUE) {
+ WINE_TRACE("Missing 'IF' true of %p:\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return incompleteLocation;
+ }
+
+ /* 'IF' true and 'IF' false */
+ if (ifTrueCmd->nextcommand != NULL && ifTrueCmd->nextcommand->type == CMD_TYPE_IF_FALSE) {
+ thisCmd->children = ifTrueCmd;
+ thisCmd->nextcommand = ifTrueCmd->nextcommand->nextcommand;
+ ifTrueCmd->nextcommand->nextcommand = NULL;
+ }
+ /* 'IF' true */
+ else {
+ thisCmd->children = ifTrueCmd;
+ thisCmd->nextcommand = ifTrueCmd->nextcommand;
+ ifTrueCmd->nextcommand = NULL;
+ }
+ }
+ /* 'FOR' expects a 'FOR' 'IN' and a 'FOR' 'DO' */
+ else if (thisCmd->type == CMD_TYPE_FOR) {
+
+ forInCmd = thisCmd->nextcommand;
+ if (forInCmd == NULL || forInCmd->type != CMD_TYPE_FOR_IN) {
+ WINE_TRACE("Missing 'FOR' 'IN' of %p:\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return incompleteLocation;
+ }
+
+ forDoCmd = forInCmd->nextcommand;
+ if (forDoCmd == NULL || forDoCmd->type != CMD_TYPE_FOR_DO) {
+ WINE_TRACE("Missing 'FOR' 'DO' of %p;\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return incompleteLocation;
+ }
+
+ thisCmd->children = forInCmd;
+ thisCmd->nextcommand = forDoCmd->nextcommand;
+ forDoCmd->nextcommand = NULL;
+ }
+ /* Convert next commands to children */
+ else if (thisCmd->type == CMD_TYPE_BRACKETS ||
+ thisCmd->type == CMD_TYPE_IF_TRUE ||
+ thisCmd->type == CMD_TYPE_IF_FALSE ||
+ thisCmd->type == CMD_TYPE_FOR_IN ||
+ thisCmd->type == CMD_TYPE_FOR_DO) {
+
+ thisCmd->children = thisCmd->nextcommand;
+ thisCmd->nextcommand = NULL;
+
+ /* 'IF' true pairs with the next 'IF' false */
+ /* 'FOR' 'IN' pairs with the next 'FOR' 'DO' */
+ pairType = ( thisCmd->type == CMD_TYPE_IF_TRUE ? CMD_TYPE_IF_FALSE
+ : thisCmd->type == CMD_TYPE_FOR_IN ? CMD_TYPE_FOR_DO
+ : CMD_TYPE_NONE );
+ if (pairType != CMD_TYPE_NONE) {
+ childLocation = &thisCmd->children;
+ for (childLocation = &thisCmd->children; *childLocation; childLocation = &(*childLocation)->nextcommand) {
+ if ((*childLocation)->type == pairType) {
+ thisCmd->nextcommand = *childLocation;
+ *childLocation = NULL;
+ break;
+ }
+ }
+ }
+
+ if (thisCmd->children == NULL) {
+ WINE_TRACE("Missing children of %p:\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return incompleteLocation;
+ }
+
+ if (!WCMD_chain_commands(&thisCmd->children)) {
+ WINE_TRACE("failed to chain children of %p:\n", thisCmd);
+ WCMD_DumpCommands(*cmdList, 0);
+ return incompleteLocation;
+ }
+ }
+ /* ERROR */
+ else {
+ WINE_FIXME("Don't know how to close incomplete %p of type %s:\n", thisCmd, WCMD_type_string(thisCmd->type));
+ WCMD_DumpCommands(*cmdList, 0);
+ return incompleteLocation;
+ }
+ }
+}
+
+/***************************************************************************
* WCMD_ReadAndParseLine
*
* Either uses supplied input or
@@ -1803,6 +2171,7 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
static const WCHAR forCmd[] = {'f','o','r'};
static const WCHAR ifCmd[] = {'i','f'};
static const WCHAR ifElse[] = {'e','l','s','e'};
+ static const WCHAR bracketPrefixChars[] = {'=',',','\t',' ','@','\0'};
BOOL inOneLine = FALSE;
BOOL inFor = FALSE;
BOOL inIn = FALSE;
@@ -1815,6 +2184,13 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
BOOL lastWasElse = FALSE;
BOOL lastWasRedirect = TRUE;
BOOL lastWasCaret = FALSE;
+ CMD_TYPE cmdType;
+ CMD_LIST **location;
+ int ifDepth;
+ int ifPending;
+ WCHAR *param;
+ WCHAR *startPos = NULL;
+ BOOL error = FALSE;
/* Allocate working space for a command read from keyboard, file etc */
if (!extraSpace)
@@ -1882,6 +2258,9 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
curCopyTo = curString;
curLen = &curStringLen;
lastWasRedirect = FALSE; /* Required e.g. for spaces between > and filename */
+ cmdType = CMD_TYPE_STRING;
+ ifDepth = 0;
+ ifPending = 0;
/* Parse every character on the line being processed */
while (*curPos != 0x00) {
@@ -1910,6 +2289,7 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
} else if (WCMD_keyword_ws_found(forCmd, sizeof(forCmd)/sizeof(forCmd[0]), curPos)) {
inFor = TRUE;
+ cmdType = CMD_TYPE_FOR; /* Incomplete 'FOR' command */
/* If command starts with 'if ' or 'else ', handle ('s mid line. We should ensure this
is only true in the command portion of the IF statement, but this
@@ -1918,16 +2298,115 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
echo they equal
)" will be parsed wrong */
} else if (WCMD_keyword_ws_found(ifCmd, sizeof(ifCmd)/sizeof(ifCmd[0]), curPos)) {
+ static const WCHAR helpOption[] = {'/','?','\0'};
+ static const WCHAR ignorecaseOption[] = {'/','I','\0'};
+ static const WCHAR notModifier[] = {'n','o','t','\0'};
+ static const WCHAR errorlevelTest[] = {'e','r','r','o','r','l','e','v','e','l','\0'};
+ static const WCHAR existTest[] = {'e','x','i','s','t','\0'};
+ static const WCHAR definedTest[] = {'d','e','f','i','n','e','d','\0'};
+
inIf = TRUE;
+ cmdType = CMD_TYPE_IF; /* Incomplete 'IF' command */
+
+ /* copy 'IF' */
+ param = WCMD_parameter(curPos, 0, &startPos, TRUE, FALSE);
+ if (startPos != NULL) {
+ strcpyW(&curCopyTo[*curLen], param);
+ *curLen += strlenW(param);
+ curPos = startPos + strlenW(param);
+ }
+
+ /* copy optional '/?' */
+ param = WCMD_parameter(curPos, 0, &startPos, TRUE, FALSE);
+ if (startPos != NULL && strcmpiW(param, helpOption) == 0) {
+ curCopyTo[(*curLen)++] = ' ';
+ strcpyW(&curCopyTo[*curLen], param);
+ *curLen += strlenW(param);
+ curPos = startPos + strlenW(param);
+ }
- } else if (WCMD_keyword_ws_found(ifElse, sizeof(ifElse)/sizeof(ifElse[0]), curPos)) {
+ /* copy optional '/I' */
+ param = WCMD_parameter(curPos, 0, &startPos, TRUE, FALSE);
+ if (startPos != NULL && strcmpiW(param, ignorecaseOption) == 0) {
+ curCopyTo[(*curLen)++] = ' ';
+ strcpyW(&curCopyTo[*curLen], param);
+ *curLen += strlenW(param);
+ curPos = startPos + strlenW(param);
+ }
+
+ /* copy optional 'NOT' */
+ param = WCMD_parameter(curPos, 0, &startPos, TRUE, FALSE);
+ if (startPos != NULL && strcmpiW(param, notModifier) == 0) {
+ curCopyTo[(*curLen)++] = ' ';
+ strcpyW(&curCopyTo[*curLen], param);
+ *curLen += strlenW(param);
+ curPos = startPos + strlenW(param);
+ }
+
+ /* 'IF' test */
+ param = WCMD_parameter(curPos, 0, &startPos, TRUE, FALSE);
+ if (startPos != NULL && (strcmpiW(param, errorlevelTest) == 0 || strcmpiW(param, existTest) == 0 || strcmpiW(param, definedTest) == 0)) {
+ /* 'ERRORLEVEL' number
+ 'EXIST' filename
+ 'DEFINED' variable
+ TODO 'CMDEXTVERSION' number */
+ curCopyTo[(*curLen)++] = ' ';
+ strcpyW(&curCopyTo[*curLen], param);
+ *curLen += strlenW(param);
+ curPos = startPos + strlenW(param);
+
+ /* at space before argument:
+ | |argument| |
+ |2| 1 |0| */
+ ifPending = 2;
+ }
+ else {
+ /* string '==' string
+ value 'LSS' value
+ value 'LEQ' value
+ value 'EQU' value
+ value 'NEQ' value
+ value 'GEQ' value
+ value 'GTR' value */
+
+ /* at space before left operand:
+ | |value| |comparator| |value| |
+ |6| 5 |4| 3 |2| 1 |0| */
+ ifPending = 6;
+ }
+
+ ifDepth++;
+
+ } else if (ifDepth > 0 && WCMD_keyword_ws_found(ifElse, sizeof(ifElse)/sizeof(ifElse[0]), curPos)) {
const int keyw_len = sizeof(ifElse)/sizeof(ifElse[0]) + 1;
- inElse = TRUE;
- lastWasElse = TRUE;
- onlyWhiteSpace = TRUE;
- memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
- (*curLen)+=keyw_len;
- curPos+=keyw_len;
+
+ /* Get last incomplete 'IF' and complete the commands that follow */
+ location = WCMD_complete_until(CMD_TYPE_IF, output, &error);
+ if (error) goto syntax_err;
+ lastEntry = *output;
+ while (lastEntry && lastEntry->nextcommand) {
+ lastEntry = lastEntry->nextcommand;
+ }
+
+ /* Add incomplete 'IF' false command */
+ if (location) {
+ WCMD_addCommand(CMD_TYPE_IF_FALSE,
+ NULL, NULL,
+ NULL, NULL,
+ NULL, NULL,
+ prevDelim, curDepth,
+ &lastEntry, output);
+
+ inElse = TRUE;
+ lastWasElse = TRUE;
+ onlyWhiteSpace = TRUE;
+ curPos+=keyw_len;
+ }
+ else {
+ WINE_FIXME("Missing incomplete 'IF' statement, discarding depth information (was %d).\n", ifDepth);
+ WCMD_DumpCommands(*output, 0);
+ ifDepth = 0;
+ }
continue;
/* In a for loop, the DO command will follow a close bracket followed by
@@ -1942,6 +2421,14 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
(*curLen)+=keyw_len;
curPos+=keyw_len;
+
+ WCMD_addCommand(CMD_TYPE_FOR_DO,
+ curString, &curStringLen,
+ curRedirs, &curRedirsLen,
+ &curCopyTo, &curLen,
+ prevDelim, curDepth,
+ &lastEntry, output);
+ cmdType = CMD_TYPE_STRING;
continue;
}
} else if (curCopyTo == curString) {
@@ -1957,9 +2444,26 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
WINE_TRACE("Found 'IN '\n");
lastWasIn = TRUE;
onlyWhiteSpace = TRUE;
+
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
+ curRedirs, &curRedirsLen,
+ &curCopyTo, &curLen,
+ prevDelim, curDepth,
+ &lastEntry, output);
+
memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
(*curLen)+=keyw_len;
curPos+=keyw_len;
+
+ WCMD_addCommand(CMD_TYPE_FOR_IN,
+ curString, &curStringLen,
+ curRedirs, &curRedirsLen,
+ &curCopyTo, &curLen,
+ prevDelim, curDepth,
+ &lastEntry, output);
+
+ cmdType = CMD_TYPE_STRING;
continue;
}
}
@@ -1977,7 +2481,19 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
switch (thisChar) {
- case '=': /* drop through - ignore token delimiters at the start of a command */
+ case '=': /* Special code for 'IF' comparator '=='
+ |value| |comparator| |value| |
+ | 5 |4| 3 |2| 1 |0| */
+ /* FIXME what to do with '=' and '===' */
+ if (inIf && (ifPending == 5 || ifPending == 4) && thisChar == '=' && *(curPos+1) == '=') {
+ /* copy '==' */
+ curCopyTo[(*curLen)++] = '=';
+ curCopyTo[(*curLen)++] = '=';
+ curPos+=2;
+ ifPending = 2; /* enter space after the comparator */
+ continue;
+ }
+ /* drop through - ignore token delimiters at the start of a command */
case ',': /* drop through - ignore token delimiters at the start of a command */
case '\t':/* drop through - ignore token delimiters at the start of a command */
case ' ':
@@ -2034,24 +2550,35 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
if (!inQuotes) {
lastWasRedirect = FALSE;
- /* Add an entry to the command list */
+ /* Add the current command if there is one */
if (curStringLen > 0) {
-
- /* Add the current command */
- WCMD_addCommand(curString, &curStringLen,
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
curRedirs, &curRedirsLen,
&curCopyTo, &curLen,
prevDelim, curDepth,
&lastEntry, output);
-
}
if (*(curPos+1) == '|') {
+ WCMD_addCommand(CMD_TYPE_CHAIN_FAILURE,
+ NULL, NULL,
+ NULL, NULL,
+ NULL, NULL,
+ prevDelim, curDepth,
+ &lastEntry, output);
curPos++; /* Skip other | */
prevDelim = CMD_ONFAILURE;
} else {
+ WCMD_addCommand(CMD_TYPE_CHAIN_PIPE,
+ NULL, NULL,
+ NULL, NULL,
+ NULL, NULL,
+ prevDelim, curDepth,
+ &lastEntry, output);
prevDelim = CMD_PIPE;
}
+ cmdType = CMD_TYPE_STRING;
} else {
curCopyTo[(*curLen)++] = *curPos;
}
@@ -2079,7 +2606,17 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
lastWasRedirect = FALSE;
/* Ignore open brackets inside the for set */
- if (*curLen == 0 && !inIn) {
+ curCopyTo[*curLen] = '\0';
+ if (!lastWasIn && *curLen == strspnW(curCopyTo, bracketPrefixChars)) {
+ /* Add incomplete '(' command */
+ curCopyTo[(*curLen)++] = *curPos;
+ WCMD_addCommand(CMD_TYPE_BRACKETS,
+ curString, &curStringLen,
+ curRedirs, &curRedirsLen,
+ &curCopyTo, &curLen,
+ prevDelim, curDepth,
+ &lastEntry, output);
+ cmdType = CMD_TYPE_STRING;
curDepth++;
/* If in quotes, ignore brackets */
@@ -2097,6 +2634,11 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
(inElse && lastWasElse && onlyWhiteSpace) ||
(inFor && (lastWasIn || lastWasDo) && onlyWhiteSpace)) {
+ if (inIf && ifPending > 0) {
+ WINE_TRACE("Incomplete 'IF', clearing argument counter (was %d),\n", ifPending);
+ ifPending = 0;
+ }
+
/* If entering into an 'IN', set inIn */
if (inFor && lastWasIn && onlyWhiteSpace) {
WINE_TRACE("Inside an IN\n");
@@ -2104,11 +2646,15 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
}
/* Add the current command */
- WCMD_addCommand(curString, &curStringLen,
- curRedirs, &curRedirsLen,
- &curCopyTo, &curLen,
- prevDelim, curDepth,
- &lastEntry, output);
+ if (curStringLen > 0) {
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
+ curRedirs, &curRedirsLen,
+ &curCopyTo, &curLen,
+ prevDelim, curDepth,
+ &lastEntry, output);
+ cmdType = CMD_TYPE_STRING;
+ }
curDepth++;
} else {
@@ -2131,24 +2677,35 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
case '&': if (!inQuotes) {
lastWasRedirect = FALSE;
- /* Add an entry to the command list */
+ /* Add the current command if there is one */
if (curStringLen > 0) {
-
- /* Add the current command */
- WCMD_addCommand(curString, &curStringLen,
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
curRedirs, &curRedirsLen,
&curCopyTo, &curLen,
prevDelim, curDepth,
&lastEntry, output);
-
}
if (*(curPos+1) == '&') {
+ WCMD_addCommand(CMD_TYPE_CHAIN_SUCCESS,
+ NULL, NULL,
+ NULL, NULL,
+ NULL, NULL,
+ prevDelim, curDepth,
+ &lastEntry, output);
curPos++; /* Skip other & */
prevDelim = CMD_ONSUCCESS;
} else {
+ WCMD_addCommand(CMD_TYPE_CHAIN_ALWAYS,
+ NULL, NULL,
+ NULL, NULL,
+ NULL, NULL,
+ prevDelim, curDepth,
+ &lastEntry, output);
prevDelim = CMD_NONE;
}
+ cmdType = CMD_TYPE_STRING;
} else {
curCopyTo[(*curLen)++] = *curPos;
}
@@ -2159,26 +2716,47 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
/* Add the current command if there is one */
if (curStringLen) {
-
- /* Add the current command */
- WCMD_addCommand(curString, &curStringLen,
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
curRedirs, &curRedirsLen,
&curCopyTo, &curLen,
prevDelim, curDepth,
&lastEntry, output);
+ cmdType = CMD_TYPE_STRING;
}
- /* Add an empty entry to the command list */
- prevDelim = CMD_NONE;
- WCMD_addCommand(NULL, &curStringLen,
- curRedirs, &curRedirsLen,
- &curCopyTo, &curLen,
- prevDelim, curDepth,
- &lastEntry, output);
- curDepth--;
+ if (inIn) {
+ inIn = FALSE;
+ }
+ else {
+ /* Get last incomplete '(' and complete the commands that follow */
+ location = WCMD_complete_until(CMD_TYPE_BRACKETS, output, &error);
+ if (error) goto syntax_err;
+ if (location) {
+ (*location)->children = (*location)->nextcommand;
+ (*location)->nextcommand = NULL;
+ WCMD_chain_commands(&(*location)->children);
+ }
+ else {
+ WINE_FIXME("Missing incomplete '(':\n");
+ WCMD_DumpCommands(*output, 0);
+ }
+ lastEntry = *output;
+ while (lastEntry && lastEntry->nextcommand) {
+ lastEntry = lastEntry->nextcommand;
+ }
+
+ /* Use dummy ')' command to capture redirects */
+ param = WCMD_parameter(curPos+1, 0, &startPos, TRUE, FALSE);
+ if (param[0] >= '1' && param[0] <= '9') param++;
+ if (startPos != NULL && (param[0] == '<' || param[0] == '>')) {
+ curCopyTo[(*curLen)++] = *curPos;
+ cmdType = CMD_TYPE_BRACKETS_AFTER;
+ }
+ }
- /* Leave inIn if necessary */
- if (inIn) inIn = FALSE;
+ curDepth--;
+ prevDelim = CMD_NONE;
} else {
curCopyTo[(*curLen)++] = *curPos;
}
@@ -2201,16 +2779,47 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
lastWasIn = lastWasDo = FALSE;
}
+ /* Transition 'IF' arguments
+ |argument| |argument| |argument| |
+ | 5 |4| 3 |2| 1 |0| */
+ if (inIf && ifPending > 0) {
+ if (!lastWasWhiteSpace && ifPending % 2 == 0) {
+ ifPending--;
+ }
+ else if (lastWasWhiteSpace && ifPending % 2 == 1) {
+ ifPending--;
+ if (ifPending == 0) {
+ /* Add incomplete 'IF' command */
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
+ curRedirs, &curRedirsLen,
+ &curCopyTo, &curLen,
+ prevDelim, curDepth,
+ &lastEntry, output);
+ /* Add incomplete 'IF' true command */
+ WCMD_addCommand(CMD_TYPE_IF_TRUE,
+ NULL, NULL,
+ NULL, NULL,
+ NULL, NULL,
+ prevDelim, curDepth,
+ &lastEntry, output);
+ cmdType = CMD_TYPE_STRING;
+ }
+ }
+ }
+
/* If we have reached the end, add this command into the list
Do not add command to list if escape char ^ was last */
if (*curPos == 0x00 && !lastWasCaret && *curLen > 0) {
/* Add an entry to the command list */
- WCMD_addCommand(curString, &curStringLen,
+ WCMD_addCommand(cmdType,
+ curString, &curStringLen,
curRedirs, &curRedirsLen,
&curCopyTo, &curLen,
prevDelim, curDepth,
&lastEntry, output);
+ cmdType = CMD_TYPE_STRING;
}
/* If we have reached the end of the string, see if bracketing or
@@ -2255,50 +2864,118 @@ WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE
}
}
+ /* Complete all commands */
+ WCMD_complete_until(CMD_TYPE_NONE, output, &error);
+ if (error) goto syntax_err;
+ WCMD_chain_commands(output);
+
/* Dump out the parsed output */
- WCMD_DumpCommands(*output);
+ WCMD_DumpCommands(*output, 0);
return extraSpace;
+
+syntax_err:
+ WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR));
+ WCMD_free_commands(*output);
+ *output = NULL;
+ return NULL;
}
/***************************************************************************
- * WCMD_process_commands
+ * WCMD_process_command
*
- * Process all the commands read in so far
+ * Processes a single command and it's children.
*/
-CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL oneBracket,
- BOOL retrycall) {
-
- int bdepth = -1;
-
- if (thisCmd && oneBracket) bdepth = thisCmd->bracketDepth;
+BOOL WCMD_process_command(CMD_LIST **cmdList, BOOL called)
+{
+ CMD_LIST *thisCmd;
+ CMD_LIST *childCmd;
+ CMD_LIST *origCmd;
+ BOOL status;
- /* Loop through the commands, processing them one by one */
- while (thisCmd) {
+ if (cmdList == NULL || *cmdList == NULL) {
+ return FALSE; /* FIXME or TRUE? */
+ }
- CMD_LIST *origCmd = thisCmd;
+ status = TRUE;
+ thisCmd = *cmdList;
+ switch (thisCmd->type)
+ {
+ case CMD_TYPE_CHAIN_PIPE: {
+ /* FIXME this is a quick fix to keep pipes based on prevDelim working */
+ childCmd = thisCmd->children;
+ while (childCmd && childCmd->nextcommand) {
+ childCmd = childCmd->nextcommand;
+ childCmd->prevDelim = CMD_PIPE;
+ }
+ /* FALL THROUGH */
+ }
+ case CMD_TYPE_IF_TRUE: /* FALL THROUGH */
+ case CMD_TYPE_IF_FALSE: /* FALL THROUGH */
+ case CMD_TYPE_CHAIN_ALWAYS: /* FALL THROUGH */
+ case CMD_TYPE_CHAIN_EOL: {
+ childCmd = origCmd = thisCmd->children;
+ while (childCmd) {
+ status = WCMD_process_command(&childCmd, called);
+ if (childCmd == origCmd) childCmd = origCmd = childCmd->nextcommand;
+ }
+ break;
+ }
- /* If processing one bracket only, and we find the end bracket
- entry (or less), return */
- if (oneBracket && !thisCmd->command &&
- bdepth <= thisCmd->bracketDepth) {
- WINE_TRACE("Finished bracket @ %p, next command is %p\n",
- thisCmd, thisCmd->nextcommand);
- return thisCmd->nextcommand;
+ case CMD_TYPE_CHAIN_FAILURE: {
+ childCmd = origCmd = thisCmd->children;
+ while (childCmd) {
+ status = WCMD_process_command(&childCmd, called);
+ if (childCmd == origCmd) childCmd = origCmd = childCmd->nextcommand;
+ /* Stop on success */
+ if (status) break;
}
+ break;
+ }
- /* Ignore the NULL entries a ')' inserts (Only 'if' cares
- about them and it will be handled in there)
- Also, skip over any batch labels (eg. :fred) */
- if (thisCmd->command && thisCmd->command[0] != ':') {
- WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd->command));
- WCMD_execute (thisCmd->command, thisCmd->redirects, &thisCmd, retrycall);
+ case CMD_TYPE_CHAIN_SUCCESS: {
+ childCmd = origCmd = thisCmd->children;
+ while (childCmd) {
+ status = WCMD_process_command(&childCmd, called);
+ if (childCmd == origCmd) childCmd = origCmd = childCmd->nextcommand;
+ /* Stop on failure */
+ if (!status) break;
}
+ break;
+ }
- /* Step on unless the command itself already stepped on */
- if (thisCmd == origCmd) thisCmd = thisCmd->nextcommand;
+ case CMD_TYPE_STRING: /* FALL THROUGH */
+ case CMD_TYPE_BRACKETS: /* FALL THROUGH */
+ case CMD_TYPE_IF: /* FALL THROUGH */
+ case CMD_TYPE_FOR: {
+ status = WCMD_execute(thisCmd->command, thisCmd->redirects, cmdList, called);
+ break;
}
- return NULL;
+
+ default:
+ WINE_FIXME("Don't know how to execute command type %s (%d)\n", WCMD_type_string(thisCmd->type), thisCmd->type);
+ status = FALSE;
+ break;
+ }
+ return status;
+}
+
+/***************************************************************************
+ * WCMD_process_commands
+ *
+ * Process all the commands read in so far
+ */
+CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL called)
+{
+ CMD_LIST *origCmd;
+
+ /* Loop through the commands, processing them one by one */
+ while (thisCmd) {
+ origCmd = thisCmd;
+ WCMD_process_command(&thisCmd, called);
+ if (thisCmd == origCmd) thisCmd = thisCmd->nextcommand;
+ }
+ return NULL;
}
/***************************************************************************
@@ -2315,6 +2992,7 @@ void WCMD_free_commands(CMD_LIST *cmds) {
while (cmds) {
CMD_LIST *thisCmd = cmds;
cmds = cmds->nextcommand;
+ WCMD_free_commands(thisCmd->children);
heap_free(thisCmd->command);
heap_free(thisCmd->redirects);
heap_free(thisCmd);
@@ -2588,7 +3266,7 @@ int wmain (int argc, WCHAR *argvW[])
/* Parse the command string, without reading any more input */
WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
- WCMD_process_commands(toExecute, FALSE, FALSE);
+ WCMD_process_commands(toExecute, FALSE);
WCMD_free_commands(toExecute);
toExecute = NULL;
@@ -2673,7 +3351,7 @@ int wmain (int argc, WCHAR *argvW[])
if (opt_k) {
/* Parse the command string, without reading any more input */
WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
- WCMD_process_commands(toExecute, FALSE, FALSE);
+ WCMD_process_commands(toExecute, FALSE);
WCMD_free_commands(toExecute);
toExecute = NULL;
heap_free(cmd);
@@ -2692,7 +3370,7 @@ int wmain (int argc, WCHAR *argvW[])
if (echo_mode) WCMD_show_prompt();
if (!WCMD_ReadAndParseLine(NULL, &toExecute, GetStdHandle(STD_INPUT_HANDLE)))
break;
- WCMD_process_commands(toExecute, FALSE, FALSE);
+ WCMD_process_commands(toExecute, FALSE);
WCMD_free_commands(toExecute);
toExecute = NULL;
}
--
2.7.4
More information about the wine-patches
mailing list