?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcp90: Added basic_string::reserve implementation.
[wine/multimedia.git] / programs / cmd / wcmdmain.c
bloba4726e864c4d4dde1fb40eecd1370dd6639c8c40
1 /*
2 * CMD - Wine-compatible command line interface.
3 *
4 * Copyright (C) 1999 - 2001 D A Pickles
5 * Copyright (C) 2007 J Edmeades
6 *
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.
11 *
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.
16 *
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
20 */
21
22 /*
23 * FIXME:
24 * - Cannot handle parameters in quotes
25 * - Lots of functionality missing from builtins
26 */
27
28 #include "config.h"
29 #include "wcmd.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
33
34 const WCHAR inbuilt[][10] = {
35 {'C','A','L','L','\0'},
36 {'C','D','\0'},
37 {'C','H','D','I','R','\0'},
38 {'C','L','S','\0'},
39 {'C','O','P','Y','\0'},
40 {'C','T','T','Y','\0'},
41 {'D','A','T','E','\0'},
42 {'D','E','L','\0'},
43 {'D','I','R','\0'},
44 {'E','C','H','O','\0'},
45 {'E','R','A','S','E','\0'},
46 {'F','O','R','\0'},
47 {'G','O','T','O','\0'},
48 {'H','E','L','P','\0'},
49 {'I','F','\0'},
50 {'L','A','B','E','L','\0'},
51 {'M','D','\0'},
52 {'M','K','D','I','R','\0'},
53 {'M','O','V','E','\0'},
54 {'P','A','T','H','\0'},
55 {'P','A','U','S','E','\0'},
56 {'P','R','O','M','P','T','\0'},
57 {'R','E','M','\0'},
58 {'R','E','N','\0'},
59 {'R','E','N','A','M','E','\0'},
60 {'R','D','\0'},
61 {'R','M','D','I','R','\0'},
62 {'S','E','T','\0'},
63 {'S','H','I','F','T','\0'},
64 {'T','I','M','E','\0'},
65 {'T','I','T','L','E','\0'},
66 {'T','Y','P','E','\0'},
67 {'V','E','R','I','F','Y','\0'},
68 {'V','E','R','\0'},
69 {'V','O','L','\0'},
70 {'E','N','D','L','O','C','A','L','\0'},
71 {'S','E','T','L','O','C','A','L','\0'},
72 {'P','U','S','H','D','\0'},
73 {'P','O','P','D','\0'},
74 {'A','S','S','O','C','\0'},
75 {'C','O','L','O','R','\0'},
76 {'F','T','Y','P','E','\0'},
77 {'M','O','R','E','\0'},
78 {'C','H','O','I','C','E','\0'},
79 {'E','X','I','T','\0'}
80 };
81
82 const WCHAR externals[NUM_EXTERNALS][10] = {
83 {'A','T','T','R','I','B','\0'},
84 {'X','C','O','P','Y','\0'}
85 };
86
87 HINSTANCE hinst;
88 DWORD errorlevel;
89 int defaultColor = 7;
90 BOOL echo_mode = TRUE;
91 static int opt_c, opt_k, opt_s;
92 const WCHAR newline[] = {'\r','\n','\0'};
93 static const WCHAR equalsW[] = {'=','\0'};
94 static const WCHAR closeBW[] = {')','\0'};
95 WCHAR anykey[100];
96 WCHAR version_string[100];
97 WCHAR quals[MAX_PATH], param1[MAXSTRING], param2[MAXSTRING];
98 BATCH_CONTEXT *context = NULL;
99 extern struct env_stack *pushd_directories;
100 static const WCHAR *pagedMessage = NULL;
101 static char *output_bufA = NULL;
102 #define MAX_WRITECONSOLE_SIZE 65535
103 static BOOL unicodePipes = FALSE;
104
105 /*
106 * Returns a buffer for reading from/writing to file
107 * Never freed
108 */
109 static char *get_file_buffer(void)
110 {
111 if (!output_bufA) {
112 output_bufA = HeapAlloc(GetProcessHeap(), 0, MAX_WRITECONSOLE_SIZE);
113 if (!output_bufA)
114 WINE_FIXME("Out of memory - could not allocate ansi 64K buffer\n");
115 }
116 return output_bufA;
117 }
118
119 /*******************************************************************
120 * WCMD_output_asis_len - send output to current standard output
121 *
122 * Output a formatted unicode string. Ideally this will go to the console
123 * and hence required WriteConsoleW to output it, however if file i/o is
124 * redirected, it needs to be WriteFile'd using OEM (not ANSI) format
125 */
126 static void WCMD_output_asis_len(const WCHAR *message, int len, HANDLE device) {
127
128 DWORD nOut= 0;
129 DWORD res = 0;
130
131 /* If nothing to write, return (MORE does this sometimes) */
132 if (!len) return;
133
134 /* Try to write as unicode assuming it is to a console */
135 res = WriteConsoleW(device, message, len, &nOut, NULL);
136
137 /* If writing to console fails, assume its file
138 i/o so convert to OEM codepage and output */
139 if (!res) {
140 BOOL usedDefaultChar = FALSE;
141 DWORD convertedChars;
142 char *buffer;
143
144 if (!unicodePipes) {
145
146 if (!(buffer = get_file_buffer()))
147 return;
148
149 /* Convert to OEM, then output */
150 convertedChars = WideCharToMultiByte(GetConsoleOutputCP(), 0, message,
151 len, buffer, MAX_WRITECONSOLE_SIZE,
152 "?", &usedDefaultChar);
153 WriteFile(device, buffer, convertedChars,
154 &nOut, FALSE);
155 } else {
156 WriteFile(device, message, len*sizeof(WCHAR),
157 &nOut, FALSE);
158 }
159 }
160 return;
161 }
162
163 /*******************************************************************
164 * WCMD_output - send output to current standard output device.
165 *
166 */
167
168 void WCMD_output (const WCHAR *format, ...) {
169
170 va_list ap;
171 WCHAR string[1024];
172 int ret;
173
174 va_start(ap,format);
175 ret = vsnprintfW(string, sizeof(string)/sizeof(WCHAR), format, ap);
176 if( ret >= (sizeof(string)/sizeof(WCHAR))) {
177 WINE_ERR("Output truncated\n" );
178 ret = (sizeof(string)/sizeof(WCHAR)) - 1;
179 string[ret] = '\0';
180 }
181 va_end(ap);
182 WCMD_output_asis_len(string, ret, GetStdHandle(STD_OUTPUT_HANDLE));
183 }
184
185 /*******************************************************************
186 * WCMD_output_stderr - send output to current standard error device.
187 *
188 */
189
190 void WCMD_output_stderr (const WCHAR *format, ...) {
191
192 va_list ap;
193 WCHAR string[1024];
194 int ret;
195
196 va_start(ap,format);
197 ret = vsnprintfW(string, sizeof(string)/sizeof(WCHAR), format, ap);
198 if( ret >= (sizeof(string)/sizeof(WCHAR))) {
199 WINE_ERR("Output truncated\n" );
200 ret = (sizeof(string)/sizeof(WCHAR)) - 1;
201 string[ret] = '\0';
202 }
203 va_end(ap);
204 WCMD_output_asis_len(string, ret, GetStdHandle(STD_ERROR_HANDLE));
205 }
206
207 static int line_count;
208 static int max_height;
209 static int max_width;
210 static BOOL paged_mode;
211 static int numChars;
212
213 void WCMD_enter_paged_mode(const WCHAR *msg)
214 {
215 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
216
217 if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo)) {
218 max_height = consoleInfo.dwSize.Y;
219 max_width = consoleInfo.dwSize.X;
220 } else {
221 max_height = 25;
222 max_width = 80;
223 }
224 paged_mode = TRUE;
225 line_count = 0;
226 numChars = 0;
227 pagedMessage = (msg==NULL)? anykey : msg;
228 }
229
230 void WCMD_leave_paged_mode(void)
231 {
232 paged_mode = FALSE;
233 pagedMessage = NULL;
234 }
235
236 /***************************************************************************
237 * WCMD_Readfile
238 *
239 * Read characters in from a console/file, returning result in Unicode
240 */
241 BOOL WCMD_ReadFile(const HANDLE hIn, WCHAR *intoBuf, const DWORD maxChars, LPDWORD charsRead)
242 {
243 DWORD numRead;
244 char *buffer;
245
246 if (WCMD_is_console_handle(hIn))
247 /* Try to read from console as Unicode */
248 return ReadConsoleW(hIn, intoBuf, maxChars, charsRead, NULL);
249
250 /* We assume it's a file handle and read then convert from assumed OEM codepage */
251 if (!(buffer = get_file_buffer()))
252 return FALSE;
253
254 if (!ReadFile(hIn, buffer, maxChars, &numRead, NULL))
255 return FALSE;
256
257 *charsRead = MultiByteToWideChar(GetConsoleCP(), 0, buffer, numRead, intoBuf, maxChars);
258
259 return TRUE;
260 }
261
262 /*******************************************************************
263 * WCMD_output_asis_handle
264 *
265 * Send output to specified handle without formatting e.g. when message contains '%'
266 */
267 static void WCMD_output_asis_handle (DWORD std_handle, const WCHAR *message) {
268 DWORD count;
269 const WCHAR* ptr;
270 WCHAR string[1024];
271 HANDLE handle = GetStdHandle(std_handle);
272
273 if (paged_mode) {
274 do {
275 ptr = message;
276 while (*ptr && *ptr!='\n' && (numChars < max_width)) {
277 numChars++;
278 ptr++;
279 };
280 if (*ptr == '\n') ptr++;
281 WCMD_output_asis_len(message, (ptr) ? ptr - message : strlenW(message), handle);
282 if (ptr) {
283 numChars = 0;
284 if (++line_count >= max_height - 1) {
285 line_count = 0;
286 WCMD_output_asis_len(pagedMessage, strlenW(pagedMessage), handle);
287 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string)/sizeof(WCHAR), &count);
288 }
289 }
290 } while (((message = ptr) != NULL) && (*ptr));
291 } else {
292 WCMD_output_asis_len(message, lstrlenW(message), handle);
293 }
294 }
295
296 /*******************************************************************
297 * WCMD_output_asis
298 *
299 * Send output to current standard output device, without formatting
300 * e.g. when message contains '%'
301 */
302 void WCMD_output_asis (const WCHAR *message) {
303 WCMD_output_asis_handle(STD_OUTPUT_HANDLE, message);
304 }
305
306 /*******************************************************************
307 * WCMD_output_asis_stderr
308 *
309 * Send output to current standard error device, without formatting
310 * e.g. when message contains '%'
311 */
312 void WCMD_output_asis_stderr (const WCHAR *message) {
313 WCMD_output_asis_handle(STD_ERROR_HANDLE, message);
314 }
315
316 /****************************************************************************
317 * WCMD_print_error
318 *
319 * Print the message for GetLastError
320 */
321
322 void WCMD_print_error (void) {
323 LPVOID lpMsgBuf;
324 DWORD error_code;
325 int status;
326
327 error_code = GetLastError ();
328 status = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
329 NULL, error_code, 0, (LPWSTR) &lpMsgBuf, 0, NULL);
330 if (!status) {
331 WINE_FIXME ("Cannot display message for error %d, status %d\n",
332 error_code, GetLastError());
333 return;
334 }
335
336 WCMD_output_asis_len(lpMsgBuf, lstrlenW(lpMsgBuf),
337 GetStdHandle(STD_ERROR_HANDLE));
338 LocalFree (lpMsgBuf);
339 WCMD_output_asis_len (newline, lstrlenW(newline),
340 GetStdHandle(STD_ERROR_HANDLE));
341 return;
342 }
343
344 /******************************************************************************
345 * WCMD_show_prompt
346 *
347 * Display the prompt on STDout
348 *
349 */
350
351 static void WCMD_show_prompt (void) {
352
353 int status;
354 WCHAR out_string[MAX_PATH], curdir[MAX_PATH], prompt_string[MAX_PATH];
355 WCHAR *p, *q;
356 DWORD len;
357 static const WCHAR envPrompt[] = {'P','R','O','M','P','T','\0'};
358
359 len = GetEnvironmentVariableW(envPrompt, prompt_string,
360 sizeof(prompt_string)/sizeof(WCHAR));
361 if ((len == 0) || (len >= (sizeof(prompt_string)/sizeof(WCHAR)))) {
362 static const WCHAR dfltPrompt[] = {'$','P','$','G','\0'};
363 strcpyW (prompt_string, dfltPrompt);
364 }
365 p = prompt_string;
366 q = out_string;
367 *q++ = '\r';
368 *q++ = '\n';
369 *q = '\0';
370 while (*p != '\0') {
371 if (*p != '$') {
372 *q++ = *p++;
373 *q = '\0';
374 }
375 else {
376 p++;
377 switch (toupper(*p)) {
378 case '$':
379 *q++ = '$';
380 break;
381 case 'A':
382 *q++ = '&';
383 break;
384 case 'B':
385 *q++ = '|';
386 break;
387 case 'C':
388 *q++ = '(';
389 break;
390 case 'D':
391 GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, q, MAX_PATH);
392 while (*q) q++;
393 break;
394 case 'E':
395 *q++ = '\E';
396 break;
397 case 'F':
398 *q++ = ')';
399 break;
400 case 'G':
401 *q++ = '>';
402 break;
403 case 'H':
404 *q++ = '\b';
405 break;
406 case 'L':
407 *q++ = '<';
408 break;
409 case 'N':
410 status = GetCurrentDirectoryW(sizeof(curdir)/sizeof(WCHAR), curdir);
411 if (status) {
412 *q++ = curdir[0];
413 }
414 break;
415 case 'P':
416 status = GetCurrentDirectoryW(sizeof(curdir)/sizeof(WCHAR), curdir);
417 if (status) {
418 strcatW (q, curdir);
419 while (*q) q++;
420 }
421 break;
422 case 'Q':
423 *q++ = '=';
424 break;
425 case 'S':
426 *q++ = ' ';
427 break;
428 case 'T':
429 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, NULL, q, MAX_PATH);
430 while (*q) q++;
431 break;
432 case 'V':
433 strcatW (q, version_string);
434 while (*q) q++;
435 break;
436 case '_':
437 *q++ = '\n';
438 break;
439 case '+':
440 if (pushd_directories) {
441 memset(q, '+', pushd_directories->u.stackdepth);
442 q = q + pushd_directories->u.stackdepth;
443 }
444 break;
445 }
446 p++;
447 *q = '\0';
448 }
449 }
450 WCMD_output_asis (out_string);
451 }
452
453
454 /*************************************************************************
455 * WCMD_strdupW
456 * A wide version of strdup as its missing from unicode.h
457 */
458 WCHAR *WCMD_strdupW(const WCHAR *input) {
459 int len=strlenW(input)+1;
460 WCHAR *result = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
461 memcpy(result, input, len * sizeof(WCHAR));
462 return result;
463 }
464
465 /*************************************************************************
466 * WCMD_strsubstW
467 * Replaces a portion of a Unicode string with the specified string.
468 * It's up to the caller to ensure there is enough space in the
469 * destination buffer.
470 */
471 void WCMD_strsubstW(WCHAR *start, const WCHAR *next, const WCHAR *insert, int len) {
472
473 if (len < 0)
474 len=insert ? lstrlenW(insert) : 0;
475 if (start+len != next)
476 memmove(start+len, next, (strlenW(next) + 1) * sizeof(*next));
477 if (insert)
478 memcpy(start, insert, len * sizeof(*insert));
479 }
480
481 /***************************************************************************
482 * WCMD_skip_leading_spaces
483 *
484 * Return a pointer to the first non-whitespace character of string.
485 * Does not modify the input string.
486 */
487 WCHAR *WCMD_skip_leading_spaces (WCHAR *string) {
488
489 WCHAR *ptr;
490
491 ptr = string;
492 while (*ptr == ' ' || *ptr == '\t') ptr++;
493 return ptr;
494 }
495
496 /***************************************************************************
497 * WCMD_keyword_ws_found
498 *
499 * Checks if the string located at ptr matches a keyword (of length len)
500 * followed by a whitespace character (space or tab)
501 */
502 BOOL WCMD_keyword_ws_found(const WCHAR *keyword, int len, const WCHAR *ptr) {
503 return (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
504 ptr, len, keyword, len) == CSTR_EQUAL)
505 && ((*(ptr + len) == ' ') || (*(ptr + len) == '\t'));
506 }
507
508 /*************************************************************************
509 * WCMD_opt_s_strip_quotes
510 *
511 * Remove first and last quote WCHARacters, preserving all other text
512 */
513 void WCMD_opt_s_strip_quotes(WCHAR *cmd) {
514 WCHAR *src = cmd + 1, *dest = cmd, *lastq = NULL;
515 while((*dest=*src) != '\0') {
516 if (*src=='\"')
517 lastq=dest;
518 dest++, src++;
519 }
520 if (lastq) {
521 dest=lastq++;
522 while ((*dest++=*lastq++) != 0)
523 ;
524 }
525 }
526
527
528 /*************************************************************************
529 * WCMD_is_magic_envvar
530 * Return TRUE if s is '%'magicvar'%'
531 * and is not masked by a real environment variable.
532 */
533
534 static inline BOOL WCMD_is_magic_envvar(const WCHAR *s, const WCHAR *magicvar)
535 {
536 int len;
537
538 if (s[0] != '%')
539 return FALSE; /* Didn't begin with % */
540 len = strlenW(s);
541 if (len < 2 || s[len-1] != '%')
542 return FALSE; /* Didn't end with another % */
543
544 if (CompareStringW(LOCALE_USER_DEFAULT,
545 NORM_IGNORECASE | SORT_STRINGSORT,
546 s+1, len-2, magicvar, -1) != CSTR_EQUAL) {
547 /* Name doesn't match. */
548 return FALSE;
549 }
550
551 if (GetEnvironmentVariableW(magicvar, NULL, 0) > 0) {
552 /* Masked by real environment variable. */
553 return FALSE;
554 }
555
556 return TRUE;
557 }
558
559 /*************************************************************************
560 * WCMD_expand_envvar
561 *
562 * Expands environment variables, allowing for WCHARacter substitution
563 */
564 static WCHAR *WCMD_expand_envvar(WCHAR *start,
565 const WCHAR *forVar, const WCHAR *forVal) {
566 WCHAR *endOfVar = NULL, *s;
567 WCHAR *colonpos = NULL;
568 WCHAR thisVar[MAXSTRING];
569 WCHAR thisVarContents[MAXSTRING];
570 WCHAR savedchar = 0x00;
571 int len;
572
573 static const WCHAR ErrorLvl[] = {'E','R','R','O','R','L','E','V','E','L','\0'};
574 static const WCHAR Date[] = {'D','A','T','E','\0'};
575 static const WCHAR Time[] = {'T','I','M','E','\0'};
576 static const WCHAR Cd[] = {'C','D','\0'};
577 static const WCHAR Random[] = {'R','A','N','D','O','M','\0'};
578 static const WCHAR Delims[] = {'%',' ',':','\0'};
579
580 WINE_TRACE("Expanding: %s (%s,%s)\n", wine_dbgstr_w(start),
581 wine_dbgstr_w(forVal), wine_dbgstr_w(forVar));
582
583 /* Find the end of the environment variable, and extract name */
584 endOfVar = strpbrkW(start+1, Delims);
585
586 if (endOfVar == NULL || *endOfVar==' ') {
587
588 /* In batch program, missing terminator for % and no following
589 ':' just removes the '%' */
590 if (context) {
591 WCMD_strsubstW(start, start + 1, NULL, 0);
592 return start;
593 } else {
594
595 /* In command processing, just ignore it - allows command line
596 syntax like: for %i in (a.a) do echo %i */
597 return start+1;
598 }
599 }
600
601 /* If ':' found, process remaining up until '%' (or stop at ':' if
602 a missing '%' */
603 if (*endOfVar==':') {
604 WCHAR *endOfVar2 = strchrW(endOfVar+1, '%');
605 if (endOfVar2 != NULL) endOfVar = endOfVar2;
606 }
607
608 memcpy(thisVar, start, ((endOfVar - start) + 1) * sizeof(WCHAR));
609 thisVar[(endOfVar - start)+1] = 0x00;
610 colonpos = strchrW(thisVar+1, ':');
611
612 /* If there's complex substitution, just need %var% for now
613 to get the expanded data to play with */
614 if (colonpos) {
615 *colonpos = '%';
616 savedchar = *(colonpos+1);
617 *(colonpos+1) = 0x00;
618 }
619
620 WINE_TRACE("Retrieving contents of %s\n", wine_dbgstr_w(thisVar));
621
622 /* Expand to contents, if unchanged, return */
623 /* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
624 /* override if existing env var called that name */
625 if (WCMD_is_magic_envvar(thisVar, ErrorLvl)) {
626 static const WCHAR fmt[] = {'%','d','\0'};
627 wsprintfW(thisVarContents, fmt, errorlevel);
628 len = strlenW(thisVarContents);
629 } else if (WCMD_is_magic_envvar(thisVar, Date)) {
630 GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL,
631 NULL, thisVarContents, MAXSTRING);
632 len = strlenW(thisVarContents);
633 } else if (WCMD_is_magic_envvar(thisVar, Time)) {
634 GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL,
635 NULL, thisVarContents, MAXSTRING);
636 len = strlenW(thisVarContents);
637 } else if (WCMD_is_magic_envvar(thisVar, Cd)) {
638 GetCurrentDirectoryW(MAXSTRING, thisVarContents);
639 len = strlenW(thisVarContents);
640 } else if (WCMD_is_magic_envvar(thisVar, Random)) {
641 static const WCHAR fmt[] = {'%','d','\0'};
642 wsprintfW(thisVarContents, fmt, rand() % 32768);
643 len = strlenW(thisVarContents);
644
645 /* Look for a matching 'for' variable */
646 } else if (forVar &&
647 (CompareStringW(LOCALE_USER_DEFAULT,
648 SORT_STRINGSORT,
649 thisVar,
650 (colonpos - thisVar) - 1,
651 forVar, -1) == CSTR_EQUAL)) {
652 strcpyW(thisVarContents, forVal);
653 len = strlenW(thisVarContents);
654
655 } else {
656
657 len = ExpandEnvironmentStringsW(thisVar, thisVarContents,
658 sizeof(thisVarContents)/sizeof(WCHAR));
659 }
660
661 if (len == 0)
662 return endOfVar+1;
663
664 /* In a batch program, unknown env vars are replaced with nothing,
665 note syntax %garbage:1,3% results in anything after the ':'
666 except the %
667 From the command line, you just get back what you entered */
668 if (lstrcmpiW(thisVar, thisVarContents) == 0) {
669
670 /* Restore the complex part after the compare */
671 if (colonpos) {
672 *colonpos = ':';
673 *(colonpos+1) = savedchar;
674 }
675
676 /* Command line - just ignore this */
677 if (context == NULL) return endOfVar+1;
678
679
680 /* Batch - replace unknown env var with nothing */
681 if (colonpos == NULL) {
682 WCMD_strsubstW(start, endOfVar + 1, NULL, 0);
683 } else {
684 len = strlenW(thisVar);
685 thisVar[len-1] = 0x00;
686 /* If %:...% supplied, : is retained */
687 if (colonpos == thisVar+1) {
688 WCMD_strsubstW(start, endOfVar + 1, colonpos, -1);
689 } else {
690 WCMD_strsubstW(start, endOfVar + 1, colonpos + 1, -1);
691 }
692 }
693 return start;
694
695 }
696
697 /* See if we need to do complex substitution (any ':'s), if not
698 then our work here is done */
699 if (colonpos == NULL) {
700 WCMD_strsubstW(start, endOfVar + 1, thisVarContents, -1);
701 return start;
702 }
703
704 /* Restore complex bit */
705 *colonpos = ':';
706 *(colonpos+1) = savedchar;
707
708 /*
709 Handle complex substitutions:
710 xxx=yyy (replace xxx with yyy)
711 *xxx=yyy (replace up to and including xxx with yyy)
712 ~x (from x WCHARs in)
713 ~-x (from x WCHARs from the end)
714 ~x,y (from x WCHARs in for y WCHARacters)
715 ~x,-y (from x WCHARs in until y WCHARacters from the end)
716 */
717
718 /* ~ is substring manipulation */
719 if (savedchar == '~') {
720
721 int substrposition, substrlength = 0;
722 WCHAR *commapos = strchrW(colonpos+2, ',');
723 WCHAR *startCopy;
724
725 substrposition = atolW(colonpos+2);
726 if (commapos) substrlength = atolW(commapos+1);
727
728 /* Check bounds */
729 if (substrposition >= 0) {
730 startCopy = &thisVarContents[min(substrposition, len)];
731 } else {
732 startCopy = &thisVarContents[max(0, len+substrposition-1)];
733 }
734
735 if (commapos == NULL) {
736 /* Copy the lot */
737 WCMD_strsubstW(start, endOfVar + 1, startCopy, -1);
738 } else if (substrlength < 0) {
739
740 int copybytes = (len+substrlength-1)-(startCopy-thisVarContents);
741 if (copybytes > len) copybytes = len;
742 else if (copybytes < 0) copybytes = 0;
743 WCMD_strsubstW(start, endOfVar + 1, startCopy, copybytes);
744 } else {
745 WCMD_strsubstW(start, endOfVar + 1, startCopy, substrlength);
746 }
747
748 return start;
749
750 /* search and replace manipulation */
751 } else {
752 WCHAR *equalspos = strstrW(colonpos, equalsW);
753 WCHAR *replacewith = equalspos+1;
754 WCHAR *found = NULL;
755 WCHAR *searchIn;
756 WCHAR *searchFor;
757
758 if (equalspos == NULL) return start+1;
759 s = WCMD_strdupW(endOfVar + 1);
760
761 /* Null terminate both strings */
762 thisVar[strlenW(thisVar)-1] = 0x00;
763 *equalspos = 0x00;
764
765 /* Since we need to be case insensitive, copy the 2 buffers */
766 searchIn = WCMD_strdupW(thisVarContents);
767 CharUpperBuffW(searchIn, strlenW(thisVarContents));
768 searchFor = WCMD_strdupW(colonpos+1);
769 CharUpperBuffW(searchFor, strlenW(colonpos+1));
770
771 /* Handle wildcard case */
772 if (*(colonpos+1) == '*') {
773 /* Search for string to replace */
774 found = strstrW(searchIn, searchFor+1);
775
776 if (found) {
777 /* Do replacement */
778 strcpyW(start, replacewith);
779 strcatW(start, thisVarContents + (found-searchIn) + strlenW(searchFor+1));
780 strcatW(start, s);
781 } else {
782 /* Copy as is */
783 strcpyW(start, thisVarContents);
784 strcatW(start, s);
785 }
786
787 } else {
788 /* Loop replacing all instances */
789 WCHAR *lastFound = searchIn;
790 WCHAR *outputposn = start;
791
792 *start = 0x00;
793 while ((found = strstrW(lastFound, searchFor))) {
794 lstrcpynW(outputposn,
795 thisVarContents + (lastFound-searchIn),
796 (found - lastFound)+1);
797 outputposn = outputposn + (found - lastFound);
798 strcatW(outputposn, replacewith);
799 outputposn = outputposn + strlenW(replacewith);
800 lastFound = found + strlenW(searchFor);
801 }
802 strcatW(outputposn,
803 thisVarContents + (lastFound-searchIn));
804 strcatW(outputposn, s);
805 }
806 HeapFree(GetProcessHeap(), 0, s);
807 HeapFree(GetProcessHeap(), 0, searchIn);
808 HeapFree(GetProcessHeap(), 0, searchFor);
809 return start;
810 }
811 return start+1;
812 }
813
814 /*****************************************************************************
815 * Expand the command. Native expands lines from batch programs as they are
816 * read in and not again, except for 'for' variable substitution.
817 * eg. As evidence, "echo %1 && shift && echo %1" or "echo %%path%%"
818 */
819 static void handleExpansion(WCHAR *cmd, BOOL justFors,
820 const WCHAR *forVariable, const WCHAR *forValue) {
821
822 /* For commands in a context (batch program): */
823 /* Expand environment variables in a batch file %{0-9} first */
824 /* including support for any ~ modifiers */
825 /* Additionally: */
826 /* Expand the DATE, TIME, CD, RANDOM and ERRORLEVEL special */
827 /* names allowing environment variable overrides */
828 /* NOTE: To support the %PATH:xxx% syntax, also perform */
829 /* manual expansion of environment variables here */
830
831 WCHAR *p = cmd;
832 WCHAR *t;
833 int i;
834
835 while ((p = strchrW(p, '%'))) {
836
837 WINE_TRACE("Translate command:%s %d (at: %s)\n",
838 wine_dbgstr_w(cmd), justFors, wine_dbgstr_w(p));
839 i = *(p+1) - '0';
840
841 /* Don't touch %% unless its in Batch */
842 if (!justFors && *(p+1) == '%') {
843 if (context) {
844 WCMD_strsubstW(p, p+1, NULL, 0);
845 }
846 p+=1;
847
848 /* Replace %~ modifications if in batch program */
849 } else if (*(p+1) == '~') {
850 WCMD_HandleTildaModifiers(&p, forVariable, forValue, justFors);
851 p++;
852
853 /* Replace use of %0...%9 if in batch program*/
854 } else if (!justFors && context && (i >= 0) && (i <= 9)) {
855 t = WCMD_parameter(context -> command, i + context -> shift_count[i], NULL, NULL);
856 WCMD_strsubstW(p, p+2, t, -1);
857
858 /* Replace use of %* if in batch program*/
859 } else if (!justFors && context && *(p+1)=='*') {
860 WCHAR *startOfParms = NULL;
861 t = WCMD_parameter(context -> command, 1, &startOfParms, NULL);
862 if (startOfParms != NULL)
863 WCMD_strsubstW(p, p+2, startOfParms, -1);
864 else
865 WCMD_strsubstW(p, p+2, NULL, 0);
866
867 } else if (forVariable &&
868 (CompareStringW(LOCALE_USER_DEFAULT,
869 SORT_STRINGSORT,
870 p,
871 strlenW(forVariable),
872 forVariable, -1) == CSTR_EQUAL)) {
873 WCMD_strsubstW(p, p + strlenW(forVariable), forValue, -1);
874
875 } else if (!justFors) {
876 p = WCMD_expand_envvar(p, forVariable, forValue);
877
878 /* In a FOR loop, see if this is the variable to replace */
879 } else { /* Ignore %'s on second pass of batch program */
880 p++;
881 }
882 }
883
884 return;
885 }
886
887
888 /*******************************************************************
889 * WCMD_parse - parse a command into parameters and qualifiers.
890 *
891 * On exit, all qualifiers are concatenated into q, the first string
892 * not beginning with "/" is in p1 and the
893 * second in p2. Any subsequent non-qualifier strings are lost.
894 * Parameters in quotes are handled.
895 */
896 static void WCMD_parse (const WCHAR *s, WCHAR *q, WCHAR *p1, WCHAR *p2)
897 {
898 int p = 0;
899
900 *q = *p1 = *p2 = '\0';
901 while (TRUE) {
902 switch (*s) {
903 case '/':
904 *q++ = *s++;
905 while ((*s != '\0') && (*s != ' ') && *s != '/') {
906 *q++ = toupperW (*s++);
907 }
908 *q = '\0';
909 break;
910 case ' ':
911 case '\t':
912 s++;
913 break;
914 case '"':
915 s++;
916 while ((*s != '\0') && (*s != '"')) {
917 if (p == 0) *p1++ = *s++;
918 else if (p == 1) *p2++ = *s++;
919 else s++;
920 }
921 if (p == 0) *p1 = '\0';
922 if (p == 1) *p2 = '\0';
923 p++;
924 if (*s == '"') s++;
925 break;
926 case '\0':
927 return;
928 default:
929 while ((*s != '\0') && (*s != ' ') && (*s != '\t')
930 && (*s != '=') && (*s != ',') ) {
931 if (p == 0) *p1++ = *s++;
932 else if (p == 1) *p2++ = *s++;
933 else s++;
934 }
935 /* Skip concurrent parms */
936 while ((*s == ' ') || (*s == '\t') || (*s == '=') || (*s == ',') ) s++;
937
938 if (p == 0) *p1 = '\0';
939 if (p == 1) *p2 = '\0';
940 p++;
941 }
942 }
943 }
944
945 static void init_msvcrt_io_block(STARTUPINFOW* st)
946 {
947 STARTUPINFOW st_p;
948 /* fetch the parent MSVCRT info block if any, so that the child can use the
949 * same handles as its grand-father
950 */
951 st_p.cb = sizeof(STARTUPINFOW);
952 GetStartupInfoW(&st_p);
953 st->cbReserved2 = st_p.cbReserved2;
954 st->lpReserved2 = st_p.lpReserved2;
955 if (st_p.cbReserved2 && st_p.lpReserved2)
956 {
957 /* Override the entries for fd 0,1,2 if we happened
958 * to change those std handles (this depends on the way cmd sets
959 * its new input & output handles)
960 */
961 size_t sz = max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * 3, st_p.cbReserved2);
962 BYTE* ptr = HeapAlloc(GetProcessHeap(), 0, sz);
963 if (ptr)
964 {
965 unsigned num = *(unsigned*)st_p.lpReserved2;
966 char* flags = (char*)(ptr + sizeof(unsigned));
967 HANDLE* handles = (HANDLE*)(flags + num * sizeof(char));
968
969 memcpy(ptr, st_p.lpReserved2, st_p.cbReserved2);
970 st->cbReserved2 = sz;
971 st->lpReserved2 = ptr;
972
973 #define WX_OPEN 0x01 /* see dlls/msvcrt/file.c */
974 if (num <= 0 || (flags[0] & WX_OPEN))
975 {
976 handles[0] = GetStdHandle(STD_INPUT_HANDLE);
977 flags[0] |= WX_OPEN;
978 }
979 if (num <= 1 || (flags[1] & WX_OPEN))
980 {
981 handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
982 flags[1] |= WX_OPEN;
983 }
984 if (num <= 2 || (flags[2] & WX_OPEN))
985 {
986 handles[2] = GetStdHandle(STD_ERROR_HANDLE);
987 flags[2] |= WX_OPEN;
988 }
989 #undef WX_OPEN
990 }
991 }
992 }
993
994 /******************************************************************************
995 * WCMD_run_program
996 *
997 * Execute a command line as an external program. Must allow recursion.
998 *
999 * Precedence:
1000 * Manual testing under windows shows PATHEXT plays a key part in this,
1001 * and the search algorithm and precedence appears to be as follows.
1002 *
1003 * Search locations:
1004 * If directory supplied on command, just use that directory
1005 * If extension supplied on command, look for that explicit name first
1006 * Otherwise, search in each directory on the path
1007 * Precedence:
1008 * If extension supplied on command, look for that explicit name first
1009 * Then look for supplied name .* (even if extension supplied, so
1010 * 'garbage.exe' will match 'garbage.exe.cmd')
1011 * If any found, cycle through PATHEXT looking for name.exe one by one
1012 * Launching
1013 * Once a match has been found, it is launched - Code currently uses
1014 * findexecutable to achieve this which is left untouched.
1015 */
1016
1017 void WCMD_run_program (WCHAR *command, int called) {
1018
1019 WCHAR temp[MAX_PATH];
1020 WCHAR pathtosearch[MAXSTRING];
1021 WCHAR *pathposn;
1022 WCHAR stemofsearch[MAX_PATH]; /* maximum allowed executable name is
1023 MAX_PATH, including null character */
1024 WCHAR *lastSlash;
1025 WCHAR pathext[MAXSTRING];
1026 BOOL extensionsupplied = FALSE;
1027 BOOL launched = FALSE;
1028 BOOL status;
1029 BOOL assumeInternal = FALSE;
1030 DWORD len;
1031 static const WCHAR envPath[] = {'P','A','T','H','\0'};
1032 static const WCHAR envPathExt[] = {'P','A','T','H','E','X','T','\0'};
1033 static const WCHAR delims[] = {'/','\\',':','\0'};
1034
1035 WCMD_parse (command, quals, param1, param2); /* Quick way to get the filename */
1036 if (!(*param1) && !(*param2))
1037 return;
1038
1039 /* Calculate the search path and stem to search for */
1040 if (strpbrkW (param1, delims) == NULL) { /* No explicit path given, search path */
1041 static const WCHAR curDir[] = {'.',';','\0'};
1042 strcpyW(pathtosearch, curDir);
1043 len = GetEnvironmentVariableW(envPath, &pathtosearch[2], (sizeof(pathtosearch)/sizeof(WCHAR))-2);
1044 if ((len == 0) || (len >= (sizeof(pathtosearch)/sizeof(WCHAR)) - 2)) {
1045 static const WCHAR curDir[] = {'.','\0'};
1046 strcpyW (pathtosearch, curDir);
1047 }
1048 if (strchrW(param1, '.') != NULL) extensionsupplied = TRUE;
1049 if (strlenW(param1) >= MAX_PATH)
1050 {
1051 WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_LINETOOLONG));
1052 return;
1053 }
1054
1055 strcpyW(stemofsearch, param1);
1056
1057 } else {
1058
1059 /* Convert eg. ..\fred to include a directory by removing file part */
1060 GetFullPathNameW(param1, sizeof(pathtosearch)/sizeof(WCHAR), pathtosearch, NULL);
1061 lastSlash = strrchrW(pathtosearch, '\\');
1062 if (lastSlash && strchrW(lastSlash, '.') != NULL) extensionsupplied = TRUE;
1063 strcpyW(stemofsearch, lastSlash+1);
1064
1065 /* Reduce pathtosearch to a path with trailing '\' to support c:\a.bat and
1066 c:\windows\a.bat syntax */
1067 if (lastSlash) *(lastSlash + 1) = 0x00;
1068 }
1069
1070 /* Now extract PATHEXT */
1071 len = GetEnvironmentVariableW(envPathExt, pathext, sizeof(pathext)/sizeof(WCHAR));
1072 if ((len == 0) || (len >= (sizeof(pathext)/sizeof(WCHAR)))) {
1073 static const WCHAR dfltPathExt[] = {'.','b','a','t',';',
1074 '.','c','o','m',';',
1075 '.','c','m','d',';',
1076 '.','e','x','e','\0'};
1077 strcpyW (pathext, dfltPathExt);
1078 }
1079
1080 /* Loop through the search path, dir by dir */
1081 pathposn = pathtosearch;
1082 WINE_TRACE("Searching in '%s' for '%s'\n", wine_dbgstr_w(pathtosearch),
1083 wine_dbgstr_w(stemofsearch));
1084 while (!launched && pathposn) {
1085
1086 WCHAR thisDir[MAX_PATH] = {'\0'};
1087 WCHAR *pos = NULL;
1088 BOOL found = FALSE;
1089 static const WCHAR slashW[] = {'\\','\0'};
1090
1091 /* Work on the first directory on the search path */
1092 pos = strchrW(pathposn, ';');
1093 if (pos) {
1094 memcpy(thisDir, pathposn, (pos-pathposn) * sizeof(WCHAR));
1095 thisDir[(pos-pathposn)] = 0x00;
1096 pathposn = pos+1;
1097
1098 } else {
1099 strcpyW(thisDir, pathposn);
1100 pathposn = NULL;
1101 }
1102
1103 /* Since you can have eg. ..\.. on the path, need to expand
1104 to full information */
1105 strcpyW(temp, thisDir);
1106 GetFullPathNameW(temp, MAX_PATH, thisDir, NULL);
1107
1108 /* 1. If extension supplied, see if that file exists */
1109 strcatW(thisDir, slashW);
1110 strcatW(thisDir, stemofsearch);
1111 pos = &thisDir[strlenW(thisDir)]; /* Pos = end of name */
1112
1113 /* 1. If extension supplied, see if that file exists */
1114 if (extensionsupplied) {
1115 if (GetFileAttributesW(thisDir) != INVALID_FILE_ATTRIBUTES) {
1116 found = TRUE;
1117 }
1118 }
1119
1120 /* 2. Any .* matches? */
1121 if (!found) {
1122 HANDLE h;
1123 WIN32_FIND_DATAW finddata;
1124 static const WCHAR allFiles[] = {'.','*','\0'};
1125
1126 strcatW(thisDir,allFiles);
1127 h = FindFirstFileW(thisDir, &finddata);
1128 FindClose(h);
1129 if (h != INVALID_HANDLE_VALUE) {
1130
1131 WCHAR *thisExt = pathext;
1132
1133 /* 3. Yes - Try each path ext */
1134 while (thisExt) {
1135 WCHAR *nextExt = strchrW(thisExt, ';');
1136
1137 if (nextExt) {
1138 memcpy(pos, thisExt, (nextExt-thisExt) * sizeof(WCHAR));
1139 pos[(nextExt-thisExt)] = 0x00;
1140 thisExt = nextExt+1;
1141 } else {
1142 strcpyW(pos, thisExt);
1143 thisExt = NULL;
1144 }
1145
1146 if (GetFileAttributesW(thisDir) != INVALID_FILE_ATTRIBUTES) {
1147 found = TRUE;
1148 thisExt = NULL;
1149 }
1150 }
1151 }
1152 }
1153
1154 /* Internal programs won't be picked up by this search, so even
1155 though not found, try one last createprocess and wait for it
1156 to complete.
1157 Note: Ideally we could tell between a console app (wait) and a
1158 windows app, but the API's for it fail in this case */
1159 if (!found && pathposn == NULL) {
1160 WINE_TRACE("ASSUMING INTERNAL\n");
1161 assumeInternal = TRUE;
1162 } else {
1163 WINE_TRACE("Found as %s\n", wine_dbgstr_w(thisDir));
1164 }
1165
1166 /* Once found, launch it */
1167 if (found || assumeInternal) {
1168 STARTUPINFOW st;
1169 PROCESS_INFORMATION pe;
1170 SHFILEINFOW psfi;
1171 DWORD console;
1172 HINSTANCE hinst;
1173 WCHAR *ext = strrchrW( thisDir, '.' );
1174 static const WCHAR batExt[] = {'.','b','a','t','\0'};
1175 static const WCHAR cmdExt[] = {'.','c','m','d','\0'};
1176
1177 launched = TRUE;
1178
1179 /* Special case BAT and CMD */
1180 if (ext && !strcmpiW(ext, batExt)) {
1181 WCMD_batch (thisDir, command, called, NULL, INVALID_HANDLE_VALUE);
1182 return;
1183 } else if (ext && !strcmpiW(ext, cmdExt)) {
1184 WCMD_batch (thisDir, command, called, NULL, INVALID_HANDLE_VALUE);
1185 return;
1186 } else {
1187
1188 /* thisDir contains the file to be launched, but with what?
1189 eg. a.exe will require a.exe to be launched, a.html may be iexplore */
1190 hinst = FindExecutableW (thisDir, NULL, temp);
1191 if ((INT_PTR)hinst < 32)
1192 console = 0;
1193 else
1194 console = SHGetFileInfoW(temp, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
1195
1196 ZeroMemory (&st, sizeof(STARTUPINFOW));
1197 st.cb = sizeof(STARTUPINFOW);
1198 init_msvcrt_io_block(&st);
1199
1200 /* Launch the process and if a CUI wait on it to complete
1201 Note: Launching internal wine processes cannot specify a full path to exe */
1202 status = CreateProcessW(assumeInternal?NULL : thisDir,
1203 command, NULL, NULL, TRUE, 0, NULL, NULL, &st, &pe);
1204 if ((opt_c || opt_k) && !opt_s && !status
1205 && GetLastError()==ERROR_FILE_NOT_FOUND && command[0]=='\"') {
1206 /* strip first and last quote WCHARacters and try again */
1207 WCMD_opt_s_strip_quotes(command);
1208 opt_s=1;
1209 WCMD_run_program(command, called);
1210 return;
1211 }
1212
1213 if (!status)
1214 break;
1215
1216 if (!assumeInternal && !console) errorlevel = 0;
1217 else
1218 {
1219 /* Always wait when called in a batch program context */
1220 if (assumeInternal || context || !HIWORD(console)) WaitForSingleObject (pe.hProcess, INFINITE);
1221 GetExitCodeProcess (pe.hProcess, &errorlevel);
1222 if (errorlevel == STILL_ACTIVE) errorlevel = 0;
1223 }
1224 CloseHandle(pe.hProcess);
1225 CloseHandle(pe.hThread);
1226 return;
1227 }
1228 }
1229 }
1230
1231 /* Not found anywhere - give up */
1232 SetLastError(ERROR_FILE_NOT_FOUND);
1233 WCMD_print_error ();
1234
1235 /* If a command fails to launch, it sets errorlevel 9009 - which
1236 does not seem to have any associated constant definition */
1237 errorlevel = 9009;
1238 return;
1239
1240 }
1241
1242 /*****************************************************************************
1243 * Process one command. If the command is EXIT this routine does not return.
1244 * We will recurse through here executing batch files.
1245 */
1246 void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
1247 const WCHAR *forVariable, const WCHAR *forValue,
1248 CMD_LIST **cmdList)
1249 {
1250 WCHAR *cmd, *p, *redir;
1251 int status, i;
1252 DWORD count, creationDisposition;
1253 HANDLE h;
1254 WCHAR *whichcmd;
1255 SECURITY_ATTRIBUTES sa;
1256 WCHAR *new_cmd = NULL;
1257 WCHAR *new_redir = NULL;
1258 HANDLE old_stdhandles[3] = {GetStdHandle (STD_INPUT_HANDLE),
1259 GetStdHandle (STD_OUTPUT_HANDLE),
1260 GetStdHandle (STD_ERROR_HANDLE)};
1261 DWORD idx_stdhandles[3] = {STD_INPUT_HANDLE,
1262 STD_OUTPUT_HANDLE,
1263 STD_ERROR_HANDLE};
1264 BOOL prev_echo_mode, piped = FALSE;
1265
1266 WINE_TRACE("command on entry:%s (%p), with forVariable '%s'='%s'\n",
1267 wine_dbgstr_w(command), cmdList,
1268 wine_dbgstr_w(forVariable), wine_dbgstr_w(forValue));
1269
1270 /* If the next command is a pipe then we implement pipes by redirecting
1271 the output from this command to a temp file and input into the
1272 next command from that temp file.
1273 FIXME: Use of named pipes would make more sense here as currently this
1274 process has to finish before the next one can start but this requires
1275 a change to not wait for the first app to finish but rather the pipe */
1276 if (cmdList && (*cmdList)->nextcommand &&
1277 (*cmdList)->nextcommand->prevDelim == CMD_PIPE) {
1278
1279 WCHAR temp_path[MAX_PATH];
1280 static const WCHAR cmdW[] = {'C','M','D','\0'};
1281
1282 /* Remember piping is in action */
1283 WINE_TRACE("Output needs to be piped\n");
1284 piped = TRUE;
1285
1286 /* Generate a unique temporary filename */
1287 GetTempPathW(sizeof(temp_path)/sizeof(WCHAR), temp_path);
1288 GetTempFileNameW(temp_path, cmdW, 0, (*cmdList)->nextcommand->pipeFile);
1289 WINE_TRACE("Using temporary file of %s\n",
1290 wine_dbgstr_w((*cmdList)->nextcommand->pipeFile));
1291 }
1292
1293 /* Move copy of the command onto the heap so it can be expanded */
1294 new_cmd = HeapAlloc( GetProcessHeap(), 0, MAXSTRING * sizeof(WCHAR));
1295 if (!new_cmd)
1296 {
1297 WINE_ERR("Could not allocate memory for new_cmd\n");
1298 return;
1299 }
1300 strcpyW(new_cmd, command);
1301
1302 /* Move copy of the redirects onto the heap so it can be expanded */
1303 new_redir = HeapAlloc( GetProcessHeap(), 0, MAXSTRING * sizeof(WCHAR));
1304 if (!new_redir)
1305 {
1306 WINE_ERR("Could not allocate memory for new_redir\n");
1307 HeapFree( GetProcessHeap(), 0, new_cmd );
1308 return;
1309 }
1310
1311 /* If piped output, send stdout to the pipe by appending >filename to redirects */
1312 if (piped) {
1313 static const WCHAR redirOut[] = {'%','s',' ','>',' ','%','s','\0'};
1314 wsprintfW (new_redir, redirOut, redirects, (*cmdList)->nextcommand->pipeFile);
1315 WINE_TRACE("Redirects now %s\n", wine_dbgstr_w(new_redir));
1316 } else {
1317 strcpyW(new_redir, redirects);
1318 }
1319
1320 /* Expand variables in command line mode only (batch mode will
1321 be expanded as the line is read in, except for 'for' loops) */
1322 handleExpansion(new_cmd, (context != NULL), forVariable, forValue);
1323 handleExpansion(new_redir, (context != NULL), forVariable, forValue);
1324 cmd = new_cmd;
1325
1326 /*
1327 * Changing default drive has to be handled as a special case.
1328 */
1329
1330 if ((cmd[1] == ':') && IsCharAlphaW(cmd[0]) && (strlenW(cmd) == 2)) {
1331 WCHAR envvar[5];
1332 WCHAR dir[MAX_PATH];
1333
1334 /* According to MSDN CreateProcess docs, special env vars record
1335 the current directory on each drive, in the form =C:
1336 so see if one specified, and if so go back to it */
1337 strcpyW(envvar, equalsW);
1338 strcatW(envvar, cmd);
1339 if (GetEnvironmentVariableW(envvar, dir, MAX_PATH) == 0) {
1340 static const WCHAR fmt[] = {'%','s','\\','\0'};
1341 wsprintfW(cmd, fmt, cmd);
1342 WINE_TRACE("No special directory settings, using dir of %s\n", wine_dbgstr_w(cmd));
1343 }
1344 WINE_TRACE("Got directory %s as %s\n", wine_dbgstr_w(envvar), wine_dbgstr_w(cmd));
1345 status = SetCurrentDirectoryW(cmd);
1346 if (!status) WCMD_print_error ();
1347 HeapFree( GetProcessHeap(), 0, cmd );
1348 HeapFree( GetProcessHeap(), 0, new_redir );
1349 return;
1350 }
1351
1352 sa.nLength = sizeof(sa);
1353 sa.lpSecurityDescriptor = NULL;
1354 sa.bInheritHandle = TRUE;
1355
1356 /*
1357 * Redirect stdin, stdout and/or stderr if required.
1358 */
1359
1360 /* STDIN could come from a preceding pipe, so delete on close if it does */
1361 if (cmdList && (*cmdList)->pipeFile[0] != 0x00) {
1362 WINE_TRACE("Input coming from %s\n", wine_dbgstr_w((*cmdList)->pipeFile));
1363 h = CreateFileW((*cmdList)->pipeFile, GENERIC_READ,
1364 FILE_SHARE_READ, &sa, OPEN_EXISTING,
1365 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL);
1366 if (h == INVALID_HANDLE_VALUE) {
1367 WCMD_print_error ();
1368 HeapFree( GetProcessHeap(), 0, cmd );
1369 HeapFree( GetProcessHeap(), 0, new_redir );
1370 return;
1371 }
1372 SetStdHandle (STD_INPUT_HANDLE, h);
1373
1374 /* No need to remember the temporary name any longer once opened */
1375 (*cmdList)->pipeFile[0] = 0x00;
1376
1377 /* Otherwise STDIN could come from a '<' redirect */
1378 } else if ((p = strchrW(new_redir,'<')) != NULL) {
1379 h = CreateFileW(WCMD_parameter(++p, 0, NULL, NULL), GENERIC_READ, FILE_SHARE_READ,
1380 &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1381 if (h == INVALID_HANDLE_VALUE) {
1382 WCMD_print_error ();
1383 HeapFree( GetProcessHeap(), 0, cmd );
1384 HeapFree( GetProcessHeap(), 0, new_redir );
1385 return;
1386 }
1387 SetStdHandle (STD_INPUT_HANDLE, h);
1388 }
1389
1390 /* Scan the whole command looking for > and 2> */
1391 redir = new_redir;
1392 while (redir != NULL && ((p = strchrW(redir,'>')) != NULL)) {
1393 int handle = 0;
1394
1395 if (p > redir && (*(p-1)=='2'))
1396 handle = 2;
1397 else
1398 handle = 1;
1399
1400 p++;
1401 if ('>' == *p) {
1402 creationDisposition = OPEN_ALWAYS;
1403 p++;
1404 }
1405 else {
1406 creationDisposition = CREATE_ALWAYS;
1407 }
1408
1409 /* Add support for 2>&1 */
1410 redir = p;
1411 if (*p == '&') {
1412 int idx = *(p+1) - '0';
1413
1414 if (DuplicateHandle(GetCurrentProcess(),
1415 GetStdHandle(idx_stdhandles[idx]),
1416 GetCurrentProcess(),
1417 &h,
1418 0, TRUE, DUPLICATE_SAME_ACCESS) == 0) {
1419 WINE_FIXME("Duplicating handle failed with gle %d\n", GetLastError());
1420 }
1421 WINE_TRACE("Redirect %d (%p) to %d (%p)\n", handle, GetStdHandle(idx_stdhandles[idx]), idx, h);
1422
1423 } else {
1424 WCHAR *param = WCMD_parameter(p, 0, NULL, NULL);
1425 h = CreateFileW(param, GENERIC_WRITE, 0, &sa, creationDisposition,
1426 FILE_ATTRIBUTE_NORMAL, NULL);
1427 if (h == INVALID_HANDLE_VALUE) {
1428 WCMD_print_error ();
1429 HeapFree( GetProcessHeap(), 0, cmd );
1430 HeapFree( GetProcessHeap(), 0, new_redir );
1431 return;
1432 }
1433 if (SetFilePointer (h, 0, NULL, FILE_END) ==
1434 INVALID_SET_FILE_POINTER) {
1435 WCMD_print_error ();
1436 }
1437 WINE_TRACE("Redirect %d to '%s' (%p)\n", handle, wine_dbgstr_w(param), h);
1438 }
1439
1440 SetStdHandle (idx_stdhandles[handle], h);
1441 }
1442
1443 /*
1444 * Strip leading whitespaces, and a '@' if supplied
1445 */
1446 whichcmd = WCMD_skip_leading_spaces(cmd);
1447 WINE_TRACE("Command: '%s'\n", wine_dbgstr_w(cmd));
1448 if (whichcmd[0] == '@') whichcmd++;
1449
1450 /*
1451 * Check if the command entered is internal. If it is, pass the rest of the
1452 * line down to the command. If not try to run a program.
1453 */
1454
1455 count = 0;
1456 while (IsCharAlphaNumericW(whichcmd[count])) {
1457 count++;
1458 }
1459 for (i=0; i<=WCMD_EXIT; i++) {
1460 if (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1461 whichcmd, count, inbuilt[i], -1) == CSTR_EQUAL) break;
1462 }
1463 p = WCMD_skip_leading_spaces (&whichcmd[count]);
1464 WCMD_parse (p, quals, param1, param2);
1465 WINE_TRACE("param1: %s, param2: %s\n", wine_dbgstr_w(param1), wine_dbgstr_w(param2));
1466
1467 if (i <= WCMD_EXIT && (p[0] == '/') && (p[1] == '?')) {
1468 /* this is a help request for a builtin program */
1469 i = WCMD_HELP;
1470 memcpy(p, whichcmd, count * sizeof(WCHAR));
1471 p[count] = '\0';
1472
1473 }
1474
1475 switch (i) {
1476
1477 case WCMD_CALL:
1478 WCMD_call (p);
1479 break;
1480 case WCMD_CD:
1481 case WCMD_CHDIR:
1482 WCMD_setshow_default (p);
1483 break;
1484 case WCMD_CLS:
1485 WCMD_clear_screen ();
1486 break;
1487 case WCMD_COPY:
1488 WCMD_copy ();
1489 break;
1490 case WCMD_CTTY:
1491 WCMD_change_tty ();
1492 break;
1493 case WCMD_DATE:
1494 WCMD_setshow_date ();
1495 break;
1496 case WCMD_DEL:
1497 case WCMD_ERASE:
1498 WCMD_delete (p);
1499 break;
1500 case WCMD_DIR:
1501 WCMD_directory (p);
1502 break;
1503 case WCMD_ECHO:
1504 WCMD_echo(&whichcmd[count]);
1505 break;
1506 case WCMD_FOR:
1507 WCMD_for (p, cmdList);
1508 break;
1509 case WCMD_GOTO:
1510 WCMD_goto (cmdList);
1511 break;
1512 case WCMD_HELP:
1513 WCMD_give_help (p);
1514 break;
1515 case WCMD_IF:
1516 WCMD_if (p, cmdList);
1517 break;
1518 case WCMD_LABEL:
1519 WCMD_volume (TRUE, p);
1520 break;
1521 case WCMD_MD:
1522 case WCMD_MKDIR:
1523 WCMD_create_dir (p);
1524 break;
1525 case WCMD_MOVE:
1526 WCMD_move ();
1527 break;
1528 case WCMD_PATH:
1529 WCMD_setshow_path (p);
1530 break;
1531 case WCMD_PAUSE:
1532 WCMD_pause ();
1533 break;
1534 case WCMD_PROMPT:
1535 WCMD_setshow_prompt ();
1536 break;
1537 case WCMD_REM:
1538 break;
1539 case WCMD_REN:
1540 case WCMD_RENAME:
1541 WCMD_rename ();
1542 break;
1543 case WCMD_RD:
1544 case WCMD_RMDIR:
1545 WCMD_remove_dir (p);
1546 break;
1547 case WCMD_SETLOCAL:
1548 WCMD_setlocal(p);
1549 break;
1550 case WCMD_ENDLOCAL:
1551 WCMD_endlocal();
1552 break;
1553 case WCMD_SET:
1554 WCMD_setshow_env (p);
1555 break;
1556 case WCMD_SHIFT:
1557 WCMD_shift (p);
1558 break;
1559 case WCMD_TIME:
1560 WCMD_setshow_time ();
1561 break;
1562 case WCMD_TITLE:
1563 if (strlenW(&whichcmd[count]) > 0)
1564 WCMD_title(&whichcmd[count+1]);
1565 break;
1566 case WCMD_TYPE:
1567 WCMD_type (p);
1568 break;
1569 case WCMD_VER:
1570 WCMD_output(newline);
1571 WCMD_version ();
1572 break;
1573 case WCMD_VERIFY:
1574 WCMD_verify (p);
1575 break;
1576 case WCMD_VOL:
1577 WCMD_volume (FALSE, p);
1578 break;
1579 case WCMD_PUSHD:
1580 WCMD_pushd(p);
1581 break;
1582 case WCMD_POPD:
1583 WCMD_popd();
1584 break;
1585 case WCMD_ASSOC:
1586 WCMD_assoc(p, TRUE);
1587 break;
1588 case WCMD_COLOR:
1589 WCMD_color();
1590 break;
1591 case WCMD_FTYPE:
1592 WCMD_assoc(p, FALSE);
1593 break;
1594 case WCMD_MORE:
1595 WCMD_more(p);
1596 break;
1597 case WCMD_CHOICE:
1598 WCMD_choice(p);
1599 break;
1600 case WCMD_EXIT:
1601 WCMD_exit (cmdList);
1602 break;
1603 default:
1604 prev_echo_mode = echo_mode;
1605 WCMD_run_program (whichcmd, 0);
1606 echo_mode = prev_echo_mode;
1607 }
1608 HeapFree( GetProcessHeap(), 0, cmd );
1609 HeapFree( GetProcessHeap(), 0, new_redir );
1610
1611 /* Restore old handles */
1612 for (i=0; i<3; i++) {
1613 if (old_stdhandles[i] != GetStdHandle(idx_stdhandles[i])) {
1614 CloseHandle (GetStdHandle (idx_stdhandles[i]));
1615 SetStdHandle (idx_stdhandles[i], old_stdhandles[i]);
1616 }
1617 }
1618 }
1619
1620 /*************************************************************************
1621 * WCMD_LoadMessage
1622 * Load a string from the resource file, handling any error
1623 * Returns string retrieved from resource file
1624 */
1625 WCHAR *WCMD_LoadMessage(UINT id) {
1626 static WCHAR msg[2048];
1627 static const WCHAR failedMsg[] = {'F','a','i','l','e','d','!','\0'};
1628
1629 if (!LoadStringW(GetModuleHandleW(NULL), id, msg, sizeof(msg)/sizeof(WCHAR))) {
1630 WINE_FIXME("LoadString failed with %d\n", GetLastError());
1631 strcpyW(msg, failedMsg);
1632 }
1633 return msg;
1634 }
1635
1636 /***************************************************************************
1637 * WCMD_DumpCommands
1638 *
1639 * Dumps out the parsed command line to ensure syntax is correct
1640 */
1641 static void WCMD_DumpCommands(CMD_LIST *commands) {
1642 CMD_LIST *thisCmd = commands;
1643
1644 WINE_TRACE("Parsed line:\n");
1645 while (thisCmd != NULL) {
1646 WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
1647 thisCmd,
1648 thisCmd->prevDelim,
1649 thisCmd->bracketDepth,
1650 thisCmd->nextcommand,
1651 wine_dbgstr_w(thisCmd->command),
1652 wine_dbgstr_w(thisCmd->redirects));
1653 thisCmd = thisCmd->nextcommand;
1654 }
1655 }
1656
1657 /***************************************************************************
1658 * WCMD_addCommand
1659 *
1660 * Adds a command to the current command list
1661 */
1662 static void WCMD_addCommand(WCHAR *command, int *commandLen,
1663 WCHAR *redirs, int *redirLen,
1664 WCHAR **copyTo, int **copyToLen,
1665 CMD_DELIMITERS prevDelim, int curDepth,
1666 CMD_LIST **lastEntry, CMD_LIST **output) {
1667
1668 CMD_LIST *thisEntry = NULL;
1669
1670 /* Allocate storage for command */
1671 thisEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(CMD_LIST));
1672
1673 /* Copy in the command */
1674 if (command) {
1675 thisEntry->command = HeapAlloc(GetProcessHeap(), 0,
1676 (*commandLen+1) * sizeof(WCHAR));
1677 memcpy(thisEntry->command, command, *commandLen * sizeof(WCHAR));
1678 thisEntry->command[*commandLen] = 0x00;
1679
1680 /* Copy in the redirects */
1681 thisEntry->redirects = HeapAlloc(GetProcessHeap(), 0,
1682 (*redirLen+1) * sizeof(WCHAR));
1683 memcpy(thisEntry->redirects, redirs, *redirLen * sizeof(WCHAR));
1684 thisEntry->redirects[*redirLen] = 0x00;
1685 thisEntry->pipeFile[0] = 0x00;
1686
1687 /* Reset the lengths */
1688 *commandLen = 0;
1689 *redirLen = 0;
1690 *copyToLen = commandLen;
1691 *copyTo = command;
1692
1693 } else {
1694 thisEntry->command = NULL;
1695 thisEntry->redirects = NULL;
1696 thisEntry->pipeFile[0] = 0x00;
1697 }
1698
1699 /* Fill in other fields */
1700 thisEntry->nextcommand = NULL;
1701 thisEntry->prevDelim = prevDelim;
1702 thisEntry->bracketDepth = curDepth;
1703 if (*lastEntry) {
1704 (*lastEntry)->nextcommand = thisEntry;
1705 } else {
1706 *output = thisEntry;
1707 }
1708 *lastEntry = thisEntry;
1709 }
1710
1711
1712 /***************************************************************************
1713 * WCMD_IsEndQuote
1714 *
1715 * Checks if the quote pointed to is the end-quote.
1716 *
1717 * Quotes end if:
1718 *
1719 * 1) The current parameter ends at EOL or at the beginning
1720 * of a redirection or pipe and not in a quote section.
1721 *
1722 * 2) If the next character is a space and not in a quote section.
1723 *
1724 * Returns TRUE if this is an end quote, and FALSE if it is not.
1725 *
1726 */
1727 static BOOL WCMD_IsEndQuote(const WCHAR *quote, int quoteIndex)
1728 {
1729 int quoteCount = quoteIndex;
1730 int i;
1731
1732 /* If we are not in a quoted section, then we are not an end-quote */
1733 if(quoteIndex == 0)
1734 {
1735 return FALSE;
1736 }
1737
1738 /* Check how many quotes are left for this parameter */
1739 for(i=0;quote[i];i++)
1740 {
1741 if(quote[i] == '"')
1742 {
1743 quoteCount++;
1744 }
1745
1746 /* Quote counting ends at EOL, redirection, space or pipe if current quote is complete */
1747 else if(((quoteCount % 2) == 0)
1748 && ((quote[i] == '<') || (quote[i] == '>') || (quote[i] == '|') || (quote[i] == ' ')))
1749 {
1750 break;
1751 }
1752 }
1753
1754 /* If the quote is part of the last part of a series of quotes-on-quotes, then it must
1755 be an end-quote */
1756 if(quoteIndex >= (quoteCount / 2))
1757 {
1758 return TRUE;
1759 }
1760
1761 /* No cigar */
1762 return FALSE;
1763 }
1764
1765 /***************************************************************************
1766 * WCMD_ReadAndParseLine
1767 *
1768 * Either uses supplied input or
1769 * Reads a file from the handle, and then...
1770 * Parse the text buffer, splitting into separate commands
1771 * - unquoted && strings split 2 commands but the 2nd is flagged as
1772 * following an &&
1773 * - ( as the first character just ups the bracket depth
1774 * - unquoted ) when bracket depth > 0 terminates a bracket and
1775 * adds a CMD_LIST structure with null command
1776 * - Anything else gets put into the command string (including
1777 * redirects)
1778 */
1779 WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE readFrom)
1780 {
1781 WCHAR *curPos;
1782 int inQuotes = 0;
1783 WCHAR curString[MAXSTRING];
1784 int curStringLen = 0;
1785 WCHAR curRedirs[MAXSTRING];
1786 int curRedirsLen = 0;
1787 WCHAR *curCopyTo;
1788 int *curLen;
1789 int curDepth = 0;
1790 CMD_LIST *lastEntry = NULL;
1791 CMD_DELIMITERS prevDelim = CMD_NONE;
1792 static WCHAR *extraSpace = NULL; /* Deliberately never freed */
1793 static const WCHAR remCmd[] = {'r','e','m'};
1794 static const WCHAR forCmd[] = {'f','o','r'};
1795 static const WCHAR ifCmd[] = {'i','f'};
1796 static const WCHAR ifElse[] = {'e','l','s','e'};
1797 BOOL inRem = FALSE;
1798 BOOL inFor = FALSE;
1799 BOOL inIn = FALSE;
1800 BOOL inIf = FALSE;
1801 BOOL inElse= FALSE;
1802 BOOL onlyWhiteSpace = FALSE;
1803 BOOL lastWasWhiteSpace = FALSE;
1804 BOOL lastWasDo = FALSE;
1805 BOOL lastWasIn = FALSE;
1806 BOOL lastWasElse = FALSE;
1807 BOOL lastWasRedirect = TRUE;
1808
1809 /* Allocate working space for a command read from keyboard, file etc */
1810 if (!extraSpace)
1811 extraSpace = HeapAlloc(GetProcessHeap(), 0, (MAXSTRING+1) * sizeof(WCHAR));
1812 if (!extraSpace)
1813 {
1814 WINE_ERR("Could not allocate memory for extraSpace\n");
1815 return NULL;
1816 }
1817
1818 /* If initial command read in, use that, otherwise get input from handle */
1819 if (optionalcmd != NULL) {
1820 strcpyW(extraSpace, optionalcmd);
1821 } else if (readFrom == INVALID_HANDLE_VALUE) {
1822 WINE_FIXME("No command nor handle supplied\n");
1823 } else {
1824 if (!WCMD_fgets(extraSpace, MAXSTRING, readFrom))
1825 return NULL;
1826 }
1827 curPos = extraSpace;
1828
1829 /* Handle truncated input - issue warning */
1830 if (strlenW(extraSpace) == MAXSTRING -1) {
1831 WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_TRUNCATEDLINE));
1832 WCMD_output_asis_stderr(extraSpace);
1833 WCMD_output_asis_stderr(newline);
1834 }
1835
1836 /* Replace env vars if in a batch context */
1837 if (context) handleExpansion(extraSpace, FALSE, NULL, NULL);
1838 /* Show prompt before batch line IF echo is on and in batch program */
1839 if (context && echo_mode && extraSpace[0] && (extraSpace[0] != '@')) {
1840 static const WCHAR spc[]={' ','\0'};
1841 static const WCHAR echoDot[] = {'e','c','h','o','.'};
1842 static const WCHAR echoCol[] = {'e','c','h','o',':'};
1843 const DWORD len = sizeof(echoDot)/sizeof(echoDot[0]);
1844 DWORD curr_size = strlenW(extraSpace);
1845 DWORD min_len = (curr_size < len ? curr_size : len);
1846 WCMD_show_prompt();
1847 WCMD_output_asis(extraSpace);
1848 /* I don't know why Windows puts a space here but it does */
1849 /* Except for lines starting with 'echo.' or 'echo:'. Ask MS why */
1850 if (CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1851 extraSpace, min_len, echoDot, len) != CSTR_EQUAL
1852 && CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1853 extraSpace, min_len, echoCol, len) != CSTR_EQUAL)
1854 {
1855 WCMD_output_asis(spc);
1856 }
1857 WCMD_output_asis(newline);
1858 }
1859
1860 /* Start with an empty string, copying to the command string */
1861 curStringLen = 0;
1862 curRedirsLen = 0;
1863 curCopyTo = curString;
1864 curLen = &curStringLen;
1865 lastWasRedirect = FALSE; /* Required for eg spaces between > and filename */
1866
1867 /* Parse every character on the line being processed */
1868 while (*curPos != 0x00) {
1869
1870 WCHAR thisChar;
1871
1872 /* Debugging AID:
1873 WINE_TRACE("Looking at '%c' (len:%d, lws:%d, ows:%d)\n", *curPos, *curLen,
1874 lastWasWhiteSpace, onlyWhiteSpace);
1875 */
1876
1877 /* Certain commands need special handling */
1878 if (curStringLen == 0 && curCopyTo == curString) {
1879 static const WCHAR forDO[] = {'d','o'};
1880
1881 /* If command starts with 'rem ', ignore any &&, ( etc. */
1882 if (WCMD_keyword_ws_found(remCmd, sizeof(remCmd)/sizeof(remCmd[0]), curPos)) {
1883 inRem = TRUE;
1884
1885 } else if (WCMD_keyword_ws_found(forCmd, sizeof(forCmd)/sizeof(forCmd[0]), curPos)) {
1886 inFor = TRUE;
1887
1888 /* If command starts with 'if ' or 'else ', handle ('s mid line. We should ensure this
1889 is only true in the command portion of the IF statement, but this
1890 should suffice for now
1891 FIXME: Silly syntax like "if 1(==1( (
1892 echo they equal
1893 )" will be parsed wrong */
1894 } else if (WCMD_keyword_ws_found(ifCmd, sizeof(ifCmd)/sizeof(ifCmd[0]), curPos)) {
1895 inIf = TRUE;
1896
1897 } else if (WCMD_keyword_ws_found(ifElse, sizeof(ifElse)/sizeof(ifElse[0]), curPos)) {
1898 const int keyw_len = sizeof(ifElse)/sizeof(ifElse[0]) + 1;
1899 inElse = TRUE;
1900 lastWasElse = TRUE;
1901 onlyWhiteSpace = TRUE;
1902 memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1903 (*curLen)+=keyw_len;
1904 curPos+=keyw_len;
1905 continue;
1906
1907 /* In a for loop, the DO command will follow a close bracket followed by
1908 whitespace, followed by DO, ie closeBracket inserts a NULL entry, curLen
1909 is then 0, and all whitespace is skipped */
1910 } else if (inFor &&
1911 WCMD_keyword_ws_found(forDO, sizeof(forDO)/sizeof(forDO[0]), curPos)) {
1912 const int keyw_len = sizeof(forDO)/sizeof(forDO[0]) + 1;
1913 WINE_TRACE("Found 'DO '\n");
1914 lastWasDo = TRUE;
1915 onlyWhiteSpace = TRUE;
1916 memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1917 (*curLen)+=keyw_len;
1918 curPos+=keyw_len;
1919 continue;
1920 }
1921 } else if (curCopyTo == curString) {
1922
1923 /* Special handling for the 'FOR' command */
1924 if (inFor && lastWasWhiteSpace) {
1925 static const WCHAR forIN[] = {'i','n'};
1926
1927 WINE_TRACE("Found 'FOR ', comparing next parm: '%s'\n", wine_dbgstr_w(curPos));
1928
1929 if (WCMD_keyword_ws_found(forIN, sizeof(forIN)/sizeof(forIN[0]), curPos)) {
1930 const int keyw_len = sizeof(forIN)/sizeof(forIN[0]) + 1;
1931 WINE_TRACE("Found 'IN '\n");
1932 lastWasIn = TRUE;
1933 onlyWhiteSpace = TRUE;
1934 memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1935 (*curLen)+=keyw_len;
1936 curPos+=keyw_len;
1937 continue;
1938 }
1939 }
1940 }
1941
1942 /* Nothing 'ends' a REM statement and &&, quotes etc are ineffective,
1943 so just use the default processing ie skip character specific
1944 matching below */
1945 if (!inRem) thisChar = *curPos;
1946 else thisChar = 'X'; /* Character with no special processing */
1947
1948 lastWasWhiteSpace = FALSE; /* Will be reset below */
1949
1950 switch (thisChar) {
1951
1952 case '=': /* drop through - ignore token delimiters at the start of a command */
1953 case ',': /* drop through - ignore token delimiters at the start of a command */
1954 case '\t':/* drop through - ignore token delimiters at the start of a command */
1955 case ' ':
1956 /* If a redirect in place, it ends here */
1957 if (!inQuotes && !lastWasRedirect) {
1958
1959 /* If finishing off a redirect, add a whitespace delimiter */
1960 if (curCopyTo == curRedirs) {
1961 curCopyTo[(*curLen)++] = ' ';
1962 }
1963 curCopyTo = curString;
1964 curLen = &curStringLen;
1965 }
1966 if (*curLen > 0) {
1967 curCopyTo[(*curLen)++] = *curPos;
1968 }
1969
1970 /* Remember just processed whitespace */
1971 lastWasWhiteSpace = TRUE;
1972
1973 break;
1974
1975 case '>': /* drop through - handle redirect chars the same */
1976 case '<':
1977 /* Make a redirect start here */
1978 if (!inQuotes) {
1979 curCopyTo = curRedirs;
1980 curLen = &curRedirsLen;
1981 lastWasRedirect = TRUE;
1982 }
1983
1984 /* See if 1>, 2> etc, in which case we have some patching up
1985 to do (provided there's a preceding whitespace, and enough
1986 chars read so far) */
1987 if (curStringLen > 2
1988 && (*(curPos-1)>='1') && (*(curPos-1)<='9')
1989 && ((*(curPos-2)==' ') || (*(curPos-2)=='\t'))) {
1990 curStringLen--;
1991 curString[curStringLen] = 0x00;
1992 curCopyTo[(*curLen)++] = *(curPos-1);
1993 }
1994
1995 curCopyTo[(*curLen)++] = *curPos;
1996
1997 /* If a redirect is immediately followed by '&' (ie. 2>&1) then
1998 do not process that ampersand as an AND operator */
1999 if (thisChar == '>' && *(curPos+1) == '&') {
2000 curCopyTo[(*curLen)++] = *(curPos+1);
2001 curPos++;
2002 }
2003 break;
2004
2005 case '|': /* Pipe character only if not || */
2006 if (!inQuotes) {
2007 lastWasRedirect = FALSE;
2008
2009 /* Add an entry to the command list */
2010 if (curStringLen > 0) {
2011
2012 /* Add the current command */
2013 WCMD_addCommand(curString, &curStringLen,
2014 curRedirs, &curRedirsLen,
2015 &curCopyTo, &curLen,
2016 prevDelim, curDepth,
2017 &lastEntry, output);
2018
2019 }
2020
2021 if (*(curPos+1) == '|') {
2022 curPos++; /* Skip other | */
2023 prevDelim = CMD_ONFAILURE;
2024 } else {
2025 prevDelim = CMD_PIPE;
2026 }
2027 } else {
2028 curCopyTo[(*curLen)++] = *curPos;
2029 }
2030 break;
2031
2032 case '"': if (WCMD_IsEndQuote(curPos, inQuotes)) {
2033 inQuotes--;
2034 } else {
2035 inQuotes++; /* Quotes within quotes are fun! */
2036 }
2037 curCopyTo[(*curLen)++] = *curPos;
2038 lastWasRedirect = FALSE;
2039 break;
2040
2041 case '(': /* If a '(' is the first non whitespace in a command portion
2042 ie start of line or just after &&, then we read until an
2043 unquoted ) is found */
2044 WINE_TRACE("Found '(' conditions: curLen(%d), inQ(%d), onlyWS(%d)"
2045 ", for(%d, In:%d, Do:%d)"
2046 ", if(%d, else:%d, lwe:%d)\n",
2047 *curLen, inQuotes,
2048 onlyWhiteSpace,
2049 inFor, lastWasIn, lastWasDo,
2050 inIf, inElse, lastWasElse);
2051 lastWasRedirect = FALSE;
2052
2053 /* Ignore open brackets inside the for set */
2054 if (*curLen == 0 && !inIn) {
2055 curDepth++;
2056
2057 /* If in quotes, ignore brackets */
2058 } else if (inQuotes) {
2059 curCopyTo[(*curLen)++] = *curPos;
2060
2061 /* In a FOR loop, an unquoted '(' may occur straight after
2062 IN or DO
2063 In an IF statement just handle it regardless as we don't
2064 parse the operands
2065 In an ELSE statement, only allow it straight away after
2066 the ELSE and whitespace
2067 */
2068 } else if (inIf ||
2069 (inElse && lastWasElse && onlyWhiteSpace) ||
2070 (inFor && (lastWasIn || lastWasDo) && onlyWhiteSpace)) {
2071
2072 /* If entering into an 'IN', set inIn */
2073 if (inFor && lastWasIn && onlyWhiteSpace) {
2074 WINE_TRACE("Inside an IN\n");
2075 inIn = TRUE;
2076 }
2077
2078 /* Add the current command */
2079 WCMD_addCommand(curString, &curStringLen,
2080 curRedirs, &curRedirsLen,
2081 &curCopyTo, &curLen,
2082 prevDelim, curDepth,
2083 &lastEntry, output);
2084
2085 curDepth++;
2086 } else {
2087 curCopyTo[(*curLen)++] = *curPos;
2088 }
2089 break;
2090
2091 case '&': if (!inQuotes) {
2092 lastWasRedirect = FALSE;
2093
2094 /* Add an entry to the command list */
2095 if (curStringLen > 0) {
2096
2097 /* Add the current command */
2098 WCMD_addCommand(curString, &curStringLen,
2099 curRedirs, &curRedirsLen,
2100 &curCopyTo, &curLen,
2101 prevDelim, curDepth,
2102 &lastEntry, output);
2103
2104 }
2105
2106 if (*(curPos+1) == '&') {
2107 curPos++; /* Skip other & */
2108 prevDelim = CMD_ONSUCCESS;
2109 } else {
2110 prevDelim = CMD_NONE;
2111 }
2112 } else {
2113 curCopyTo[(*curLen)++] = *curPos;
2114 }
2115 break;
2116
2117 case ')': if (!inQuotes && curDepth > 0) {
2118 lastWasRedirect = FALSE;
2119
2120 /* Add the current command if there is one */
2121 if (curStringLen) {
2122
2123 /* Add the current command */
2124 WCMD_addCommand(curString, &curStringLen,
2125 curRedirs, &curRedirsLen,
2126 &curCopyTo, &curLen,
2127 prevDelim, curDepth,
2128 &lastEntry, output);
2129 }
2130
2131 /* Add an empty entry to the command list */
2132 prevDelim = CMD_NONE;
2133 WCMD_addCommand(NULL, &curStringLen,
2134 curRedirs, &curRedirsLen,
2135 &curCopyTo, &curLen,
2136 prevDelim, curDepth,
2137 &lastEntry, output);
2138 curDepth--;
2139
2140 /* Leave inIn if necessary */
2141 if (inIn) inIn = FALSE;
2142 } else {
2143 curCopyTo[(*curLen)++] = *curPos;
2144 }
2145 break;
2146 default:
2147 lastWasRedirect = FALSE;
2148 curCopyTo[(*curLen)++] = *curPos;
2149 }
2150
2151 curPos++;
2152
2153 /* At various times we need to know if we have only skipped whitespace,
2154 so reset this variable and then it will remain true until a non
2155 whitespace is found */
2156 if ((thisChar != ' ') && (thisChar != '\t') && (thisChar != '\n'))
2157 onlyWhiteSpace = FALSE;
2158
2159 /* Flag end of interest in FOR DO and IN parms once something has been processed */
2160 if (!lastWasWhiteSpace) {
2161 lastWasIn = lastWasDo = FALSE;
2162 }
2163
2164 /* If we have reached the end, add this command into the list */
2165 if (*curPos == 0x00 && *curLen > 0) {
2166
2167 /* Add an entry to the command list */
2168 WCMD_addCommand(curString, &curStringLen,
2169 curRedirs, &curRedirsLen,
2170 &curCopyTo, &curLen,
2171 prevDelim, curDepth,
2172 &lastEntry, output);
2173 }
2174
2175 /* If we have reached the end of the string, see if bracketing outstanding */
2176 if (*curPos == 0x00 && curDepth > 0 && readFrom != INVALID_HANDLE_VALUE) {
2177 inRem = FALSE;
2178 prevDelim = CMD_NONE;
2179 inQuotes = 0;
2180 memset(extraSpace, 0x00, (MAXSTRING+1) * sizeof(WCHAR));
2181
2182 /* Read more, skipping any blank lines */
2183 while (*extraSpace == 0x00) {
2184 if (!context) WCMD_output_asis( WCMD_LoadMessage(WCMD_MOREPROMPT));
2185 if (!WCMD_fgets(extraSpace, MAXSTRING, readFrom))
2186 break;
2187 }
2188 curPos = extraSpace;
2189 if (context) handleExpansion(extraSpace, FALSE, NULL, NULL);
2190 /* Continue to echo commands IF echo is on and in batch program */
2191 if (context && echo_mode && extraSpace[0] && (extraSpace[0] != '@')) {
2192 WCMD_output_asis(extraSpace);
2193 WCMD_output_asis(newline);
2194 }
2195 }
2196 }
2197
2198 /* Dump out the parsed output */
2199 WCMD_DumpCommands(*output);
2200
2201 return extraSpace;
2202 }
2203
2204 /***************************************************************************
2205 * WCMD_process_commands
2206 *
2207 * Process all the commands read in so far
2208 */
2209 CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL oneBracket,
2210 const WCHAR *var, const WCHAR *val) {
2211
2212 int bdepth = -1;
2213
2214 if (thisCmd && oneBracket) bdepth = thisCmd->bracketDepth;
2215
2216 /* Loop through the commands, processing them one by one */
2217 while (thisCmd) {
2218
2219 CMD_LIST *origCmd = thisCmd;
2220
2221 /* If processing one bracket only, and we find the end bracket
2222 entry (or less), return */
2223 if (oneBracket && !thisCmd->command &&
2224 bdepth <= thisCmd->bracketDepth) {
2225 WINE_TRACE("Finished bracket @ %p, next command is %p\n",
2226 thisCmd, thisCmd->nextcommand);
2227 return thisCmd->nextcommand;
2228 }
2229
2230 /* Ignore the NULL entries a ')' inserts (Only 'if' cares
2231 about them and it will be handled in there)
2232 Also, skip over any batch labels (eg. :fred) */
2233 if (thisCmd->command && thisCmd->command[0] != ':') {
2234 WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd->command));
2235 WCMD_execute (thisCmd->command, thisCmd->redirects, var, val, &thisCmd);
2236 }
2237
2238 /* Step on unless the command itself already stepped on */
2239 if (thisCmd == origCmd) thisCmd = thisCmd->nextcommand;
2240 }
2241 return NULL;
2242 }
2243
2244 /***************************************************************************
2245 * WCMD_free_commands
2246 *
2247 * Frees the storage held for a parsed command line
2248 * - This is not done in the process_commands, as eventually the current
2249 * pointer will be modified within the commands, and hence a single free
2250 * routine is simpler
2251 */
2252 void WCMD_free_commands(CMD_LIST *cmds) {
2253
2254 /* Loop through the commands, freeing them one by one */
2255 while (cmds) {
2256 CMD_LIST *thisCmd = cmds;
2257 cmds = cmds->nextcommand;
2258 HeapFree(GetProcessHeap(), 0, thisCmd->command);
2259 HeapFree(GetProcessHeap(), 0, thisCmd->redirects);
2260 HeapFree(GetProcessHeap(), 0, thisCmd);
2261 }
2262 }
2263
2264
2265 /*****************************************************************************
2266 * Main entry point. This is a console application so we have a main() not a
2267 * winmain().
2268 */
2269
2270 int wmain (int argc, WCHAR *argvW[])
2271 {
2272 int args;
2273 WCHAR *cmd = NULL;
2274 WCHAR string[1024];
2275 WCHAR envvar[4];
2276 int opt_q;
2277 int opt_t = 0;
2278 static const WCHAR promptW[] = {'P','R','O','M','P','T','\0'};
2279 static const WCHAR defaultpromptW[] = {'$','P','$','G','\0'};
2280 char ansiVersion[100];
2281 CMD_LIST *toExecute = NULL; /* Commands left to be executed */
2282
2283 srand(time(NULL));
2284
2285 /* Pre initialize some messages */
2286 strcpy(ansiVersion, PACKAGE_VERSION);
2287 MultiByteToWideChar(CP_ACP, 0, ansiVersion, -1, string, 1024);
2288 wsprintfW(version_string, WCMD_LoadMessage(WCMD_VERSION), string);
2289 strcpyW(anykey, WCMD_LoadMessage(WCMD_ANYKEY));
2290
2291 args = argc;
2292 opt_c=opt_k=opt_q=opt_s=0;
2293 while (args > 0)
2294 {
2295 WCHAR c;
2296 WINE_TRACE("Command line parm: '%s'\n", wine_dbgstr_w(*argvW));
2297 if ((*argvW)[0]!='/' || (*argvW)[1]=='\0') {
2298 argvW++;
2299 args--;
2300 continue;
2301 }
2302
2303 c=(*argvW)[1];
2304 if (tolowerW(c)=='c') {
2305 opt_c=1;
2306 } else if (tolowerW(c)=='q') {
2307 opt_q=1;
2308 } else if (tolowerW(c)=='k') {
2309 opt_k=1;
2310 } else if (tolowerW(c)=='s') {
2311 opt_s=1;
2312 } else if (tolowerW(c)=='a') {
2313 unicodePipes=FALSE;
2314 } else if (tolowerW(c)=='u') {
2315 unicodePipes=TRUE;
2316 } else if (tolowerW(c)=='t' && (*argvW)[2]==':') {
2317 opt_t=strtoulW(&(*argvW)[3], NULL, 16);
2318 } else if (tolowerW(c)=='x' || tolowerW(c)=='y') {
2319 /* Ignored for compatibility with Windows */
2320 }
2321
2322 if ((*argvW)[2]==0) {
2323 argvW++;
2324 args--;
2325 }
2326 else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
2327 {
2328 *argvW+=2;
2329 }
2330
2331 if (opt_c || opt_k) /* break out of parsing immediately after c or k */
2332 break;
2333 }
2334
2335 if (opt_q) {
2336 static const WCHAR eoff[] = {'O','F','F','\0'};
2337 WCMD_echo(eoff);
2338 }
2339
2340 if (opt_c || opt_k) {
2341 int len,qcount;
2342 WCHAR** arg;
2343 int argsLeft;
2344 WCHAR* p;
2345
2346 /* opt_s left unflagged if the command starts with and contains exactly
2347 * one quoted string (exactly two quote characters). The quoted string
2348 * must be an executable name that has whitespace and must not have the
2349 * following characters: &<>()@^| */
2350
2351 /* Build the command to execute */
2352 len = 0;
2353 qcount = 0;
2354 argsLeft = args;
2355 for (arg = argvW; argsLeft>0; arg++,argsLeft--)
2356 {
2357 int has_space,bcount;
2358 WCHAR* a;
2359
2360 has_space=0;
2361 bcount=0;
2362 a=*arg;
2363 if( !*a ) has_space=1;
2364 while (*a!='\0') {
2365 if (*a=='\\') {
2366 bcount++;
2367 } else {
2368 if (*a==' ' || *a=='\t') {
2369 has_space=1;
2370 } else if (*a=='"') {
2371 /* doubling of '\' preceding a '"',
2372 * plus escaping of said '"'
2373 */
2374 len+=2*bcount+1;
2375 qcount++;
2376 }
2377 bcount=0;
2378 }
2379 a++;
2380 }
2381 len+=(a-*arg) + 1; /* for the separating space */
2382 if (has_space)
2383 {
2384 len+=2; /* for the quotes */
2385 qcount+=2;
2386 }
2387 }
2388
2389 if (qcount!=2)
2390 opt_s=1;
2391
2392 /* check argvW[0] for a space and invalid characters */
2393 if (!opt_s) {
2394 opt_s=1;
2395 p=*argvW;
2396 while (*p!='\0') {
2397 if (*p=='&' || *p=='<' || *p=='>' || *p=='(' || *p==')'
2398 || *p=='@' || *p=='^' || *p=='|') {
2399 opt_s=1;
2400 break;
2401 }
2402 if (*p==' ')
2403 opt_s=0;
2404 p++;
2405 }
2406 }
2407
2408 cmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2409 if (!cmd)
2410 exit(1);
2411
2412 p = cmd;
2413 argsLeft = args;
2414 for (arg = argvW; argsLeft>0; arg++,argsLeft--)
2415 {
2416 int has_space,has_quote;
2417 WCHAR* a;
2418
2419 /* Check for quotes and spaces in this argument */
2420 has_space=has_quote=0;
2421 a=*arg;
2422 if( !*a ) has_space=1;
2423 while (*a!='\0') {
2424 if (*a==' ' || *a=='\t') {
2425 has_space=1;
2426 if (has_quote)
2427 break;
2428 } else if (*a=='"') {
2429 has_quote=1;
2430 if (has_space)
2431 break;
2432 }
2433 a++;
2434 }
2435
2436 /* Now transfer it to the command line */
2437 if (has_space)
2438 *p++='"';
2439 if (has_quote) {
2440 int bcount;
2441 WCHAR* a;
2442
2443 bcount=0;
2444 a=*arg;
2445 while (*a!='\0') {
2446 if (*a=='\\') {
2447 *p++=*a;
2448 bcount++;
2449 } else {
2450 if (*a=='"') {
2451 int i;
2452
2453 /* Double all the '\\' preceding this '"', plus one */
2454 for (i=0;i<=bcount;i++)
2455 *p++='\\';
2456 *p++='"';
2457 } else {
2458 *p++=*a;
2459 }
2460 bcount=0;
2461 }
2462 a++;
2463 }
2464 } else {
2465 strcpyW(p,*arg);
2466 p+=strlenW(*arg);
2467 }
2468 if (has_space)
2469 *p++='"';
2470 *p++=' ';
2471 }
2472 if (p > cmd)
2473 p--; /* remove last space */
2474 *p = '\0';
2475
2476 WINE_TRACE("/c command line: '%s'\n", wine_dbgstr_w(cmd));
2477
2478 /* strip first and last quote characters if opt_s; check for invalid
2479 * executable is done later */
2480 if (opt_s && *cmd=='\"')
2481 WCMD_opt_s_strip_quotes(cmd);
2482 }
2483
2484 if (opt_c) {
2485 /* If we do a "cmd /c command", we don't want to allocate a new
2486 * console since the command returns immediately. Rather, we use
2487 * the currently allocated input and output handles. This allows
2488 * us to pipe to and read from the command interpreter.
2489 */
2490
2491 /* Parse the command string, without reading any more input */
2492 WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
2493 WCMD_process_commands(toExecute, FALSE, NULL, NULL);
2494 WCMD_free_commands(toExecute);
2495 toExecute = NULL;
2496
2497 HeapFree(GetProcessHeap(), 0, cmd);
2498 return errorlevel;
2499 }
2500
2501 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_LINE_INPUT |
2502 ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
2503 SetConsoleTitleW(WCMD_LoadMessage(WCMD_CONSTITLE));
2504
2505 /* Note: cmd.exe /c dir does not get a new color, /k dir does */
2506 if (opt_t) {
2507 if (!(((opt_t & 0xF0) >> 4) == (opt_t & 0x0F))) {
2508 defaultColor = opt_t & 0xFF;
2509 param1[0] = 0x00;
2510 WCMD_color();
2511 }
2512 } else {
2513 /* Check HKCU\Software\Microsoft\Command Processor
2514 Then HKLM\Software\Microsoft\Command Processor
2515 for defaultcolour value
2516 Note Can be supplied as DWORD or REG_SZ
2517 Note2 When supplied as REG_SZ it's in decimal!!! */
2518 HKEY key;
2519 DWORD type;
2520 DWORD value=0, size=4;
2521 static const WCHAR regKeyW[] = {'S','o','f','t','w','a','r','e','\\',
2522 'M','i','c','r','o','s','o','f','t','\\',
2523 'C','o','m','m','a','n','d',' ','P','r','o','c','e','s','s','o','r','\0'};
2524 static const WCHAR dfltColorW[] = {'D','e','f','a','u','l','t','C','o','l','o','r','\0'};
2525
2526 if (RegOpenKeyExW(HKEY_CURRENT_USER, regKeyW,
2527 0, KEY_READ, &key) == ERROR_SUCCESS) {
2528 WCHAR strvalue[4];
2529
2530 /* See if DWORD or REG_SZ */
2531 if (RegQueryValueExW(key, dfltColorW, NULL, &type,
2532 NULL, NULL) == ERROR_SUCCESS) {
2533 if (type == REG_DWORD) {
2534 size = sizeof(DWORD);
2535 RegQueryValueExW(key, dfltColorW, NULL, NULL,
2536 (LPBYTE)&value, &size);
2537 } else if (type == REG_SZ) {
2538 size = sizeof(strvalue)/sizeof(WCHAR);
2539 RegQueryValueExW(key, dfltColorW, NULL, NULL,
2540 (LPBYTE)strvalue, &size);
2541 value = strtoulW(strvalue, NULL, 10);
2542 }
2543 }
2544 RegCloseKey(key);
2545 }
2546
2547 if (value == 0 && RegOpenKeyExW(HKEY_LOCAL_MACHINE, regKeyW,
2548 0, KEY_READ, &key) == ERROR_SUCCESS) {
2549 WCHAR strvalue[4];
2550
2551 /* See if DWORD or REG_SZ */
2552 if (RegQueryValueExW(key, dfltColorW, NULL, &type,
2553 NULL, NULL) == ERROR_SUCCESS) {
2554 if (type == REG_DWORD) {
2555 size = sizeof(DWORD);
2556 RegQueryValueExW(key, dfltColorW, NULL, NULL,
2557 (LPBYTE)&value, &size);
2558 } else if (type == REG_SZ) {
2559 size = sizeof(strvalue)/sizeof(WCHAR);
2560 RegQueryValueExW(key, dfltColorW, NULL, NULL,
2561 (LPBYTE)strvalue, &size);
2562 value = strtoulW(strvalue, NULL, 10);
2563 }
2564 }
2565 RegCloseKey(key);
2566 }
2567
2568 /* If one found, set the screen to that colour */
2569 if (!(((value & 0xF0) >> 4) == (value & 0x0F))) {
2570 defaultColor = value & 0xFF;
2571 param1[0] = 0x00;
2572 WCMD_color();
2573 }
2574
2575 }
2576
2577 /* Save cwd into appropriate env var */
2578 GetCurrentDirectoryW(1024, string);
2579 if (IsCharAlphaW(string[0]) && string[1] == ':') {
2580 static const WCHAR fmt[] = {'=','%','c',':','\0'};
2581 wsprintfW(envvar, fmt, string[0]);
2582 SetEnvironmentVariableW(envvar, string);
2583 WINE_TRACE("Set %s to %s\n", wine_dbgstr_w(envvar), wine_dbgstr_w(string));
2584 }
2585
2586 if (opt_k) {
2587 /* Parse the command string, without reading any more input */
2588 WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
2589 WCMD_process_commands(toExecute, FALSE, NULL, NULL);
2590 WCMD_free_commands(toExecute);
2591 toExecute = NULL;
2592 HeapFree(GetProcessHeap(), 0, cmd);
2593 }
2594
2595 /*
2596 * Loop forever getting commands and executing them.
2597 */
2598
2599 SetEnvironmentVariableW(promptW, defaultpromptW);
2600 WCMD_version ();
2601 while (TRUE) {
2602
2603 /* Read until EOF (which for std input is never, but if redirect
2604 in place, may occur */
2605 if (echo_mode) WCMD_show_prompt();
2606 if (!WCMD_ReadAndParseLine(NULL, &toExecute, GetStdHandle(STD_INPUT_HANDLE)))
2607 break;
2608 WCMD_process_commands(toExecute, FALSE, NULL, NULL);
2609 WCMD_free_commands(toExecute);
2610 toExecute = NULL;
2611 }
2612 return 0;
2613 }
Maarten's multimedia branch