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