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
30 #include "wine/debug.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(cmd
);
34 const WCHAR inbuilt
[][10] = {
35 {'A','T','T','R','I','B','\0'},
36 {'C','A','L','L','\0'},
38 {'C','H','D','I','R','\0'},
40 {'C','O','P','Y','\0'},
41 {'C','T','T','Y','\0'},
42 {'D','A','T','E','\0'},
45 {'E','C','H','O','\0'},
46 {'E','R','A','S','E','\0'},
48 {'G','O','T','O','\0'},
49 {'H','E','L','P','\0'},
51 {'L','A','B','E','L','\0'},
53 {'M','K','D','I','R','\0'},
54 {'M','O','V','E','\0'},
55 {'P','A','T','H','\0'},
56 {'P','A','U','S','E','\0'},
57 {'P','R','O','M','P','T','\0'},
60 {'R','E','N','A','M','E','\0'},
62 {'R','M','D','I','R','\0'},
64 {'S','H','I','F','T','\0'},
65 {'T','I','M','E','\0'},
66 {'T','I','T','L','E','\0'},
67 {'T','Y','P','E','\0'},
68 {'V','E','R','I','F','Y','\0'},
71 {'E','N','D','L','O','C','A','L','\0'},
72 {'S','E','T','L','O','C','A','L','\0'},
73 {'P','U','S','H','D','\0'},
74 {'P','O','P','D','\0'},
75 {'A','S','S','O','C','\0'},
76 {'C','O','L','O','R','\0'},
77 {'F','T','Y','P','E','\0'},
78 {'M','O','R','E','\0'},
79 {'E','X','I','T','\0'}
84 int echo_mode
= 1, verify_mode
= 0, defaultColor
= 7;
85 static int opt_c
, opt_k
, opt_s
;
86 const WCHAR newline
[] = {'\n','\0'};
87 static const WCHAR equalsW
[] = {'=','\0'};
88 static const WCHAR closeBW
[] = {')','\0'};
90 WCHAR version_string
[100];
91 WCHAR quals
[MAX_PATH
], param1
[MAXSTRING
], param2
[MAXSTRING
];
92 BATCH_CONTEXT
*context
= NULL
;
93 extern struct env_stack
*pushd_directories
;
94 static const WCHAR
*pagedMessage
= NULL
;
95 static char *output_bufA
= NULL
;
96 #define MAX_WRITECONSOLE_SIZE 65535
97 BOOL unicodePipes
= FALSE
;
100 /*******************************************************************
101 * WCMD_output_asis_len - send output to current standard output
103 * Output a formatted unicode string. Ideally this will go to the console
104 * and hence required WriteConsoleW to output it, however if file i/o is
105 * redirected, it needs to be WriteFile'd using OEM (not ANSI) format
107 static void WCMD_output_asis_len(const WCHAR
*message
, int len
, HANDLE device
) {
112 /* If nothing to write, return (MORE does this sometimes) */
115 /* Try to write as unicode assuming it is to a console */
116 res
= WriteConsoleW(device
, message
, len
, &nOut
, NULL
);
118 /* If writing to console fails, assume its file
119 i/o so convert to OEM codepage and output */
121 BOOL usedDefaultChar
= FALSE
;
122 DWORD convertedChars
;
126 * Allocate buffer to use when writing to file. (Not freed, as one off)
128 if (!output_bufA
) output_bufA
= HeapAlloc(GetProcessHeap(), 0,
129 MAX_WRITECONSOLE_SIZE
);
131 WINE_FIXME("Out of memory - could not allocate ansi 64K buffer\n");
135 /* Convert to OEM, then output */
136 convertedChars
= WideCharToMultiByte(GetConsoleOutputCP(), 0, message
,
137 len
, output_bufA
, MAX_WRITECONSOLE_SIZE
,
138 "?", &usedDefaultChar
);
139 WriteFile(device
, output_bufA
, convertedChars
,
142 WriteFile(device
, message
, len
*sizeof(WCHAR
),
149 /*******************************************************************
150 * WCMD_output - send output to current standard output device.
154 void WCMD_output (const WCHAR
*format
, ...) {
161 ret
= vsnprintfW(string
, sizeof(string
)/sizeof(WCHAR
), format
, ap
);
162 if( ret
>= (sizeof(string
)/sizeof(WCHAR
))) {
163 WINE_ERR("Output truncated in WCMD_output\n" );
164 ret
= (sizeof(string
)/sizeof(WCHAR
)) - 1;
168 WCMD_output_asis_len(string
, ret
, GetStdHandle(STD_OUTPUT_HANDLE
));
172 static int line_count
;
173 static int max_height
;
174 static int max_width
;
175 static BOOL paged_mode
;
178 void WCMD_enter_paged_mode(const WCHAR
*msg
)
180 CONSOLE_SCREEN_BUFFER_INFO consoleInfo
;
182 if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE
), &consoleInfo
)) {
183 max_height
= consoleInfo
.dwSize
.Y
;
184 max_width
= consoleInfo
.dwSize
.X
;
192 pagedMessage
= (msg
==NULL
)? anykey
: msg
;
195 void WCMD_leave_paged_mode(void)
201 /***************************************************************************
204 * Read characters in from a console/file, returning result in Unicode
205 * with signature identical to ReadFile
207 BOOL
WCMD_ReadFile(const HANDLE hIn
, WCHAR
*intoBuf
, const DWORD maxChars
,
208 LPDWORD charsRead
, const LPOVERLAPPED unused
) {
212 /* Try to read from console as Unicode */
213 res
= ReadConsoleW(hIn
, intoBuf
, maxChars
, charsRead
, NULL
);
215 /* If reading from console has failed we assume its file
216 i/o so read in and convert from OEM codepage */
221 * Allocate buffer to use when reading from file. Not freed
223 if (!output_bufA
) output_bufA
= HeapAlloc(GetProcessHeap(), 0,
224 MAX_WRITECONSOLE_SIZE
);
226 WINE_FIXME("Out of memory - could not allocate ansi 64K buffer\n");
230 /* Read from file (assume OEM codepage) */
231 res
= ReadFile(hIn
, output_bufA
, maxChars
, &numRead
, unused
);
233 /* Convert from OEM */
234 *charsRead
= MultiByteToWideChar(GetConsoleCP(), 0, output_bufA
, numRead
,
241 /*******************************************************************
242 * WCMD_output_asis - send output to current standard output device.
243 * without formatting eg. when message contains '%'
245 void WCMD_output_asis (const WCHAR
*message
) {
253 while (*ptr
&& *ptr
!='\n' && (numChars
< max_width
)) {
257 if (*ptr
== '\n') ptr
++;
258 WCMD_output_asis_len(message
, (ptr
) ? ptr
- message
: strlenW(message
),
259 GetStdHandle(STD_OUTPUT_HANDLE
));
262 if (++line_count
>= max_height
- 1) {
264 WCMD_output_asis_len(pagedMessage
, strlenW(pagedMessage
),
265 GetStdHandle(STD_OUTPUT_HANDLE
));
266 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE
), string
,
267 sizeof(string
)/sizeof(WCHAR
), &count
, NULL
);
270 } while (((message
= ptr
) != NULL
) && (*ptr
));
272 WCMD_output_asis_len(message
, lstrlen(message
),
273 GetStdHandle(STD_OUTPUT_HANDLE
));
277 /****************************************************************************
280 * Print the message for GetLastError
283 void WCMD_print_error (void) {
288 error_code
= GetLastError ();
289 status
= FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
290 NULL
, error_code
, 0, (LPTSTR
) &lpMsgBuf
, 0, NULL
);
292 WINE_FIXME ("Cannot display message for error %d, status %d\n",
293 error_code
, GetLastError());
297 WCMD_output_asis_len(lpMsgBuf
, lstrlen(lpMsgBuf
),
298 GetStdHandle(STD_ERROR_HANDLE
));
299 LocalFree (lpMsgBuf
);
300 WCMD_output_asis_len (newline
, lstrlen(newline
),
301 GetStdHandle(STD_ERROR_HANDLE
));
305 /******************************************************************************
308 * Display the prompt on STDout
312 static void WCMD_show_prompt (void) {
315 WCHAR out_string
[MAX_PATH
], curdir
[MAX_PATH
], prompt_string
[MAX_PATH
];
318 static const WCHAR envPrompt
[] = {'P','R','O','M','P','T','\0'};
320 len
= GetEnvironmentVariable (envPrompt
, prompt_string
,
321 sizeof(prompt_string
)/sizeof(WCHAR
));
322 if ((len
== 0) || (len
>= (sizeof(prompt_string
)/sizeof(WCHAR
)))) {
323 const WCHAR dfltPrompt
[] = {'$','P','$','G','\0'};
324 strcpyW (prompt_string
, dfltPrompt
);
336 switch (toupper(*p
)) {
350 GetDateFormat (LOCALE_USER_DEFAULT
, DATE_SHORTDATE
, NULL
, NULL
, q
, MAX_PATH
);
369 status
= GetCurrentDirectory (sizeof(curdir
)/sizeof(WCHAR
), curdir
);
375 status
= GetCurrentDirectory (sizeof(curdir
)/sizeof(WCHAR
), curdir
);
388 GetTimeFormat (LOCALE_USER_DEFAULT
, 0, NULL
, NULL
, q
, MAX_PATH
);
392 strcatW (q
, version_string
);
399 if (pushd_directories
) {
400 memset(q
, '+', pushd_directories
->u
.stackdepth
);
401 q
= q
+ pushd_directories
->u
.stackdepth
;
409 WCMD_output_asis (out_string
);
413 /*************************************************************************
415 * A wide version of strdup as its missing from unicode.h
417 WCHAR
*WCMD_strdupW(WCHAR
*input
) {
418 int len
=strlenW(input
)+1;
419 /* Note: Use malloc not HeapAlloc to emulate strdup */
420 WCHAR
*result
= malloc(len
* sizeof(WCHAR
));
421 memcpy(result
, input
, len
* sizeof(WCHAR
));
425 /***************************************************************************
426 * WCMD_strtrim_leading_spaces
428 * Remove leading spaces from a string. Return a pointer to the first
429 * non-space character. Does not modify the input string
431 WCHAR
*WCMD_strtrim_leading_spaces (WCHAR
*string
) {
436 while (*ptr
== ' ') ptr
++;
440 /*************************************************************************
441 * WCMD_opt_s_strip_quotes
443 * Remove first and last quote WCHARacters, preserving all other text
445 static void WCMD_opt_s_strip_quotes(WCHAR
*cmd
) {
446 WCHAR
*src
= cmd
+ 1, *dest
= cmd
, *lastq
= NULL
;
447 while((*dest
=*src
) != '\0') {
454 while ((*dest
++=*lastq
++) != 0)
460 /*************************************************************************
463 * Expands environment variables, allowing for WCHARacter substitution
465 static WCHAR
*WCMD_expand_envvar(WCHAR
*start
, WCHAR
*forVar
, WCHAR
*forVal
) {
466 WCHAR
*endOfVar
= NULL
, *s
;
467 WCHAR
*colonpos
= NULL
;
468 WCHAR thisVar
[MAXSTRING
];
469 WCHAR thisVarContents
[MAXSTRING
];
470 WCHAR savedchar
= 0x00;
473 static const WCHAR ErrorLvl
[] = {'E','R','R','O','R','L','E','V','E','L','\0'};
474 static const WCHAR ErrorLvlP
[] = {'%','E','R','R','O','R','L','E','V','E','L','%','\0'};
475 static const WCHAR Date
[] = {'D','A','T','E','\0'};
476 static const WCHAR DateP
[] = {'%','D','A','T','E','%','\0'};
477 static const WCHAR Time
[] = {'T','I','M','E','\0'};
478 static const WCHAR TimeP
[] = {'%','T','I','M','E','%','\0'};
479 static const WCHAR Cd
[] = {'C','D','\0'};
480 static const WCHAR CdP
[] = {'%','C','D','%','\0'};
481 static const WCHAR Random
[] = {'R','A','N','D','O','M','\0'};
482 static const WCHAR RandomP
[] = {'%','R','A','N','D','O','M','%','\0'};
483 static const WCHAR Delims
[] = {'%',' ',':','\0'};
485 WINE_TRACE("Expanding: %s (%s,%s)\n", wine_dbgstr_w(start
),
486 wine_dbgstr_w(forVal
), wine_dbgstr_w(forVar
));
488 /* Find the end of the environment variable, and extract name */
489 endOfVar
= strpbrkW(start
+1, Delims
);
491 if (endOfVar
== NULL
|| *endOfVar
==' ') {
493 /* In batch program, missing terminator for % and no following
494 ':' just removes the '%' */
496 s
= WCMD_strdupW(start
+ 1);
502 /* In command processing, just ignore it - allows command line
503 syntax like: for %i in (a.a) do echo %i */
508 /* If ':' found, process remaining up until '%' (or stop at ':' if
510 if (*endOfVar
==':') {
511 WCHAR
*endOfVar2
= strchrW(endOfVar
+1, '%');
512 if (endOfVar2
!= NULL
) endOfVar
= endOfVar2
;
515 memcpy(thisVar
, start
, ((endOfVar
- start
) + 1) * sizeof(WCHAR
));
516 thisVar
[(endOfVar
- start
)+1] = 0x00;
517 colonpos
= strchrW(thisVar
+1, ':');
519 /* If there's complex substitution, just need %var% for now
520 to get the expanded data to play with */
523 savedchar
= *(colonpos
+1);
524 *(colonpos
+1) = 0x00;
527 WINE_TRACE("Retrieving contents of %s\n", wine_dbgstr_w(thisVar
));
529 /* Expand to contents, if unchanged, return */
530 /* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
531 /* override if existing env var called that name */
532 if ((CompareString (LOCALE_USER_DEFAULT
,
533 NORM_IGNORECASE
| SORT_STRINGSORT
,
534 thisVar
, 12, ErrorLvlP
, -1) == 2) &&
535 (GetEnvironmentVariable(ErrorLvl
, thisVarContents
, 1) == 0) &&
536 (GetLastError() == ERROR_ENVVAR_NOT_FOUND
)) {
537 static const WCHAR fmt
[] = {'%','d','\0'};
538 wsprintf(thisVarContents
, fmt
, errorlevel
);
539 len
= strlenW(thisVarContents
);
541 } else if ((CompareString (LOCALE_USER_DEFAULT
,
542 NORM_IGNORECASE
| SORT_STRINGSORT
,
543 thisVar
, 6, DateP
, -1) == 2) &&
544 (GetEnvironmentVariable(Date
, thisVarContents
, 1) == 0) &&
545 (GetLastError() == ERROR_ENVVAR_NOT_FOUND
)) {
547 GetDateFormat(LOCALE_USER_DEFAULT
, DATE_SHORTDATE
, NULL
,
548 NULL
, thisVarContents
, MAXSTRING
);
549 len
= strlenW(thisVarContents
);
551 } else if ((CompareString (LOCALE_USER_DEFAULT
,
552 NORM_IGNORECASE
| SORT_STRINGSORT
,
553 thisVar
, 6, TimeP
, -1) == 2) &&
554 (GetEnvironmentVariable(Time
, thisVarContents
, 1) == 0) &&
555 (GetLastError() == ERROR_ENVVAR_NOT_FOUND
)) {
556 GetTimeFormat(LOCALE_USER_DEFAULT
, TIME_NOSECONDS
, NULL
,
557 NULL
, thisVarContents
, MAXSTRING
);
558 len
= strlenW(thisVarContents
);
560 } else if ((CompareString (LOCALE_USER_DEFAULT
,
561 NORM_IGNORECASE
| SORT_STRINGSORT
,
562 thisVar
, 4, CdP
, -1) == 2) &&
563 (GetEnvironmentVariable(Cd
, thisVarContents
, 1) == 0) &&
564 (GetLastError() == ERROR_ENVVAR_NOT_FOUND
)) {
565 GetCurrentDirectory (MAXSTRING
, thisVarContents
);
566 len
= strlenW(thisVarContents
);
568 } else if ((CompareString (LOCALE_USER_DEFAULT
,
569 NORM_IGNORECASE
| SORT_STRINGSORT
,
570 thisVar
, 8, RandomP
, -1) == 2) &&
571 (GetEnvironmentVariable(Random
, thisVarContents
, 1) == 0) &&
572 (GetLastError() == ERROR_ENVVAR_NOT_FOUND
)) {
573 static const WCHAR fmt
[] = {'%','d','\0'};
574 wsprintf(thisVarContents
, fmt
, rand() % 32768);
575 len
= strlenW(thisVarContents
);
577 /* Look for a matching 'for' variable */
579 (CompareString (LOCALE_USER_DEFAULT
,
582 (colonpos
- thisVar
) - 1,
584 strcpyW(thisVarContents
, forVal
);
585 len
= strlenW(thisVarContents
);
589 len
= ExpandEnvironmentStrings(thisVar
, thisVarContents
,
590 sizeof(thisVarContents
)/sizeof(WCHAR
));
596 /* In a batch program, unknown env vars are replaced with nothing,
597 note syntax %garbage:1,3% results in anything after the ':'
599 From the command line, you just get back what you entered */
600 if (lstrcmpiW(thisVar
, thisVarContents
) == 0) {
602 /* Restore the complex part after the compare */
605 *(colonpos
+1) = savedchar
;
608 /* Command line - just ignore this */
609 if (context
== NULL
) return endOfVar
+1;
611 s
= WCMD_strdupW(endOfVar
+ 1);
613 /* Batch - replace unknown env var with nothing */
614 if (colonpos
== NULL
) {
618 len
= strlenW(thisVar
);
619 thisVar
[len
-1] = 0x00;
620 /* If %:...% supplied, : is retained */
621 if (colonpos
== thisVar
+1) {
622 strcpyW (start
, colonpos
);
624 strcpyW (start
, colonpos
+1);
633 /* See if we need to do complex substitution (any ':'s), if not
634 then our work here is done */
635 if (colonpos
== NULL
) {
636 s
= WCMD_strdupW(endOfVar
+ 1);
637 strcpyW (start
, thisVarContents
);
643 /* Restore complex bit */
645 *(colonpos
+1) = savedchar
;
648 Handle complex substitutions:
649 xxx=yyy (replace xxx with yyy)
650 *xxx=yyy (replace up to and including xxx with yyy)
651 ~x (from x WCHARs in)
652 ~-x (from x WCHARs from the end)
653 ~x,y (from x WCHARs in for y WCHARacters)
654 ~x,-y (from x WCHARs in until y WCHARacters from the end)
657 /* ~ is substring manipulation */
658 if (savedchar
== '~') {
660 int substrposition
, substrlength
= 0;
661 WCHAR
*commapos
= strchrW(colonpos
+2, ',');
664 substrposition
= atolW(colonpos
+2);
665 if (commapos
) substrlength
= atolW(commapos
+1);
667 s
= WCMD_strdupW(endOfVar
+ 1);
670 if (substrposition
>= 0) {
671 startCopy
= &thisVarContents
[min(substrposition
, len
)];
673 startCopy
= &thisVarContents
[max(0, len
+substrposition
-1)];
676 if (commapos
== NULL
) {
677 strcpyW (start
, startCopy
); /* Copy the lot */
678 } else if (substrlength
< 0) {
680 int copybytes
= (len
+substrlength
-1)-(startCopy
-thisVarContents
);
681 if (copybytes
> len
) copybytes
= len
;
682 else if (copybytes
< 0) copybytes
= 0;
683 memcpy (start
, startCopy
, copybytes
* sizeof(WCHAR
)); /* Copy the lot */
684 start
[copybytes
] = 0x00;
686 memcpy (start
, startCopy
, substrlength
* sizeof(WCHAR
)); /* Copy the lot */
687 start
[substrlength
] = 0x00;
694 /* search and replace manipulation */
696 WCHAR
*equalspos
= strstrW(colonpos
, equalsW
);
697 WCHAR
*replacewith
= equalspos
+1;
702 if (equalspos
== NULL
) return start
+1;
703 s
= WCMD_strdupW(endOfVar
+ 1);
705 /* Null terminate both strings */
706 thisVar
[strlenW(thisVar
)-1] = 0x00;
709 /* Since we need to be case insensitive, copy the 2 buffers */
710 searchIn
= WCMD_strdupW(thisVarContents
);
711 CharUpperBuff(searchIn
, strlenW(thisVarContents
));
712 searchFor
= WCMD_strdupW(colonpos
+1);
713 CharUpperBuff(searchFor
, strlenW(colonpos
+1));
715 /* Handle wildcard case */
716 if (*(colonpos
+1) == '*') {
717 /* Search for string to replace */
718 found
= strstrW(searchIn
, searchFor
+1);
722 strcpyW(start
, replacewith
);
723 strcatW(start
, thisVarContents
+ (found
-searchIn
) + strlenW(searchFor
+1));
727 strcpyW(start
, thisVarContents
);
732 /* Loop replacing all instances */
733 WCHAR
*lastFound
= searchIn
;
734 WCHAR
*outputposn
= start
;
737 while ((found
= strstrW(lastFound
, searchFor
))) {
738 lstrcpynW(outputposn
,
739 thisVarContents
+ (lastFound
-searchIn
),
740 (found
- lastFound
)+1);
741 outputposn
= outputposn
+ (found
- lastFound
);
742 strcatW(outputposn
, replacewith
);
743 outputposn
= outputposn
+ strlenW(replacewith
);
744 lastFound
= found
+ strlenW(searchFor
);
747 thisVarContents
+ (lastFound
-searchIn
));
748 strcatW(outputposn
, s
);
758 /*****************************************************************************
759 * Expand the command. Native expands lines from batch programs as they are
760 * read in and not again, except for 'for' variable substitution.
761 * eg. As evidence, "echo %1 && shift && echo %1" or "echo %%path%%"
763 static void handleExpansion(WCHAR
*cmd
, BOOL justFors
, WCHAR
*forVariable
, WCHAR
*forValue
) {
765 /* For commands in a context (batch program): */
766 /* Expand environment variables in a batch file %{0-9} first */
767 /* including support for any ~ modifiers */
769 /* Expand the DATE, TIME, CD, RANDOM and ERRORLEVEL special */
770 /* names allowing environment variable overrides */
771 /* NOTE: To support the %PATH:xxx% syntax, also perform */
772 /* manual expansion of environment variables here */
778 while ((p
= strchrW(p
, '%'))) {
780 WINE_TRACE("Translate command:%s %d (at: %s)\n",
781 wine_dbgstr_w(cmd
), justFors
, wine_dbgstr_w(p
));
784 /* Don't touch %% unless its in Batch */
785 if (!justFors
&& *(p
+1) == '%') {
787 s
= WCMD_strdupW(p
+1);
793 /* Replace %~ modifications if in batch program */
794 } else if (*(p
+1) == '~') {
795 WCMD_HandleTildaModifiers(&p
, forVariable
, forValue
, justFors
);
798 /* Replace use of %0...%9 if in batch program*/
799 } else if (!justFors
&& context
&& (i
>= 0) && (i
<= 9)) {
800 s
= WCMD_strdupW(p
+2);
801 t
= WCMD_parameter (context
-> command
, i
+ context
-> shift_count
[i
], NULL
);
806 /* Replace use of %* if in batch program*/
807 } else if (!justFors
&& context
&& *(p
+1)=='*') {
808 WCHAR
*startOfParms
= NULL
;
809 s
= WCMD_strdupW(p
+2);
810 t
= WCMD_parameter (context
-> command
, 1, &startOfParms
);
811 if (startOfParms
!= NULL
) strcpyW (p
, startOfParms
);
816 } else if (forVariable
&&
817 (CompareString (LOCALE_USER_DEFAULT
,
820 strlenW(forVariable
),
821 forVariable
, -1) == 2)) {
822 s
= WCMD_strdupW(p
+ strlenW(forVariable
));
823 strcpyW(p
, forValue
);
827 } else if (!justFors
) {
828 p
= WCMD_expand_envvar(p
, forVariable
, forValue
);
830 /* In a FOR loop, see if this is the variable to replace */
831 } else { /* Ignore %'s on second pass of batch program */
840 /*******************************************************************
841 * WCMD_parse - parse a command into parameters and qualifiers.
843 * On exit, all qualifiers are concatenated into q, the first string
844 * not beginning with "/" is in p1 and the
845 * second in p2. Any subsequent non-qualifier strings are lost.
846 * Parameters in quotes are handled.
848 static void WCMD_parse (WCHAR
*s
, WCHAR
*q
, WCHAR
*p1
, WCHAR
*p2
)
852 *q
= *p1
= *p2
= '\0';
857 while ((*s
!= '\0') && (*s
!= ' ') && *s
!= '/') {
858 *q
++ = toupperW (*s
++);
868 while ((*s
!= '\0') && (*s
!= '"')) {
869 if (p
== 0) *p1
++ = *s
++;
870 else if (p
== 1) *p2
++ = *s
++;
873 if (p
== 0) *p1
= '\0';
874 if (p
== 1) *p2
= '\0';
881 while ((*s
!= '\0') && (*s
!= ' ') && (*s
!= '\t')
882 && (*s
!= '=') && (*s
!= ',') ) {
883 if (p
== 0) *p1
++ = *s
++;
884 else if (p
== 1) *p2
++ = *s
++;
887 /* Skip concurrent parms */
888 while ((*s
== ' ') || (*s
== '\t') || (*s
== '=') || (*s
== ',') ) s
++;
890 if (p
== 0) *p1
= '\0';
891 if (p
== 1) *p2
= '\0';
897 static void init_msvcrt_io_block(STARTUPINFO
* st
)
900 /* fetch the parent MSVCRT info block if any, so that the child can use the
901 * same handles as its grand-father
903 st_p
.cb
= sizeof(STARTUPINFO
);
904 GetStartupInfo(&st_p
);
905 st
->cbReserved2
= st_p
.cbReserved2
;
906 st
->lpReserved2
= st_p
.lpReserved2
;
907 if (st_p
.cbReserved2
&& st_p
.lpReserved2
)
909 /* Override the entries for fd 0,1,2 if we happened
910 * to change those std handles (this depends on the way wcmd sets
911 * it's new input & output handles)
913 size_t sz
= max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE
)) * 3, st_p
.cbReserved2
);
914 BYTE
* ptr
= HeapAlloc(GetProcessHeap(), 0, sz
);
917 unsigned num
= *(unsigned*)st_p
.lpReserved2
;
918 char* flags
= (char*)(ptr
+ sizeof(unsigned));
919 HANDLE
* handles
= (HANDLE
*)(flags
+ num
* sizeof(char));
921 memcpy(ptr
, st_p
.lpReserved2
, st_p
.cbReserved2
);
922 st
->cbReserved2
= sz
;
923 st
->lpReserved2
= ptr
;
925 #define WX_OPEN 0x01 /* see dlls/msvcrt/file.c */
926 if (num
<= 0 || (flags
[0] & WX_OPEN
))
928 handles
[0] = GetStdHandle(STD_INPUT_HANDLE
);
931 if (num
<= 1 || (flags
[1] & WX_OPEN
))
933 handles
[1] = GetStdHandle(STD_OUTPUT_HANDLE
);
936 if (num
<= 2 || (flags
[2] & WX_OPEN
))
938 handles
[2] = GetStdHandle(STD_ERROR_HANDLE
);
946 /******************************************************************************
949 * Execute a command line as an external program. Must allow recursion.
952 * Manual testing under windows shows PATHEXT plays a key part in this,
953 * and the search algorithm and precedence appears to be as follows.
956 * If directory supplied on command, just use that directory
957 * If extension supplied on command, look for that explicit name first
958 * Otherwise, search in each directory on the path
960 * If extension supplied on command, look for that explicit name first
961 * Then look for supplied name .* (even if extension supplied, so
962 * 'garbage.exe' will match 'garbage.exe.cmd')
963 * If any found, cycle through PATHEXT looking for name.exe one by one
965 * Once a match has been found, it is launched - Code currently uses
966 * findexecutable to achieve this which is left untouched.
969 void WCMD_run_program (WCHAR
*command
, int called
) {
971 WCHAR temp
[MAX_PATH
];
972 WCHAR pathtosearch
[MAXSTRING
];
974 WCHAR stemofsearch
[MAX_PATH
]; /* maximum allowed executable name is
975 MAX_PATH, including null character */
977 WCHAR pathext
[MAXSTRING
];
978 BOOL extensionsupplied
= FALSE
;
979 BOOL launched
= FALSE
;
981 BOOL assumeInternal
= FALSE
;
983 static const WCHAR envPath
[] = {'P','A','T','H','\0'};
984 static const WCHAR envPathExt
[] = {'P','A','T','H','E','X','T','\0'};
985 static const WCHAR delims
[] = {'/','\\',':','\0'};
987 WCMD_parse (command
, quals
, param1
, param2
); /* Quick way to get the filename */
988 if (!(*param1
) && !(*param2
))
991 /* Calculate the search path and stem to search for */
992 if (strpbrkW (param1
, delims
) == NULL
) { /* No explicit path given, search path */
993 static const WCHAR curDir
[] = {'.',';','\0'};
994 strcpyW(pathtosearch
, curDir
);
995 len
= GetEnvironmentVariable (envPath
, &pathtosearch
[2], (sizeof(pathtosearch
)/sizeof(WCHAR
))-2);
996 if ((len
== 0) || (len
>= (sizeof(pathtosearch
)/sizeof(WCHAR
)) - 2)) {
997 static const WCHAR curDir
[] = {'.','\0'};
998 strcpyW (pathtosearch
, curDir
);
1000 if (strchrW(param1
, '.') != NULL
) extensionsupplied
= TRUE
;
1001 if (strlenW(param1
) >= MAX_PATH
)
1003 WCMD_output_asis(WCMD_LoadMessage(WCMD_LINETOOLONG
));
1007 strcpyW(stemofsearch
, param1
);
1011 /* Convert eg. ..\fred to include a directory by removing file part */
1012 GetFullPathName(param1
, sizeof(pathtosearch
)/sizeof(WCHAR
), pathtosearch
, NULL
);
1013 lastSlash
= strrchrW(pathtosearch
, '\\');
1014 if (lastSlash
&& strchrW(lastSlash
, '.') != NULL
) extensionsupplied
= TRUE
;
1015 strcpyW(stemofsearch
, lastSlash
+1);
1017 /* Reduce pathtosearch to a path with trailing '\' to support c:\a.bat and
1018 c:\windows\a.bat syntax */
1019 if (lastSlash
) *(lastSlash
+ 1) = 0x00;
1022 /* Now extract PATHEXT */
1023 len
= GetEnvironmentVariable (envPathExt
, pathext
, sizeof(pathext
)/sizeof(WCHAR
));
1024 if ((len
== 0) || (len
>= (sizeof(pathext
)/sizeof(WCHAR
)))) {
1025 static const WCHAR dfltPathExt
[] = {'.','b','a','t',';',
1026 '.','c','o','m',';',
1027 '.','c','m','d',';',
1028 '.','e','x','e','\0'};
1029 strcpyW (pathext
, dfltPathExt
);
1032 /* Loop through the search path, dir by dir */
1033 pathposn
= pathtosearch
;
1034 WINE_TRACE("Searching in '%s' for '%s'\n", wine_dbgstr_w(pathtosearch
),
1035 wine_dbgstr_w(stemofsearch
));
1036 while (!launched
&& pathposn
) {
1038 WCHAR thisDir
[MAX_PATH
] = {'\0'};
1041 const WCHAR slashW
[] = {'\\','\0'};
1043 /* Work on the first directory on the search path */
1044 pos
= strchrW(pathposn
, ';');
1046 memcpy(thisDir
, pathposn
, (pos
-pathposn
) * sizeof(WCHAR
));
1047 thisDir
[(pos
-pathposn
)] = 0x00;
1051 strcpyW(thisDir
, pathposn
);
1055 /* Since you can have eg. ..\.. on the path, need to expand
1056 to full information */
1057 strcpyW(temp
, thisDir
);
1058 GetFullPathName(temp
, MAX_PATH
, thisDir
, NULL
);
1060 /* 1. If extension supplied, see if that file exists */
1061 strcatW(thisDir
, slashW
);
1062 strcatW(thisDir
, stemofsearch
);
1063 pos
= &thisDir
[strlenW(thisDir
)]; /* Pos = end of name */
1065 /* 1. If extension supplied, see if that file exists */
1066 if (extensionsupplied
) {
1067 if (GetFileAttributes(thisDir
) != INVALID_FILE_ATTRIBUTES
) {
1072 /* 2. Any .* matches? */
1075 WIN32_FIND_DATA finddata
;
1076 static const WCHAR allFiles
[] = {'.','*','\0'};
1078 strcatW(thisDir
,allFiles
);
1079 h
= FindFirstFile(thisDir
, &finddata
);
1081 if (h
!= INVALID_HANDLE_VALUE
) {
1083 WCHAR
*thisExt
= pathext
;
1085 /* 3. Yes - Try each path ext */
1087 WCHAR
*nextExt
= strchrW(thisExt
, ';');
1090 memcpy(pos
, thisExt
, (nextExt
-thisExt
) * sizeof(WCHAR
));
1091 pos
[(nextExt
-thisExt
)] = 0x00;
1092 thisExt
= nextExt
+1;
1094 strcpyW(pos
, thisExt
);
1098 if (GetFileAttributes(thisDir
) != INVALID_FILE_ATTRIBUTES
) {
1106 /* Internal programs won't be picked up by this search, so even
1107 though not found, try one last createprocess and wait for it
1109 Note: Ideally we could tell between a console app (wait) and a
1110 windows app, but the API's for it fail in this case */
1111 if (!found
&& pathposn
== NULL
) {
1112 WINE_TRACE("ASSUMING INTERNAL\n");
1113 assumeInternal
= TRUE
;
1115 WINE_TRACE("Found as %s\n", wine_dbgstr_w(thisDir
));
1118 /* Once found, launch it */
1119 if (found
|| assumeInternal
) {
1121 PROCESS_INFORMATION pe
;
1125 WCHAR
*ext
= strrchrW( thisDir
, '.' );
1126 static const WCHAR batExt
[] = {'.','b','a','t','\0'};
1127 static const WCHAR cmdExt
[] = {'.','c','m','d','\0'};
1131 /* Special case BAT and CMD */
1132 if (ext
&& !strcmpiW(ext
, batExt
)) {
1133 WCMD_batch (thisDir
, command
, called
, NULL
, INVALID_HANDLE_VALUE
);
1135 } else if (ext
&& !strcmpiW(ext
, cmdExt
)) {
1136 WCMD_batch (thisDir
, command
, called
, NULL
, INVALID_HANDLE_VALUE
);
1140 /* thisDir contains the file to be launched, but with what?
1141 eg. a.exe will require a.exe to be launched, a.html may be iexplore */
1142 hinst
= FindExecutable (thisDir
, NULL
, temp
);
1143 if ((INT_PTR
)hinst
< 32)
1146 console
= SHGetFileInfo (temp
, 0, &psfi
, sizeof(psfi
), SHGFI_EXETYPE
);
1148 ZeroMemory (&st
, sizeof(STARTUPINFO
));
1149 st
.cb
= sizeof(STARTUPINFO
);
1150 init_msvcrt_io_block(&st
);
1152 /* Launch the process and if a CUI wait on it to complete
1153 Note: Launching internal wine processes cannot specify a full path to exe */
1154 status
= CreateProcess (assumeInternal
?NULL
: thisDir
,
1155 command
, NULL
, NULL
, TRUE
, 0, NULL
, NULL
, &st
, &pe
);
1156 if ((opt_c
|| opt_k
) && !opt_s
&& !status
1157 && GetLastError()==ERROR_FILE_NOT_FOUND
&& command
[0]=='\"') {
1158 /* strip first and last quote WCHARacters and try again */
1159 WCMD_opt_s_strip_quotes(command
);
1161 WCMD_run_program(command
, called
);
1165 WCMD_print_error ();
1166 /* If a command fails to launch, it sets errorlevel 9009 - which
1167 does not seem to have any associated constant definition */
1171 if (!assumeInternal
&& !console
) errorlevel
= 0;
1174 /* Always wait when called in a batch program context */
1175 if (assumeInternal
|| context
|| !HIWORD(console
)) WaitForSingleObject (pe
.hProcess
, INFINITE
);
1176 GetExitCodeProcess (pe
.hProcess
, &errorlevel
);
1177 if (errorlevel
== STILL_ACTIVE
) errorlevel
= 0;
1179 CloseHandle(pe
.hProcess
);
1180 CloseHandle(pe
.hThread
);
1186 /* Not found anywhere - give up */
1187 SetLastError(ERROR_FILE_NOT_FOUND
);
1188 WCMD_print_error ();
1190 /* If a command fails to launch, it sets errorlevel 9009 - which
1191 does not seem to have any associated constant definition */
1197 /*****************************************************************************
1198 * Process one command. If the command is EXIT this routine does not return.
1199 * We will recurse through here executing batch files.
1201 void WCMD_execute (WCHAR
*command
, WCHAR
*redirects
,
1202 WCHAR
*forVariable
, WCHAR
*forValue
,
1205 WCHAR
*cmd
, *p
, *redir
;
1207 DWORD count
, creationDisposition
;
1210 SECURITY_ATTRIBUTES sa
;
1211 WCHAR
*new_cmd
= NULL
;
1212 WCHAR
*new_redir
= NULL
;
1213 HANDLE old_stdhandles
[3] = {GetStdHandle (STD_INPUT_HANDLE
),
1214 GetStdHandle (STD_OUTPUT_HANDLE
),
1215 GetStdHandle (STD_ERROR_HANDLE
)};
1216 DWORD idx_stdhandles
[3] = {STD_INPUT_HANDLE
,
1221 WINE_TRACE("command on entry:%s (%p), with '%s'='%s'\n",
1222 wine_dbgstr_w(command
), cmdList
,
1223 wine_dbgstr_w(forVariable
), wine_dbgstr_w(forValue
));
1225 /* If the next command is a pipe then we implement pipes by redirecting
1226 the output from this command to a temp file and input into the
1227 next command from that temp file.
1228 FIXME: Use of named pipes would make more sense here as currently this
1229 process has to finish before the next one can start but this requires
1230 a change to not wait for the first app to finish but rather the pipe */
1231 if (cmdList
&& (*cmdList
)->nextcommand
&&
1232 (*cmdList
)->nextcommand
->prevDelim
== CMD_PIPE
) {
1234 WCHAR temp_path
[MAX_PATH
];
1235 static const WCHAR cmdW
[] = {'C','M','D','\0'};
1237 /* Remember piping is in action */
1238 WINE_TRACE("Output needs to be piped\n");
1241 /* Generate a unique temporary filename */
1242 GetTempPath (sizeof(temp_path
)/sizeof(WCHAR
), temp_path
);
1243 GetTempFileName (temp_path
, cmdW
, 0, (*cmdList
)->nextcommand
->pipeFile
);
1244 WINE_TRACE("Using temporary file of %s\n",
1245 wine_dbgstr_w((*cmdList
)->nextcommand
->pipeFile
));
1248 /* Move copy of the command onto the heap so it can be expanded */
1249 new_cmd
= HeapAlloc( GetProcessHeap(), 0, MAXSTRING
* sizeof(WCHAR
));
1252 WINE_ERR("Could not allocate memory for new_cmd\n");
1255 strcpyW(new_cmd
, command
);
1257 /* Move copy of the redirects onto the heap so it can be expanded */
1258 new_redir
= HeapAlloc( GetProcessHeap(), 0, MAXSTRING
* sizeof(WCHAR
));
1261 WINE_ERR("Could not allocate memory for new_redir\n");
1262 HeapFree( GetProcessHeap(), 0, new_cmd
);
1266 /* If piped output, send stdout to the pipe by appending >filename to redirects */
1268 static const WCHAR redirOut
[] = {'%','s',' ','>',' ','%','s','\0'};
1269 wsprintf (new_redir
, redirOut
, redirects
, (*cmdList
)->nextcommand
->pipeFile
);
1270 WINE_TRACE("Redirects now %s\n", wine_dbgstr_w(new_redir
));
1272 strcpyW(new_redir
, redirects
);
1275 /* Expand variables in command line mode only (batch mode will
1276 be expanded as the line is read in, except for 'for' loops) */
1277 handleExpansion(new_cmd
, (context
!= NULL
), forVariable
, forValue
);
1278 handleExpansion(new_redir
, (context
!= NULL
), forVariable
, forValue
);
1281 /* Show prompt before batch line IF echo is on and in batch program */
1282 if (context
&& echo_mode
&& (cmd
[0] != '@')) {
1284 WCMD_output_asis ( cmd
);
1285 WCMD_output_asis ( newline
);
1289 * Changing default drive has to be handled as a special case.
1292 if ((cmd
[1] == ':') && IsCharAlpha (cmd
[0]) && (strlenW(cmd
) == 2)) {
1294 WCHAR dir
[MAX_PATH
];
1296 /* According to MSDN CreateProcess docs, special env vars record
1297 the current directory on each drive, in the form =C:
1298 so see if one specified, and if so go back to it */
1299 strcpyW(envvar
, equalsW
);
1300 strcatW(envvar
, cmd
);
1301 if (GetEnvironmentVariable(envvar
, dir
, MAX_PATH
) == 0) {
1302 static const WCHAR fmt
[] = {'%','s','\\','\0'};
1303 wsprintf(cmd
, fmt
, cmd
);
1304 WINE_TRACE("No special directory settings, using dir of %s\n", wine_dbgstr_w(cmd
));
1306 WINE_TRACE("Got directory %s as %s\n", wine_dbgstr_w(envvar
), wine_dbgstr_w(cmd
));
1307 status
= SetCurrentDirectory (cmd
);
1308 if (!status
) WCMD_print_error ();
1309 HeapFree( GetProcessHeap(), 0, cmd
);
1310 HeapFree( GetProcessHeap(), 0, new_redir
);
1314 sa
.nLength
= sizeof(sa
);
1315 sa
.lpSecurityDescriptor
= NULL
;
1316 sa
.bInheritHandle
= TRUE
;
1319 * Redirect stdin, stdout and/or stderr if required.
1322 /* STDIN could come from a preceding pipe, so delete on close if it does */
1323 if (cmdList
&& (*cmdList
)->pipeFile
[0] != 0x00) {
1324 WINE_TRACE("Input coming from %s\n", wine_dbgstr_w((*cmdList
)->pipeFile
));
1325 h
= CreateFile ((*cmdList
)->pipeFile
, GENERIC_READ
,
1326 FILE_SHARE_READ
, &sa
, OPEN_EXISTING
,
1327 FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_DELETE_ON_CLOSE
, NULL
);
1328 if (h
== INVALID_HANDLE_VALUE
) {
1329 WCMD_print_error ();
1330 HeapFree( GetProcessHeap(), 0, cmd
);
1331 HeapFree( GetProcessHeap(), 0, new_redir
);
1334 SetStdHandle (STD_INPUT_HANDLE
, h
);
1336 /* No need to remember the temporary name any longer once opened */
1337 (*cmdList
)->pipeFile
[0] = 0x00;
1339 /* Otherwise STDIN could come from a '<' redirect */
1340 } else if ((p
= strchrW(new_redir
,'<')) != NULL
) {
1341 h
= CreateFile (WCMD_parameter (++p
, 0, NULL
), GENERIC_READ
, FILE_SHARE_READ
, &sa
, OPEN_EXISTING
,
1342 FILE_ATTRIBUTE_NORMAL
, NULL
);
1343 if (h
== INVALID_HANDLE_VALUE
) {
1344 WCMD_print_error ();
1345 HeapFree( GetProcessHeap(), 0, cmd
);
1346 HeapFree( GetProcessHeap(), 0, new_redir
);
1349 SetStdHandle (STD_INPUT_HANDLE
, h
);
1352 /* Scan the whole command looking for > and 2> */
1354 while (redir
!= NULL
&& ((p
= strchrW(redir
,'>')) != NULL
)) {
1365 creationDisposition
= OPEN_ALWAYS
;
1369 creationDisposition
= CREATE_ALWAYS
;
1372 /* Add support for 2>&1 */
1375 int idx
= *(p
+1) - '0';
1377 if (DuplicateHandle(GetCurrentProcess(),
1378 GetStdHandle(idx_stdhandles
[idx
]),
1379 GetCurrentProcess(),
1381 0, TRUE
, DUPLICATE_SAME_ACCESS
) == 0) {
1382 WINE_FIXME("Duplicating handle failed with gle %d\n", GetLastError());
1384 WINE_TRACE("Redirect %d (%p) to %d (%p)\n", handle
, GetStdHandle(idx_stdhandles
[idx
]), idx
, h
);
1387 WCHAR
*param
= WCMD_parameter (p
, 0, NULL
);
1388 h
= CreateFile (param
, GENERIC_WRITE
, 0, &sa
, creationDisposition
,
1389 FILE_ATTRIBUTE_NORMAL
, NULL
);
1390 if (h
== INVALID_HANDLE_VALUE
) {
1391 WCMD_print_error ();
1392 HeapFree( GetProcessHeap(), 0, cmd
);
1393 HeapFree( GetProcessHeap(), 0, new_redir
);
1396 if (SetFilePointer (h
, 0, NULL
, FILE_END
) ==
1397 INVALID_SET_FILE_POINTER
) {
1398 WCMD_print_error ();
1400 WINE_TRACE("Redirect %d to '%s' (%p)\n", handle
, wine_dbgstr_w(param
), h
);
1403 SetStdHandle (idx_stdhandles
[handle
], h
);
1407 * Strip leading whitespaces, and a '@' if supplied
1409 whichcmd
= WCMD_strtrim_leading_spaces(cmd
);
1410 WINE_TRACE("Command: '%s'\n", wine_dbgstr_w(cmd
));
1411 if (whichcmd
[0] == '@') whichcmd
++;
1414 * Check if the command entered is internal. If it is, pass the rest of the
1415 * line down to the command. If not try to run a program.
1419 while (IsCharAlphaNumeric(whichcmd
[count
])) {
1422 for (i
=0; i
<=WCMD_EXIT
; i
++) {
1423 if (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1424 whichcmd
, count
, inbuilt
[i
], -1) == 2) break;
1426 p
= WCMD_strtrim_leading_spaces (&whichcmd
[count
]);
1427 WCMD_parse (p
, quals
, param1
, param2
);
1428 WINE_TRACE("param1: %s, param2: %s\n", wine_dbgstr_w(param1
), wine_dbgstr_w(param2
));
1433 WCMD_setshow_attrib ();
1440 WCMD_setshow_default (p
);
1443 WCMD_clear_screen ();
1452 WCMD_setshow_date ();
1456 WCMD_delete (p
, TRUE
);
1462 WCMD_echo(&whichcmd
[count
]);
1465 WCMD_for (p
, cmdList
);
1468 WCMD_goto (cmdList
);
1474 WCMD_if (p
, cmdList
);
1487 WCMD_setshow_path (p
);
1493 WCMD_setshow_prompt ();
1503 WCMD_remove_dir (p
);
1512 WCMD_setshow_env (p
);
1518 WCMD_setshow_time ();
1521 if (strlenW(&whichcmd
[count
]) > 0)
1522 WCMD_title(&whichcmd
[count
+1]);
1543 WCMD_assoc(p
, TRUE
);
1549 WCMD_assoc(p
, FALSE
);
1555 WCMD_exit (cmdList
);
1558 WCMD_run_program (whichcmd
, 0);
1560 HeapFree( GetProcessHeap(), 0, cmd
);
1561 HeapFree( GetProcessHeap(), 0, new_redir
);
1563 /* Restore old handles */
1564 for (i
=0; i
<3; i
++) {
1565 if (old_stdhandles
[i
] != GetStdHandle(idx_stdhandles
[i
])) {
1566 CloseHandle (GetStdHandle (idx_stdhandles
[i
]));
1567 SetStdHandle (idx_stdhandles
[i
], old_stdhandles
[i
]);
1571 /*************************************************************************
1573 * Load a string from the resource file, handling any error
1574 * Returns string retrieved from resource file
1576 WCHAR
*WCMD_LoadMessage(UINT id
) {
1577 static WCHAR msg
[2048];
1578 static const WCHAR failedMsg
[] = {'F','a','i','l','e','d','!','\0'};
1580 if (!LoadString(GetModuleHandle(NULL
), id
, msg
, sizeof(msg
)/sizeof(WCHAR
))) {
1581 WINE_FIXME("LoadString failed with %d\n", GetLastError());
1582 strcpyW(msg
, failedMsg
);
1587 /***************************************************************************
1590 * Dumps out the parsed command line to ensure syntax is correct
1592 static void WCMD_DumpCommands(CMD_LIST
*commands
) {
1593 CMD_LIST
*thisCmd
= commands
;
1595 WINE_TRACE("Parsed line:\n");
1596 while (thisCmd
!= NULL
) {
1597 WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
1600 thisCmd
->bracketDepth
,
1601 thisCmd
->nextcommand
,
1602 wine_dbgstr_w(thisCmd
->command
),
1603 wine_dbgstr_w(thisCmd
->redirects
));
1604 thisCmd
= thisCmd
->nextcommand
;
1608 /***************************************************************************
1611 * Adds a command to the current command list
1613 static void WCMD_addCommand(WCHAR
*command
, int *commandLen
,
1614 WCHAR
*redirs
, int *redirLen
,
1615 WCHAR
**copyTo
, int **copyToLen
,
1616 CMD_DELIMITERS prevDelim
, int curDepth
,
1617 CMD_LIST
**lastEntry
, CMD_LIST
**output
) {
1619 CMD_LIST
*thisEntry
= NULL
;
1621 /* Allocate storage for command */
1622 thisEntry
= HeapAlloc(GetProcessHeap(), 0, sizeof(CMD_LIST
));
1624 /* Copy in the command */
1626 thisEntry
->command
= HeapAlloc(GetProcessHeap(), 0,
1627 (*commandLen
+1) * sizeof(WCHAR
));
1628 memcpy(thisEntry
->command
, command
, *commandLen
* sizeof(WCHAR
));
1629 thisEntry
->command
[*commandLen
] = 0x00;
1631 /* Copy in the redirects */
1632 thisEntry
->redirects
= HeapAlloc(GetProcessHeap(), 0,
1633 (*redirLen
+1) * sizeof(WCHAR
));
1634 memcpy(thisEntry
->redirects
, redirs
, *redirLen
* sizeof(WCHAR
));
1635 thisEntry
->redirects
[*redirLen
] = 0x00;
1636 thisEntry
->pipeFile
[0] = 0x00;
1638 /* Reset the lengths */
1641 *copyToLen
= commandLen
;
1645 thisEntry
->command
= NULL
;
1648 /* Fill in other fields */
1649 thisEntry
->nextcommand
= NULL
;
1650 thisEntry
->prevDelim
= prevDelim
;
1651 thisEntry
->bracketDepth
= curDepth
;
1653 (*lastEntry
)->nextcommand
= thisEntry
;
1655 *output
= thisEntry
;
1657 *lastEntry
= thisEntry
;
1660 /***************************************************************************
1661 * WCMD_ReadAndParseLine
1663 * Either uses supplied input or
1664 * Reads a file from the handle, and then...
1665 * Parse the text buffer, spliting into separate commands
1666 * - unquoted && strings split 2 commands but the 2nd is flagged as
1668 * - ( as the first character just ups the bracket depth
1669 * - unquoted ) when bracket depth > 0 terminates a bracket and
1670 * adds a CMD_LIST structure with null command
1671 * - Anything else gets put into the command string (including
1674 WCHAR
*WCMD_ReadAndParseLine(WCHAR
*optionalcmd
, CMD_LIST
**output
, HANDLE readFrom
) {
1678 WCHAR curString
[MAXSTRING
];
1679 int curStringLen
= 0;
1680 WCHAR curRedirs
[MAXSTRING
];
1681 int curRedirsLen
= 0;
1685 CMD_LIST
*lastEntry
= NULL
;
1686 CMD_DELIMITERS prevDelim
= CMD_NONE
;
1687 static WCHAR
*extraSpace
= NULL
; /* Deliberately never freed */
1688 const WCHAR remCmd
[] = {'r','e','m',' ','\0'};
1689 const WCHAR forCmd
[] = {'f','o','r',' ','\0'};
1690 const WCHAR ifCmd
[] = {'i','f',' ','\0'};
1691 const WCHAR ifElse
[] = {'e','l','s','e',' ','\0'};
1697 BOOL onlyWhiteSpace
= FALSE
;
1698 BOOL lastWasWhiteSpace
= FALSE
;
1699 BOOL lastWasDo
= FALSE
;
1700 BOOL lastWasIn
= FALSE
;
1701 BOOL lastWasElse
= FALSE
;
1702 BOOL lastWasRedirect
= TRUE
;
1704 /* Allocate working space for a command read from keyboard, file etc */
1706 extraSpace
= HeapAlloc(GetProcessHeap(), 0, (MAXSTRING
+1) * sizeof(WCHAR
));
1709 WINE_ERR("Could not allocate memory for extraSpace\n");
1713 /* If initial command read in, use that, otherwise get input from handle */
1714 if (optionalcmd
!= NULL
) {
1715 strcpyW(extraSpace
, optionalcmd
);
1716 } else if (readFrom
== INVALID_HANDLE_VALUE
) {
1717 WINE_FIXME("No command nor handle supplied\n");
1719 if (WCMD_fgets(extraSpace
, MAXSTRING
, readFrom
) == NULL
) return NULL
;
1721 curPos
= extraSpace
;
1723 /* Handle truncated input - issue warning */
1724 if (strlenW(extraSpace
) == MAXSTRING
-1) {
1725 WCMD_output_asis(WCMD_LoadMessage(WCMD_TRUNCATEDLINE
));
1726 WCMD_output_asis(extraSpace
);
1727 WCMD_output_asis(newline
);
1730 /* Replace env vars if in a batch context */
1731 if (context
) handleExpansion(extraSpace
, FALSE
, NULL
, NULL
);
1733 /* Start with an empty string, copying to the command string */
1736 curCopyTo
= curString
;
1737 curLen
= &curStringLen
;
1738 lastWasRedirect
= FALSE
; /* Required for eg spaces between > and filename */
1740 /* Parse every character on the line being processed */
1741 while (*curPos
!= 0x00) {
1746 WINE_TRACE("Looking at '%c' (len:%d, lws:%d, ows:%d)\n", *curPos, *curLen,
1747 lastWasWhiteSpace, onlyWhiteSpace);
1750 /* Certain commands need special handling */
1751 if (curStringLen
== 0 && curCopyTo
== curString
) {
1752 const WCHAR forDO
[] = {'d','o',' ','\0'};
1754 /* If command starts with 'rem', ignore any &&, ( etc */
1755 if (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1756 curPos
, 4, remCmd
, -1) == 2) {
1759 /* If command starts with 'for', handle ('s mid line after IN or DO */
1760 } else if (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1761 curPos
, 4, forCmd
, -1) == 2) {
1764 /* If command starts with 'if' or 'else', handle ('s mid line. We should ensure this
1765 is only true in the command portion of the IF statement, but this
1766 should suffice for now
1767 FIXME: Silly syntax like "if 1(==1( (
1769 )" will be parsed wrong */
1770 } else if (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1771 curPos
, 3, ifCmd
, -1) == 2) {
1774 } else if (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1775 curPos
, 5, ifElse
, -1) == 2) {
1778 onlyWhiteSpace
= TRUE
;
1779 memcpy(&curCopyTo
[*curLen
], curPos
, 5*sizeof(WCHAR
));
1784 /* In a for loop, the DO command will follow a close bracket followed by
1785 whitespace, followed by DO, ie closeBracket inserts a NULL entry, curLen
1786 is then 0, and all whitespace is skipped */
1788 (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1789 curPos
, 3, forDO
, -1) == 2)) {
1790 WINE_TRACE("Found DO\n");
1792 onlyWhiteSpace
= TRUE
;
1793 memcpy(&curCopyTo
[*curLen
], curPos
, 3*sizeof(WCHAR
));
1798 } else if (curCopyTo
== curString
) {
1800 /* Special handling for the 'FOR' command */
1801 if (inFor
&& lastWasWhiteSpace
) {
1802 const WCHAR forIN
[] = {'i','n',' ','\0'};
1804 WINE_TRACE("Found 'FOR', comparing next parm: '%s'\n", wine_dbgstr_w(curPos
));
1806 if (CompareString (LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1807 curPos
, 3, forIN
, -1) == 2) {
1808 WINE_TRACE("Found IN\n");
1810 onlyWhiteSpace
= TRUE
;
1811 memcpy(&curCopyTo
[*curLen
], curPos
, 3*sizeof(WCHAR
));
1819 /* Nothing 'ends' a REM statement and &&, quotes etc are ineffective,
1820 so just use the default processing ie skip character specific
1822 if (!inRem
) thisChar
= *curPos
;
1823 else thisChar
= 'X'; /* Character with no special processing */
1825 lastWasWhiteSpace
= FALSE
; /* Will be reset below */
1829 case '=': /* drop through - ignore token delimiters at the start of a command */
1830 case ',': /* drop through - ignore token delimiters at the start of a command */
1831 case '\t':/* drop through - ignore token delimiters at the start of a command */
1833 /* If a redirect in place, it ends here */
1834 if (!inQuotes
&& !lastWasRedirect
) {
1836 /* If finishing off a redirect, add a whitespace delimiter */
1837 if (curCopyTo
== curRedirs
) {
1838 curCopyTo
[(*curLen
)++] = ' ';
1840 curCopyTo
= curString
;
1841 curLen
= &curStringLen
;
1844 curCopyTo
[(*curLen
)++] = *curPos
;
1847 /* Remember just processed whitespace */
1848 lastWasWhiteSpace
= TRUE
;
1852 case '>': /* drop through - handle redirect chars the same */
1854 /* Make a redirect start here */
1856 curCopyTo
= curRedirs
;
1857 curLen
= &curRedirsLen
;
1858 lastWasRedirect
= TRUE
;
1861 /* See if 1>, 2> etc, in which case we have some patching up
1863 if (curPos
!= extraSpace
&&
1864 *(curPos
-1)>='1' && *(curPos
-1)<='9') {
1867 curString
[curStringLen
] = 0x00;
1868 curCopyTo
[(*curLen
)++] = *(curPos
-1);
1871 curCopyTo
[(*curLen
)++] = *curPos
;
1873 /* If a redirect is immediately followed by '&' (ie. 2>&1) then
1874 do not process that ampersand as an AND operator */
1875 if (thisChar
== '>' && *(curPos
+1) == '&') {
1876 curCopyTo
[(*curLen
)++] = *(curPos
+1);
1881 case '|': /* Pipe character only if not || */
1883 lastWasRedirect
= FALSE
;
1885 /* Add an entry to the command list */
1886 if (curStringLen
> 0) {
1888 /* Add the current command */
1889 WCMD_addCommand(curString
, &curStringLen
,
1890 curRedirs
, &curRedirsLen
,
1891 &curCopyTo
, &curLen
,
1892 prevDelim
, curDepth
,
1893 &lastEntry
, output
);
1897 if (*(curPos
+1) == '|') {
1898 curPos
++; /* Skip other | */
1899 prevDelim
= CMD_ONFAILURE
;
1901 prevDelim
= CMD_PIPE
;
1904 curCopyTo
[(*curLen
)++] = *curPos
;
1908 case '"': if (inQuotes
&& *(curPos
+1) == ' ') {
1909 inQuotes
--; /* An end quote must be proceeded by a space */
1911 inQuotes
++; /* Quotes within quotes are fun! */
1913 curCopyTo
[(*curLen
)++] = *curPos
;
1914 lastWasRedirect
= FALSE
;
1917 case '(': /* If a '(' is the first non whitespace in a command portion
1918 ie start of line or just after &&, then we read until an
1919 unquoted ) is found */
1920 WINE_TRACE("Found '(' conditions: curLen(%d), inQ(%d), onlyWS(%d)"
1921 ", for(%d, In:%d, Do:%d)"
1922 ", if(%d, else:%d, lwe:%d)\n",
1925 inFor
, lastWasIn
, lastWasDo
,
1926 inIf
, inElse
, lastWasElse
);
1927 lastWasRedirect
= FALSE
;
1929 /* Ignore open brackets inside the for set */
1930 if (*curLen
== 0 && !inIn
) {
1933 /* If in quotes, ignore brackets */
1934 } else if (inQuotes
) {
1935 curCopyTo
[(*curLen
)++] = *curPos
;
1937 /* In a FOR loop, an unquoted '(' may occur straight after
1939 In an IF statement just handle it regardless as we don't
1941 In an ELSE statement, only allow it straight away after
1942 the ELSE and whitespace
1945 (inElse
&& lastWasElse
&& onlyWhiteSpace
) ||
1946 (inFor
&& (lastWasIn
|| lastWasDo
) && onlyWhiteSpace
)) {
1948 /* If entering into an 'IN', set inIn */
1949 if (inFor
&& lastWasIn
&& onlyWhiteSpace
) {
1950 WINE_TRACE("Inside an IN\n");
1954 /* Add the current command */
1955 WCMD_addCommand(curString
, &curStringLen
,
1956 curRedirs
, &curRedirsLen
,
1957 &curCopyTo
, &curLen
,
1958 prevDelim
, curDepth
,
1959 &lastEntry
, output
);
1963 curCopyTo
[(*curLen
)++] = *curPos
;
1967 case '&': if (!inQuotes
) {
1968 lastWasRedirect
= FALSE
;
1970 /* Add an entry to the command list */
1971 if (curStringLen
> 0) {
1973 /* Add the current command */
1974 WCMD_addCommand(curString
, &curStringLen
,
1975 curRedirs
, &curRedirsLen
,
1976 &curCopyTo
, &curLen
,
1977 prevDelim
, curDepth
,
1978 &lastEntry
, output
);
1982 if (*(curPos
+1) == '&') {
1983 curPos
++; /* Skip other & */
1984 prevDelim
= CMD_ONSUCCESS
;
1986 prevDelim
= CMD_NONE
;
1989 curCopyTo
[(*curLen
)++] = *curPos
;
1993 case ')': if (!inQuotes
&& curDepth
> 0) {
1994 lastWasRedirect
= FALSE
;
1996 /* Add the current command if there is one */
1999 /* Add the current command */
2000 WCMD_addCommand(curString
, &curStringLen
,
2001 curRedirs
, &curRedirsLen
,
2002 &curCopyTo
, &curLen
,
2003 prevDelim
, curDepth
,
2004 &lastEntry
, output
);
2007 /* Add an empty entry to the command list */
2008 prevDelim
= CMD_NONE
;
2009 WCMD_addCommand(NULL
, &curStringLen
,
2010 curRedirs
, &curRedirsLen
,
2011 &curCopyTo
, &curLen
,
2012 prevDelim
, curDepth
,
2013 &lastEntry
, output
);
2016 /* Leave inIn if necessary */
2017 if (inIn
) inIn
= FALSE
;
2019 curCopyTo
[(*curLen
)++] = *curPos
;
2023 lastWasRedirect
= FALSE
;
2024 curCopyTo
[(*curLen
)++] = *curPos
;
2029 /* At various times we need to know if we have only skipped whitespace,
2030 so reset this variable and then it will remain true until a non
2031 whitespace is found */
2032 if ((thisChar
!= ' ') && (thisChar
!= '\n')) onlyWhiteSpace
= FALSE
;
2034 /* Flag end of interest in FOR DO and IN parms once something has been processed */
2035 if (!lastWasWhiteSpace
) {
2036 lastWasIn
= lastWasDo
= FALSE
;
2039 /* If we have reached the end, add this command into the list */
2040 if (*curPos
== 0x00 && *curLen
> 0) {
2042 /* Add an entry to the command list */
2043 WCMD_addCommand(curString
, &curStringLen
,
2044 curRedirs
, &curRedirsLen
,
2045 &curCopyTo
, &curLen
,
2046 prevDelim
, curDepth
,
2047 &lastEntry
, output
);
2050 /* If we have reached the end of the string, see if bracketing outstanding */
2051 if (*curPos
== 0x00 && curDepth
> 0 && readFrom
!= INVALID_HANDLE_VALUE
) {
2053 prevDelim
= CMD_NONE
;
2055 memset(extraSpace
, 0x00, (MAXSTRING
+1) * sizeof(WCHAR
));
2057 /* Read more, skipping any blank lines */
2058 while (*extraSpace
== 0x00) {
2059 if (!context
) WCMD_output_asis( WCMD_LoadMessage(WCMD_MOREPROMPT
));
2060 if (WCMD_fgets(extraSpace
, MAXSTRING
, readFrom
) == NULL
) break;
2062 curPos
= extraSpace
;
2063 if (context
) handleExpansion(extraSpace
, FALSE
, NULL
, NULL
);
2067 /* Dump out the parsed output */
2068 WCMD_DumpCommands(*output
);
2073 /***************************************************************************
2074 * WCMD_process_commands
2076 * Process all the commands read in so far
2078 CMD_LIST
*WCMD_process_commands(CMD_LIST
*thisCmd
, BOOL oneBracket
,
2079 WCHAR
*var
, WCHAR
*val
) {
2083 if (thisCmd
&& oneBracket
) bdepth
= thisCmd
->bracketDepth
;
2085 /* Loop through the commands, processing them one by one */
2088 CMD_LIST
*origCmd
= thisCmd
;
2090 /* If processing one bracket only, and we find the end bracket
2091 entry (or less), return */
2092 if (oneBracket
&& !thisCmd
->command
&&
2093 bdepth
<= thisCmd
->bracketDepth
) {
2094 WINE_TRACE("Finished bracket @ %p, next command is %p\n",
2095 thisCmd
, thisCmd
->nextcommand
);
2096 return thisCmd
->nextcommand
;
2099 /* Ignore the NULL entries a ')' inserts (Only 'if' cares
2100 about them and it will be handled in there)
2101 Also, skip over any batch labels (eg. :fred) */
2102 if (thisCmd
->command
&& thisCmd
->command
[0] != ':') {
2103 WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd
->command
));
2104 WCMD_execute (thisCmd
->command
, thisCmd
->redirects
, var
, val
, &thisCmd
);
2107 /* Step on unless the command itself already stepped on */
2108 if (thisCmd
== origCmd
) thisCmd
= thisCmd
->nextcommand
;
2113 /***************************************************************************
2114 * WCMD_free_commands
2116 * Frees the storage held for a parsed command line
2117 * - This is not done in the process_commands, as eventually the current
2118 * pointer will be modified within the commands, and hence a single free
2119 * routine is simpler
2121 void WCMD_free_commands(CMD_LIST
*cmds
) {
2123 /* Loop through the commands, freeing them one by one */
2125 CMD_LIST
*thisCmd
= cmds
;
2126 cmds
= cmds
->nextcommand
;
2127 HeapFree(GetProcessHeap(), 0, thisCmd
->command
);
2128 HeapFree(GetProcessHeap(), 0, thisCmd
);
2133 /*****************************************************************************
2134 * Main entry point. This is a console application so we have a main() not a
2138 int wmain (int argc
, WCHAR
*argvW
[])
2147 static const WCHAR autoexec
[] = {'\\','a','u','t','o','e','x','e','c','.',
2149 char ansiVersion
[100];
2150 CMD_LIST
*toExecute
= NULL
; /* Commands left to be executed */
2154 /* Pre initialize some messages */
2155 strcpy(ansiVersion
, PACKAGE_VERSION
);
2156 MultiByteToWideChar(CP_ACP
, 0, ansiVersion
, -1, string
, 1024);
2157 wsprintf(version_string
, WCMD_LoadMessage(WCMD_VERSION
), string
);
2158 strcpyW(anykey
, WCMD_LoadMessage(WCMD_ANYKEY
));
2161 opt_c
=opt_k
=opt_q
=opt_s
=0;
2165 WINE_TRACE("Command line parm: '%s'\n", wine_dbgstr_w(*argvW
));
2166 if ((*argvW
)[0]!='/' || (*argvW
)[1]=='\0') {
2173 if (tolowerW(c
)=='c') {
2175 } else if (tolowerW(c
)=='q') {
2177 } else if (tolowerW(c
)=='k') {
2179 } else if (tolowerW(c
)=='s') {
2181 } else if (tolowerW(c
)=='a') {
2183 } else if (tolowerW(c
)=='u') {
2185 } else if (tolowerW(c
)=='t' && (*argvW
)[2]==':') {
2186 opt_t
=strtoulW(&(*argvW
)[3], NULL
, 16);
2187 } else if (tolowerW(c
)=='x' || tolowerW(c
)=='y') {
2188 /* Ignored for compatibility with Windows */
2191 if ((*argvW
)[2]==0) {
2195 else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
2200 if (opt_c
|| opt_k
) /* break out of parsing immediately after c or k */
2205 const WCHAR eoff
[] = {'O','F','F','\0'};
2209 if (opt_c
|| opt_k
) {
2215 /* opt_s left unflagged if the command starts with and contains exactly
2216 * one quoted string (exactly two quote characters). The quoted string
2217 * must be an executable name that has whitespace and must not have the
2218 * following characters: &<>()@^| */
2220 /* Build the command to execute */
2224 for (arg
= argvW
; argsLeft
>0; arg
++,argsLeft
--)
2226 int has_space
,bcount
;
2232 if( !*a
) has_space
=1;
2237 if (*a
==' ' || *a
=='\t') {
2239 } else if (*a
=='"') {
2240 /* doubling of '\' preceding a '"',
2241 * plus escaping of said '"'
2250 len
+=(a
-*arg
) + 1; /* for the separating space */
2253 len
+=2; /* for the quotes */
2261 /* check argvW[0] for a space and invalid characters */
2266 if (*p
=='&' || *p
=='<' || *p
=='>' || *p
=='(' || *p
==')'
2267 || *p
=='@' || *p
=='^' || *p
=='|') {
2277 cmd
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2283 for (arg
= argvW
; argsLeft
>0; arg
++,argsLeft
--)
2285 int has_space
,has_quote
;
2288 /* Check for quotes and spaces in this argument */
2289 has_space
=has_quote
=0;
2291 if( !*a
) has_space
=1;
2293 if (*a
==' ' || *a
=='\t') {
2297 } else if (*a
=='"') {
2305 /* Now transfer it to the command line */
2322 /* Double all the '\\' preceding this '"', plus one */
2323 for (i
=0;i
<=bcount
;i
++)
2342 p
--; /* remove last space */
2345 WINE_TRACE("/c command line: '%s'\n", wine_dbgstr_w(cmd
));
2347 /* strip first and last quote characters if opt_s; check for invalid
2348 * executable is done later */
2349 if (opt_s
&& *cmd
=='\"')
2350 WCMD_opt_s_strip_quotes(cmd
);
2354 /* If we do a "wcmd /c command", we don't want to allocate a new
2355 * console since the command returns immediately. Rather, we use
2356 * the currently allocated input and output handles. This allows
2357 * us to pipe to and read from the command interpreter.
2360 /* Parse the command string, without reading any more input */
2361 WCMD_ReadAndParseLine(cmd
, &toExecute
, INVALID_HANDLE_VALUE
);
2362 WCMD_process_commands(toExecute
, FALSE
, NULL
, NULL
);
2363 WCMD_free_commands(toExecute
);
2366 HeapFree(GetProcessHeap(), 0, cmd
);
2370 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), ENABLE_LINE_INPUT
|
2371 ENABLE_ECHO_INPUT
| ENABLE_PROCESSED_INPUT
);
2372 SetConsoleTitle(WCMD_LoadMessage(WCMD_CONSTITLE
));
2374 /* Note: cmd.exe /c dir does not get a new color, /k dir does */
2376 if (!(((opt_t
& 0xF0) >> 4) == (opt_t
& 0x0F))) {
2377 defaultColor
= opt_t
& 0xFF;
2382 /* Check HKCU\Software\Microsoft\Command Processor
2383 Then HKLM\Software\Microsoft\Command Processor
2384 for defaultcolour value
2385 Note Can be supplied as DWORD or REG_SZ
2386 Note2 When supplied as REG_SZ it's in decimal!!! */
2389 DWORD value
=0, size
=4;
2390 static const WCHAR regKeyW
[] = {'S','o','f','t','w','a','r','e','\\',
2391 'M','i','c','r','o','s','o','f','t','\\',
2392 'C','o','m','m','a','n','d',' ','P','r','o','c','e','s','s','o','r','\0'};
2393 static const WCHAR dfltColorW
[] = {'D','e','f','a','u','l','t','C','o','l','o','r','\0'};
2395 if (RegOpenKeyEx(HKEY_CURRENT_USER
, regKeyW
,
2396 0, KEY_READ
, &key
) == ERROR_SUCCESS
) {
2399 /* See if DWORD or REG_SZ */
2400 if (RegQueryValueEx(key
, dfltColorW
, NULL
, &type
,
2401 NULL
, NULL
) == ERROR_SUCCESS
) {
2402 if (type
== REG_DWORD
) {
2403 size
= sizeof(DWORD
);
2404 RegQueryValueEx(key
, dfltColorW
, NULL
, NULL
,
2405 (LPBYTE
)&value
, &size
);
2406 } else if (type
== REG_SZ
) {
2407 size
= sizeof(strvalue
)/sizeof(WCHAR
);
2408 RegQueryValueEx(key
, dfltColorW
, NULL
, NULL
,
2409 (LPBYTE
)strvalue
, &size
);
2410 value
= strtoulW(strvalue
, NULL
, 10);
2416 if (value
== 0 && RegOpenKeyEx(HKEY_LOCAL_MACHINE
, regKeyW
,
2417 0, KEY_READ
, &key
) == ERROR_SUCCESS
) {
2420 /* See if DWORD or REG_SZ */
2421 if (RegQueryValueEx(key
, dfltColorW
, NULL
, &type
,
2422 NULL
, NULL
) == ERROR_SUCCESS
) {
2423 if (type
== REG_DWORD
) {
2424 size
= sizeof(DWORD
);
2425 RegQueryValueEx(key
, dfltColorW
, NULL
, NULL
,
2426 (LPBYTE
)&value
, &size
);
2427 } else if (type
== REG_SZ
) {
2428 size
= sizeof(strvalue
)/sizeof(WCHAR
);
2429 RegQueryValueEx(key
, dfltColorW
, NULL
, NULL
,
2430 (LPBYTE
)strvalue
, &size
);
2431 value
= strtoulW(strvalue
, NULL
, 10);
2437 /* If one found, set the screen to that colour */
2438 if (!(((value
& 0xF0) >> 4) == (value
& 0x0F))) {
2439 defaultColor
= value
& 0xFF;
2446 /* Save cwd into appropriate env var */
2447 GetCurrentDirectory(1024, string
);
2448 if (IsCharAlpha(string
[0]) && string
[1] == ':') {
2449 static const WCHAR fmt
[] = {'=','%','c',':','\0'};
2450 wsprintf(envvar
, fmt
, string
[0]);
2451 SetEnvironmentVariable(envvar
, string
);
2452 WINE_TRACE("Set %s to %s\n", wine_dbgstr_w(envvar
), wine_dbgstr_w(string
));
2456 /* Parse the command string, without reading any more input */
2457 WCMD_ReadAndParseLine(cmd
, &toExecute
, INVALID_HANDLE_VALUE
);
2458 WCMD_process_commands(toExecute
, FALSE
, NULL
, NULL
);
2459 WCMD_free_commands(toExecute
);
2461 HeapFree(GetProcessHeap(), 0, cmd
);
2465 * If there is an AUTOEXEC.BAT file, try to execute it.
2468 GetFullPathName (autoexec
, sizeof(string
)/sizeof(WCHAR
), string
, NULL
);
2469 h
= CreateFile (string
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2470 if (h
!= INVALID_HANDLE_VALUE
) {
2473 WCMD_batch (autoexec
, autoexec
, 0, NULL
, INVALID_HANDLE_VALUE
);
2478 * Loop forever getting commands and executing them.
2484 /* Read until EOF (which for std input is never, but if redirect
2485 in place, may occur */
2486 WCMD_show_prompt ();
2487 if (WCMD_ReadAndParseLine(NULL
, &toExecute
,
2488 GetStdHandle(STD_INPUT_HANDLE
)) == NULL
)
2490 WCMD_process_commands(toExecute
, FALSE
, NULL
, NULL
);
2491 WCMD_free_commands(toExecute
);