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