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
500 * Returns the location of the final quote
502 WCHAR
*WCMD_strip_quotes(WCHAR
*cmd
) {
503 WCHAR
*src
= cmd
+ 1, *dest
= cmd
, *lastq
= NULL
, *lastquote
;
504 while((*dest
=*src
) != '\0') {
512 while ((*dest
++=*lastq
++) != 0)
519 /*************************************************************************
520 * WCMD_is_magic_envvar
521 * Return TRUE if s is '%'magicvar'%'
522 * and is not masked by a real environment variable.
525 static inline BOOL
WCMD_is_magic_envvar(const WCHAR
*s
, const WCHAR
*magicvar
)
530 return FALSE
; /* Didn't begin with % */
532 if (len
< 2 || s
[len
-1] != '%')
533 return FALSE
; /* Didn't end with another % */
535 if (CompareStringW(LOCALE_USER_DEFAULT
,
536 NORM_IGNORECASE
| SORT_STRINGSORT
,
537 s
+1, len
-2, magicvar
, -1) != CSTR_EQUAL
) {
538 /* Name doesn't match. */
542 if (GetEnvironmentVariableW(magicvar
, NULL
, 0) > 0) {
543 /* Masked by real environment variable. */
550 /*************************************************************************
553 * Expands environment variables, allowing for WCHARacter substitution
555 static WCHAR
*WCMD_expand_envvar(WCHAR
*start
, WCHAR startchar
)
557 WCHAR
*endOfVar
= NULL
, *s
;
558 WCHAR
*colonpos
= NULL
;
559 WCHAR thisVar
[MAXSTRING
];
560 WCHAR thisVarContents
[MAXSTRING
];
561 WCHAR savedchar
= 0x00;
564 static const WCHAR ErrorLvl
[] = {'E','R','R','O','R','L','E','V','E','L','\0'};
565 static const WCHAR Date
[] = {'D','A','T','E','\0'};
566 static const WCHAR Time
[] = {'T','I','M','E','\0'};
567 static const WCHAR Cd
[] = {'C','D','\0'};
568 static const WCHAR Random
[] = {'R','A','N','D','O','M','\0'};
569 WCHAR Delims
[] = {'%',':','\0'}; /* First char gets replaced appropriately */
571 WINE_TRACE("Expanding: %s (%c)\n", wine_dbgstr_w(start
), startchar
);
573 /* Find the end of the environment variable, and extract name */
574 Delims
[0] = startchar
;
575 endOfVar
= strpbrkW(start
+1, Delims
);
577 if (endOfVar
== NULL
|| *endOfVar
==' ') {
579 /* In batch program, missing terminator for % and no following
580 ':' just removes the '%' */
582 WCMD_strsubstW(start
, start
+ 1, NULL
, 0);
586 /* In command processing, just ignore it - allows command line
587 syntax like: for %i in (a.a) do echo %i */
592 /* If ':' found, process remaining up until '%' (or stop at ':' if
594 if (*endOfVar
==':') {
595 WCHAR
*endOfVar2
= strchrW(endOfVar
+1, startchar
);
596 if (endOfVar2
!= NULL
) endOfVar
= endOfVar2
;
599 memcpy(thisVar
, start
, ((endOfVar
- start
) + 1) * sizeof(WCHAR
));
600 thisVar
[(endOfVar
- start
)+1] = 0x00;
601 colonpos
= strchrW(thisVar
+1, ':');
603 /* If there's complex substitution, just need %var% for now
604 to get the expanded data to play with */
606 *colonpos
= startchar
;
607 savedchar
= *(colonpos
+1);
608 *(colonpos
+1) = 0x00;
611 /* By now, we know the variable we want to expand but it may be
612 surrounded by '!' if we are in delayed expansion - if so convert
614 if (startchar
=='!') {
616 thisVar
[(endOfVar
- start
)] = '%';
618 WINE_TRACE("Retrieving contents of %s\n", wine_dbgstr_w(thisVar
));
620 /* Expand to contents, if unchanged, return */
621 /* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
622 /* override if existing env var called that name */
623 if (WCMD_is_magic_envvar(thisVar
, ErrorLvl
)) {
624 static const WCHAR fmt
[] = {'%','d','\0'};
625 wsprintfW(thisVarContents
, fmt
, errorlevel
);
626 len
= strlenW(thisVarContents
);
627 } else if (WCMD_is_magic_envvar(thisVar
, Date
)) {
628 GetDateFormatW(LOCALE_USER_DEFAULT
, DATE_SHORTDATE
, NULL
,
629 NULL
, thisVarContents
, MAXSTRING
);
630 len
= strlenW(thisVarContents
);
631 } else if (WCMD_is_magic_envvar(thisVar
, Time
)) {
632 GetTimeFormatW(LOCALE_USER_DEFAULT
, TIME_NOSECONDS
, NULL
,
633 NULL
, thisVarContents
, MAXSTRING
);
634 len
= strlenW(thisVarContents
);
635 } else if (WCMD_is_magic_envvar(thisVar
, Cd
)) {
636 GetCurrentDirectoryW(MAXSTRING
, thisVarContents
);
637 len
= strlenW(thisVarContents
);
638 } else if (WCMD_is_magic_envvar(thisVar
, Random
)) {
639 static const WCHAR fmt
[] = {'%','d','\0'};
640 wsprintfW(thisVarContents
, fmt
, rand() % 32768);
641 len
= strlenW(thisVarContents
);
644 len
= ExpandEnvironmentStringsW(thisVar
, thisVarContents
,
645 sizeof(thisVarContents
)/sizeof(WCHAR
));
651 /* In a batch program, unknown env vars are replaced with nothing,
652 note syntax %garbage:1,3% results in anything after the ':'
654 From the command line, you just get back what you entered */
655 if (lstrcmpiW(thisVar
, thisVarContents
) == 0) {
657 /* Restore the complex part after the compare */
660 *(colonpos
+1) = savedchar
;
663 /* Command line - just ignore this */
664 if (context
== NULL
) return endOfVar
+1;
667 /* Batch - replace unknown env var with nothing */
668 if (colonpos
== NULL
) {
669 WCMD_strsubstW(start
, endOfVar
+ 1, NULL
, 0);
671 len
= strlenW(thisVar
);
672 thisVar
[len
-1] = 0x00;
673 /* If %:...% supplied, : is retained */
674 if (colonpos
== thisVar
+1) {
675 WCMD_strsubstW(start
, endOfVar
+ 1, colonpos
, -1);
677 WCMD_strsubstW(start
, endOfVar
+ 1, colonpos
+ 1, -1);
684 /* See if we need to do complex substitution (any ':'s), if not
685 then our work here is done */
686 if (colonpos
== NULL
) {
687 WCMD_strsubstW(start
, endOfVar
+ 1, thisVarContents
, -1);
691 /* Restore complex bit */
693 *(colonpos
+1) = savedchar
;
696 Handle complex substitutions:
697 xxx=yyy (replace xxx with yyy)
698 *xxx=yyy (replace up to and including xxx with yyy)
699 ~x (from x WCHARs in)
700 ~-x (from x WCHARs from the end)
701 ~x,y (from x WCHARs in for y WCHARacters)
702 ~x,-y (from x WCHARs in until y WCHARacters from the end)
705 /* ~ is substring manipulation */
706 if (savedchar
== '~') {
708 int substrposition
, substrlength
= 0;
709 WCHAR
*commapos
= strchrW(colonpos
+2, ',');
712 substrposition
= atolW(colonpos
+2);
713 if (commapos
) substrlength
= atolW(commapos
+1);
716 if (substrposition
>= 0) {
717 startCopy
= &thisVarContents
[min(substrposition
, len
)];
719 startCopy
= &thisVarContents
[max(0, len
+substrposition
-1)];
722 if (commapos
== NULL
) {
724 WCMD_strsubstW(start
, endOfVar
+ 1, startCopy
, -1);
725 } else if (substrlength
< 0) {
727 int copybytes
= (len
+substrlength
-1)-(startCopy
-thisVarContents
);
728 if (copybytes
> len
) copybytes
= len
;
729 else if (copybytes
< 0) copybytes
= 0;
730 WCMD_strsubstW(start
, endOfVar
+ 1, startCopy
, copybytes
);
732 substrlength
= min(substrlength
, len
- (startCopy
- thisVarContents
+ 1));
733 WCMD_strsubstW(start
, endOfVar
+ 1, startCopy
, substrlength
);
736 /* search and replace manipulation */
738 WCHAR
*equalspos
= strstrW(colonpos
, equalW
);
739 WCHAR
*replacewith
= equalspos
+1;
744 if (equalspos
== NULL
) return start
+1;
745 s
= heap_strdupW(endOfVar
+ 1);
747 /* Null terminate both strings */
748 thisVar
[strlenW(thisVar
)-1] = 0x00;
751 /* Since we need to be case insensitive, copy the 2 buffers */
752 searchIn
= heap_strdupW(thisVarContents
);
753 CharUpperBuffW(searchIn
, strlenW(thisVarContents
));
754 searchFor
= heap_strdupW(colonpos
+1);
755 CharUpperBuffW(searchFor
, strlenW(colonpos
+1));
757 /* Handle wildcard case */
758 if (*(colonpos
+1) == '*') {
759 /* Search for string to replace */
760 found
= strstrW(searchIn
, searchFor
+1);
764 strcpyW(start
, replacewith
);
765 strcatW(start
, thisVarContents
+ (found
-searchIn
) + strlenW(searchFor
+1));
769 strcpyW(start
, thisVarContents
);
774 /* Loop replacing all instances */
775 WCHAR
*lastFound
= searchIn
;
776 WCHAR
*outputposn
= start
;
779 while ((found
= strstrW(lastFound
, searchFor
))) {
780 lstrcpynW(outputposn
,
781 thisVarContents
+ (lastFound
-searchIn
),
782 (found
- lastFound
)+1);
783 outputposn
= outputposn
+ (found
- lastFound
);
784 strcatW(outputposn
, replacewith
);
785 outputposn
= outputposn
+ strlenW(replacewith
);
786 lastFound
= found
+ strlenW(searchFor
);
789 thisVarContents
+ (lastFound
-searchIn
));
790 strcatW(outputposn
, s
);
794 heap_free(searchFor
);
799 /*****************************************************************************
800 * Expand the command. Native expands lines from batch programs as they are
801 * read in and not again, except for 'for' variable substitution.
802 * eg. As evidence, "echo %1 && shift && echo %1" or "echo %%path%%"
803 * atExecute is TRUE when the expansion is occurring as the command is executed
804 * rather than at parse time, i.e. delayed expansion and for loops need to be
807 static void handleExpansion(WCHAR
*cmd
, BOOL atExecute
, BOOL delayed
) {
809 /* For commands in a context (batch program): */
810 /* Expand environment variables in a batch file %{0-9} first */
811 /* including support for any ~ modifiers */
813 /* Expand the DATE, TIME, CD, RANDOM and ERRORLEVEL special */
814 /* names allowing environment variable overrides */
815 /* NOTE: To support the %PATH:xxx% syntax, also perform */
816 /* manual expansion of environment variables here */
821 WCHAR
*delayedp
= NULL
;
822 WCHAR startchar
= '%';
825 /* Display the FOR variables in effect */
827 if (forloopcontext
.variable
[i
]) {
828 WINE_TRACE("FOR variable context: %c = '%s'\n",
829 i
<26?i
+'a':(i
-26)+'A',
830 wine_dbgstr_w(forloopcontext
.variable
[i
]));
834 /* Find the next environment variable delimiter */
835 normalp
= strchrW(p
, '%');
836 if (delayed
) delayedp
= strchrW(p
, '!');
837 if (!normalp
) p
= delayedp
;
838 else if (!delayedp
) p
= normalp
;
839 else p
= min(p
,delayedp
);
840 if (p
) startchar
= *p
;
844 WINE_TRACE("Translate command:%s %d (at: %s)\n",
845 wine_dbgstr_w(cmd
), atExecute
, wine_dbgstr_w(p
));
848 /* Don't touch %% unless its in Batch */
849 if (!atExecute
&& *(p
+1) == startchar
) {
851 WCMD_strsubstW(p
, p
+1, NULL
, 0);
855 /* Replace %~ modifications if in batch program */
856 } else if (*(p
+1) == '~') {
857 WCMD_HandleTildaModifiers(&p
, atExecute
);
860 /* Replace use of %0...%9 if in batch program*/
861 } else if (!atExecute
&& context
&& (i
>= 0) && (i
<= 9) && startchar
== '%') {
862 t
= WCMD_parameter(context
-> command
, i
+ context
-> shift_count
[i
],
864 WCMD_strsubstW(p
, p
+2, t
, -1);
866 /* Replace use of %* if in batch program*/
867 } else if (!atExecute
&& context
&& *(p
+1)=='*' && startchar
== '%') {
868 WCHAR
*startOfParms
= NULL
;
869 WCHAR
*thisParm
= WCMD_parameter(context
-> command
, 0, &startOfParms
, TRUE
, TRUE
);
870 if (startOfParms
!= NULL
) {
871 startOfParms
+= strlenW(thisParm
);
872 while (*startOfParms
==' ' || *startOfParms
== '\t') startOfParms
++;
873 WCMD_strsubstW(p
, p
+2, startOfParms
, -1);
875 WCMD_strsubstW(p
, p
+2, NULL
, 0);
878 int forvaridx
= FOR_VAR_IDX(*(p
+1));
879 if (startchar
== '%' && forvaridx
!= -1 && forloopcontext
.variable
[forvaridx
]) {
880 /* Replace the 2 characters, % and for variable character */
881 WCMD_strsubstW(p
, p
+ 2, forloopcontext
.variable
[forvaridx
], -1);
882 } else if (!atExecute
|| (atExecute
&& startchar
== '!')) {
883 p
= WCMD_expand_envvar(p
, startchar
);
885 /* In a FOR loop, see if this is the variable to replace */
886 } else { /* Ignore %'s on second pass of batch program */
891 /* Find the next environment variable delimiter */
892 normalp
= strchrW(p
, '%');
893 if (delayed
) delayedp
= strchrW(p
, '!');
894 if (!normalp
) p
= delayedp
;
895 else if (!delayedp
) p
= normalp
;
896 else p
= min(p
,delayedp
);
897 if (p
) startchar
= *p
;
904 /*******************************************************************
905 * WCMD_parse - parse a command into parameters and qualifiers.
907 * On exit, all qualifiers are concatenated into q, the first string
908 * not beginning with "/" is in p1 and the
909 * second in p2. Any subsequent non-qualifier strings are lost.
910 * Parameters in quotes are handled.
912 static void WCMD_parse (const WCHAR
*s
, WCHAR
*q
, WCHAR
*p1
, WCHAR
*p2
)
916 *q
= *p1
= *p2
= '\0';
921 while ((*s
!= '\0') && (*s
!= ' ') && *s
!= '/') {
922 *q
++ = toupperW (*s
++);
932 while ((*s
!= '\0') && (*s
!= '"')) {
933 if (p
== 0) *p1
++ = *s
++;
934 else if (p
== 1) *p2
++ = *s
++;
937 if (p
== 0) *p1
= '\0';
938 if (p
== 1) *p2
= '\0';
945 while ((*s
!= '\0') && (*s
!= ' ') && (*s
!= '\t')
946 && (*s
!= '=') && (*s
!= ',') ) {
947 if (p
== 0) *p1
++ = *s
++;
948 else if (p
== 1) *p2
++ = *s
++;
951 /* Skip concurrent parms */
952 while ((*s
== ' ') || (*s
== '\t') || (*s
== '=') || (*s
== ',') ) s
++;
954 if (p
== 0) *p1
= '\0';
955 if (p
== 1) *p2
= '\0';
961 static void init_msvcrt_io_block(STARTUPINFOW
* st
)
964 /* fetch the parent MSVCRT info block if any, so that the child can use the
965 * same handles as its grand-father
967 st_p
.cb
= sizeof(STARTUPINFOW
);
968 GetStartupInfoW(&st_p
);
969 st
->cbReserved2
= st_p
.cbReserved2
;
970 st
->lpReserved2
= st_p
.lpReserved2
;
971 if (st_p
.cbReserved2
&& st_p
.lpReserved2
)
973 unsigned num
= *(unsigned*)st_p
.lpReserved2
;
979 /* Override the entries for fd 0,1,2 if we happened
980 * to change those std handles (this depends on the way cmd sets
981 * its new input & output handles)
983 sz
= max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE
)) * 3, st_p
.cbReserved2
);
984 ptr
= heap_alloc(sz
);
985 flags
= (char*)(ptr
+ sizeof(unsigned));
986 handles
= (HANDLE
*)(flags
+ num
* sizeof(char));
988 memcpy(ptr
, st_p
.lpReserved2
, st_p
.cbReserved2
);
989 st
->cbReserved2
= sz
;
990 st
->lpReserved2
= ptr
;
992 #define WX_OPEN 0x01 /* see dlls/msvcrt/file.c */
993 if (num
<= 0 || (flags
[0] & WX_OPEN
))
995 handles
[0] = GetStdHandle(STD_INPUT_HANDLE
);
998 if (num
<= 1 || (flags
[1] & WX_OPEN
))
1000 handles
[1] = GetStdHandle(STD_OUTPUT_HANDLE
);
1001 flags
[1] |= WX_OPEN
;
1003 if (num
<= 2 || (flags
[2] & WX_OPEN
))
1005 handles
[2] = GetStdHandle(STD_ERROR_HANDLE
);
1006 flags
[2] |= WX_OPEN
;
1012 /******************************************************************************
1015 * Execute a command line as an external program. Must allow recursion.
1018 * Manual testing under windows shows PATHEXT plays a key part in this,
1019 * and the search algorithm and precedence appears to be as follows.
1022 * If directory supplied on command, just use that directory
1023 * If extension supplied on command, look for that explicit name first
1024 * Otherwise, search in each directory on the path
1026 * If extension supplied on command, look for that explicit name first
1027 * Then look for supplied name .* (even if extension supplied, so
1028 * 'garbage.exe' will match 'garbage.exe.cmd')
1029 * If any found, cycle through PATHEXT looking for name.exe one by one
1031 * Once a match has been found, it is launched - Code currently uses
1032 * findexecutable to achieve this which is left untouched.
1033 * If an executable has not been found, and we were launched through
1034 * a call, we need to check if the command is an internal command,
1035 * so go back through wcmd_execute.
1038 void WCMD_run_program (WCHAR
*command
, BOOL called
)
1040 WCHAR temp
[MAX_PATH
];
1041 WCHAR pathtosearch
[MAXSTRING
];
1043 WCHAR stemofsearch
[MAX_PATH
]; /* maximum allowed executable name is
1044 MAX_PATH, including null character */
1046 WCHAR pathext
[MAXSTRING
];
1048 BOOL extensionsupplied
= FALSE
;
1049 BOOL launched
= FALSE
;
1052 static const WCHAR envPath
[] = {'P','A','T','H','\0'};
1053 static const WCHAR delims
[] = {'/','\\',':','\0'};
1055 /* Quick way to get the filename is to extract the first argument. */
1056 WINE_TRACE("Running '%s' (%d)\n", wine_dbgstr_w(command
), called
);
1057 firstParam
= WCMD_parameter(command
, 0, NULL
, FALSE
, TRUE
);
1058 if (!firstParam
) return;
1060 /* Calculate the search path and stem to search for */
1061 if (strpbrkW (firstParam
, delims
) == NULL
) { /* No explicit path given, search path */
1062 static const WCHAR curDir
[] = {'.',';','\0'};
1063 strcpyW(pathtosearch
, curDir
);
1064 len
= GetEnvironmentVariableW(envPath
, &pathtosearch
[2], (sizeof(pathtosearch
)/sizeof(WCHAR
))-2);
1065 if ((len
== 0) || (len
>= (sizeof(pathtosearch
)/sizeof(WCHAR
)) - 2)) {
1066 static const WCHAR curDir
[] = {'.','\0'};
1067 strcpyW (pathtosearch
, curDir
);
1069 if (strchrW(firstParam
, '.') != NULL
) extensionsupplied
= TRUE
;
1070 if (strlenW(firstParam
) >= MAX_PATH
)
1072 WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_LINETOOLONG
));
1076 strcpyW(stemofsearch
, firstParam
);
1080 /* Convert eg. ..\fred to include a directory by removing file part */
1081 GetFullPathNameW(firstParam
, sizeof(pathtosearch
)/sizeof(WCHAR
), pathtosearch
, NULL
);
1082 lastSlash
= strrchrW(pathtosearch
, '\\');
1083 if (lastSlash
&& strchrW(lastSlash
, '.') != NULL
) extensionsupplied
= TRUE
;
1084 strcpyW(stemofsearch
, lastSlash
+1);
1086 /* Reduce pathtosearch to a path with trailing '\' to support c:\a.bat and
1087 c:\windows\a.bat syntax */
1088 if (lastSlash
) *(lastSlash
+ 1) = 0x00;
1091 /* Now extract PATHEXT */
1092 len
= GetEnvironmentVariableW(envPathExt
, pathext
, sizeof(pathext
)/sizeof(WCHAR
));
1093 if ((len
== 0) || (len
>= (sizeof(pathext
)/sizeof(WCHAR
)))) {
1094 strcpyW (pathext
, dfltPathExt
);
1097 /* Loop through the search path, dir by dir */
1098 pathposn
= pathtosearch
;
1099 WINE_TRACE("Searching in '%s' for '%s'\n", wine_dbgstr_w(pathtosearch
),
1100 wine_dbgstr_w(stemofsearch
));
1101 while (!launched
&& pathposn
) {
1103 WCHAR thisDir
[MAX_PATH
] = {'\0'};
1107 /* Work on the first directory on the search path */
1108 pos
= strchrW(pathposn
, ';');
1110 memcpy(thisDir
, pathposn
, (pos
-pathposn
) * sizeof(WCHAR
));
1111 thisDir
[(pos
-pathposn
)] = 0x00;
1115 strcpyW(thisDir
, pathposn
);
1119 /* Since you can have eg. ..\.. on the path, need to expand
1120 to full information */
1121 strcpyW(temp
, thisDir
);
1122 GetFullPathNameW(temp
, MAX_PATH
, thisDir
, NULL
);
1124 /* 1. If extension supplied, see if that file exists */
1125 strcatW(thisDir
, slashW
);
1126 strcatW(thisDir
, stemofsearch
);
1127 pos
= &thisDir
[strlenW(thisDir
)]; /* Pos = end of name */
1129 /* 1. If extension supplied, see if that file exists */
1130 if (extensionsupplied
) {
1131 if (GetFileAttributesW(thisDir
) != INVALID_FILE_ATTRIBUTES
) {
1136 /* 2. Any .* matches? */
1139 WIN32_FIND_DATAW finddata
;
1140 static const WCHAR allFiles
[] = {'.','*','\0'};
1142 strcatW(thisDir
,allFiles
);
1143 h
= FindFirstFileW(thisDir
, &finddata
);
1145 if (h
!= INVALID_HANDLE_VALUE
) {
1147 WCHAR
*thisExt
= pathext
;
1149 /* 3. Yes - Try each path ext */
1151 WCHAR
*nextExt
= strchrW(thisExt
, ';');
1154 memcpy(pos
, thisExt
, (nextExt
-thisExt
) * sizeof(WCHAR
));
1155 pos
[(nextExt
-thisExt
)] = 0x00;
1156 thisExt
= nextExt
+1;
1158 strcpyW(pos
, thisExt
);
1162 if (GetFileAttributesW(thisDir
) != INVALID_FILE_ATTRIBUTES
) {
1170 /* Once found, launch it */
1173 PROCESS_INFORMATION pe
;
1177 WCHAR
*ext
= strrchrW( thisDir
, '.' );
1178 static const WCHAR batExt
[] = {'.','b','a','t','\0'};
1179 static const WCHAR cmdExt
[] = {'.','c','m','d','\0'};
1181 WINE_TRACE("Found as %s\n", wine_dbgstr_w(thisDir
));
1183 /* Special case BAT and CMD */
1184 if (ext
&& (!strcmpiW(ext
, batExt
) || !strcmpiW(ext
, cmdExt
))) {
1185 BOOL oldinteractive
= interactive
;
1186 interactive
= FALSE
;
1187 WCMD_batch (thisDir
, command
, called
, NULL
, INVALID_HANDLE_VALUE
);
1188 interactive
= oldinteractive
;
1192 /* thisDir contains the file to be launched, but with what?
1193 eg. a.exe will require a.exe to be launched, a.html may be iexplore */
1194 hinst
= FindExecutableW (thisDir
, NULL
, temp
);
1195 if ((INT_PTR
)hinst
< 32)
1198 console
= SHGetFileInfoW(temp
, 0, &psfi
, sizeof(psfi
), SHGFI_EXETYPE
);
1200 ZeroMemory (&st
, sizeof(STARTUPINFOW
));
1201 st
.cb
= sizeof(STARTUPINFOW
);
1202 init_msvcrt_io_block(&st
);
1204 /* Launch the process and if a CUI wait on it to complete
1205 Note: Launching internal wine processes cannot specify a full path to exe */
1206 status
= CreateProcessW(thisDir
,
1207 command
, NULL
, NULL
, TRUE
, 0, NULL
, NULL
, &st
, &pe
);
1208 heap_free(st
.lpReserved2
);
1209 if ((opt_c
|| opt_k
) && !opt_s
&& !status
1210 && GetLastError()==ERROR_FILE_NOT_FOUND
&& command
[0]=='\"') {
1211 /* strip first and last quote WCHARacters and try again */
1212 WCMD_strip_quotes(command
);
1214 WCMD_run_program(command
, called
);
1221 /* Always wait when non-interactive (cmd /c or in batch program),
1222 or for console applications */
1223 if (!interactive
|| (console
&& !HIWORD(console
)))
1224 WaitForSingleObject (pe
.hProcess
, INFINITE
);
1225 GetExitCodeProcess (pe
.hProcess
, &errorlevel
);
1226 if (errorlevel
== STILL_ACTIVE
) errorlevel
= 0;
1228 CloseHandle(pe
.hProcess
);
1229 CloseHandle(pe
.hThread
);
1235 /* Not found anywhere - were we called? */
1237 CMD_LIST
*toExecute
= NULL
; /* Commands left to be executed */
1239 /* Parse the command string, without reading any more input */
1240 WCMD_ReadAndParseLine(command
, &toExecute
, INVALID_HANDLE_VALUE
);
1241 WCMD_process_commands(toExecute
, FALSE
, called
);
1242 WCMD_free_commands(toExecute
);
1247 /* Not found anywhere - give up */
1248 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NO_COMMAND_FOUND
), command
);
1250 /* If a command fails to launch, it sets errorlevel 9009 - which
1251 does not seem to have any associated constant definition */
1257 /*****************************************************************************
1258 * Process one command. If the command is EXIT this routine does not return.
1259 * We will recurse through here executing batch files.
1260 * Note: If call is used to a non-existing program, we reparse the line and
1261 * try to run it as an internal command. 'retrycall' represents whether
1262 * we are attempting this retry.
1264 void WCMD_execute (const WCHAR
*command
, const WCHAR
*redirects
,
1265 CMD_LIST
**cmdList
, BOOL retrycall
)
1267 WCHAR
*cmd
, *p
, *redir
;
1269 DWORD count
, creationDisposition
;
1272 SECURITY_ATTRIBUTES sa
;
1273 WCHAR
*new_cmd
= NULL
;
1274 WCHAR
*new_redir
= NULL
;
1275 HANDLE old_stdhandles
[3] = {GetStdHandle (STD_INPUT_HANDLE
),
1276 GetStdHandle (STD_OUTPUT_HANDLE
),
1277 GetStdHandle (STD_ERROR_HANDLE
)};
1278 DWORD idx_stdhandles
[3] = {STD_INPUT_HANDLE
,
1281 BOOL prev_echo_mode
, piped
= FALSE
;
1283 WINE_TRACE("command on entry:%s (%p)\n",
1284 wine_dbgstr_w(command
), cmdList
);
1286 /* If the next command is a pipe then we implement pipes by redirecting
1287 the output from this command to a temp file and input into the
1288 next command from that temp file.
1289 FIXME: Use of named pipes would make more sense here as currently this
1290 process has to finish before the next one can start but this requires
1291 a change to not wait for the first app to finish but rather the pipe */
1292 if (cmdList
&& (*cmdList
)->nextcommand
&&
1293 (*cmdList
)->nextcommand
->prevDelim
== CMD_PIPE
) {
1295 WCHAR temp_path
[MAX_PATH
];
1296 static const WCHAR cmdW
[] = {'C','M','D','\0'};
1298 /* Remember piping is in action */
1299 WINE_TRACE("Output needs to be piped\n");
1302 /* Generate a unique temporary filename */
1303 GetTempPathW(sizeof(temp_path
)/sizeof(WCHAR
), temp_path
);
1304 GetTempFileNameW(temp_path
, cmdW
, 0, (*cmdList
)->nextcommand
->pipeFile
);
1305 WINE_TRACE("Using temporary file of %s\n",
1306 wine_dbgstr_w((*cmdList
)->nextcommand
->pipeFile
));
1309 /* Move copy of the command onto the heap so it can be expanded */
1310 new_cmd
= heap_alloc(MAXSTRING
* sizeof(WCHAR
));
1311 strcpyW(new_cmd
, command
);
1313 /* Move copy of the redirects onto the heap so it can be expanded */
1314 new_redir
= heap_alloc(MAXSTRING
* sizeof(WCHAR
));
1316 /* If piped output, send stdout to the pipe by appending >filename to redirects */
1318 static const WCHAR redirOut
[] = {'%','s',' ','>',' ','%','s','\0'};
1319 wsprintfW (new_redir
, redirOut
, redirects
, (*cmdList
)->nextcommand
->pipeFile
);
1320 WINE_TRACE("Redirects now %s\n", wine_dbgstr_w(new_redir
));
1322 strcpyW(new_redir
, redirects
);
1325 /* Expand variables in command line mode only (batch mode will
1326 be expanded as the line is read in, except for 'for' loops) */
1327 handleExpansion(new_cmd
, (context
!= NULL
), delayedsubst
);
1328 handleExpansion(new_redir
, (context
!= NULL
), delayedsubst
);
1332 * Changing default drive has to be handled as a special case.
1335 if ((cmd
[1] == ':') && IsCharAlphaW(cmd
[0]) && (strlenW(cmd
) == 2)) {
1337 WCHAR dir
[MAX_PATH
];
1339 /* According to MSDN CreateProcess docs, special env vars record
1340 the current directory on each drive, in the form =C:
1341 so see if one specified, and if so go back to it */
1342 strcpyW(envvar
, equalW
);
1343 strcatW(envvar
, cmd
);
1344 if (GetEnvironmentVariableW(envvar
, dir
, MAX_PATH
) == 0) {
1345 static const WCHAR fmt
[] = {'%','s','\\','\0'};
1346 wsprintfW(cmd
, fmt
, cmd
);
1347 WINE_TRACE("No special directory settings, using dir of %s\n", wine_dbgstr_w(cmd
));
1349 WINE_TRACE("Got directory %s as %s\n", wine_dbgstr_w(envvar
), wine_dbgstr_w(cmd
));
1350 status
= SetCurrentDirectoryW(cmd
);
1351 if (!status
) WCMD_print_error ();
1353 heap_free(new_redir
);
1357 sa
.nLength
= sizeof(sa
);
1358 sa
.lpSecurityDescriptor
= NULL
;
1359 sa
.bInheritHandle
= TRUE
;
1362 * Redirect stdin, stdout and/or stderr if required.
1365 /* STDIN could come from a preceding pipe, so delete on close if it does */
1366 if (cmdList
&& (*cmdList
)->pipeFile
[0] != 0x00) {
1367 WINE_TRACE("Input coming from %s\n", wine_dbgstr_w((*cmdList
)->pipeFile
));
1368 h
= CreateFileW((*cmdList
)->pipeFile
, GENERIC_READ
,
1369 FILE_SHARE_READ
, &sa
, OPEN_EXISTING
,
1370 FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_DELETE_ON_CLOSE
, NULL
);
1371 if (h
== INVALID_HANDLE_VALUE
) {
1372 WCMD_print_error ();
1374 heap_free(new_redir
);
1377 SetStdHandle (STD_INPUT_HANDLE
, h
);
1379 /* No need to remember the temporary name any longer once opened */
1380 (*cmdList
)->pipeFile
[0] = 0x00;
1382 /* Otherwise STDIN could come from a '<' redirect */
1383 } else if ((p
= strchrW(new_redir
,'<')) != NULL
) {
1384 h
= CreateFileW(WCMD_parameter(++p
, 0, NULL
, FALSE
, FALSE
), GENERIC_READ
, FILE_SHARE_READ
,
1385 &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1386 if (h
== INVALID_HANDLE_VALUE
) {
1387 WCMD_print_error ();
1389 heap_free(new_redir
);
1392 SetStdHandle (STD_INPUT_HANDLE
, h
);
1395 /* Scan the whole command looking for > and 2> */
1397 while (redir
!= NULL
&& ((p
= strchrW(redir
,'>')) != NULL
)) {
1400 if (p
> redir
&& (*(p
-1)=='2'))
1407 creationDisposition
= OPEN_ALWAYS
;
1411 creationDisposition
= CREATE_ALWAYS
;
1414 /* Add support for 2>&1 */
1417 int idx
= *(p
+1) - '0';
1419 if (DuplicateHandle(GetCurrentProcess(),
1420 GetStdHandle(idx_stdhandles
[idx
]),
1421 GetCurrentProcess(),
1423 0, TRUE
, DUPLICATE_SAME_ACCESS
) == 0) {
1424 WINE_FIXME("Duplicating handle failed with gle %d\n", GetLastError());
1426 WINE_TRACE("Redirect %d (%p) to %d (%p)\n", handle
, GetStdHandle(idx_stdhandles
[idx
]), idx
, h
);
1429 WCHAR
*param
= WCMD_parameter(p
, 0, NULL
, FALSE
, FALSE
);
1430 h
= CreateFileW(param
, GENERIC_WRITE
, 0, &sa
, creationDisposition
,
1431 FILE_ATTRIBUTE_NORMAL
, NULL
);
1432 if (h
== INVALID_HANDLE_VALUE
) {
1433 WCMD_print_error ();
1435 heap_free(new_redir
);
1438 if (SetFilePointer (h
, 0, NULL
, FILE_END
) ==
1439 INVALID_SET_FILE_POINTER
) {
1440 WCMD_print_error ();
1442 WINE_TRACE("Redirect %d to '%s' (%p)\n", handle
, wine_dbgstr_w(param
), h
);
1445 SetStdHandle (idx_stdhandles
[handle
], h
);
1449 * Strip leading whitespaces, and a '@' if supplied
1451 whichcmd
= WCMD_skip_leading_spaces(cmd
);
1452 WINE_TRACE("Command: '%s'\n", wine_dbgstr_w(cmd
));
1453 if (whichcmd
[0] == '@') whichcmd
++;
1456 * Check if the command entered is internal. If it is, pass the rest of the
1457 * line down to the command. If not try to run a program.
1461 while (IsCharAlphaNumericW(whichcmd
[count
])) {
1464 for (i
=0; i
<=WCMD_EXIT
; i
++) {
1465 if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1466 whichcmd
, count
, inbuilt
[i
], -1) == CSTR_EQUAL
) break;
1468 p
= WCMD_skip_leading_spaces (&whichcmd
[count
]);
1469 WCMD_parse (p
, quals
, param1
, param2
);
1470 WINE_TRACE("param1: %s, param2: %s\n", wine_dbgstr_w(param1
), wine_dbgstr_w(param2
));
1472 if (i
<= WCMD_EXIT
&& (p
[0] == '/') && (p
[1] == '?')) {
1473 /* this is a help request for a builtin program */
1475 memcpy(p
, whichcmd
, count
* sizeof(WCHAR
));
1487 WCMD_setshow_default (p
);
1490 WCMD_clear_screen ();
1499 WCMD_setshow_date ();
1509 WCMD_echo(&whichcmd
[count
]);
1512 WCMD_goto (cmdList
);
1518 WCMD_volume (TRUE
, p
);
1522 WCMD_create_dir (p
);
1528 WCMD_setshow_path (p
);
1534 WCMD_setshow_prompt ();
1544 WCMD_remove_dir (p
);
1553 WCMD_setshow_env (p
);
1562 WCMD_setshow_time ();
1565 if (strlenW(&whichcmd
[count
]) > 0)
1566 WCMD_title(&whichcmd
[count
+1]);
1572 WCMD_output_asis(newlineW
);
1579 WCMD_volume (FALSE
, p
);
1588 WCMD_assoc(p
, TRUE
);
1594 WCMD_assoc(p
, FALSE
);
1603 WCMD_exit (cmdList
);
1607 /* Very oddly, probably because of all the special parsing required for
1608 these two commands, neither for nor if are supported when called,
1609 ie call if 1==1... will fail. */
1611 if (i
==WCMD_FOR
) WCMD_for (p
, cmdList
);
1612 else if (i
==WCMD_IF
) WCMD_if (p
, cmdList
);
1615 /* else: drop through */
1617 prev_echo_mode
= echo_mode
;
1618 WCMD_run_program (whichcmd
, FALSE
);
1619 echo_mode
= prev_echo_mode
;
1622 heap_free(new_redir
);
1624 /* Restore old handles */
1625 for (i
=0; i
<3; i
++) {
1626 if (old_stdhandles
[i
] != GetStdHandle(idx_stdhandles
[i
])) {
1627 CloseHandle (GetStdHandle (idx_stdhandles
[i
]));
1628 SetStdHandle (idx_stdhandles
[i
], old_stdhandles
[i
]);
1633 /*************************************************************************
1635 * Load a string from the resource file, handling any error
1636 * Returns string retrieved from resource file
1638 WCHAR
*WCMD_LoadMessage(UINT id
) {
1639 static WCHAR msg
[2048];
1640 static const WCHAR failedMsg
[] = {'F','a','i','l','e','d','!','\0'};
1642 if (!LoadStringW(GetModuleHandleW(NULL
), id
, msg
, sizeof(msg
)/sizeof(WCHAR
))) {
1643 WINE_FIXME("LoadString failed with %d\n", GetLastError());
1644 strcpyW(msg
, failedMsg
);
1649 /***************************************************************************
1652 * Dumps out the parsed command line to ensure syntax is correct
1654 static void WCMD_DumpCommands(CMD_LIST
*commands
) {
1655 CMD_LIST
*thisCmd
= commands
;
1657 WINE_TRACE("Parsed line:\n");
1658 while (thisCmd
!= NULL
) {
1659 WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
1662 thisCmd
->bracketDepth
,
1663 thisCmd
->nextcommand
,
1664 wine_dbgstr_w(thisCmd
->command
),
1665 wine_dbgstr_w(thisCmd
->redirects
));
1666 thisCmd
= thisCmd
->nextcommand
;
1670 /***************************************************************************
1673 * Adds a command to the current command list
1675 static void WCMD_addCommand(WCHAR
*command
, int *commandLen
,
1676 WCHAR
*redirs
, int *redirLen
,
1677 WCHAR
**copyTo
, int **copyToLen
,
1678 CMD_DELIMITERS prevDelim
, int curDepth
,
1679 CMD_LIST
**lastEntry
, CMD_LIST
**output
) {
1681 CMD_LIST
*thisEntry
= NULL
;
1683 /* Allocate storage for command */
1684 thisEntry
= heap_alloc(sizeof(CMD_LIST
));
1686 /* Copy in the command */
1688 thisEntry
->command
= heap_alloc((*commandLen
+1) * sizeof(WCHAR
));
1689 memcpy(thisEntry
->command
, command
, *commandLen
* sizeof(WCHAR
));
1690 thisEntry
->command
[*commandLen
] = 0x00;
1692 /* Copy in the redirects */
1693 thisEntry
->redirects
= heap_alloc((*redirLen
+1) * sizeof(WCHAR
));
1694 memcpy(thisEntry
->redirects
, redirs
, *redirLen
* sizeof(WCHAR
));
1695 thisEntry
->redirects
[*redirLen
] = 0x00;
1696 thisEntry
->pipeFile
[0] = 0x00;
1698 /* Reset the lengths */
1701 *copyToLen
= commandLen
;
1705 thisEntry
->command
= NULL
;
1706 thisEntry
->redirects
= NULL
;
1707 thisEntry
->pipeFile
[0] = 0x00;
1710 /* Fill in other fields */
1711 thisEntry
->nextcommand
= NULL
;
1712 thisEntry
->prevDelim
= prevDelim
;
1713 thisEntry
->bracketDepth
= curDepth
;
1715 (*lastEntry
)->nextcommand
= thisEntry
;
1717 *output
= thisEntry
;
1719 *lastEntry
= thisEntry
;
1723 /***************************************************************************
1726 * Checks if the quote pointed to is the end-quote.
1730 * 1) The current parameter ends at EOL or at the beginning
1731 * of a redirection or pipe and not in a quote section.
1733 * 2) If the next character is a space and not in a quote section.
1735 * Returns TRUE if this is an end quote, and FALSE if it is not.
1738 static BOOL
WCMD_IsEndQuote(const WCHAR
*quote
, int quoteIndex
)
1740 int quoteCount
= quoteIndex
;
1743 /* If we are not in a quoted section, then we are not an end-quote */
1749 /* Check how many quotes are left for this parameter */
1750 for(i
=0;quote
[i
];i
++)
1757 /* Quote counting ends at EOL, redirection, space or pipe if current quote is complete */
1758 else if(((quoteCount
% 2) == 0)
1759 && ((quote
[i
] == '<') || (quote
[i
] == '>') || (quote
[i
] == '|') || (quote
[i
] == ' ')))
1765 /* If the quote is part of the last part of a series of quotes-on-quotes, then it must
1767 if(quoteIndex
>= (quoteCount
/ 2))
1776 /***************************************************************************
1777 * WCMD_ReadAndParseLine
1779 * Either uses supplied input or
1780 * Reads a file from the handle, and then...
1781 * Parse the text buffer, splitting into separate commands
1782 * - unquoted && strings split 2 commands but the 2nd is flagged as
1784 * - ( as the first character just ups the bracket depth
1785 * - unquoted ) when bracket depth > 0 terminates a bracket and
1786 * adds a CMD_LIST structure with null command
1787 * - Anything else gets put into the command string (including
1790 WCHAR
*WCMD_ReadAndParseLine(const WCHAR
*optionalcmd
, CMD_LIST
**output
, HANDLE readFrom
)
1794 WCHAR curString
[MAXSTRING
];
1795 int curStringLen
= 0;
1796 WCHAR curRedirs
[MAXSTRING
];
1797 int curRedirsLen
= 0;
1801 CMD_LIST
*lastEntry
= NULL
;
1802 CMD_DELIMITERS prevDelim
= CMD_NONE
;
1803 static WCHAR
*extraSpace
= NULL
; /* Deliberately never freed */
1804 static const WCHAR remCmd
[] = {'r','e','m'};
1805 static const WCHAR forCmd
[] = {'f','o','r'};
1806 static const WCHAR ifCmd
[] = {'i','f'};
1807 static const WCHAR ifElse
[] = {'e','l','s','e'};
1808 BOOL inOneLine
= FALSE
;
1813 BOOL onlyWhiteSpace
= FALSE
;
1814 BOOL lastWasWhiteSpace
= FALSE
;
1815 BOOL lastWasDo
= FALSE
;
1816 BOOL lastWasIn
= FALSE
;
1817 BOOL lastWasElse
= FALSE
;
1818 BOOL lastWasRedirect
= TRUE
;
1819 BOOL lastWasCaret
= FALSE
;
1821 /* Allocate working space for a command read from keyboard, file etc */
1823 extraSpace
= heap_alloc((MAXSTRING
+1) * sizeof(WCHAR
));
1826 WINE_ERR("Could not allocate memory for extraSpace\n");
1830 /* If initial command read in, use that, otherwise get input from handle */
1831 if (optionalcmd
!= NULL
) {
1832 strcpyW(extraSpace
, optionalcmd
);
1833 } else if (readFrom
== INVALID_HANDLE_VALUE
) {
1834 WINE_FIXME("No command nor handle supplied\n");
1836 if (!WCMD_fgets(extraSpace
, MAXSTRING
, readFrom
))
1839 curPos
= extraSpace
;
1841 /* Handle truncated input - issue warning */
1842 if (strlenW(extraSpace
) == MAXSTRING
-1) {
1843 WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_TRUNCATEDLINE
));
1844 WCMD_output_asis_stderr(extraSpace
);
1845 WCMD_output_asis_stderr(newlineW
);
1848 /* Replace env vars if in a batch context */
1849 if (context
) handleExpansion(extraSpace
, FALSE
, FALSE
);
1851 /* Skip preceding whitespace */
1852 while (*curPos
== ' ' || *curPos
== '\t') curPos
++;
1854 /* Show prompt before batch line IF echo is on and in batch program */
1855 if (context
&& echo_mode
&& *curPos
&& (*curPos
!= '@')) {
1856 static const WCHAR echoDot
[] = {'e','c','h','o','.'};
1857 static const WCHAR echoCol
[] = {'e','c','h','o',':'};
1858 const DWORD len
= sizeof(echoDot
)/sizeof(echoDot
[0]);
1859 DWORD curr_size
= strlenW(curPos
);
1860 DWORD min_len
= (curr_size
< len
? curr_size
: len
);
1862 WCMD_output_asis(curPos
);
1863 /* I don't know why Windows puts a space here but it does */
1864 /* Except for lines starting with 'echo.' or 'echo:'. Ask MS why */
1865 if (CompareStringW(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
1866 curPos
, min_len
, echoDot
, len
) != CSTR_EQUAL
1867 && CompareStringW(LOCALE_SYSTEM_DEFAULT
, NORM_IGNORECASE
,
1868 curPos
, min_len
, echoCol
, len
) != CSTR_EQUAL
)
1870 WCMD_output_asis(spaceW
);
1872 WCMD_output_asis(newlineW
);
1875 /* Skip repeated 'no echo' characters */
1876 while (*curPos
== '@') curPos
++;
1878 /* Start with an empty string, copying to the command string */
1881 curCopyTo
= curString
;
1882 curLen
= &curStringLen
;
1883 lastWasRedirect
= FALSE
; /* Required e.g. for spaces between > and filename */
1885 /* Parse every character on the line being processed */
1886 while (*curPos
!= 0x00) {
1891 WINE_TRACE("Looking at '%c' (len:%d, lws:%d, ows:%d)\n", *curPos, *curLen,
1892 lastWasWhiteSpace, onlyWhiteSpace);
1895 /* Prevent overflow caused by the caret escape char */
1896 if (*curLen
>= MAXSTRING
) {
1897 WINE_ERR("Overflow detected in command\n");
1901 /* Certain commands need special handling */
1902 if (curStringLen
== 0 && curCopyTo
== curString
) {
1903 static const WCHAR forDO
[] = {'d','o'};
1905 /* If command starts with 'rem ' or identifies a label, ignore any &&, ( etc. */
1906 if (WCMD_keyword_ws_found(remCmd
, sizeof(remCmd
)/sizeof(remCmd
[0]), curPos
) ||
1910 } else if (WCMD_keyword_ws_found(forCmd
, sizeof(forCmd
)/sizeof(forCmd
[0]), curPos
)) {
1913 /* If command starts with 'if ' or 'else ', handle ('s mid line. We should ensure this
1914 is only true in the command portion of the IF statement, but this
1915 should suffice for now
1916 FIXME: Silly syntax like "if 1(==1( (
1918 )" will be parsed wrong */
1919 } else if (WCMD_keyword_ws_found(ifCmd
, sizeof(ifCmd
)/sizeof(ifCmd
[0]), curPos
)) {
1922 } else if (WCMD_keyword_ws_found(ifElse
, sizeof(ifElse
)/sizeof(ifElse
[0]), curPos
)) {
1923 const int keyw_len
= sizeof(ifElse
)/sizeof(ifElse
[0]) + 1;
1926 onlyWhiteSpace
= TRUE
;
1927 memcpy(&curCopyTo
[*curLen
], curPos
, keyw_len
*sizeof(WCHAR
));
1928 (*curLen
)+=keyw_len
;
1932 /* In a for loop, the DO command will follow a close bracket followed by
1933 whitespace, followed by DO, ie closeBracket inserts a NULL entry, curLen
1934 is then 0, and all whitespace is skipped */
1936 WCMD_keyword_ws_found(forDO
, sizeof(forDO
)/sizeof(forDO
[0]), curPos
)) {
1937 const int keyw_len
= sizeof(forDO
)/sizeof(forDO
[0]) + 1;
1938 WINE_TRACE("Found 'DO '\n");
1940 onlyWhiteSpace
= TRUE
;
1941 memcpy(&curCopyTo
[*curLen
], curPos
, keyw_len
*sizeof(WCHAR
));
1942 (*curLen
)+=keyw_len
;
1946 } else if (curCopyTo
== curString
) {
1948 /* Special handling for the 'FOR' command */
1949 if (inFor
&& lastWasWhiteSpace
) {
1950 static const WCHAR forIN
[] = {'i','n'};
1952 WINE_TRACE("Found 'FOR ', comparing next parm: '%s'\n", wine_dbgstr_w(curPos
));
1954 if (WCMD_keyword_ws_found(forIN
, sizeof(forIN
)/sizeof(forIN
[0]), curPos
)) {
1955 const int keyw_len
= sizeof(forIN
)/sizeof(forIN
[0]) + 1;
1956 WINE_TRACE("Found 'IN '\n");
1958 onlyWhiteSpace
= TRUE
;
1959 memcpy(&curCopyTo
[*curLen
], curPos
, keyw_len
*sizeof(WCHAR
));
1960 (*curLen
)+=keyw_len
;
1967 /* Nothing 'ends' a one line statement (e.g. REM or :labels mean
1968 the &&, quotes and redirection etc are ineffective, so just force
1969 the use of the default processing by skipping character specific
1971 if (!inOneLine
) thisChar
= *curPos
;
1972 else thisChar
= 'X'; /* Character with no special processing */
1974 lastWasWhiteSpace
= FALSE
; /* Will be reset below */
1975 lastWasCaret
= FALSE
;
1979 case '=': /* drop through - ignore token delimiters at the start of a command */
1980 case ',': /* drop through - ignore token delimiters at the start of a command */
1981 case '\t':/* drop through - ignore token delimiters at the start of a command */
1983 /* If a redirect in place, it ends here */
1984 if (!inQuotes
&& !lastWasRedirect
) {
1986 /* If finishing off a redirect, add a whitespace delimiter */
1987 if (curCopyTo
== curRedirs
) {
1988 curCopyTo
[(*curLen
)++] = ' ';
1990 curCopyTo
= curString
;
1991 curLen
= &curStringLen
;
1994 curCopyTo
[(*curLen
)++] = *curPos
;
1997 /* Remember just processed whitespace */
1998 lastWasWhiteSpace
= TRUE
;
2002 case '>': /* drop through - handle redirect chars the same */
2004 /* Make a redirect start here */
2006 curCopyTo
= curRedirs
;
2007 curLen
= &curRedirsLen
;
2008 lastWasRedirect
= TRUE
;
2011 /* See if 1>, 2> etc, in which case we have some patching up
2012 to do (provided there's a preceding whitespace, and enough
2013 chars read so far) */
2014 if (curStringLen
> 2
2015 && (*(curPos
-1)>='1') && (*(curPos
-1)<='9')
2016 && ((*(curPos
-2)==' ') || (*(curPos
-2)=='\t'))) {
2018 curString
[curStringLen
] = 0x00;
2019 curCopyTo
[(*curLen
)++] = *(curPos
-1);
2022 curCopyTo
[(*curLen
)++] = *curPos
;
2024 /* If a redirect is immediately followed by '&' (ie. 2>&1) then
2025 do not process that ampersand as an AND operator */
2026 if (thisChar
== '>' && *(curPos
+1) == '&') {
2027 curCopyTo
[(*curLen
)++] = *(curPos
+1);
2032 case '|': /* Pipe character only if not || */
2034 lastWasRedirect
= FALSE
;
2036 /* Add an entry to the command list */
2037 if (curStringLen
> 0) {
2039 /* Add the current command */
2040 WCMD_addCommand(curString
, &curStringLen
,
2041 curRedirs
, &curRedirsLen
,
2042 &curCopyTo
, &curLen
,
2043 prevDelim
, curDepth
,
2044 &lastEntry
, output
);
2048 if (*(curPos
+1) == '|') {
2049 curPos
++; /* Skip other | */
2050 prevDelim
= CMD_ONFAILURE
;
2052 prevDelim
= CMD_PIPE
;
2055 curCopyTo
[(*curLen
)++] = *curPos
;
2059 case '"': if (WCMD_IsEndQuote(curPos
, inQuotes
)) {
2062 inQuotes
++; /* Quotes within quotes are fun! */
2064 curCopyTo
[(*curLen
)++] = *curPos
;
2065 lastWasRedirect
= FALSE
;
2068 case '(': /* If a '(' is the first non whitespace in a command portion
2069 ie start of line or just after &&, then we read until an
2070 unquoted ) is found */
2071 WINE_TRACE("Found '(' conditions: curLen(%d), inQ(%d), onlyWS(%d)"
2072 ", for(%d, In:%d, Do:%d)"
2073 ", if(%d, else:%d, lwe:%d)\n",
2076 inFor
, lastWasIn
, lastWasDo
,
2077 inIf
, inElse
, lastWasElse
);
2078 lastWasRedirect
= FALSE
;
2080 /* Ignore open brackets inside the for set */
2081 if (*curLen
== 0 && !inIn
) {
2084 /* If in quotes, ignore brackets */
2085 } else if (inQuotes
) {
2086 curCopyTo
[(*curLen
)++] = *curPos
;
2088 /* In a FOR loop, an unquoted '(' may occur straight after
2090 In an IF statement just handle it regardless as we don't
2092 In an ELSE statement, only allow it straight away after
2093 the ELSE and whitespace
2096 (inElse
&& lastWasElse
&& onlyWhiteSpace
) ||
2097 (inFor
&& (lastWasIn
|| lastWasDo
) && onlyWhiteSpace
)) {
2099 /* If entering into an 'IN', set inIn */
2100 if (inFor
&& lastWasIn
&& onlyWhiteSpace
) {
2101 WINE_TRACE("Inside an IN\n");
2105 /* Add the current command */
2106 WCMD_addCommand(curString
, &curStringLen
,
2107 curRedirs
, &curRedirsLen
,
2108 &curCopyTo
, &curLen
,
2109 prevDelim
, curDepth
,
2110 &lastEntry
, output
);
2114 curCopyTo
[(*curLen
)++] = *curPos
;
2118 case '^': if (!inQuotes
) {
2119 /* If we reach the end of the input, we need to wait for more */
2120 if (*(curPos
+1) == 0x00) {
2121 lastWasCaret
= TRUE
;
2122 WINE_TRACE("Caret found at end of line\n");
2127 curCopyTo
[(*curLen
)++] = *curPos
;
2130 case '&': if (!inQuotes
) {
2131 lastWasRedirect
= FALSE
;
2133 /* Add an entry to the command list */
2134 if (curStringLen
> 0) {
2136 /* Add the current command */
2137 WCMD_addCommand(curString
, &curStringLen
,
2138 curRedirs
, &curRedirsLen
,
2139 &curCopyTo
, &curLen
,
2140 prevDelim
, curDepth
,
2141 &lastEntry
, output
);
2145 if (*(curPos
+1) == '&') {
2146 curPos
++; /* Skip other & */
2147 prevDelim
= CMD_ONSUCCESS
;
2149 prevDelim
= CMD_NONE
;
2152 curCopyTo
[(*curLen
)++] = *curPos
;
2156 case ')': if (!inQuotes
&& curDepth
> 0) {
2157 lastWasRedirect
= FALSE
;
2159 /* Add the current command if there is one */
2162 /* Add the current command */
2163 WCMD_addCommand(curString
, &curStringLen
,
2164 curRedirs
, &curRedirsLen
,
2165 &curCopyTo
, &curLen
,
2166 prevDelim
, curDepth
,
2167 &lastEntry
, output
);
2170 /* Add an empty entry to the command list */
2171 prevDelim
= CMD_NONE
;
2172 WCMD_addCommand(NULL
, &curStringLen
,
2173 curRedirs
, &curRedirsLen
,
2174 &curCopyTo
, &curLen
,
2175 prevDelim
, curDepth
,
2176 &lastEntry
, output
);
2179 /* Leave inIn if necessary */
2180 if (inIn
) inIn
= FALSE
;
2182 curCopyTo
[(*curLen
)++] = *curPos
;
2186 lastWasRedirect
= FALSE
;
2187 curCopyTo
[(*curLen
)++] = *curPos
;
2192 /* At various times we need to know if we have only skipped whitespace,
2193 so reset this variable and then it will remain true until a non
2194 whitespace is found */
2195 if ((thisChar
!= ' ') && (thisChar
!= '\t') && (thisChar
!= '\n'))
2196 onlyWhiteSpace
= FALSE
;
2198 /* Flag end of interest in FOR DO and IN parms once something has been processed */
2199 if (!lastWasWhiteSpace
) {
2200 lastWasIn
= lastWasDo
= FALSE
;
2203 /* If we have reached the end, add this command into the list
2204 Do not add command to list if escape char ^ was last */
2205 if (*curPos
== 0x00 && !lastWasCaret
&& *curLen
> 0) {
2207 /* Add an entry to the command list */
2208 WCMD_addCommand(curString
, &curStringLen
,
2209 curRedirs
, &curRedirsLen
,
2210 &curCopyTo
, &curLen
,
2211 prevDelim
, curDepth
,
2212 &lastEntry
, output
);
2215 /* If we have reached the end of the string, see if bracketing or
2216 final caret is outstanding */
2217 if (*curPos
== 0x00 && (curDepth
> 0 || lastWasCaret
) &&
2218 readFrom
!= INVALID_HANDLE_VALUE
) {
2221 WINE_TRACE("Need to read more data as outstanding brackets or carets\n");
2223 prevDelim
= CMD_NONE
;
2225 memset(extraSpace
, 0x00, (MAXSTRING
+1) * sizeof(WCHAR
));
2226 extraData
= extraSpace
;
2228 /* Read more, skipping any blank lines */
2230 WINE_TRACE("Read more input\n");
2231 if (!context
) WCMD_output_asis( WCMD_LoadMessage(WCMD_MOREPROMPT
));
2232 if (!WCMD_fgets(extraData
, MAXSTRING
, readFrom
))
2235 /* Edge case for carets - a completely blank line (i.e. was just
2236 CRLF) is oddly added as an LF but then more data is received (but
2239 if (*extraSpace
== 0x00) {
2240 WINE_TRACE("Read nothing, so appending LF char and will try again\n");
2241 *extraData
++ = '\r';
2246 } while (*extraData
== 0x00);
2247 curPos
= extraSpace
;
2248 if (context
) handleExpansion(extraSpace
, FALSE
, FALSE
);
2249 /* Continue to echo commands IF echo is on and in batch program */
2250 if (context
&& echo_mode
&& extraSpace
[0] && (extraSpace
[0] != '@')) {
2251 WCMD_output_asis(extraSpace
);
2252 WCMD_output_asis(newlineW
);
2257 /* Dump out the parsed output */
2258 WCMD_DumpCommands(*output
);
2263 /***************************************************************************
2264 * WCMD_process_commands
2266 * Process all the commands read in so far
2268 CMD_LIST
*WCMD_process_commands(CMD_LIST
*thisCmd
, BOOL oneBracket
,
2273 if (thisCmd
&& oneBracket
) bdepth
= thisCmd
->bracketDepth
;
2275 /* Loop through the commands, processing them one by one */
2278 CMD_LIST
*origCmd
= thisCmd
;
2280 /* If processing one bracket only, and we find the end bracket
2281 entry (or less), return */
2282 if (oneBracket
&& !thisCmd
->command
&&
2283 bdepth
<= thisCmd
->bracketDepth
) {
2284 WINE_TRACE("Finished bracket @ %p, next command is %p\n",
2285 thisCmd
, thisCmd
->nextcommand
);
2286 return thisCmd
->nextcommand
;
2289 /* Ignore the NULL entries a ')' inserts (Only 'if' cares
2290 about them and it will be handled in there)
2291 Also, skip over any batch labels (eg. :fred) */
2292 if (thisCmd
->command
&& thisCmd
->command
[0] != ':') {
2293 WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd
->command
));
2294 WCMD_execute (thisCmd
->command
, thisCmd
->redirects
, &thisCmd
, retrycall
);
2297 /* Step on unless the command itself already stepped on */
2298 if (thisCmd
== origCmd
) thisCmd
= thisCmd
->nextcommand
;
2303 /***************************************************************************
2304 * WCMD_free_commands
2306 * Frees the storage held for a parsed command line
2307 * - This is not done in the process_commands, as eventually the current
2308 * pointer will be modified within the commands, and hence a single free
2309 * routine is simpler
2311 void WCMD_free_commands(CMD_LIST
*cmds
) {
2313 /* Loop through the commands, freeing them one by one */
2315 CMD_LIST
*thisCmd
= cmds
;
2316 cmds
= cmds
->nextcommand
;
2317 heap_free(thisCmd
->command
);
2318 heap_free(thisCmd
->redirects
);
2324 /*****************************************************************************
2325 * Main entry point. This is a console application so we have a main() not a
2329 int wmain (int argc
, WCHAR
*argvW
[])
2332 WCHAR
*cmdLine
= NULL
;
2334 WCHAR
*argPos
= NULL
;
2339 static const WCHAR offW
[] = {'O','F','F','\0'};
2340 static const WCHAR promptW
[] = {'P','R','O','M','P','T','\0'};
2341 static const WCHAR defaultpromptW
[] = {'$','P','$','G','\0'};
2342 CMD_LIST
*toExecute
= NULL
; /* Commands left to be executed */
2348 /* Get the windows version being emulated */
2349 osv
.dwOSVersionInfoSize
= sizeof(osv
);
2350 GetVersionExW(&osv
);
2352 /* Pre initialize some messages */
2353 strcpyW(anykey
, WCMD_LoadMessage(WCMD_ANYKEY
));
2354 sprintf(osver
, "%d.%d.%d (%s)", osv
.dwMajorVersion
, osv
.dwMinorVersion
,
2355 osv
.dwBuildNumber
, PACKAGE_VERSION
);
2356 cmd
= WCMD_format_string(WCMD_LoadMessage(WCMD_VERSION
), osver
);
2357 strcpyW(version_string
, cmd
);
2361 /* Can't use argc/argv as it will have stripped quotes from parameters
2362 * meaning cmd.exe /C echo "quoted string" is impossible
2364 cmdLine
= GetCommandLineW();
2365 WINE_TRACE("Full commandline '%s'\n", wine_dbgstr_w(cmdLine
));
2366 args
= 1; /* start at first arg, skipping cmd.exe itself */
2368 opt_c
= opt_k
= opt_q
= opt_s
= FALSE
;
2369 WCMD_parameter(cmdLine
, args
, &argPos
, TRUE
, TRUE
);
2370 while (argPos
&& argPos
[0] != 0x00)
2373 WINE_TRACE("Command line parm: '%s'\n", wine_dbgstr_w(argPos
));
2374 if (argPos
[0]!='/' || argPos
[1]=='\0') {
2376 WCMD_parameter(cmdLine
, args
, &argPos
, TRUE
, TRUE
);
2381 if (tolowerW(c
)=='c') {
2383 } else if (tolowerW(c
)=='q') {
2385 } else if (tolowerW(c
)=='k') {
2387 } else if (tolowerW(c
)=='s') {
2389 } else if (tolowerW(c
)=='a') {
2390 unicodeOutput
= FALSE
;
2391 } else if (tolowerW(c
)=='u') {
2392 unicodeOutput
= TRUE
;
2393 } else if (tolowerW(c
)=='v' && argPos
[2]==':') {
2394 delayedsubst
= strncmpiW(&argPos
[3], offW
, 3);
2395 if (delayedsubst
) WINE_TRACE("Delayed substitution is on\n");
2396 } else if (tolowerW(c
)=='t' && argPos
[2]==':') {
2397 opt_t
=strtoulW(&argPos
[3], NULL
, 16);
2398 } else if (tolowerW(c
)=='x' || tolowerW(c
)=='y') {
2399 /* Ignored for compatibility with Windows */
2402 if (argPos
[2]==0 || argPos
[2]==' ' || argPos
[2]=='\t' ||
2405 WCMD_parameter(cmdLine
, args
, &argPos
, TRUE
, TRUE
);
2407 else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
2409 /* Do not step to next parameter, instead carry on parsing this one */
2413 if (opt_c
|| opt_k
) /* break out of parsing immediately after c or k */
2421 /* Until we start to read from the keyboard, stay as non-interactive */
2422 interactive
= FALSE
;
2424 if (opt_c
|| opt_k
) {
2426 WCHAR
*q1
= NULL
,*q2
= NULL
,*p
;
2428 /* Handle very edge case error scenario, "cmd.exe /c" ie when there are no
2429 * parameters after the /C or /K by pretending there was a single space */
2430 if (argPos
== NULL
) argPos
= (WCHAR
*)spaceW
;
2433 cmd
= heap_strdupW(argPos
);
2435 /* opt_s left unflagged if the command starts with and contains exactly
2436 * one quoted string (exactly two quote characters). The quoted string
2437 * must be an executable name that has whitespace and must not have the
2438 * following characters: &<>()@^| */
2441 /* 1. Confirm there is at least one quote */
2442 q1
= strchrW(argPos
, '"');
2447 /* 2. Confirm there is a second quote */
2448 q2
= strchrW(q1
+1, '"');
2453 /* 3. Ensure there are no more quotes */
2454 if (strchrW(q2
+1, '"')) opt_s
=1;
2457 /* check first parameter for a space and invalid characters. There must not be any
2458 * invalid characters, but there must be one or more whitespace */
2463 if (*p
=='&' || *p
=='<' || *p
=='>' || *p
=='(' || *p
==')'
2464 || *p
=='@' || *p
=='^' || *p
=='|') {
2468 if (*p
==' ' || *p
=='\t')
2474 WINE_TRACE("/c command line: '%s'\n", wine_dbgstr_w(cmd
));
2476 /* Finally, we only stay in new mode IF the first parameter is quoted and
2477 is a valid executable, i.e. must exist, otherwise drop back to old mode */
2479 WCHAR
*thisArg
= WCMD_parameter(cmd
, 0, NULL
, FALSE
, TRUE
);
2480 WCHAR pathext
[MAXSTRING
];
2483 /* Now extract PATHEXT */
2484 len
= GetEnvironmentVariableW(envPathExt
, pathext
, sizeof(pathext
)/sizeof(WCHAR
));
2485 if ((len
== 0) || (len
>= (sizeof(pathext
)/sizeof(WCHAR
)))) {
2486 strcpyW (pathext
, dfltPathExt
);
2489 /* If the supplied parameter has any directory information, look there */
2490 WINE_TRACE("First parameter is '%s'\n", wine_dbgstr_w(thisArg
));
2491 if (strchrW(thisArg
, '\\') != NULL
) {
2493 GetFullPathNameW(thisArg
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
);
2494 WINE_TRACE("Full path name '%s'\n", wine_dbgstr_w(string
));
2495 p
= string
+ strlenW(string
);
2497 /* Does file exist with this name? */
2498 if (GetFileAttributesW(string
) != INVALID_FILE_ATTRIBUTES
) {
2499 WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string
));
2502 WCHAR
*thisExt
= pathext
;
2504 /* No - try with each of the PATHEXT extensions */
2505 while (!found
&& thisExt
) {
2506 WCHAR
*nextExt
= strchrW(thisExt
, ';');
2509 memcpy(p
, thisExt
, (nextExt
-thisExt
) * sizeof(WCHAR
));
2510 p
[(nextExt
-thisExt
)] = 0x00;
2511 thisExt
= nextExt
+1;
2513 strcpyW(p
, thisExt
);
2517 /* Does file exist with this extension appended? */
2518 if (GetFileAttributesW(string
) != INVALID_FILE_ATTRIBUTES
) {
2519 WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string
));
2525 /* Otherwise we now need to look in the path to see if we can find it */
2527 p
= thisArg
+ strlenW(thisArg
);
2529 /* Does file exist with this name? */
2530 if (SearchPathW(NULL
, thisArg
, NULL
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
) != 0) {
2531 WINE_TRACE("Found on path as '%s'\n", wine_dbgstr_w(string
));
2534 WCHAR
*thisExt
= pathext
;
2536 /* No - try with each of the PATHEXT extensions */
2537 while (!found
&& thisExt
) {
2538 WCHAR
*nextExt
= strchrW(thisExt
, ';');
2542 nextExt
= nextExt
+1;
2547 /* Does file exist with this extension? */
2548 if (SearchPathW(NULL
, thisArg
, thisExt
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
) != 0) {
2549 WINE_TRACE("Found on path as '%s' with extension '%s'\n", wine_dbgstr_w(string
),
2550 wine_dbgstr_w(thisExt
));
2558 /* If not found, drop back to old behaviour */
2560 WINE_TRACE("Binary not found, dropping back to old behaviour\n");
2566 /* strip first and last quote characters if opt_s; check for invalid
2567 * executable is done later */
2568 if (opt_s
&& *cmd
=='\"')
2569 WCMD_strip_quotes(cmd
);
2572 /* Save cwd into appropriate env var (Must be before the /c processing */
2573 GetCurrentDirectoryW(sizeof(string
)/sizeof(WCHAR
), string
);
2574 if (IsCharAlphaW(string
[0]) && string
[1] == ':') {
2575 static const WCHAR fmt
[] = {'=','%','c',':','\0'};
2576 wsprintfW(envvar
, fmt
, string
[0]);
2577 SetEnvironmentVariableW(envvar
, string
);
2578 WINE_TRACE("Set %s to %s\n", wine_dbgstr_w(envvar
), wine_dbgstr_w(string
));
2582 /* If we do a "cmd /c command", we don't want to allocate a new
2583 * console since the command returns immediately. Rather, we use
2584 * the currently allocated input and output handles. This allows
2585 * us to pipe to and read from the command interpreter.
2588 /* Parse the command string, without reading any more input */
2589 WCMD_ReadAndParseLine(cmd
, &toExecute
, INVALID_HANDLE_VALUE
);
2590 WCMD_process_commands(toExecute
, FALSE
, FALSE
);
2591 WCMD_free_commands(toExecute
);
2598 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), ENABLE_LINE_INPUT
|
2599 ENABLE_ECHO_INPUT
| ENABLE_PROCESSED_INPUT
);
2600 SetConsoleTitleW(WCMD_LoadMessage(WCMD_CONSTITLE
));
2602 /* Note: cmd.exe /c dir does not get a new color, /k dir does */
2604 if (!(((opt_t
& 0xF0) >> 4) == (opt_t
& 0x0F))) {
2605 defaultColor
= opt_t
& 0xFF;
2610 /* Check HKCU\Software\Microsoft\Command Processor
2611 Then HKLM\Software\Microsoft\Command Processor
2612 for defaultcolour value
2613 Note Can be supplied as DWORD or REG_SZ
2614 Note2 When supplied as REG_SZ it's in decimal!!! */
2617 DWORD value
=0, size
=4;
2618 static const WCHAR regKeyW
[] = {'S','o','f','t','w','a','r','e','\\',
2619 'M','i','c','r','o','s','o','f','t','\\',
2620 'C','o','m','m','a','n','d',' ','P','r','o','c','e','s','s','o','r','\0'};
2621 static const WCHAR dfltColorW
[] = {'D','e','f','a','u','l','t','C','o','l','o','r','\0'};
2623 if (RegOpenKeyExW(HKEY_CURRENT_USER
, regKeyW
,
2624 0, KEY_READ
, &key
) == ERROR_SUCCESS
) {
2627 /* See if DWORD or REG_SZ */
2628 if (RegQueryValueExW(key
, dfltColorW
, NULL
, &type
,
2629 NULL
, NULL
) == ERROR_SUCCESS
) {
2630 if (type
== REG_DWORD
) {
2631 size
= sizeof(DWORD
);
2632 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2633 (LPBYTE
)&value
, &size
);
2634 } else if (type
== REG_SZ
) {
2635 size
= sizeof(strvalue
)/sizeof(WCHAR
);
2636 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2637 (LPBYTE
)strvalue
, &size
);
2638 value
= strtoulW(strvalue
, NULL
, 10);
2644 if (value
== 0 && RegOpenKeyExW(HKEY_LOCAL_MACHINE
, regKeyW
,
2645 0, KEY_READ
, &key
) == ERROR_SUCCESS
) {
2648 /* See if DWORD or REG_SZ */
2649 if (RegQueryValueExW(key
, dfltColorW
, NULL
, &type
,
2650 NULL
, NULL
) == ERROR_SUCCESS
) {
2651 if (type
== REG_DWORD
) {
2652 size
= sizeof(DWORD
);
2653 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2654 (LPBYTE
)&value
, &size
);
2655 } else if (type
== REG_SZ
) {
2656 size
= sizeof(strvalue
)/sizeof(WCHAR
);
2657 RegQueryValueExW(key
, dfltColorW
, NULL
, NULL
,
2658 (LPBYTE
)strvalue
, &size
);
2659 value
= strtoulW(strvalue
, NULL
, 10);
2665 /* If one found, set the screen to that colour */
2666 if (!(((value
& 0xF0) >> 4) == (value
& 0x0F))) {
2667 defaultColor
= value
& 0xFF;
2675 /* Parse the command string, without reading any more input */
2676 WCMD_ReadAndParseLine(cmd
, &toExecute
, INVALID_HANDLE_VALUE
);
2677 WCMD_process_commands(toExecute
, FALSE
, FALSE
);
2678 WCMD_free_commands(toExecute
);
2684 * Loop forever getting commands and executing them.
2687 SetEnvironmentVariableW(promptW
, defaultpromptW
);
2689 if (!opt_k
) WCMD_version ();
2692 /* Read until EOF (which for std input is never, but if redirect
2693 in place, may occur */
2694 if (echo_mode
) WCMD_show_prompt();
2695 if (!WCMD_ReadAndParseLine(NULL
, &toExecute
, GetStdHandle(STD_INPUT_HANDLE
)))
2697 WCMD_process_commands(toExecute
, FALSE
, FALSE
);
2698 WCMD_free_commands(toExecute
);