2 * CMD - Wine-compatible command line interface.
4 * Copyright (C) 1999 - 2001 D A Pickles
5 * Copyright (C) 2007 J Edmeades
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 * - Cannot handle parameters in quotes
25 * - Lots of functionality missing from builtins
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(cmd
);
36 extern const WCHAR inbuilt
[][10];
37 extern struct env_stack
*pushd_directories
;
39 BATCH_CONTEXT
*context
= NULL
;
41 WCHAR quals
[MAX_PATH
], param1
[MAXSTRING
], param2
[MAXSTRING
];
43 FOR_CONTEXT forloopcontext
; /* The 'for' loop context */
44 BOOL delayedsubst
= FALSE
; /* The current delayed substitution setting */
47 BOOL echo_mode
= TRUE
;
49 WCHAR anykey
[100], version_string
[100];
50 const WCHAR newlineW
[] = {'\r','\n','\0'};
51 const WCHAR spaceW
[] = {' ','\0'};
52 static const WCHAR envPathExt
[] = {'P','A','T','H','E','X','T','\0'};
53 static const WCHAR dfltPathExt
[] = {'.','b','a','t',';',
56 '.','e','x','e','\0'};
58 static BOOL opt_c
, opt_k
, opt_s
, unicodeOutput
= FALSE
;
60 /* Variables pertaining to paging */
61 static BOOL paged_mode
;
62 static const WCHAR
*pagedMessage
= NULL
;
63 static int line_count
;
64 static int max_height
;
68 #define MAX_WRITECONSOLE_SIZE 65535
71 * Returns a buffer for reading from/writing to file
74 static char *get_file_buffer(void)
76 static char *output_bufA
= NULL
;
78 output_bufA
= heap_alloc(MAX_WRITECONSOLE_SIZE
);
82 /*******************************************************************
83 * WCMD_output_asis_len - send output to current standard output
85 * Output a formatted unicode string. Ideally this will go to the console
86 * and hence required WriteConsoleW to output it, however if file i/o is
87 * redirected, it needs to be WriteFile'd using OEM (not ANSI) format
89 static void WCMD_output_asis_len(const WCHAR
*message
, DWORD len
, HANDLE device
)
94 /* If nothing to write, return (MORE does this sometimes) */
97 /* Try to write as unicode assuming it is to a console */
98 res
= WriteConsoleW(device
, message
, len
, &nOut
, NULL
);
100 /* If writing to console fails, assume its file
101 i/o so convert to OEM codepage and output */
103 BOOL usedDefaultChar
= FALSE
;
104 DWORD convertedChars
;
107 if (!unicodeOutput
) {
109 if (!(buffer
= get_file_buffer()))
112 /* Convert to OEM, then output */
113 convertedChars
= WideCharToMultiByte(GetConsoleOutputCP(), 0, message
,
114 len
, buffer
, MAX_WRITECONSOLE_SIZE
,
115 "?", &usedDefaultChar
);
116 WriteFile(device
, buffer
, convertedChars
,
119 WriteFile(device
, message
, len
*sizeof(WCHAR
),
126 /*******************************************************************
127 * WCMD_output - send output to current standard output device.
131 void CDECL
WCMD_output (const WCHAR
*format
, ...) {
137 __ms_va_start(ap
,format
);
138 SetLastError(NO_ERROR
);
140 len
= FormatMessageW(FORMAT_MESSAGE_FROM_STRING
|FORMAT_MESSAGE_ALLOCATE_BUFFER
,
141 format
, 0, 0, (LPWSTR
)&string
, 0, &ap
);
143 if (len
== 0 && GetLastError() != NO_ERROR
)
144 WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format
));
147 WCMD_output_asis_len(string
, len
, GetStdHandle(STD_OUTPUT_HANDLE
));
152 /*******************************************************************
153 * WCMD_output_stderr - send output to current standard error device.
157 void CDECL
WCMD_output_stderr (const WCHAR
*format
, ...) {
163 __ms_va_start(ap
,format
);
164 SetLastError(NO_ERROR
);
166 len
= FormatMessageW(FORMAT_MESSAGE_FROM_STRING
|FORMAT_MESSAGE_ALLOCATE_BUFFER
,
167 format
, 0, 0, (LPWSTR
)&string
, 0, &ap
);
169 if (len
== 0 && GetLastError() != NO_ERROR
)
170 WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format
));
173 WCMD_output_asis_len(string
, len
, GetStdHandle(STD_ERROR_HANDLE
));
178 /*******************************************************************
179 * WCMD_format_string - allocate a buffer and format a string
183 WCHAR
* CDECL
WCMD_format_string (const WCHAR
*format
, ...) {
189 __ms_va_start(ap
,format
);
190 SetLastError(NO_ERROR
);
191 len
= FormatMessageW(FORMAT_MESSAGE_FROM_STRING
|FORMAT_MESSAGE_ALLOCATE_BUFFER
,
192 format
, 0, 0, (LPWSTR
)&string
, 0, &ap
);
194 if (len
== 0 && GetLastError() != NO_ERROR
) {
195 WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format
));
196 string
= (WCHAR
*)LocalAlloc(LMEM_FIXED
, 2);
202 void WCMD_enter_paged_mode(const WCHAR
*msg
)
204 CONSOLE_SCREEN_BUFFER_INFO consoleInfo
;
206 if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE
), &consoleInfo
)) {
207 max_height
= consoleInfo
.dwSize
.Y
;
208 max_width
= consoleInfo
.dwSize
.X
;
216 pagedMessage
= (msg
==NULL
)? anykey
: msg
;
219 void WCMD_leave_paged_mode(void)
225 /***************************************************************************
228 * Read characters in from a console/file, returning result in Unicode
230 BOOL
WCMD_ReadFile(const HANDLE hIn
, WCHAR
*intoBuf
, const DWORD maxChars
, LPDWORD charsRead
)
235 if (WCMD_is_console_handle(hIn
))
236 /* Try to read from console as Unicode */
237 return ReadConsoleW(hIn
, intoBuf
, maxChars
, charsRead
, NULL
);
239 /* We assume it's a file handle and read then convert from assumed OEM codepage */
240 if (!(buffer
= get_file_buffer()))
243 if (!ReadFile(hIn
, buffer
, maxChars
, &numRead
, NULL
))
246 *charsRead
= MultiByteToWideChar(GetConsoleCP(), 0, buffer
, numRead
, intoBuf
, maxChars
);
251 /*******************************************************************
252 * WCMD_output_asis_handle
254 * Send output to specified handle without formatting e.g. when message contains '%'
256 static void WCMD_output_asis_handle (DWORD std_handle
, const WCHAR
*message
) {
260 HANDLE handle
= GetStdHandle(std_handle
);
265 while (*ptr
&& *ptr
!='\n' && (numChars
< max_width
)) {
269 if (*ptr
== '\n') ptr
++;
270 WCMD_output_asis_len(message
, ptr
- message
, handle
);
272 if (++line_count
>= max_height
- 1) {
274 WCMD_output_asis_len(pagedMessage
, strlenW(pagedMessage
), handle
);
275 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), string
, sizeof(string
)/sizeof(WCHAR
), &count
);
277 } while (((message
= ptr
) != NULL
) && (*ptr
));
279 WCMD_output_asis_len(message
, lstrlenW(message
), handle
);
283 /*******************************************************************
286 * Send output to current standard output device, without formatting
287 * e.g. when message contains '%'
289 void WCMD_output_asis (const WCHAR
*message
) {
290 WCMD_output_asis_handle(STD_OUTPUT_HANDLE
, message
);
293 /*******************************************************************
294 * WCMD_output_asis_stderr
296 * Send output to current standard error device, without formatting
297 * e.g. when message contains '%'
299 void WCMD_output_asis_stderr (const WCHAR
*message
) {
300 WCMD_output_asis_handle(STD_ERROR_HANDLE
, message
);
303 /****************************************************************************
306 * Print the message for GetLastError
309 void WCMD_print_error (void) {
314 error_code
= GetLastError ();
315 status
= FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
316 NULL
, error_code
, 0, (LPWSTR
) &lpMsgBuf
, 0, NULL
);
318 WINE_FIXME ("Cannot display message for error %d, status %d\n",
319 error_code
, GetLastError());
323 WCMD_output_asis_len(lpMsgBuf
, lstrlenW(lpMsgBuf
),
324 GetStdHandle(STD_ERROR_HANDLE
));
325 LocalFree (lpMsgBuf
);
326 WCMD_output_asis_len (newlineW
, lstrlenW(newlineW
),
327 GetStdHandle(STD_ERROR_HANDLE
));
331 /******************************************************************************
334 * Display the prompt on STDout
338 static void WCMD_show_prompt (void) {
341 WCHAR out_string
[MAX_PATH
], curdir
[MAX_PATH
], prompt_string
[MAX_PATH
];
344 static const WCHAR envPrompt
[] = {'P','R','O','M','P','T','\0'};
346 len
= GetEnvironmentVariableW(envPrompt
, prompt_string
,
347 sizeof(prompt_string
)/sizeof(WCHAR
));
348 if ((len
== 0) || (len
>= (sizeof(prompt_string
)/sizeof(WCHAR
)))) {
349 static const WCHAR dfltPrompt
[] = {'$','P','$','G','\0'};
350 strcpyW (prompt_string
, dfltPrompt
);
364 switch (toupper(*p
)) {
378 GetDateFormatW(LOCALE_USER_DEFAULT
, DATE_SHORTDATE
, NULL
, NULL
, q
, MAX_PATH
);
397 status
= GetCurrentDirectoryW(sizeof(curdir
)/sizeof(WCHAR
), curdir
);
403 status
= GetCurrentDirectoryW(sizeof(curdir
)/sizeof(WCHAR
), curdir
);
416 GetTimeFormatW(LOCALE_USER_DEFAULT
, 0, NULL
, NULL
, q
, MAX_PATH
);
420 strcatW (q
, version_string
);
427 if (pushd_directories
) {
428 memset(q
, '+', pushd_directories
->u
.stackdepth
);
429 q
= q
+ pushd_directories
->u
.stackdepth
;
437 WCMD_output_asis (out_string
);
440 void *heap_alloc(size_t size
)
444 ret
= HeapAlloc(GetProcessHeap(), 0, size
);
446 ERR("Out of memory\n");
453 /*************************************************************************
455 * Replaces a portion of a Unicode string with the specified string.
456 * It's up to the caller to ensure there is enough space in the
457 * destination buffer.
459 void WCMD_strsubstW(WCHAR
*start
, const WCHAR
*next
, const WCHAR
*insert
, int len
) {
462 len
=insert
? lstrlenW(insert
) : 0;
463 if (start
+len
!= next
)
464 memmove(start
+len
, next
, (strlenW(next
) + 1) * sizeof(*next
));
466 memcpy(start
, insert
, len
* sizeof(*insert
));
469 /***************************************************************************
470 * WCMD_skip_leading_spaces
472 * Return a pointer to the first non-whitespace character of string.
473 * Does not modify the input string.
475 WCHAR
*WCMD_skip_leading_spaces (WCHAR
*string
) {
480 while (*ptr
== ' ' || *ptr
== '\t') ptr
++;
484 /***************************************************************************
485 * WCMD_keyword_ws_found
487 * Checks if the string located at ptr matches a keyword (of length len)
488 * followed by a whitespace character (space or tab)
490 BOOL
WCMD_keyword_ws_found(const WCHAR
*keyword
, int len
, const WCHAR
*ptr
) {
491 return (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
492 ptr
, len
, keyword
, len
) == CSTR_EQUAL
)
493 && ((*(ptr
+ len
) == ' ') || (*(ptr
+ len
) == '\t'));
496 /*************************************************************************
499 * Remove first and last quote WCHARacters, preserving all other text
501 void WCMD_strip_quotes(WCHAR
*cmd
) {
502 WCHAR
*src
= cmd
+ 1, *dest
= cmd
, *lastq
= NULL
;
503 while((*dest
=*src
) != '\0') {
510 while ((*dest
++=*lastq
++) != 0)
516 /*************************************************************************
517 * WCMD_is_magic_envvar
518 * Return TRUE if s is '%'magicvar'%'
519 * and is not masked by a real environment variable.
522 static inline BOOL
WCMD_is_magic_envvar(const WCHAR
*s
, const WCHAR
*magicvar
)
527 return FALSE
; /* Didn't begin with % */
529 if (len
< 2 || s
[len
-1] != '%')
530 return FALSE
; /* Didn't end with another % */
532 if (CompareStringW(LOCALE_USER_DEFAULT
,
533 NORM_IGNORECASE
| SORT_STRINGSORT
,
534 s
+1, len
-2, magicvar
, -1) != CSTR_EQUAL
) {
535 /* Name doesn't match. */
539 if (GetEnvironmentVariableW(magicvar
, NULL
, 0) > 0) {
540 /* Masked by real environment variable. */
547 /*************************************************************************
550 * Expands environment variables, allowing for WCHARacter substitution
552 static WCHAR
*WCMD_expand_envvar(WCHAR
*start
, WCHAR startchar
)
554 WCHAR
*endOfVar
= NULL
, *s
;
555 WCHAR
*colonpos
= NULL
;
556 WCHAR thisVar
[MAXSTRING
];
557 WCHAR thisVarContents
[MAXSTRING
];
558 WCHAR savedchar
= 0x00;
561 static const WCHAR ErrorLvl
[] = {'E','R','R','O','R','L','E','V','E','L','\0'};
562 static const WCHAR Date
[] = {'D','A','T','E','\0'};
563 static const WCHAR Time
[] = {'T','I','M','E','\0'};
564 static const WCHAR Cd
[] = {'C','D','\0'};
565 static const WCHAR Random
[] = {'R','A','N','D','O','M','\0'};
566 WCHAR Delims
[] = {'%',':','\0'}; /* First char gets replaced appropriately */
568 WINE_TRACE("Expanding: %s (%c)\n", wine_dbgstr_w(start
), startchar
);
570 /* Find the end of the environment variable, and extract name */
571 Delims
[0] = startchar
;
572 endOfVar
= strpbrkW(start
+1, Delims
);
574 if (endOfVar
== NULL
|| *endOfVar
==' ') {
576 /* In batch program, missing terminator for % and no following
577 ':' just removes the '%' */
579 WCMD_strsubstW(start
, start
+ 1, NULL
, 0);
583 /* In command processing, just ignore it - allows command line
584 syntax like: for %i in (a.a) do echo %i */
589 /* If ':' found, process remaining up until '%' (or stop at ':' if
591 if (*endOfVar
==':') {
592 WCHAR
*endOfVar2
= strchrW(endOfVar
+1, startchar
);
593 if (endOfVar2
!= NULL
) endOfVar
= endOfVar2
;
596 memcpy(thisVar
, start
, ((endOfVar
- start
) + 1) * sizeof(WCHAR
));
597 thisVar
[(endOfVar
- start
)+1] = 0x00;
598 colonpos
= strchrW(thisVar
+1, ':');
600 /* If there's complex substitution, just need %var% for now
601 to get the expanded data to play with */
603 *colonpos
= startchar
;
604 savedchar
= *(colonpos
+1);
605 *(colonpos
+1) = 0x00;
608 /* By now, we know the variable we want to expand but it may be
609 surrounded by '!' if we are in delayed expansion - if so convert
611 if (startchar
=='!') {
613 thisVar
[(endOfVar
- start
)] = '%';
615 WINE_TRACE("Retrieving contents of %s\n", wine_dbgstr_w(thisVar
));
617 /* Expand to contents, if unchanged, return */
618 /* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
619 /* override if existing env var called that name */
620 if (WCMD_is_magic_envvar(thisVar
, ErrorLvl
)) {
621 static const WCHAR fmt
[] = {'%','d','\0'};
622 wsprintfW(thisVarContents
, fmt
, errorlevel
);
623 len
= strlenW(thisVarContents
);
624 } else if (WCMD_is_magic_envvar(thisVar
, Date
)) {
625 GetDateFormatW(LOCALE_USER_DEFAULT
, DATE_SHORTDATE
, NULL
,
626 NULL
, thisVarContents
, MAXSTRING
);
627 len
= strlenW(thisVarContents
);
628 } else if (WCMD_is_magic_envvar(thisVar
, Time
)) {
629 GetTimeFormatW(LOCALE_USER_DEFAULT
, TIME_NOSECONDS
, NULL
,
630 NULL
, thisVarContents
, MAXSTRING
);
631 len
= strlenW(thisVarContents
);
632 } else if (WCMD_is_magic_envvar(thisVar
, Cd
)) {
633 GetCurrentDirectoryW(MAXSTRING
, thisVarContents
);
634 len
= strlenW(thisVarContents
);
635 } else if (WCMD_is_magic_envvar(thisVar
, Random
)) {
636 static const WCHAR fmt
[] = {'%','d','\0'};
637 wsprintfW(thisVarContents
, fmt
, rand() % 32768);
638 len
= strlenW(thisVarContents
);
641 len
= ExpandEnvironmentStringsW(thisVar
, thisVarContents
,
642 sizeof(thisVarContents
)/sizeof(WCHAR
));
648 /* In a batch program, unknown env vars are replaced with nothing,
649 note syntax %garbage:1,3% results in anything after the ':'
651 From the command line, you just get back what you entered */
652 if (lstrcmpiW(thisVar
, thisVarContents
) == 0) {
654 /* Restore the complex part after the compare */
657 *(colonpos
+1) = savedchar
;
660 /* Command line - just ignore this */
661 if (context
== NULL
) return endOfVar
+1;
664 /* Batch - replace unknown env var with nothing */
665 if (colonpos
== NULL
) {
666 WCMD_strsubstW(start
, endOfVar
+ 1, NULL
, 0);
668 len
= strlenW(thisVar
);
669 thisVar
[len
-1] = 0x00;
670 /* If %:...% supplied, : is retained */
671 if (colonpos
== thisVar
+1) {
672 WCMD_strsubstW(start
, endOfVar
+ 1, colonpos
, -1);
674 WCMD_strsubstW(start
, endOfVar
+ 1, colonpos
+ 1, -1);
681 /* See if we need to do complex substitution (any ':'s), if not
682 then our work here is done */
683 if (colonpos
== NULL
) {
684 WCMD_strsubstW(start
, endOfVar
+ 1, thisVarContents
, -1);
688 /* Restore complex bit */
690 *(colonpos
+1) = savedchar
;
693 Handle complex substitutions:
694 xxx=yyy (replace xxx with yyy)
695 *xxx=yyy (replace up to and including xxx with yyy)
696 ~x (from x WCHARs in)
697 ~-x (from x WCHARs from the end)
698 ~x,y (from x WCHARs in for y WCHARacters)
699 ~x,-y (from x WCHARs in until y WCHARacters from the end)
702 /* ~ is substring manipulation */
703 if (savedchar
== '~') {
705 int substrposition
, substrlength
= 0;
706 WCHAR
*commapos
= strchrW(colonpos
+2, ',');
709 substrposition
= atolW(colonpos
+2);
710 if (commapos
) substrlength
= atolW(commapos
+1);
713 if (substrposition
>= 0) {
714 startCopy
= &thisVarContents
[min(substrposition
, len
)];
716 startCopy
= &thisVarContents
[max(0, len
+substrposition
-1)];
719 if (commapos
== NULL
) {
721 WCMD_strsubstW(start
, endOfVar
+ 1, startCopy
, -1);
722 } else if (substrlength
< 0) {
724 int copybytes
= (len
+substrlength
-1)-(startCopy
-thisVarContents
);
725 if (copybytes
> len
) copybytes
= len
;
726 else if (copybytes
< 0) copybytes
= 0;
727 WCMD_strsubstW(start
, endOfVar
+ 1, startCopy
, copybytes
);
729 substrlength
= min(substrlength
, len
- (startCopy
- thisVarContents
+ 1));
730 WCMD_strsubstW(start
, endOfVar
+ 1, startCopy
, substrlength
);
733 /* search and replace manipulation */
735 WCHAR
*equalspos
= strstrW(colonpos
, equalW
);
736 WCHAR
*replacewith
= equalspos
+1;
741 if (equalspos
== NULL
) return start
+1;
742 s
= heap_strdupW(endOfVar
+ 1);
744 /* Null terminate both strings */
745 thisVar
[strlenW(thisVar
)-1] = 0x00;
748 /* Since we need to be case insensitive, copy the 2 buffers */
749 searchIn
= heap_strdupW(thisVarContents
);
750 CharUpperBuffW(searchIn
, strlenW(thisVarContents
));
751 searchFor
= heap_strdupW(colonpos
+1);
752 CharUpperBuffW(searchFor
, strlenW(colonpos
+1));
754 /* Handle wildcard case */
755 if (*(colonpos
+1) == '*') {
756 /* Search for string to replace */
757 found
= strstrW(searchIn
, searchFor
+1);
761 strcpyW(start
, replacewith
);
762 strcatW(start
, thisVarContents
+ (found
-searchIn
) + strlenW(searchFor
+1));
766 strcpyW(start
, thisVarContents
);
771 /* Loop replacing all instances */
772 WCHAR
*lastFound
= searchIn
;
773 WCHAR
*outputposn
= start
;
776 while ((found
= strstrW(lastFound
, searchFor
))) {
777 lstrcpynW(outputposn
,
778 thisVarContents
+ (lastFound
-searchIn
),
779 (found
- lastFound
)+1);
780 outputposn
= outputposn
+ (found
- lastFound
);
781 strcatW(outputposn
, replacewith
);
782 outputposn
= outputposn
+ strlenW(replacewith
);
783 lastFound
= found
+ strlenW(searchFor
);
786 thisVarContents
+ (lastFound
-searchIn
));
787 strcatW(outputposn
, s
);
791 heap_free(searchFor
);
796 /*****************************************************************************
797 * Expand the command. Native expands lines from batch programs as they are
798 * read in and not again, except for 'for' variable substitution.
799 * eg. As evidence, "echo %1 && shift && echo %1" or "echo %%path%%"
800 * atExecute is TRUE when the expansion is occurring as the command is executed
801 * rather than at parse time, i.e. delayed expansion and for loops need to be
804 static void handleExpansion(WCHAR
*cmd
, BOOL atExecute
, BOOL delayed
) {
806 /* For commands in a context (batch program): */
807 /* Expand environment variables in a batch file %{0-9} first */
808 /* including support for any ~ modifiers */
810 /* Expand the DATE, TIME, CD, RANDOM and ERRORLEVEL special */
811 /* names allowing environment variable overrides */
812 /* NOTE: To support the %PATH:xxx% syntax, also perform */
813 /* manual expansion of environment variables here */
818 WCHAR
*delayedp
= NULL
;
819 WCHAR startchar
= '%';
822 /* Display the FOR variables in effect */
824 if (forloopcontext
.variable
[i
]) {
825 WINE_TRACE("FOR variable context: %c = '%s'\n",
826 i
<26?i
+'a':(i
-26)+'A',
827 wine_dbgstr_w(forloopcontext
.variable
[i
]));
831 /* Find the next environment variable delimiter */
832 normalp
= strchrW(p
, '%');
833 if (delayed
) delayedp
= strchrW(p
, '!');
834 if (!normalp
) p
= delayedp
;
835 else if (!delayedp
) p
= normalp
;
836 else p
= min(p
,delayedp
);
837 if (p
) startchar
= *p
;
841 WINE_TRACE("Translate command:%s %d (at: %s)\n",
842 wine_dbgstr_w(cmd
), atExecute
, wine_dbgstr_w(p
));
845 /* Don't touch %% unless its in Batch */
846 if (!atExecute
&& *(p
+1) == startchar
) {
848 WCMD_strsubstW(p
, p
+1, NULL
, 0);
852 /* Replace %~ modifications if in batch program */
853 } else if (*(p
+1) == '~') {
854 WCMD_HandleTildaModifiers(&p
, atExecute
);
857 /* Replace use of %0...%9 if in batch program*/
858 } else if (!atExecute
&& context
&& (i
>= 0) && (i
<= 9) && startchar
== '%') {
859 t
= WCMD_parameter(context
-> command
, i
+ context
-> shift_count
[i
],
861 WCMD_strsubstW(p
, p
+2, t
, -1);
863 /* Replace use of %* if in batch program*/
864 } else if (!atExecute
&& context
&& *(p
+1)=='*' && startchar
== '%') {
865 WCHAR
*startOfParms
= NULL
;
866 WCHAR
*thisParm
= WCMD_parameter(context
-> command
, 0, &startOfParms
, TRUE
, TRUE
);
867 if (startOfParms
!= NULL
) {
868 startOfParms
+= strlenW(thisParm
);
869 while (*startOfParms
==' ' || *startOfParms
== '\t') startOfParms
++;
870 WCMD_strsubstW(p
, p
+2, startOfParms
, -1);
872 WCMD_strsubstW(p
, p
+2, NULL
, 0);
875 int forvaridx
= FOR_VAR_IDX(*(p
+1));
876 if (startchar
== '%' && forvaridx
!= -1 && forloopcontext
.variable
[forvaridx
]) {
877 /* Replace the 2 characters, % and for variable character */
878 WCMD_strsubstW(p
, p
+ 2, forloopcontext
.variable
[forvaridx
], -1);
879 } else if (!atExecute
|| (atExecute
&& startchar
== '!')) {
880 p
= WCMD_expand_envvar(p
, startchar
);
882 /* In a FOR loop, see if this is the variable to replace */
883 } else { /* Ignore %'s on second pass of batch program */
888 /* Find the next environment variable delimiter */
889 normalp
= strchrW(p
, '%');
890 if (delayed
) delayedp
= strchrW(p
, '!');
891 if (!normalp
) p
= delayedp
;
892 else if (!delayedp
) p
= normalp
;
893 else p
= min(p
,delayedp
);
894 if (p
) startchar
= *p
;
901 /*******************************************************************
902 * WCMD_parse - parse a command into parameters and qualifiers.
904 * On exit, all qualifiers are concatenated into q, the first string
905 * not beginning with "/" is in p1 and the
906 * second in p2. Any subsequent non-qualifier strings are lost.
907 * Parameters in quotes are handled.
909 static void WCMD_parse (const WCHAR
*s
, WCHAR
*q
, WCHAR
*p1
, WCHAR
*p2
)
913 *q
= *p1
= *p2
= '\0';
918 while ((*s
!= '\0') && (*s
!= ' ') && *s
!= '/') {
919 *q
++ = toupperW (*s
++);
929 while ((*s
!= '\0') && (*s
!= '"')) {
930 if (p
== 0) *p1
++ = *s
++;
931 else if (p
== 1) *p2
++ = *s
++;
934 if (p
== 0) *p1
= '\0';
935 if (p
== 1) *p2
= '\0';
942 while ((*s
!= '\0') && (*s
!= ' ') && (*s
!= '\t')
943 && (*s
!= '=') && (*s
!= ',') ) {
944 if (p
== 0) *p1
++ = *s
++;
945 else if (p
== 1) *p2
++ = *s
++;
948 /* Skip concurrent parms */
949 while ((*s
== ' ') || (*s
== '\t') || (*s
== '=') || (*s
== ',') ) s
++;
951 if (p
== 0) *p1
= '\0';
952 if (p
== 1) *p2
= '\0';
958 static void init_msvcrt_io_block(STARTUPINFOW
* st
)
961 /* fetch the parent MSVCRT info block if any, so that the child can use the
962 * same handles as its grand-father
964 st_p
.cb
= sizeof(STARTUPINFOW
);
965 GetStartupInfoW(&st_p
);
966 st
->cbReserved2
= st_p
.cbReserved2
;
967 st
->lpReserved2
= st_p
.lpReserved2
;
968 if (st_p
.cbReserved2
&& st_p
.lpReserved2
)
970 unsigned num
= *(unsigned*)st_p
.lpReserved2
;
976 /* Override the entries for fd 0,1,2 if we happened
977 * to change those std handles (this depends on the way cmd sets
978 * its new input & output handles)
980 sz
= max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE
)) * 3, st_p
.cbReserved2
);
981 ptr
= heap_alloc(sz
);
982 flags
= (char*)(ptr
+ sizeof(unsigned));
983 handles
= (HANDLE
*)(flags
+ num
* sizeof(char));
985 memcpy(ptr
, st_p
.lpReserved2
, st_p
.cbReserved2
);
986 st
->cbReserved2
= sz
;
987 st
->lpReserved2
= ptr
;
989 #define WX_OPEN 0x01 /* see dlls/msvcrt/file.c */
990 if (num
<= 0 || (flags
[0] & WX_OPEN
))
992 handles
[0] = GetStdHandle(STD_INPUT_HANDLE
);
995 if (num
<= 1 || (flags
[1] & WX_OPEN
))
997 handles
[1] = GetStdHandle(STD_OUTPUT_HANDLE
);
1000 if (num
<= 2 || (flags
[2] & WX_OPEN
))
1002 handles
[2] = GetStdHandle(STD_ERROR_HANDLE
);
1003 flags
[2] |= WX_OPEN
;
1009 /******************************************************************************
1012 * Execute a command line as an external program. Must allow recursion.
1015 * Manual testing under windows shows PATHEXT plays a key part in this,
1016 * and the search algorithm and precedence appears to be as follows.
1019 * If directory supplied on command, just use that directory
1020 * If extension supplied on command, look for that explicit name first
1021 * Otherwise, search in each directory on the path
1023 * If extension supplied on command, look for that explicit name first
1024 * Then look for supplied name .* (even if extension supplied, so
1025 * 'garbage.exe' will match 'garbage.exe.cmd')
1026 * If any found, cycle through PATHEXT looking for name.exe one by one
1028 * Once a match has been found, it is launched - Code currently uses
1029 * findexecutable to achieve this which is left untouched.
1030 * If an executable has not been found, and we were launched through
1031 * a call, we need to check if the command is an internal command,
1032 * so go back through wcmd_execute.
1035 void WCMD_run_program (WCHAR
*command
, BOOL called
)
1037 WCHAR temp
[MAX_PATH
];
1038 WCHAR pathtosearch
[MAXSTRING
];
1040 WCHAR stemofsearch
[MAX_PATH
]; /* maximum allowed executable name is
1041 MAX_PATH, including null character */
1043 WCHAR pathext
[MAXSTRING
];
1045 BOOL extensionsupplied
= FALSE
;
1046 BOOL launched
= FALSE
;
1048 BOOL assumeInternal
= FALSE
;
1050 static const WCHAR envPath
[] = {'P','A','T','H','\0'};
1051 static const WCHAR delims
[] = {'/','\\',':','\0'};
1053 /* Quick way to get the filename is to extract the first argument. */
1054 WINE_TRACE("Running '%s' (%d)\n", wine_dbgstr_w(command
), called
);
1055 firstParam
= WCMD_parameter(command
, 0, NULL
, FALSE
, TRUE
);
1056 if (!firstParam
) return;
1058 /* Calculate the search path and stem to search for */
1059 if (strpbrkW (firstParam
, delims
) == NULL
) { /* No explicit path given, search path */
1060 static const WCHAR curDir
[] = {'.',';','\0'};
1061 strcpyW(pathtosearch
, curDir
);
1062 len
= GetEnvironmentVariableW(envPath
, &pathtosearch
[2], (sizeof(pathtosearch
)/sizeof(WCHAR
))-2);
1063 if ((len
== 0) || (len
>= (sizeof(pathtosearch
)/sizeof(WCHAR
)) - 2)) {
1064 static const WCHAR curDir
[] = {'.','\0'};
1065 strcpyW (pathtosearch
, curDir
);
1067 if (strchrW(firstParam
, '.') != NULL
) extensionsupplied
= TRUE
;
1068 if (strlenW(firstParam
) >= MAX_PATH
)
1070 WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_LINETOOLONG
));
1074 strcpyW(stemofsearch
, firstParam
);
1078 /* Convert eg. ..\fred to include a directory by removing file part */
1079 GetFullPathNameW(firstParam
, sizeof(pathtosearch
)/sizeof(WCHAR
), pathtosearch
, NULL
);
1080 lastSlash
= strrchrW(pathtosearch
, '\\');
1081 if (lastSlash
&& strchrW(lastSlash
, '.') != NULL
) extensionsupplied
= TRUE
;
1082 strcpyW(stemofsearch
, lastSlash
+1);
1084 /* Reduce pathtosearch to a path with trailing '\' to support c:\a.bat and
1085 c:\windows\a.bat syntax */
1086 if (lastSlash
) *(lastSlash
+ 1) = 0x00;
1089 /* Now extract PATHEXT */
1090 len
= GetEnvironmentVariableW(envPathExt
, pathext
, sizeof(pathext
)/sizeof(WCHAR
));
1091 if ((len
== 0) || (len
>= (sizeof(pathext
)/sizeof(WCHAR
)))) {
1092 strcpyW (pathext
, dfltPathExt
);
1095 /* Loop through the search path, dir by dir */
1096 pathposn
= pathtosearch
;
1097 WINE_TRACE("Searching in '%s' for '%s'\n", wine_dbgstr_w(pathtosearch
),
1098 wine_dbgstr_w(stemofsearch
));
1099 while (!launched
&& pathposn
) {
1101 WCHAR thisDir
[MAX_PATH
] = {'\0'};
1105 /* Work on the first directory on the search path */
1106 pos
= strchrW(pathposn
, ';');
1108 memcpy(thisDir
, pathposn
, (pos
-pathposn
) * sizeof(WCHAR
));
1109 thisDir
[(pos
-pathposn
)] = 0x00;
1113 strcpyW(thisDir
, pathposn
);
1117 /* Since you can have eg. ..\.. on the path, need to expand
1118 to full information */
1119 strcpyW(temp
, thisDir
);
1120 GetFullPathNameW(temp
, MAX_PATH
, thisDir
, NULL
);
1122 /* 1. If extension supplied, see if that file exists */
1123 strcatW(thisDir
, slashW
);
1124 strcatW(thisDir
, stemofsearch
);
1125 pos
= &thisDir
[strlenW(thisDir
)]; /* Pos = end of name */
1127 /* 1. If extension supplied, see if that file exists */
1128 if (extensionsupplied
) {
1129 if (GetFileAttributesW(thisDir
) != INVALID_FILE_ATTRIBUTES
) {
1134 /* 2. Any .* matches? */
1137 WIN32_FIND_DATAW finddata
;
1138 static const WCHAR allFiles
[] = {'.','*','\0'};
1140 strcatW(thisDir
,allFiles
);
1141 h
= FindFirstFileW(thisDir
, &finddata
);
1143 if (h
!= INVALID_HANDLE_VALUE
) {
1145 WCHAR
*thisExt
= pathext
;
1147 /* 3. Yes - Try each path ext */
1149 WCHAR
*nextExt
= strchrW(thisExt
, ';');
1152 memcpy(pos
, thisExt
, (nextExt
-thisExt
) * sizeof(WCHAR
));
1153 pos
[(nextExt
-thisExt
)] = 0x00;
1154 thisExt
= nextExt
+1;
1156 strcpyW(pos
, thisExt
);
1160 if (GetFileAttributesW(thisDir
) != INVALID_FILE_ATTRIBUTES
) {
1168 /* Internal programs won't be picked up by this search, so even
1169 though not found, try one last createprocess and wait for it
1171 Note: Ideally we could tell between a console app (wait) and a
1172 windows app, but the API's for it fail in this case */
1173 if (!found
&& pathposn
== NULL
) {
1174 WINE_TRACE("ASSUMING INTERNAL\n");
1175 assumeInternal
= TRUE
;
1177 WINE_TRACE("Found as %s\n", wine_dbgstr_w(thisDir
));
1180 /* Once found, launch it */
1181 if (found
|| assumeInternal
) {
1183 PROCESS_INFORMATION pe
;
1187 WCHAR
*ext
= strrchrW( thisDir
, '.' );
1188 static const WCHAR batExt
[] = {'.','b','a','t','\0'};
1189 static const WCHAR cmdExt
[] = {'.','c','m','d','\0'};
1191 /* Special case BAT and CMD */
1192 if (ext
&& (!strcmpiW(ext
, batExt
) || !strcmpiW(ext
, cmdExt
))) {
1193 BOOL oldinteractive
= interactive
;
1194 interactive
= FALSE
;
1195 WCMD_batch (thisDir
, command
, called
, NULL
, INVALID_HANDLE_VALUE
);
1196 interactive
= oldinteractive
;
1200 /* thisDir contains the file to be launched, but with what?
1201 eg. a.exe will require a.exe to be launched, a.html may be iexplore */
1202 hinst
= FindExecutableW (thisDir
, NULL
, temp
);
1203 if ((INT_PTR
)hinst
< 32)
1206 console
= SHGetFileInfoW(temp
, 0, &psfi
, sizeof(psfi
), SHGFI_EXETYPE
);
1208 ZeroMemory (&st
, sizeof(STARTUPINFOW
));
1209 st
.cb
= sizeof(STARTUPINFOW
);
1210 init_msvcrt_io_block(&st
);
1212 /* Launch the process and if a CUI wait on it to complete
1213 Note: Launching internal wine processes cannot specify a full path to exe */
1214 status
= CreateProcessW(assumeInternal
?NULL
: thisDir
,
1215 command
, NULL
, NULL
, TRUE
, 0, NULL
, NULL
, &st
, &pe
);
1216 if ((opt_c
|| opt_k
) && !opt_s
&& !status
1217 && GetLastError()==ERROR_FILE_NOT_FOUND
&& command
[0]=='\"') {
1218 /* strip first and last quote WCHARacters and try again */
1219 WCMD_strip_quotes(command
);
1221 WCMD_run_program(command
, called
);
1228 /* Always wait when non-interactive (cmd /c or in batch program),
1229 or for console applications */
1230 if (assumeInternal
|| !interactive
|| (console
&& !HIWORD(console
)))
1231 WaitForSingleObject (pe
.hProcess
, INFINITE
);
1232 GetExitCodeProcess (pe
.hProcess
, &errorlevel
);
1233 if (errorlevel
== STILL_ACTIVE
) errorlevel
= 0;
1235 CloseHandle(pe
.hProcess
);
1236 CloseHandle(pe
.hThread
);
1242 /* Not found anywhere - were we called? */
1244 CMD_LIST
*toExecute
= NULL
; /* Commands left to be executed */
1246 /* Parse the command string, without reading any more input */
1247 WCMD_ReadAndParseLine(command
, &toExecute
, INVALID_HANDLE_VALUE
);
1248 WCMD_process_commands(toExecute
, FALSE
, called
);
1249 WCMD_free_commands(toExecute
);
1254 /* Not found anywhere - give up */
1255 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NO_COMMAND_FOUND
), command
);
1257 /* If a command fails to launch, it sets errorlevel 9009 - which
1258 does not seem to have any associated constant definition */
1264 /*****************************************************************************
1265 * Process one command. If the command is EXIT this routine does not return.
1266 * We will recurse through here executing batch files.
1267 * Note: If call is used to a non-existing program, we reparse the line and
1268 * try to run it as an internal command. 'retrycall' represents whether
1269 * we are attempting this retry.
1271 void WCMD_execute (const WCHAR
*command
, const WCHAR
*redirects
,
1272 CMD_LIST
**cmdList
, BOOL retrycall
)
1274 WCHAR
*cmd
, *p
, *redir
;
1276 DWORD count
, creationDisposition
;
1279 SECURITY_ATTRIBUTES sa
;
1280 WCHAR
*new_cmd
= NULL
;
1281 WCHAR
*new_redir
= NULL
;
1282 HANDLE old_stdhandles
[3] = {GetStdHandle (STD_INPUT_HANDLE
),
1283 GetStdHandle (STD_OUTPUT_HANDLE
),
1284 GetStdHandle (STD_ERROR_HANDLE
)};
1285 DWORD idx_stdhandles
[3] = {STD_INPUT_HANDLE
,
1288 BOOL prev_echo_mode
, piped
= FALSE
;
1290 WINE_TRACE("command on entry:%s (%p)\n",
1291 wine_dbgstr_w(command
), cmdList
);
1293 /* If the next command is a pipe then we implement pipes by redirecting
1294 the output from this command to a temp file and input into the
1295 next command from that temp file.
1296 FIXME: Use of named pipes would make more sense here as currently this
1297 process has to finish before the next one can start but this requires
1298 a change to not wait for the first app to finish but rather the pipe */
1299 if (cmdList
&& (*cmdList
)->nextcommand
&&
1300 (*cmdList
)->nextcommand
->prevDelim
== CMD_PIPE
) {
1302 WCHAR temp_path
[MAX_PATH
];
1303 static const WCHAR cmdW
[] = {'C','M','D','\0'};
1305 /* Remember piping is in action */
1306 WINE_TRACE("Output needs to be piped\n");
1309 /* Generate a unique temporary filename */
1310 GetTempPathW(sizeof(temp_path
)/sizeof(WCHAR
), temp_path
);
1311 GetTempFileNameW(temp_path
, cmdW
, 0, (*cmdList
)->nextcommand
->pipeFile
);
1312 WINE_TRACE("Using temporary file of %s\n",
1313 wine_dbgstr_w((*cmdList
)->nextcommand
->pipeFile
));
1316 /* Move copy of the command onto the heap so it can be expanded */
1317 new_cmd
= heap_alloc(MAXSTRING
* sizeof(WCHAR
));
1318 strcpyW(new_cmd
, command
);
1320 /* Move copy of the redirects onto the heap so it can be expanded */
1321 new_redir
= heap_alloc(MAXSTRING
* sizeof(WCHAR
));
1323 /* If piped output, send stdout to the pipe by appending >filename to redirects */
1325 static const WCHAR redirOut
[] = {'%','s',' ','>',' ','%','s','\0'};
1326 wsprintfW (new_redir
, redirOut
, redirects
, (*cmdList
)->nextcommand
->pipeFile
);
1327 WINE_TRACE("Redirects now %s\n", wine_dbgstr_w(new_redir
));
1329 strcpyW(new_redir
, redirects
);
1332 /* Expand variables in command line mode only (batch mode will
1333 be expanded as the line is read in, except for 'for' loops) */
1334 handleExpansion(new_cmd
, (context
!= NULL
), delayedsubst
);
1335 handleExpansion(new_redir
, (context
!= NULL
), delayedsubst
);
1339 * Changing default drive has to be handled as a special case.
1342 if ((cmd
[1] == ':') && IsCharAlphaW(cmd
[0]) && (strlenW(cmd
) == 2)) {
1344 WCHAR dir
[MAX_PATH
];
1346 /* According to MSDN CreateProcess docs, special env vars record
1347 the current directory on each drive, in the form =C:
1348 so see if one specified, and if so go back to it */
1349 strcpyW(envvar
, equalW
);
1350 strcatW(envvar
, cmd
);
1351 if (GetEnvironmentVariableW(envvar
, dir
, MAX_PATH
) == 0) {
1352 static const WCHAR fmt
[] = {'%','s','\\','\0'};
1353 wsprintfW(cmd
, fmt
, cmd
);
1354 WINE_TRACE("No special directory settings, using dir of %s\n", wine_dbgstr_w(cmd
));
1356 WINE_TRACE("Got directory %s as %s\n", wine_dbgstr_w(envvar
), wine_dbgstr_w(cmd
));
1357 status
= SetCurrentDirectoryW(cmd
);
1358 if (!status
) WCMD_print_error ();
1360 heap_free(new_redir
);
1364 sa
.nLength
= sizeof(sa
);
1365 sa
.lpSecurityDescriptor
= NULL
;
1366 sa
.bInheritHandle
= TRUE
;
1369 * Redirect stdin, stdout and/or stderr if required.
1372 /* STDIN could come from a preceding pipe, so delete on close if it does */
1373 if (cmdList
&& (*cmdList
)->pipeFile
[0] != 0x00) {
1374 WINE_TRACE("Input coming from %s\n", wine_dbgstr_w((*cmdList
)->pipeFile
));
1375 h
= CreateFileW((*cmdList
)->pipeFile
, GENERIC_READ
,
1376 FILE_SHARE_READ
, &sa
, OPEN_EXISTING
,
1377 FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_DELETE_ON_CLOSE
, NULL
);
1378 if (h
== INVALID_HANDLE_VALUE
) {
1379 WCMD_print_error ();
1381 heap_free(new_redir
);
1384 SetStdHandle (STD_INPUT_HANDLE
, h
);
1386 /* No need to remember the temporary name any longer once opened */
1387 (*cmdList
)->pipeFile
[0] = 0x00;
1389 /* Otherwise STDIN could come from a '<' redirect */
1390 } else if ((p
= strchrW(new_redir
,'<')) != NULL
) {
1391 h
= CreateFileW(WCMD_parameter(++p
, 0, NULL
, FALSE
, FALSE
), GENERIC_READ
, FILE_SHARE_READ
,
1392 &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1393 if (h
== INVALID_HANDLE_VALUE
) {
1394 WCMD_print_error ();
1396 heap_free(new_redir
);
1399 SetStdHandle (STD_INPUT_HANDLE
, h
);
1402 /* Scan the whole command looking for > and 2> */
1404 while (redir
!= NULL
&& ((p
= strchrW(redir
,'>')) != NULL
)) {
1407 if (p
> redir
&& (*(p
-1)=='2'))
1414 creationDisposition
= OPEN_ALWAYS
;
1418 creationDisposition
= CREATE_ALWAYS
;
1421 /* Add support for 2>&1 */
1424 int idx
= *(p
+1) - '0';
1426 if (DuplicateHandle(GetCurrentProcess(),
1427 GetStdHandle(idx_stdhandles
[idx
]),
1428 GetCurrentProcess(),
1430 0, TRUE
, DUPLICATE_SAME_ACCESS
) == 0) {
1431 WINE_FIXME("Duplicating handle failed with gle %d\n", GetLastError());
1433 WINE_TRACE("Redirect %d (%p) to %d (%p)\n", handle
, GetStdHandle(idx_stdhandles
[idx
]), idx
, h
);
1436 WCHAR
*param
= WCMD_parameter(p
, 0, NULL
, FALSE
, FALSE
);
1437 h
= CreateFileW(param
, GENERIC_WRITE
, 0, &sa
, creationDisposition
,
1438 FILE_ATTRIBUTE_NORMAL
, NULL
);
1439 if (h
== INVALID_HANDLE_VALUE
) {
1440 WCMD_print_error ();
1442 heap_free(new_redir
);
1445 if (SetFilePointer (h
, 0, NULL
, FILE_END
) ==
1446 INVALID_SET_FILE_POINTER
) {
1447 WCMD_print_error ();
1449 WINE_TRACE("Redirect %d to '%s' (%p)\n", handle
, wine_dbgstr_w(param
), h
);
1452 SetStdHandle (idx_stdhandles
[handle
], h
);
1456 * Strip leading whitespaces, and a '@' if supplied
1458 whichcmd
= WCMD_skip_leading_spaces(cmd
);
1459 WINE_TRACE("Command: '%s'\n", wine_dbgstr_w(cmd
));
1460 if (whichcmd
[0] == '@') whichcmd
++;
1463 * Check if the command entered is internal. If it is, pass the rest of the
1464 * line down to the command. If not try to run a program.
1468 while (IsCharAlphaNumericW(whichcmd
[count
])) {
1471 for (i
=0; i
<=WCMD_EXIT
; i
++) {
1472 if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1473 whichcmd
, count
, inbuilt
[i
], -1) == CSTR_EQUAL
) break;
1475 p
= WCMD_skip_leading_spaces (&whichcmd
[count
]);
1476 WCMD_parse (p
, quals
, param1
, param2
);
1477 WINE_TRACE("param1: %s, param2: %s\n", wine_dbgstr_w(param1
), wine_dbgstr_w(param2
));
1479 if (i
<= WCMD_EXIT
&& (p
[0] == '/') && (p
[1] == '?')) {
1480 /* this is a help request for a builtin program */
1482 memcpy(p
, whichcmd
, count
* sizeof(WCHAR
));
1494 WCMD_setshow_default (p
);
1497 WCMD_clear_screen ();
1506 WCMD_setshow_date ();
1516 WCMD_echo(&whichcmd
[count
]);
1519 WCMD_goto (cmdList
);
1525 WCMD_volume (TRUE
, p
);
1529 WCMD_create_dir (p
);
1535 WCMD_setshow_path (p
);
1541 WCMD_setshow_prompt ();
1551 WCMD_remove_dir (p
);
1560 WCMD_setshow_env (p
);
1569 WCMD_setshow_time ();
1572 if (strlenW(&whichcmd
[count
]) > 0)
1573 WCMD_title(&whichcmd
[count
+1]);
1579 WCMD_output_asis(newlineW
);
1586 WCMD_volume (FALSE
, p
);
1595 WCMD_assoc(p
, TRUE
);
1601 WCMD_assoc(p
, FALSE
);
1610 WCMD_exit (cmdList
);
1614 /* Very oddly, probably because of all the special parsing required for
1615 these two commands, neither for nor if are supported when called,
1616 ie call if 1==1... will fail. */
1618 if (i
==WCMD_FOR
) WCMD_for (p
, cmdList
);
1619 else if (i
==WCMD_IF
) WCMD_if (p
, cmdList
);
1622 /* else: drop through */
1624 prev_echo_mode
= echo_mode
;
1625 WCMD_run_program (whichcmd
, FALSE
);
1626 echo_mode
= prev_echo_mode
;
1629 heap_free(new_redir
);
1631 /* Restore old handles */
1632 for (i
=0; i
<3; i
++) {
1633 if (old_stdhandles
[i
] != GetStdHandle(idx_stdhandles
[i
])) {
1634 CloseHandle (GetStdHandle (idx_stdhandles
[i
]));
1635 SetStdHandle (idx_stdhandles
[i
], old_stdhandles
[i
]);
1640 /*************************************************************************
1642 * Load a string from the resource file, handling any error
1643 * Returns string retrieved from resource file
1645 WCHAR
*WCMD_LoadMessage(UINT id
) {
1646 static WCHAR msg
[2048];
1647 static const WCHAR failedMsg
[] = {'F','a','i','l','e','d','!','\0'};
1649 if (!LoadStringW(GetModuleHandleW(NULL
), id
, msg
, sizeof(msg
)/sizeof(WCHAR
))) {
1650 WINE_FIXME("LoadString failed with %d\n", GetLastError());
1651 strcpyW(msg
, failedMsg
);
1656 /***************************************************************************
1659 * Dumps out the parsed command line to ensure syntax is correct
1661 static void WCMD_DumpCommands(CMD_LIST
*commands
) {
1662 CMD_LIST
*thisCmd
= commands
;
1664 WINE_TRACE("Parsed line:\n");
1665 while (thisCmd
!= NULL
) {
1666 WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
1669 thisCmd
->bracketDepth
,
1670 thisCmd
->nextcommand
,
1671 wine_dbgstr_w(thisCmd
->command
),
1672 wine_dbgstr_w(thisCmd
->redirects
));
1673 thisCmd
= thisCmd
->nextcommand
;
1677 /***************************************************************************
1680 * Adds a command to the current command list
1682 static void WCMD_addCommand(WCHAR
*command
, int *commandLen
,
1683 WCHAR
*redirs
, int *redirLen
,
1684 WCHAR
**copyTo
, int **copyToLen
,
1685 CMD_DELIMITERS prevDelim
, int curDepth
,
1686 CMD_LIST
**lastEntry
, CMD_LIST
**output
) {
1688 CMD_LIST
*thisEntry
= NULL
;
1690 /* Allocate storage for command */
1691 thisEntry
= heap_alloc(sizeof(CMD_LIST
));
1693 /* Copy in the command */
1695 thisEntry
->command
= heap_alloc((*commandLen
+1) * sizeof(WCHAR
));
1696 memcpy(thisEntry
->command
, command
, *commandLen
* sizeof(WCHAR
));
1697 thisEntry
->command
[*commandLen
] = 0x00;
1699 /* Copy in the redirects */
1700 thisEntry
->redirects
= heap_alloc((*redirLen
+1) * sizeof(WCHAR
));
1701 memcpy(thisEntry
->redirects
, redirs
, *redirLen
* sizeof(WCHAR
));
1702 thisEntry
->redirects
[*redirLen
] = 0x00;
1703 thisEntry
->pipeFile
[0] = 0x00;
1705 /* Reset the lengths */
1708 *copyToLen
= commandLen
;
1712 thisEntry
->command
= NULL
;
1713 thisEntry
->redirects
= NULL
;
1714 thisEntry
->pipeFile
[0] = 0x00;
1717 /* Fill in other fields */
1718 thisEntry
->nextcommand
= NULL
;
1719 thisEntry
->prevDelim
= prevDelim
;
1720 thisEntry
->bracketDepth
= curDepth
;
1722 (*lastEntry
)->nextcommand
= thisEntry
;
1724 *output
= thisEntry
;
1726 *lastEntry
= thisEntry
;
1730 /***************************************************************************
1733 * Checks if the quote pointed to is the end-quote.
1737 * 1) The current parameter ends at EOL or at the beginning
1738 * of a redirection or pipe and not in a quote section.
1740 * 2) If the next character is a space and not in a quote section.
1742 * Returns TRUE if this is an end quote, and FALSE if it is not.
1745 static BOOL
WCMD_IsEndQuote(const WCHAR
*quote
, int quoteIndex
)
1747 int quoteCount
= quoteIndex
;
1750 /* If we are not in a quoted section, then we are not an end-quote */
1756 /* Check how many quotes are left for this parameter */
1757 for(i
=0;quote
[i
];i
++)
1764 /* Quote counting ends at EOL, redirection, space or pipe if current quote is complete */
1765 else if(((quoteCount
% 2) == 0)
1766 && ((quote
[i
] == '<') || (quote
[i
] == '>') || (quote
[i
] == '|') || (quote
[i
] == ' ')))
1772 /* If the quote is part of the last part of a series of quotes-on-quotes, then it must
1774 if(quoteIndex
>= (quoteCount
/ 2))
1783 /***************************************************************************
1784 * WCMD_ReadAndParseLine
1786 * Either uses supplied input or
1787 * Reads a file from the handle, and then...
1788 * Parse the text buffer, splitting into separate commands
1789 * - unquoted && strings split 2 commands but the 2nd is flagged as
1791 * - ( as the first character just ups the bracket depth
1792 * - unquoted ) when bracket depth > 0 terminates a bracket and
1793 * adds a CMD_LIST structure with null command
1794 * - Anything else gets put into the command string (including
1797 WCHAR
*WCMD_ReadAndParseLine(const WCHAR
*optionalcmd
, CMD_LIST
**output
, HANDLE readFrom
)
1801 WCHAR curString
[MAXSTRING
];
1802 int curStringLen
= 0;
1803 WCHAR curRedirs
[MAXSTRING
];
1804 int curRedirsLen
= 0;
1808 CMD_LIST
*lastEntry
= NULL
;
1809 CMD_DELIMITERS prevDelim
= CMD_NONE
;
1810 static WCHAR
*extraSpace
= NULL
; /* Deliberately never freed */
1811 static const WCHAR remCmd
[] = {'r','e','m'};
1812 static const WCHAR forCmd
[] = {'f','o','r'};
1813 static const WCHAR ifCmd
[] = {'i','f'};
1814 static const WCHAR ifElse
[] = {'e','l','s','e'};
1820 BOOL onlyWhiteSpace
= FALSE
;
1821 BOOL lastWasWhiteSpace
= FALSE
;
1822 BOOL lastWasDo
= FALSE
;
1823 BOOL lastWasIn
= FALSE
;
1824 BOOL lastWasElse
= FALSE
;
1825 BOOL lastWasRedirect
= TRUE
;
1826 BOOL lastWasCaret
= FALSE
;
1828 /* Allocate working space for a command read from keyboard, file etc */
1830 extraSpace
= heap_alloc((MAXSTRING
+1) * sizeof(WCHAR
));
1833 WINE_ERR("Could not allocate memory for extraSpace\n");
1837 /* If initial command read in, use that, otherwise get input from handle */
1838 if (optionalcmd
!= NULL
) {
1839 strcpyW(extraSpace
, optionalcmd
);
1840 } else if (readFrom
== INVALID_HANDLE_VALUE
) {
1841 WINE_FIXME("No command nor handle supplied\n");
1843 if (!WCMD_fgets(extraSpace
, MAXSTRING
, readFrom
))
1846 curPos
= extraSpace
;
1848 /* Handle truncated input - issue warning */
1849 if (strlenW(extraSpace
) == MAXSTRING
-1) {
1850 WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_TRUNCATEDLINE
));
1851 WCMD_output_asis_stderr(extraSpace
);
1852 WCMD_output_asis_stderr(newlineW
);
1855 /* Replace env vars if in a batch context */
1856 if (context
) handleExpansion(extraSpace
, FALSE
, FALSE
);
1858 /* Skip preceding whitespace */
1859 while (*curPos
== ' ' || *curPos
== '\t') curPos
++;
1861 /* Show prompt before batch line IF echo is on and in batch program */
1862 if (context
&& echo_mode
&& *curPos
&& (*curPos
!= '@')) {
1863 static const WCHAR echoDot
[] = {'e','c','h','o','.'};
1864 static const WCHAR echoCol
[] = {'e','c','h','o',':'};
1865 const DWORD len
= sizeof(echoDot
)/sizeof(echoDot
[0]);
1866 DWORD curr_size
= strlenW(curPos
);
1867 DWORD min_len
= (curr_size
< len
? curr_size
: len
);
1869 WCMD_output_asis(curPos
);
1870 /* I don't know why Windows puts a space here but it does */
1871 /* Except for lines starting with 'echo.' or 'echo:'. Ask MS why */
1872 if (CompareStringW(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
1873 curPos
, min_len
, echoDot
, len
) != CSTR_EQUAL
1874 && CompareStringW(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
1875 curPos
, min_len
, echoCol
, len
) != CSTR_EQUAL
)
1877 WCMD_output_asis(spaceW
);
1879 WCMD_output_asis(newlineW
);
1882 /* Skip repeated 'no echo' characters */
1883 while (*curPos
== '@') curPos
++;
1885 /* Start with an empty string, copying to the command string */
1888 curCopyTo
= curString
;
1889 curLen
= &curStringLen
;
1890 lastWasRedirect
= FALSE
; /* Required e.g. for spaces between > and filename */
1892 /* Parse every character on the line being processed */
1893 while (*curPos
!= 0x00) {
1898 WINE_TRACE("Looking at '%c' (len:%d, lws:%d, ows:%d)\n", *curPos, *curLen,
1899 lastWasWhiteSpace, onlyWhiteSpace);
1902 /* Prevent overflow caused by the caret escape char */
1903 if (*curLen
>= MAXSTRING
) {
1904 WINE_ERR("Overflow detected in command\n");
1908 /* Certain commands need special handling */
1909 if (curStringLen
== 0 && curCopyTo
== curString
) {
1910 static const WCHAR forDO
[] = {'d','o'};
1912 /* If command starts with 'rem ', ignore any &&, ( etc. */
1913 if (WCMD_keyword_ws_found(remCmd
, sizeof(remCmd
)/sizeof(remCmd
[0]), curPos
)) {
1916 } else if (WCMD_keyword_ws_found(forCmd
, sizeof(forCmd
)/sizeof(forCmd
[0]), curPos
)) {
1919 /* If command starts with 'if ' or 'else ', handle ('s mid line. We should ensure this
1920 is only true in the command portion of the IF statement, but this
1921 should suffice for now
1922 FIXME: Silly syntax like "if 1(==1( (
1924 )" will be parsed wrong */
1925 } else if (WCMD_keyword_ws_found(ifCmd
, sizeof(ifCmd
)/sizeof(ifCmd
[0]), curPos
)) {
1928 } else if (WCMD_keyword_ws_found(ifElse
, sizeof(ifElse
)/sizeof(ifElse
[0]), curPos
)) {
1929 const int keyw_len
= sizeof(ifElse
)/sizeof(ifElse
[0]) + 1;
1932 onlyWhiteSpace
= TRUE
;
1933 memcpy(&curCopyTo
[*curLen
], curPos
, keyw_len
*sizeof(WCHAR
));
1934 (*curLen
)+=keyw_len
;
1938 /* In a for loop, the DO command will follow a close bracket followed by
1939 whitespace, followed by DO, ie closeBracket inserts a NULL entry, curLen
1940 is then 0, and all whitespace is skipped */
1942 WCMD_keyword_ws_found(forDO
, sizeof(forDO
)/sizeof(forDO
[0]), curPos
)) {
1943 const int keyw_len
= sizeof(forDO
)/sizeof(forDO
[0]) + 1;
1944 WINE_TRACE("Found 'DO '\n");
1946 onlyWhiteSpace
= TRUE
;
1947 memcpy(&curCopyTo
[*curLen
], curPos
, keyw_len
*sizeof(WCHAR
));
1948 (*curLen
)+=keyw_len
;
1952 } else if (curCopyTo
== curString
) {
1954 /* Special handling for the 'FOR' command */
1955 if (inFor
&& lastWasWhiteSpace
) {
1956 static const WCHAR forIN
[] = {'i','n'};
1958 WINE_TRACE("Found 'FOR ', comparing next parm: '%s'\n", wine_dbgstr_w(curPos
));
1960 if (WCMD_keyword_ws_found(forIN
, sizeof(forIN
)/sizeof(forIN
[0]), curPos
)) {
1961 const int keyw_len
= sizeof(forIN
)/sizeof(forIN
[0]) + 1;
1962 WINE_TRACE("Found 'IN '\n");
1964 onlyWhiteSpace
= TRUE
;
1965 memcpy(&curCopyTo
[*curLen
], curPos
, keyw_len
*sizeof(WCHAR
));
1966 (*curLen
)+=keyw_len
;
1973 /* Nothing 'ends' a REM statement and &&, quotes etc are ineffective,
1974 so just use the default processing ie skip character specific
1976 if (!inRem
) thisChar
= *curPos
;
1977 else thisChar
= 'X'; /* Character with no special processing */
1979 lastWasWhiteSpace
= FALSE
; /* Will be reset below */
1980 lastWasCaret
= FALSE
;
1984 case '=': /* drop through - ignore token delimiters at the start of a command */
1985 case ',': /* drop through - ignore token delimiters at the start of a command */
1986 case '\t':/* drop through - ignore token delimiters at the start of a command */
1988 /* If a redirect in place, it ends here */
1989 if (!inQuotes
&& !lastWasRedirect
) {
1991 /* If finishing off a redirect, add a whitespace delimiter */
1992 if (curCopyTo
== curRedirs
) {
1993 curCopyTo
[(*curLen
)++] = ' ';
1995 curCopyTo
= curString
;
1996 curLen
= &curStringLen
;
1999 curCopyTo
[(*curLen
)++] = *curPos
;
2002 /* Remember just processed whitespace */
2003 lastWasWhiteSpace
= TRUE
;
2007 case '>': /* drop through - handle redirect chars the same */
2009 /* Make a redirect start here */
2011 curCopyTo
= curRedirs
;
2012 curLen
= &curRedirsLen
;
2013 lastWasRedirect
= TRUE
;
2016 /* See if 1>, 2> etc, in which case we have some patching up
2017 to do (provided there's a preceding whitespace, and enough
2018 chars read so far) */
2019 if (curStringLen
> 2
2020 && (*(curPos
-1)>='1') && (*(curPos
-1)<='9')
2021 && ((*(curPos
-2)==' ') || (*(curPos
-2)=='\t'))) {
2023 curString
[curStringLen
] = 0x00;
2024 curCopyTo
[(*curLen
)++] = *(curPos
-1);
2027 curCopyTo
[(*curLen
)++] = *curPos
;
2029 /* If a redirect is immediately followed by '&' (ie. 2>&1) then
2030 do not process that ampersand as an AND operator */
2031 if (thisChar
== '>' && *(curPos
+1) == '&') {
2032 curCopyTo
[(*curLen
)++] = *(curPos
+1);
2037 case '|': /* Pipe character only if not || */
2039 lastWasRedirect
= FALSE
;
2041 /* Add an entry to the command list */
2042 if (curStringLen
> 0) {
2044 /* Add the current command */
2045 WCMD_addCommand(curString
, &curStringLen
,
2046 curRedirs
, &curRedirsLen
,
2047 &curCopyTo
, &curLen
,
2048 prevDelim
, curDepth
,
2049 &lastEntry
, output
);
2053 if (*(curPos
+1) == '|') {
2054 curPos
++; /* Skip other | */
2055 prevDelim
= CMD_ONFAILURE
;
2057 prevDelim
= CMD_PIPE
;
2060 curCopyTo
[(*curLen
)++] = *curPos
;
2064 case '"': if (WCMD_IsEndQuote(curPos
, inQuotes
)) {
2067 inQuotes
++; /* Quotes within quotes are fun! */
2069 curCopyTo
[(*curLen
)++] = *curPos
;
2070 lastWasRedirect
= FALSE
;
2073 case '(': /* If a '(' is the first non whitespace in a command portion
2074 ie start of line or just after &&, then we read until an
2075 unquoted ) is found */
2076 WINE_TRACE("Found '(' conditions: curLen(%d), inQ(%d), onlyWS(%d)"
2077 ", for(%d, In:%d, Do:%d)"
2078 ", if(%d, else:%d, lwe:%d)\n",
2081 inFor
, lastWasIn
, lastWasDo
,
2082 inIf
, inElse
, lastWasElse
);
2083 lastWasRedirect
= FALSE
;
2085 /* Ignore open brackets inside the for set */
2086 if (*curLen
== 0 && !inIn
) {
2089 /* If in quotes, ignore brackets */
2090 } else if (inQuotes
) {
2091 curCopyTo
[(*curLen
)++] = *curPos
;
2093 /* In a FOR loop, an unquoted '(' may occur straight after
2095 In an IF statement just handle it regardless as we don't
2097 In an ELSE statement, only allow it straight away after
2098 the ELSE and whitespace
2101 (inElse
&& lastWasElse
&& onlyWhiteSpace
) ||
2102 (inFor
&& (lastWasIn
|| lastWasDo
) && onlyWhiteSpace
)) {
2104 /* If entering into an 'IN', set inIn */
2105 if (inFor
&& lastWasIn
&& onlyWhiteSpace
) {
2106 WINE_TRACE("Inside an IN\n");
2110 /* Add the current command */
2111 WCMD_addCommand(curString
, &curStringLen
,
2112 curRedirs
, &curRedirsLen
,
2113 &curCopyTo
, &curLen
,
2114 prevDelim
, curDepth
,
2115 &lastEntry
, output
);
2119 curCopyTo
[(*curLen
)++] = *curPos
;
2123 case '^': if (!inQuotes
) {
2124 /* If we reach the end of the input, we need to wait for more */
2125 if (*(curPos
+1) == 0x00) {
2126 lastWasCaret
= TRUE
;
2127 WINE_TRACE("Caret found at end of line\n");
2132 curCopyTo
[(*curLen
)++] = *curPos
;
2135 case '&': if (!inQuotes
) {
2136 lastWasRedirect
= FALSE
;
2138 /* Add an entry to the command list */
2139 if (curStringLen
> 0) {
2141 /* Add the current command */
2142 WCMD_addCommand(curString
, &curStringLen
,
2143 curRedirs
, &curRedirsLen
,
2144 &curCopyTo
, &curLen
,
2145 prevDelim
, curDepth
,
2146 &lastEntry
, output
);
2150 if (*(curPos
+1) == '&') {
2151 curPos
++; /* Skip other & */
2152 prevDelim
= CMD_ONSUCCESS
;
2154 prevDelim
= CMD_NONE
;
2157 curCopyTo
[(*curLen
)++] = *curPos
;
2161 case ')': if (!inQuotes
&& curDepth
> 0) {
2162 lastWasRedirect
= FALSE
;
2164 /* Add the current command if there is one */
2167 /* Add the current command */
2168 WCMD_addCommand(curString
, &curStringLen
,
2169 curRedirs
, &curRedirsLen
,
2170 &curCopyTo
, &curLen
,
2171 prevDelim
, curDepth
,
2172 &lastEntry
, output
);
2175 /* Add an empty entry to the command list */
2176 prevDelim
= CMD_NONE
;
2177 WCMD_addCommand(NULL
, &curStringLen
,
2178 curRedirs
, &curRedirsLen
,
2179 &curCopyTo
, &curLen
,
2180 prevDelim
, curDepth
,
2181 &lastEntry
, output
);
2184 /* Leave inIn if necessary */
2185 if (inIn
) inIn
= FALSE
;
2187 curCopyTo
[(*curLen
)++] = *curPos
;
2191 lastWasRedirect
= FALSE
;
2192 curCopyTo
[(*curLen
)++] = *curPos
;
2197 /* At various times we need to know if we have only skipped whitespace,
2198 so reset this variable and then it will remain true until a non
2199 whitespace is found */
2200 if ((thisChar
!= ' ') && (thisChar
!= '\t') && (thisChar
!= '\n'))
2201 onlyWhiteSpace
= FALSE
;
2203 /* Flag end of interest in FOR DO and IN parms once something has been processed */
2204 if (!lastWasWhiteSpace
) {
2205 lastWasIn
= lastWasDo
= FALSE
;
2208 /* If we have reached the end, add this command into the list
2209 Do not add command to list if escape char ^ was last */
2210 if (*curPos
== 0x00 && !lastWasCaret
&& *curLen
> 0) {
2212 /* Add an entry to the command list */
2213 WCMD_addCommand(curString
, &curStringLen
,
2214 curRedirs
, &curRedirsLen
,
2215 &curCopyTo
, &curLen
,
2216 prevDelim
, curDepth
,
2217 &lastEntry
, output
);
2220 /* If we have reached the end of the string, see if bracketing or
2221 final caret is outstanding */
2222 if (*curPos
== 0x00 && (curDepth
> 0 || lastWasCaret
) &&
2223 readFrom
!= INVALID_HANDLE_VALUE
) {
2226 WINE_TRACE("Need to read more data as outstanding brackets or carets\n");
2228 prevDelim
= CMD_NONE
;
2230 memset(extraSpace
, 0x00, (MAXSTRING
+1) * sizeof(WCHAR
));
2231 extraData
= extraSpace
;
2233 /* Read more, skipping any blank lines */
2235 WINE_TRACE("Read more input\n");
2236 if (!context
) WCMD_output_asis( WCMD_LoadMessage(WCMD_MOREPROMPT
));
2237 if (!WCMD_fgets(extraData
, MAXSTRING
, readFrom
))
2240 /* Edge case for carets - a completely blank line (i.e. was just
2241 CRLF) is oddly added as an LF but then more data is received (but
2244 if (*extraSpace
== 0x00) {
2245 WINE_TRACE("Read nothing, so appending LF char and will try again\n");
2246 *extraData
++ = '\r';
2251 } while (*extraData
== 0x00);
2252 curPos
= extraSpace
;
2253 if (context
) handleExpansion(extraSpace
, FALSE
, FALSE
);
2254 /* Continue to echo commands IF echo is on and in batch program */
2255 if (context
&& echo_mode
&& extraSpace
[0] && (extraSpace
[0] != '@')) {
2256 WCMD_output_asis(extraSpace
);
2257 WCMD_output_asis(newlineW
);
2262 /* Dump out the parsed output */
2263 WCMD_DumpCommands(*output
);
2268 /***************************************************************************
2269 * WCMD_process_commands
2271 * Process all the commands read in so far
2273 CMD_LIST
*WCMD_process_commands(CMD_LIST
*thisCmd
, BOOL oneBracket
,
2278 if (thisCmd
&& oneBracket
) bdepth
= thisCmd
->bracketDepth
;
2280 /* Loop through the commands, processing them one by one */
2283 CMD_LIST
*origCmd
= thisCmd
;
2285 /* If processing one bracket only, and we find the end bracket
2286 entry (or less), return */
2287 if (oneBracket
&& !thisCmd
->command
&&
2288 bdepth
<= thisCmd
->bracketDepth
) {
2289 WINE_TRACE("Finished bracket @ %p, next command is %p\n",
2290 thisCmd
, thisCmd
->nextcommand
);
2291 return thisCmd
->nextcommand
;
2294 /* Ignore the NULL entries a ')' inserts (Only 'if' cares
2295 about them and it will be handled in there)
2296 Also, skip over any batch labels (eg. :fred) */
2297 if (thisCmd
->command
&& thisCmd
->command
[0] != ':') {
2298 WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd
->command
));
2299 WCMD_execute (thisCmd
->command
, thisCmd
->redirects
, &thisCmd
, retrycall
);
2302 /* Step on unless the command itself already stepped on */
2303 if (thisCmd
== origCmd
) thisCmd
= thisCmd
->nextcommand
;
2308 /***************************************************************************
2309 * WCMD_free_commands
2311 * Frees the storage held for a parsed command line
2312 * - This is not done in the process_commands, as eventually the current
2313 * pointer will be modified within the commands, and hence a single free
2314 * routine is simpler
2316 void WCMD_free_commands(CMD_LIST
*cmds
) {
2318 /* Loop through the commands, freeing them one by one */
2320 CMD_LIST
*thisCmd
= cmds
;
2321 cmds
= cmds
->nextcommand
;
2322 heap_free(thisCmd
->command
);
2323 heap_free(thisCmd
->redirects
);
2329 /*****************************************************************************
2330 * Main entry point. This is a console application so we have a main() not a
2334 int wmain (int argc
, WCHAR
*argvW
[])
2337 WCHAR
*cmdLine
= NULL
;
2339 WCHAR
*argPos
= NULL
;
2344 static const WCHAR offW
[] = {'O','F','F','\0'};
2345 static const WCHAR promptW
[] = {'P','R','O','M','P','T','\0'};
2346 static const WCHAR defaultpromptW
[] = {'$','P','$','G','\0'};
2347 CMD_LIST
*toExecute
= NULL
; /* Commands left to be executed */
2353 /* Get the windows version being emulated */
2354 osv
.dwOSVersionInfoSize
= sizeof(osv
);
2355 GetVersionExW(&osv
);
2357 /* Pre initialize some messages */
2358 strcpyW(anykey
, WCMD_LoadMessage(WCMD_ANYKEY
));
2359 sprintf(osver
, "%d.%d.%d (%s)", osv
.dwMajorVersion
, osv
.dwMinorVersion
,
2360 osv
.dwBuildNumber
, PACKAGE_VERSION
);
2361 cmd
= WCMD_format_string(WCMD_LoadMessage(WCMD_VERSION
), osver
);
2362 strcpyW(version_string
, cmd
);
2366 /* Can't use argc/argv as it will have stripped quotes from parameters
2367 * meaning cmd.exe /C echo "quoted string" is impossible
2369 cmdLine
= GetCommandLineW();
2370 WINE_TRACE("Full commandline '%s'\n", wine_dbgstr_w(cmdLine
));
2371 args
= 1; /* start at first arg, skipping cmd.exe itself */
2373 opt_c
= opt_k
= opt_q
= opt_s
= FALSE
;
2374 WCMD_parameter(cmdLine
, args
, &argPos
, TRUE
, TRUE
);
2375 while (argPos
&& argPos
[0] != 0x00)
2378 WINE_TRACE("Command line parm: '%s'\n", wine_dbgstr_w(argPos
));
2379 if (argPos
[0]!='/' || argPos
[1]=='\0') {
2381 WCMD_parameter(cmdLine
, args
, &argPos
, TRUE
, TRUE
);
2386 if (tolowerW(c
)=='c') {
2388 } else if (tolowerW(c
)=='q') {
2390 } else if (tolowerW(c
)=='k') {
2392 } else if (tolowerW(c
)=='s') {
2394 } else if (tolowerW(c
)=='a') {
2395 unicodeOutput
= FALSE
;
2396 } else if (tolowerW(c
)=='u') {
2397 unicodeOutput
= TRUE
;
2398 } else if (tolowerW(c
)=='v' && argPos
[2]==':') {
2399 delayedsubst
= strncmpiW(&argPos
[3], offW
, 3);
2400 if (delayedsubst
) WINE_TRACE("Delayed substitution is on\n");
2401 } else if (tolowerW(c
)=='t' && argPos
[2]==':') {
2402 opt_t
=strtoulW(&argPos
[3], NULL
, 16);
2403 } else if (tolowerW(c
)=='x' || tolowerW(c
)=='y') {
2404 /* Ignored for compatibility with Windows */
2407 if (argPos
[2]==0 || argPos
[2]==' ' || argPos
[2]=='\t' ||
2410 WCMD_parameter(cmdLine
, args
, &argPos
, TRUE
, TRUE
);
2412 else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
2414 /* Do not step to next parameter, instead carry on parsing this one */
2418 if (opt_c
|| opt_k
) /* break out of parsing immediately after c or k */
2426 /* Until we start to read from the keyboard, stay as non-interactive */
2427 interactive
= FALSE
;
2429 if (opt_c
|| opt_k
) {
2431 WCHAR
*q1
= NULL
,*q2
= NULL
,*p
;
2433 /* Handle very edge case error scenario, "cmd.exe /c" ie when there are no
2434 * parameters after the /C or /K by pretending there was a single space */
2435 if (argPos
== NULL
) argPos
= (WCHAR
*)spaceW
;
2438 cmd
= heap_strdupW(argPos
);
2440 /* opt_s left unflagged if the command starts with and contains exactly
2441 * one quoted string (exactly two quote characters). The quoted string
2442 * must be an executable name that has whitespace and must not have the
2443 * following characters: &<>()@^| */
2446 /* 1. Confirm there is at least one quote */
2447 q1
= strchrW(argPos
, '"');
2452 /* 2. Confirm there is a second quote */
2453 q2
= strchrW(q1
+1, '"');
2458 /* 3. Ensure there are no more quotes */
2459 if (strchrW(q2
+1, '"')) opt_s
=1;
2462 /* check first parameter for a space and invalid characters. There must not be any
2463 * invalid characters, but there must be one or more whitespace */
2468 if (*p
=='&' || *p
=='<' || *p
=='>' || *p
=='(' || *p
==')'
2469 || *p
=='@' || *p
=='^' || *p
=='|') {
2473 if (*p
==' ' || *p
=='\t')
2479 WINE_TRACE("/c command line: '%s'\n", wine_dbgstr_w(cmd
));
2481 /* Finally, we only stay in new mode IF the first parameter is quoted and
2482 is a valid executable, i.e. must exist, otherwise drop back to old mode */
2484 WCHAR
*thisArg
= WCMD_parameter(cmd
, 0, NULL
, FALSE
, TRUE
);
2485 WCHAR pathext
[MAXSTRING
];
2488 /* Now extract PATHEXT */
2489 len
= GetEnvironmentVariableW(envPathExt
, pathext
, sizeof(pathext
)/sizeof(WCHAR
));
2490 if ((len
== 0) || (len
>= (sizeof(pathext
)/sizeof(WCHAR
)))) {
2491 strcpyW (pathext
, dfltPathExt
);
2494 /* If the supplied parameter has any directory information, look there */
2495 WINE_TRACE("First parameter is '%s'\n", wine_dbgstr_w(thisArg
));
2496 if (strchrW(thisArg
, '\\') != NULL
) {
2498 GetFullPathNameW(thisArg
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
);
2499 WINE_TRACE("Full path name '%s'\n", wine_dbgstr_w(string
));
2500 p
= string
+ strlenW(string
);
2502 /* Does file exist with this name? */
2503 if (GetFileAttributesW(string
) != INVALID_FILE_ATTRIBUTES
) {
2504 WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string
));
2507 WCHAR
*thisExt
= pathext
;
2509 /* No - try with each of the PATHEXT extensions */
2510 while (!found
&& thisExt
) {
2511 WCHAR
*nextExt
= strchrW(thisExt
, ';');
2514 memcpy(p
, thisExt
, (nextExt
-thisExt
) * sizeof(WCHAR
));
2515 p
[(nextExt
-thisExt
)] = 0x00;
2516 thisExt
= nextExt
+1;
2518 strcpyW(p
, thisExt
);
2522 /* Does file exist with this extension appended? */
2523 if (GetFileAttributesW(string
) != INVALID_FILE_ATTRIBUTES
) {
2524 WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string
));
2530 /* Otherwise we now need to look in the path to see if we can find it */
2532 p
= thisArg
+ strlenW(thisArg
);
2534 /* Does file exist with this name? */
2535 if (SearchPathW(NULL
, thisArg
, NULL
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
) != 0) {
2536 WINE_TRACE("Found on path as '%s'\n", wine_dbgstr_w(string
));
2539 WCHAR
*thisExt
= pathext
;
2541 /* No - try with each of the PATHEXT extensions */
2542 while (!found
&& thisExt
) {
2543 WCHAR
*nextExt
= strchrW(thisExt
, ';');
2547 nextExt
= nextExt
+1;
2552 /* Does file exist with this extension? */
2553 if (SearchPathW(NULL
, thisArg
, thisExt
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
) != 0) {
2554 WINE_TRACE("Found on path as '%s' with extension '%s'\n", wine_dbgstr_w(string
),
2555 wine_dbgstr_w(thisExt
));
2563 /* If not found, drop back to old behaviour */
2565 WINE_TRACE("Binary not found, dropping back to old behaviour\n");
2571 /* strip first and last quote characters if opt_s; check for invalid
2572 * executable is done later */
2573 if (opt_s
&& *cmd
=='\"')
2574 WCMD_strip_quotes(cmd
);
2577 /* Save cwd into appropriate env var (Must be before the /c processing */
2578 GetCurrentDirectoryW(sizeof(string
)/sizeof(WCHAR
), string
);
2579 if (IsCharAlphaW(string
[0]) && string
[1] == ':') {
2580 static const WCHAR fmt
[] = {'=','%','c',':','\0'};
2581 wsprintfW(envvar
, fmt
, string
[0]);
2582 SetEnvironmentVariableW(envvar
, string
);
2583 WINE_TRACE("Set %s to %s\n", wine_dbgstr_w(envvar
), wine_dbgstr_w(string
));
2587 /* If we do a "cmd /c command", we don't want to allocate a new
2588 * console since the command returns immediately. Rather, we use
2589 * the currently allocated input and output handles. This allows
2590 * us to pipe to and read from the command interpreter.
2593 /* Parse the command string, without reading any more input */
2594 WCMD_ReadAndParseLine(cmd
, &toExecute
, INVALID_HANDLE_VALUE
);
2595 WCMD_process_commands(toExecute
, FALSE
, FALSE
);
2596 WCMD_free_commands(toExecute
);
2603 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), ENABLE_LINE_INPUT
|
2604 ENABLE_ECHO_INPUT
| ENABLE_PROCESSED_INPUT
);
2605 SetConsoleTitleW(WCMD_LoadMessage(WCMD_CONSTITLE
));
2607 /* Note: cmd.exe /c dir does not get a new color, /k dir does */
2609 if (!(((opt_t
& 0xF0) >> 4) == (opt_t
& 0x0F))) {
2610 defaultColor
= opt_t
& 0xFF;
2615 /* Check HKCU\Software\Microsoft\Command Processor
2616 Then HKLM\Software\Microsoft\Command Processor
2617 for defaultcolour value
2618 Note Can be supplied as DWORD or REG_SZ
2619 Note2 When supplied as REG_SZ it's in decimal!!! */
2622 DWORD value
=0, size
=4;
2623 static const WCHAR regKeyW
[] = {'S','o','f','t','w','a','r','e','\\',
2624 'M','i','c','r','o','s','o','f','t','\\',
2625 'C','o','m','m','a','n','d',' ','P','r','o','c','e','s','s','o','r','\0'};
2626 static const WCHAR dfltColorW
[] = {'D','e','f','a','u','l','t','C','o','l','o','r','\0'};
2628 if (RegOpenKeyExW(HKEY_CURRENT_USER
, regKeyW
,
2629 0, KEY_READ
, &key
) == ERROR_SUCCESS
) {
2632 /* See if DWORD or REG_SZ */
2633 if (RegQueryValueExW(key
, dfltColorW
, NULL
, &type
,
2634 NULL
, NULL
) == ERROR_SUCCESS
) {
2635 if (type
== REG_DWORD
) {
2636 size
= sizeof(DWORD
);
2637 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2638 (LPBYTE
)&value
, &size
);
2639 } else if (type
== REG_SZ
) {
2640 size
= sizeof(strvalue
)/sizeof(WCHAR
);
2641 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2642 (LPBYTE
)strvalue
, &size
);
2643 value
= strtoulW(strvalue
, NULL
, 10);
2649 if (value
== 0 && RegOpenKeyExW(HKEY_LOCAL_MACHINE
, regKeyW
,
2650 0, KEY_READ
, &key
) == ERROR_SUCCESS
) {
2653 /* See if DWORD or REG_SZ */
2654 if (RegQueryValueExW(key
, dfltColorW
, NULL
, &type
,
2655 NULL
, NULL
) == ERROR_SUCCESS
) {
2656 if (type
== REG_DWORD
) {
2657 size
= sizeof(DWORD
);
2658 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2659 (LPBYTE
)&value
, &size
);
2660 } else if (type
== REG_SZ
) {
2661 size
= sizeof(strvalue
)/sizeof(WCHAR
);
2662 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2663 (LPBYTE
)strvalue
, &size
);
2664 value
= strtoulW(strvalue
, NULL
, 10);
2670 /* If one found, set the screen to that colour */
2671 if (!(((value
& 0xF0) >> 4) == (value
& 0x0F))) {
2672 defaultColor
= value
& 0xFF;
2680 /* Parse the command string, without reading any more input */
2681 WCMD_ReadAndParseLine(cmd
, &toExecute
, INVALID_HANDLE_VALUE
);
2682 WCMD_process_commands(toExecute
, FALSE
, FALSE
);
2683 WCMD_free_commands(toExecute
);
2689 * Loop forever getting commands and executing them.
2692 SetEnvironmentVariableW(promptW
, defaultpromptW
);
2694 if (!opt_k
) WCMD_version ();
2697 /* Read until EOF (which for std input is never, but if redirect
2698 in place, may occur */
2699 if (echo_mode
) WCMD_show_prompt();
2700 if (!WCMD_ReadAndParseLine(NULL
, &toExecute
, GetStdHandle(STD_INPUT_HANDLE
)))
2702 WCMD_process_commands(toExecute
, FALSE
, FALSE
);
2703 WCMD_free_commands(toExecute
);