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