?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: Adjust GetCaps behaviour to documentation
[wine/gsoc_dplay.git] / programs / cmd / builtins.c
blob612e5d9dd55cd9f4d547f3f45db50b8c7416cd8c
1 /*
2 * CMD - Wine-compatible command line interface - built-in functions.
3 *
4 * Copyright (C) 1999 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 * NOTES:
24 * On entry to each function, global variables quals, param1, param2 contain
25 * the qualifiers (uppercased and concatenated) and parameters entered, with
26 * environment-variable and batch parameter substitution already done.
27 */
28
29 /*
30 * FIXME:
31 * - No support for pipes, shell parameters
32 * - Lots of functionality missing from builtins
33 * - Messages etc need international support
34 */
35
36 #define WIN32_LEAN_AND_MEAN
37
38 #include "wcmd.h"
39 #include <shellapi.h>
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
43
44 static void WCMD_part_execute(CMD_LIST **commands, WCHAR *firstcmd, WCHAR *variable,
45 WCHAR *value, BOOL isIF, BOOL conditionTRUE);
46
47 struct env_stack *saved_environment;
48 struct env_stack *pushd_directories;
49
50 extern HINSTANCE hinst;
51 extern WCHAR inbuilt[][10];
52 extern int echo_mode, verify_mode, defaultColor;
53 extern WCHAR quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
54 extern BATCH_CONTEXT *context;
55 extern DWORD errorlevel;
56
57 static const WCHAR dotW[] = {'.','\0'};
58 static const WCHAR dotdotW[] = {'.','.','\0'};
59 static const WCHAR slashW[] = {'\\','\0'};
60 static const WCHAR starW[] = {'*','\0'};
61 static const WCHAR equalW[] = {'=','\0'};
62 static const WCHAR fslashW[] = {'/','\0'};
63 static const WCHAR onW[] = {'O','N','\0'};
64 static const WCHAR offW[] = {'O','F','F','\0'};
65 static const WCHAR parmY[] = {'/','Y','\0'};
66 static const WCHAR parmNoY[] = {'/','-','Y','\0'};
67 static const WCHAR nullW[] = {'\0'};
68
69 /**************************************************************************
70 * WCMD_ask_confirm
71 *
72 * Issue a message and ask 'Are you sure (Y/N)', waiting on a valid
73 * answer.
74 *
75 * Returns True if Y (or A) answer is selected
76 * If optionAll contains a pointer, ALL is allowed, and if answered
77 * set to TRUE
78 *
79 */
80 static BOOL WCMD_ask_confirm (WCHAR *message, BOOL showSureText, BOOL *optionAll) {
81
82 WCHAR msgbuffer[MAXSTRING];
83 WCHAR Ybuffer[MAXSTRING];
84 WCHAR Nbuffer[MAXSTRING];
85 WCHAR Abuffer[MAXSTRING];
86 WCHAR answer[MAX_PATH] = {'\0'};
87 DWORD count = 0;
88
89 /* Load the translated 'Are you sure', plus valid answers */
90 LoadString (hinst, WCMD_CONFIRM, msgbuffer, sizeof(msgbuffer)/sizeof(WCHAR));
91 LoadString (hinst, WCMD_YES, Ybuffer, sizeof(Ybuffer)/sizeof(WCHAR));
92 LoadString (hinst, WCMD_NO, Nbuffer, sizeof(Nbuffer)/sizeof(WCHAR));
93 LoadString (hinst, WCMD_ALL, Abuffer, sizeof(Abuffer)/sizeof(WCHAR));
94
95 /* Loop waiting on a Y or N */
96 while (answer[0] != Ybuffer[0] && answer[0] != Nbuffer[0]) {
97 static const WCHAR startBkt[] = {' ','(','\0'};
98 static const WCHAR endBkt[] = {')','?','\0'};
99
100 WCMD_output_asis (message);
101 if (showSureText) {
102 WCMD_output_asis (msgbuffer);
103 }
104 WCMD_output_asis (startBkt);
105 WCMD_output_asis (Ybuffer);
106 WCMD_output_asis (fslashW);
107 WCMD_output_asis (Nbuffer);
108 if (optionAll) {
109 WCMD_output_asis (fslashW);
110 WCMD_output_asis (Abuffer);
111 }
112 WCMD_output_asis (endBkt);
113 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer,
114 sizeof(answer)/sizeof(WCHAR), &count, NULL);
115 answer[0] = toupperW(answer[0]);
116 }
117
118 /* Return the answer */
119 return ((answer[0] == Ybuffer[0]) ||
120 (optionAll && (answer[0] == Abuffer[0])));
121 }
122
123 /****************************************************************************
124 * WCMD_clear_screen
125 *
126 * Clear the terminal screen.
127 */
128
129 void WCMD_clear_screen (void) {
130
131 /* Emulate by filling the screen from the top left to bottom right with
132 spaces, then moving the cursor to the top left afterwards */
133 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
134 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
135
136 if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
137 {
138 COORD topLeft;
139 DWORD screenSize;
140
141 screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
142
143 topLeft.X = 0;
144 topLeft.Y = 0;
145 FillConsoleOutputCharacter(hStdOut, ' ', screenSize, topLeft, &screenSize);
146 SetConsoleCursorPosition(hStdOut, topLeft);
147 }
148 }
149
150 /****************************************************************************
151 * WCMD_change_tty
152 *
153 * Change the default i/o device (ie redirect STDin/STDout).
154 */
155
156 void WCMD_change_tty (void) {
157
158 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
159
160 }
161
162 /****************************************************************************
163 * WCMD_copy
164 *
165 * Copy a file or wildcarded set.
166 * FIXME: Add support for a+b+c type syntax
167 */
168
169 void WCMD_copy (void) {
170
171 WIN32_FIND_DATA fd;
172 HANDLE hff;
173 BOOL force, status;
174 WCHAR outpath[MAX_PATH], srcpath[MAX_PATH], copycmd[3];
175 DWORD len;
176 static const WCHAR copyCmdW[] = {'C','O','P','Y','C','M','D','\0'};
177 BOOL copyToDir = FALSE;
178 BOOL copyFromDir = FALSE;
179 WCHAR srcspec[MAX_PATH];
180 DWORD attribs;
181 WCHAR drive[10];
182 WCHAR dir[MAX_PATH];
183 WCHAR fname[MAX_PATH];
184 WCHAR ext[MAX_PATH];
185
186 if (param1[0] == 0x00) {
187 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
188 return;
189 }
190
191 /* Convert source into full spec */
192 WINE_TRACE("Copy source (supplied): '%s'\n", wine_dbgstr_w(param1));
193 GetFullPathName (param1, sizeof(srcpath)/sizeof(WCHAR), srcpath, NULL);
194 if (srcpath[strlenW(srcpath) - 1] == '\\')
195 srcpath[strlenW(srcpath) - 1] = '\0';
196
197 if ((strchrW(srcpath,'*') == NULL) && (strchrW(srcpath,'?') == NULL)) {
198 attribs = GetFileAttributes(srcpath);
199 } else {
200 attribs = 0;
201 }
202 strcpyW(srcspec, srcpath);
203
204 /* If a directory, then add \* on the end when searching */
205 if (attribs & FILE_ATTRIBUTE_DIRECTORY) {
206 strcatW(srcpath, slashW);
207 copyFromDir = TRUE;
208 strcatW(srcspec, slashW);
209 strcatW(srcspec, starW);
210 } else {
211 WCMD_splitpath(srcpath, drive, dir, fname, ext);
212 strcpyW(srcpath, drive);
213 strcatW(srcpath, dir);
214 }
215
216 WINE_TRACE("Copy source (calculated): path: '%s'\n", wine_dbgstr_w(srcpath));
217
218 /* If no destination supplied, assume current directory */
219 WINE_TRACE("Copy destination (supplied): '%s'\n", wine_dbgstr_w(param2));
220 if (param2[0] == 0x00) {
221 strcpyW(param2, dotW);
222 }
223
224 GetFullPathName (param2, sizeof(outpath)/sizeof(WCHAR), outpath, NULL);
225 if (outpath[strlenW(outpath) - 1] == '\\')
226 outpath[strlenW(outpath) - 1] = '\0';
227 attribs = GetFileAttributes(outpath);
228 if (attribs != INVALID_FILE_ATTRIBUTES && (attribs & FILE_ATTRIBUTE_DIRECTORY)) {
229 strcatW (outpath, slashW);
230 copyToDir = TRUE;
231 }
232 WINE_TRACE("Copy destination (calculated): '%s'(%d)\n",
233 wine_dbgstr_w(outpath), copyToDir);
234
235 /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
236 if (strstrW (quals, parmNoY))
237 force = FALSE;
238 else if (strstrW (quals, parmY))
239 force = TRUE;
240 else {
241 len = GetEnvironmentVariable (copyCmdW, copycmd, sizeof(copycmd)/sizeof(WCHAR));
242 force = (len && len < (sizeof(copycmd)/sizeof(WCHAR)) && ! lstrcmpiW (copycmd, parmY));
243 }
244
245 /* Loop through all source files */
246 WINE_TRACE("Searching for: '%s'\n", wine_dbgstr_w(srcspec));
247 hff = FindFirstFile (srcspec, &fd);
248 if (hff != INVALID_HANDLE_VALUE) {
249 do {
250 WCHAR outname[MAX_PATH];
251 WCHAR srcname[MAX_PATH];
252 BOOL overwrite = force;
253
254 /* Destination is either supplied filename, or source name in
255 supplied destination directory */
256 strcpyW(outname, outpath);
257 if (copyToDir) strcatW(outname, fd.cFileName);
258 strcpyW(srcname, srcpath);
259 strcatW(srcname, fd.cFileName);
260
261 WINE_TRACE("Copying from : '%s'\n", wine_dbgstr_w(srcname));
262 WINE_TRACE("Copying to : '%s'\n", wine_dbgstr_w(outname));
263
264 /* Skip . and .., and directories */
265 if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
266 overwrite = FALSE;
267 WINE_TRACE("Skipping directories\n");
268 }
269
270 /* Prompt before overwriting */
271 else if (!overwrite) {
272 attribs = GetFileAttributes(outname);
273 if (attribs != INVALID_FILE_ATTRIBUTES) {
274 WCHAR buffer[MAXSTRING];
275 wsprintf(buffer, WCMD_LoadMessage(WCMD_OVERWRITE), outname);
276 overwrite = WCMD_ask_confirm(buffer, FALSE, NULL);
277 }
278 else overwrite = TRUE;
279 }
280
281 /* Do the copy as appropriate */
282 if (overwrite) {
283 status = CopyFile (srcname, outname, FALSE);
284 if (!status) WCMD_print_error ();
285 }
286
287 } while (FindNextFile(hff, &fd) != 0);
288 FindClose (hff);
289 } else {
290 status = ERROR_FILE_NOT_FOUND;
291 WCMD_print_error ();
292 }
293 }
294
295 /****************************************************************************
296 * WCMD_create_dir
297 *
298 * Create a directory.
299 *
300 * this works recursively. so mkdir dir1\dir2\dir3 will create dir1 and dir2 if
301 * they do not already exist.
302 */
303
304 static BOOL create_full_path(WCHAR* path)
305 {
306 int len;
307 WCHAR *new_path;
308 BOOL ret = TRUE;
309
310 new_path = HeapAlloc(GetProcessHeap(),0,(strlenW(path) * sizeof(WCHAR))+1);
311 strcpyW(new_path,path);
312
313 while ((len = strlenW(new_path)) && new_path[len - 1] == '\\')
314 new_path[len - 1] = 0;
315
316 while (!CreateDirectory(new_path,NULL))
317 {
318 WCHAR *slash;
319 DWORD last_error = GetLastError();
320 if (last_error == ERROR_ALREADY_EXISTS)
321 break;
322
323 if (last_error != ERROR_PATH_NOT_FOUND)
324 {
325 ret = FALSE;
326 break;
327 }
328
329 if (!(slash = strrchrW(new_path,'\\')) && ! (slash = strrchrW(new_path,'/')))
330 {
331 ret = FALSE;
332 break;
333 }
334
335 len = slash - new_path;
336 new_path[len] = 0;
337 if (!create_full_path(new_path))
338 {
339 ret = FALSE;
340 break;
341 }
342 new_path[len] = '\\';
343 }
344 HeapFree(GetProcessHeap(),0,new_path);
345 return ret;
346 }
347
348 void WCMD_create_dir (void) {
349
350 if (param1[0] == 0x00) {
351 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
352 return;
353 }
354 if (!create_full_path(param1)) WCMD_print_error ();
355 }
356
357 /****************************************************************************
358 * WCMD_delete
359 *
360 * Delete a file or wildcarded set.
361 *
362 * Note on /A:
363 * - Testing shows /A is repeatable, eg. /a-r /ar matches all files
364 * - Each set is a pattern, eg /ahr /as-r means
365 * readonly+hidden OR nonreadonly system files
366 * - The '-' applies to a single field, ie /a:-hr means read only
367 * non-hidden files
368 */
369
370 BOOL WCMD_delete (WCHAR *command, BOOL expectDir) {
371
372 int argno = 0;
373 int argsProcessed = 0;
374 WCHAR *argN = command;
375 BOOL foundAny = FALSE;
376 static const WCHAR parmA[] = {'/','A','\0'};
377 static const WCHAR parmQ[] = {'/','Q','\0'};
378 static const WCHAR parmP[] = {'/','P','\0'};
379 static const WCHAR parmS[] = {'/','S','\0'};
380 static const WCHAR parmF[] = {'/','F','\0'};
381
382 /* If not recursing, clear error flag */
383 if (expectDir) errorlevel = 0;
384
385 /* Loop through all args */
386 while (argN) {
387 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
388 WCHAR argCopy[MAX_PATH];
389
390 if (argN && argN[0] != '/') {
391
392 WIN32_FIND_DATA fd;
393 HANDLE hff;
394 WCHAR fpath[MAX_PATH];
395 WCHAR *p;
396 BOOL handleParm = TRUE;
397 BOOL found = FALSE;
398 static const WCHAR anyExt[]= {'.','*','\0'};
399
400 strcpyW(argCopy, thisArg);
401 WINE_TRACE("del: Processing arg %s (quals:%s)\n",
402 wine_dbgstr_w(argCopy), wine_dbgstr_w(quals));
403 argsProcessed++;
404
405 /* If filename part of parameter is * or *.*, prompt unless
406 /Q supplied. */
407 if ((strstrW (quals, parmQ) == NULL) && (strstrW (quals, parmP) == NULL)) {
408
409 WCHAR drive[10];
410 WCHAR dir[MAX_PATH];
411 WCHAR fname[MAX_PATH];
412 WCHAR ext[MAX_PATH];
413
414 /* Convert path into actual directory spec */
415 GetFullPathName (argCopy, sizeof(fpath)/sizeof(WCHAR), fpath, NULL);
416 WCMD_splitpath(fpath, drive, dir, fname, ext);
417
418 /* Only prompt for * and *.*, not *a, a*, *.a* etc */
419 if ((strcmpW(fname, starW) == 0) &&
420 (*ext == 0x00 || (strcmpW(ext, anyExt) == 0))) {
421 BOOL ok;
422 WCHAR question[MAXSTRING];
423 static const WCHAR fmt[] = {'%','s',' ','\0'};
424
425 /* Note: Flag as found, to avoid file not found message */
426 found = TRUE;
427
428 /* Ask for confirmation */
429 wsprintf(question, fmt, fpath);
430 ok = WCMD_ask_confirm(question, TRUE, NULL);
431
432 /* Abort if answer is 'N' */
433 if (!ok) continue;
434 }
435 }
436
437 /* First, try to delete in the current directory */
438 hff = FindFirstFile (argCopy, &fd);
439 if (hff == INVALID_HANDLE_VALUE) {
440 handleParm = FALSE;
441 } else {
442 found = TRUE;
443 }
444
445 /* Support del <dirname> by just deleting all files dirname\* */
446 if (handleParm && (strchrW(argCopy,'*') == NULL) && (strchrW(argCopy,'?') == NULL)
447 && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
448 WCHAR modifiedParm[MAX_PATH];
449 static const WCHAR slashStar[] = {'\\','*','\0'};
450
451 strcpyW(modifiedParm, argCopy);
452 strcatW(modifiedParm, slashStar);
453 FindClose(hff);
454 found = TRUE;
455 WCMD_delete(modifiedParm, FALSE);
456
457 } else if (handleParm) {
458
459 /* Build the filename to delete as <supplied directory>\<findfirst filename> */
460 strcpyW (fpath, argCopy);
461 do {
462 p = strrchrW (fpath, '\\');
463 if (p != NULL) {
464 *++p = '\0';
465 strcatW (fpath, fd.cFileName);
466 }
467 else strcpyW (fpath, fd.cFileName);
468 if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
469 BOOL ok = TRUE;
470 WCHAR *nextA = strstrW (quals, parmA);
471
472 /* Handle attribute matching (/A) */
473 if (nextA != NULL) {
474 ok = FALSE;
475 while (nextA != NULL && !ok) {
476
477 WCHAR *thisA = (nextA+2);
478 BOOL stillOK = TRUE;
479
480 /* Skip optional : */
481 if (*thisA == ':') thisA++;
482
483 /* Parse each of the /A[:]xxx in turn */
484 while (*thisA && *thisA != '/') {
485 BOOL negate = FALSE;
486 BOOL attribute = FALSE;
487
488 /* Match negation of attribute first */
489 if (*thisA == '-') {
490 negate=TRUE;
491 thisA++;
492 }
493
494 /* Match attribute */
495 switch (*thisA) {
496 case 'R': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
497 break;
498 case 'H': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
499 break;
500 case 'S': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM);
501 break;
502 case 'A': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE);
503 break;
504 default:
505 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
506 }
507
508 /* Now check result, keeping a running boolean about whether it
509 matches all parsed attributes so far */
510 if (attribute && !negate) {
511 stillOK = stillOK;
512 } else if (!attribute && negate) {
513 stillOK = stillOK;
514 } else {
515 stillOK = FALSE;
516 }
517 thisA++;
518 }
519
520 /* Save the running total as the final result */
521 ok = stillOK;
522
523 /* Step on to next /A set */
524 nextA = strstrW (nextA+1, parmA);
525 }
526 }
527
528 /* /P means prompt for each file */
529 if (ok && strstrW (quals, parmP) != NULL) {
530 WCHAR question[MAXSTRING];
531
532 /* Ask for confirmation */
533 wsprintf(question, WCMD_LoadMessage(WCMD_DELPROMPT), fpath);
534 ok = WCMD_ask_confirm(question, FALSE, NULL);
535 }
536
537 /* Only proceed if ok to */
538 if (ok) {
539
540 /* If file is read only, and /F supplied, delete it */
541 if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY &&
542 strstrW (quals, parmF) != NULL) {
543 SetFileAttributes(fpath, fd.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
544 }
545
546 /* Now do the delete */
547 if (!DeleteFile (fpath)) WCMD_print_error ();
548 }
549
550 }
551 } while (FindNextFile(hff, &fd) != 0);
552 FindClose (hff);
553 }
554
555 /* Now recurse into all subdirectories handling the parameter in the same way */
556 if (strstrW (quals, parmS) != NULL) {
557
558 WCHAR thisDir[MAX_PATH];
559 int cPos;
560
561 WCHAR drive[10];
562 WCHAR dir[MAX_PATH];
563 WCHAR fname[MAX_PATH];
564 WCHAR ext[MAX_PATH];
565
566 /* Convert path into actual directory spec */
567 GetFullPathName (argCopy, sizeof(thisDir)/sizeof(WCHAR), thisDir, NULL);
568 WCMD_splitpath(thisDir, drive, dir, fname, ext);
569
570 strcpyW(thisDir, drive);
571 strcatW(thisDir, dir);
572 cPos = strlenW(thisDir);
573
574 WINE_TRACE("Searching recursively in '%s'\n", wine_dbgstr_w(thisDir));
575
576 /* Append '*' to the directory */
577 thisDir[cPos] = '*';
578 thisDir[cPos+1] = 0x00;
579
580 hff = FindFirstFile (thisDir, &fd);
581
582 /* Remove residual '*' */
583 thisDir[cPos] = 0x00;
584
585 if (hff != INVALID_HANDLE_VALUE) {
586 DIRECTORY_STACK *allDirs = NULL;
587 DIRECTORY_STACK *lastEntry = NULL;
588
589 do {
590 if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
591 (strcmpW(fd.cFileName, dotdotW) != 0) &&
592 (strcmpW(fd.cFileName, dotW) != 0)) {
593
594 DIRECTORY_STACK *nextDir;
595 WCHAR subParm[MAX_PATH];
596
597 /* Work out search parameter in sub dir */
598 strcpyW (subParm, thisDir);
599 strcatW (subParm, fd.cFileName);
600 strcatW (subParm, slashW);
601 strcatW (subParm, fname);
602 strcatW (subParm, ext);
603 WINE_TRACE("Recursive, Adding to search list '%s'\n", wine_dbgstr_w(subParm));
604
605 /* Allocate memory, add to list */
606 nextDir = HeapAlloc(GetProcessHeap(),0,sizeof(DIRECTORY_STACK));
607 if (allDirs == NULL) allDirs = nextDir;
608 if (lastEntry != NULL) lastEntry->next = nextDir;
609 lastEntry = nextDir;
610 nextDir->next = NULL;
611 nextDir->dirName = HeapAlloc(GetProcessHeap(),0,
612 (strlenW(subParm)+1) * sizeof(WCHAR));
613 strcpyW(nextDir->dirName, subParm);
614 }
615 } while (FindNextFile(hff, &fd) != 0);
616 FindClose (hff);
617
618 /* Go through each subdir doing the delete */
619 while (allDirs != NULL) {
620 DIRECTORY_STACK *tempDir;
621
622 tempDir = allDirs->next;
623 found |= WCMD_delete (allDirs->dirName, FALSE);
624
625 HeapFree(GetProcessHeap(),0,allDirs->dirName);
626 HeapFree(GetProcessHeap(),0,allDirs);
627 allDirs = tempDir;
628 }
629 }
630 }
631 /* Keep running total to see if any found, and if not recursing
632 issue error message */
633 if (expectDir) {
634 if (!found) {
635 errorlevel = 1;
636 WCMD_output (WCMD_LoadMessage(WCMD_FILENOTFOUND), argCopy);
637 }
638 }
639 foundAny |= found;
640 }
641 }
642
643 /* Handle no valid args */
644 if (argsProcessed == 0) {
645 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
646 }
647
648 return foundAny;
649 }
650
651 /****************************************************************************
652 * WCMD_echo
653 *
654 * Echo input to the screen (or not). We don't try to emulate the bugs
655 * in DOS (try typing "ECHO ON AGAIN" for an example).
656 */
657
658 void WCMD_echo (const WCHAR *command) {
659
660 int count;
661
662 if ((command[0] == '.') && (command[1] == 0)) {
663 WCMD_output (newline);
664 return;
665 }
666 if (command[0]==' ')
667 command++;
668 count = strlenW(command);
669 if (count == 0) {
670 if (echo_mode) WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT), onW);
671 else WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT), offW);
672 return;
673 }
674 if (lstrcmpiW(command, onW) == 0) {
675 echo_mode = 1;
676 return;
677 }
678 if (lstrcmpiW(command, offW) == 0) {
679 echo_mode = 0;
680 return;
681 }
682 WCMD_output_asis (command);
683 WCMD_output (newline);
684
685 }
686
687 /**************************************************************************
688 * WCMD_for
689 *
690 * Batch file loop processing.
691 *
692 * On entry: cmdList contains the syntax up to the set
693 * next cmdList and all in that bracket contain the set data
694 * next cmdlist contains the DO cmd
695 * following that is either brackets or && entries (as per if)
696 *
697 */
698
699 void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
700
701 WIN32_FIND_DATA fd;
702 HANDLE hff;
703 int i;
704 const WCHAR inW[] = {'i', 'n', ' ', '\0'};
705 const WCHAR doW[] = {'d', 'o', ' ', '\0'};
706 CMD_LIST *setStart, *thisSet, *cmdStart, *cmdEnd;
707 WCHAR variable[4];
708 WCHAR *firstCmd;
709 int thisDepth;
710
711 WCHAR *curPos = p;
712 BOOL expandDirs = FALSE;
713 BOOL useNumbers = FALSE;
714 BOOL doRecursive = FALSE;
715 BOOL doFileset = FALSE;
716 LONG numbers[3] = {0,0,0}; /* Defaults to 0 in native */
717 int itemNum;
718 CMD_LIST *thisCmdStart;
719
720
721 /* Handle optional qualifiers (multiple are allowed) */
722 while (*curPos && *curPos == '/') {
723 WINE_TRACE("Processing qualifier at %s\n", wine_dbgstr_w(curPos));
724 curPos++;
725 switch (toupperW(*curPos)) {
726 case 'D': curPos++; expandDirs = TRUE; break;
727 case 'L': curPos++; useNumbers = TRUE; break;
728
729 /* Recursive is special case - /R can have an optional path following it */
730 /* filenamesets are another special case - /F can have an optional options following it */
731 case 'R':
732 case 'F':
733 {
734 BOOL isRecursive = (*curPos == 'R');
735
736 if (isRecursive) doRecursive = TRUE;
737 else doFileset = TRUE;
738
739 /* Skip whitespace */
740 curPos++;
741 while (*curPos && *curPos==' ') curPos++;
742
743 /* Next parm is either qualifier, path/options or variable -
744 only care about it if it is the path/options */
745 if (*curPos && *curPos != '/' && *curPos != '%') {
746 if (isRecursive) WINE_FIXME("/R needs to handle supplied root\n");
747 else WINE_FIXME("/F needs to handle options\n");
748 }
749 break;
750 }
751 default:
752 WINE_FIXME("for qualifier '%c' unhandled\n", *curPos);
753 curPos++;
754 }
755
756 /* Skip whitespace between qualifiers */
757 while (*curPos && *curPos==' ') curPos++;
758 }
759
760 /* Skip whitespace before variable */
761 while (*curPos && *curPos==' ') curPos++;
762
763 /* Ensure line continues with variable */
764 if (!*curPos || *curPos != '%') {
765 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
766 return;
767 }
768
769 /* Variable should follow */
770 i = 0;
771 while (curPos[i] && curPos[i]!=' ') i++;
772 memcpy(&variable[0], curPos, i*sizeof(WCHAR));
773 variable[i] = 0x00;
774 WINE_TRACE("Variable identified as %s\n", wine_dbgstr_w(variable));
775 curPos = &curPos[i];
776
777 /* Skip whitespace before IN */
778 while (*curPos && *curPos==' ') curPos++;
779
780 /* Ensure line continues with IN */
781 if (!*curPos || lstrcmpiW (curPos, inW)) {
782 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
783 return;
784 }
785
786 /* Save away where the set of data starts and the variable */
787 thisDepth = (*cmdList)->bracketDepth;
788 *cmdList = (*cmdList)->nextcommand;
789 setStart = (*cmdList);
790
791 /* Skip until the close bracket */
792 WINE_TRACE("Searching %p as the set\n", *cmdList);
793 while (*cmdList &&
794 (*cmdList)->command != NULL &&
795 (*cmdList)->bracketDepth > thisDepth) {
796 WINE_TRACE("Skipping %p which is part of the set\n", *cmdList);
797 *cmdList = (*cmdList)->nextcommand;
798 }
799
800 /* Skip the close bracket, if there is one */
801 if (*cmdList) *cmdList = (*cmdList)->nextcommand;
802
803 /* Syntax error if missing close bracket, or nothing following it
804 and once we have the complete set, we expect a DO */
805 WINE_TRACE("Looking for 'do' in %p\n", *cmdList);
806 if ((*cmdList == NULL) ||
807 (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
808 (*cmdList)->command, 3, doW, -1) != 2)) {
809 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
810 return;
811 }
812
813 /* Save away the starting position for the commands (and offset for the
814 first one */
815 cmdStart = *cmdList;
816 cmdEnd = *cmdList;
817 firstCmd = (*cmdList)->command + 3; /* Skip 'do ' */
818 itemNum = 0;
819
820 thisSet = setStart;
821 /* Loop through all set entries */
822 while (thisSet &&
823 thisSet->command != NULL &&
824 thisSet->bracketDepth >= thisDepth) {
825
826 /* Loop through all entries on the same line */
827 WCHAR *item;
828 WCHAR *itemStart;
829
830 WINE_TRACE("Processing for set %p\n", thisSet);
831 i = 0;
832 while (*(item = WCMD_parameter (thisSet->command, i, &itemStart))) {
833
834 /*
835 * If the parameter within the set has a wildcard then search for matching files
836 * otherwise do a literal substitution.
837 */
838 static const WCHAR wildcards[] = {'*','?','\0'};
839 thisCmdStart = cmdStart;
840
841 itemNum++;
842 WINE_TRACE("Processing for item %d '%s'\n", itemNum, wine_dbgstr_w(item));
843
844 if (!useNumbers && !doFileset) {
845 if (strpbrkW (item, wildcards)) {
846 hff = FindFirstFile (item, &fd);
847 if (hff != INVALID_HANDLE_VALUE) {
848 do {
849 BOOL isDirectory = FALSE;
850
851 if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) isDirectory = TRUE;
852
853 /* Handle as files or dirs appropriately, but ignore . and .. */
854 if (isDirectory == expandDirs &&
855 (strcmpW(fd.cFileName, dotdotW) != 0) &&
856 (strcmpW(fd.cFileName, dotW) != 0))
857 {
858 thisCmdStart = cmdStart;
859 WINE_TRACE("Processing FOR filename %s\n", wine_dbgstr_w(fd.cFileName));
860 WCMD_part_execute (&thisCmdStart, firstCmd, variable,
861 fd.cFileName, FALSE, TRUE);
862 }
863
864 } while (FindNextFile(hff, &fd) != 0);
865 FindClose (hff);
866 }
867 } else {
868 WCMD_part_execute(&thisCmdStart, firstCmd, variable, item, FALSE, TRUE);
869 }
870
871 } else if (useNumbers) {
872 /* Convert the first 3 numbers to signed longs and save */
873 if (itemNum <=3) numbers[itemNum-1] = atolW(item);
874 /* else ignore them! */
875
876 /* Filesets - either a list of files, or a command to run and parse the output */
877 } else if (doFileset && *itemStart != '"') {
878
879 HANDLE input;
880 WCHAR temp_file[MAX_PATH];
881
882 WINE_TRACE("Processing for filespec from item %d '%s'\n", itemNum,
883 wine_dbgstr_w(item));
884
885 /* If backquote or single quote, we need to launch that command
886 and parse the results - use a temporary file */
887 if (*itemStart == '`' || *itemStart == '\'') {
888
889 WCHAR temp_path[MAX_PATH], temp_cmd[MAXSTRING];
890 static const WCHAR redirOut[] = {'>','%','s','\0'};
891 static const WCHAR cmdW[] = {'C','M','D','\0'};
892
893 /* Remove trailing character */
894 itemStart[strlenW(itemStart)-1] = 0x00;
895
896 /* Get temp filename */
897 GetTempPath (sizeof(temp_path)/sizeof(WCHAR), temp_path);
898 GetTempFileName (temp_path, cmdW, 0, temp_file);
899
900 /* Execute program and redirect output */
901 wsprintf (temp_cmd, redirOut, (itemStart+1), temp_file);
902 WCMD_execute (itemStart, temp_cmd, NULL, NULL, NULL);
903
904 /* Open the file, read line by line and process */
905 input = CreateFile (temp_file, GENERIC_READ, FILE_SHARE_READ,
906 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
907 } else {
908
909 /* Open the file, read line by line and process */
910 input = CreateFile (item, GENERIC_READ, FILE_SHARE_READ,
911 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
912 }
913
914 /* Process the input file */
915 if (input == INVALID_HANDLE_VALUE) {
916 WCMD_print_error ();
917 WCMD_output (WCMD_LoadMessage(WCMD_READFAIL), item);
918 errorlevel = 1;
919 return; /* FOR loop aborts at first failure here */
920
921 } else {
922
923 WCHAR buffer[MAXSTRING] = {'\0'};
924 WCHAR *where, *parm;
925
926 while (WCMD_fgets (buffer, sizeof(buffer)/sizeof(WCHAR), input)) {
927
928 /* Skip blank lines*/
929 parm = WCMD_parameter (buffer, 0, &where);
930 WINE_TRACE("Parsed parameter: %s from %s\n", wine_dbgstr_w(parm),
931 wine_dbgstr_w(buffer));
932
933 if (where) {
934 /* FIXME: The following should be moved into its own routine and
935 reused for the string literal parsing below */
936 thisCmdStart = cmdStart;
937 WCMD_part_execute(&thisCmdStart, firstCmd, variable, parm, FALSE, TRUE);
938 cmdEnd = thisCmdStart;
939 }
940
941 buffer[0] = 0x00;
942
943 }
944 CloseHandle (input);
945 }
946
947 /* Delete the temporary file */
948 if (*itemStart == '`' || *itemStart == '\'') {
949 DeleteFile (temp_file);
950 }
951
952 /* Filesets - A string literal */
953 } else if (doFileset && *itemStart == '"') {
954 WCHAR buffer[MAXSTRING] = {'\0'};
955 WCHAR *where, *parm;
956
957 /* Skip blank lines, and re-extract parameter now string has quotes removed */
958 strcpyW(buffer, item);
959 parm = WCMD_parameter (buffer, 0, &where);
960 WINE_TRACE("Parsed parameter: %s from %s\n", wine_dbgstr_w(parm),
961 wine_dbgstr_w(buffer));
962
963 if (where) {
964 /* FIXME: The following should be moved into its own routine and
965 reused for the string literal parsing below */
966 thisCmdStart = cmdStart;
967 WCMD_part_execute(&thisCmdStart, firstCmd, variable, parm, FALSE, TRUE);
968 cmdEnd = thisCmdStart;
969 }
970 }
971
972 WINE_TRACE("Post-command, cmdEnd = %p\n", cmdEnd);
973 cmdEnd = thisCmdStart;
974 i++;
975 }
976
977 /* Move onto the next set line */
978 thisSet = thisSet->nextcommand;
979 }
980
981 /* If /L is provided, now run the for loop */
982 if (useNumbers) {
983 WCHAR thisNum[20];
984 static const WCHAR fmt[] = {'%','d','\0'};
985
986 WINE_TRACE("FOR /L provided range from %d to %d step %d\n",
987 numbers[0], numbers[2], numbers[1]);
988 for (i=numbers[0];
989 (numbers[1]<0)? i>numbers[2] : i<numbers[2];
990 i=i + numbers[1]) {
991
992 sprintfW(thisNum, fmt, i);
993 WINE_TRACE("Processing FOR number %s\n", wine_dbgstr_w(thisNum));
994
995 thisCmdStart = cmdStart;
996 WCMD_part_execute(&thisCmdStart, firstCmd, variable, thisNum, FALSE, TRUE);
997 cmdEnd = thisCmdStart;
998 }
999 }
1000
1001 /* When the loop ends, either something like a GOTO or EXIT /b has terminated
1002 all processing, OR it should be pointing to the end of && processing OR
1003 it should be pointing at the NULL end of bracket for the DO. The return
1004 value needs to be the NEXT command to execute, which it either is, or
1005 we need to step over the closing bracket */
1006 *cmdList = cmdEnd;
1007 if (cmdEnd && cmdEnd->command == NULL) *cmdList = cmdEnd->nextcommand;
1008 }
1009
1010
1011 /*****************************************************************************
1012 * WCMD_part_execute
1013 *
1014 * Execute a command, and any && or bracketed follow on to the command. The
1015 * first command to be executed may not be at the front of the
1016 * commands->thiscommand string (eg. it may point after a DO or ELSE)
1017 */
1018 void WCMD_part_execute(CMD_LIST **cmdList, WCHAR *firstcmd, WCHAR *variable,
1019 WCHAR *value, BOOL isIF, BOOL conditionTRUE) {
1020
1021 CMD_LIST *curPosition = *cmdList;
1022 int myDepth = (*cmdList)->bracketDepth;
1023
1024 WINE_TRACE("cmdList(%p), firstCmd(%p), with '%s'='%s', doIt(%d)\n",
1025 cmdList, wine_dbgstr_w(firstcmd),
1026 wine_dbgstr_w(variable), wine_dbgstr_w(value),
1027 conditionTRUE);
1028
1029 /* Skip leading whitespace between condition and the command */
1030 while (firstcmd && *firstcmd && (*firstcmd==' ' || *firstcmd=='\t')) firstcmd++;
1031
1032 /* Process the first command, if there is one */
1033 if (conditionTRUE && firstcmd && *firstcmd) {
1034 WCHAR *command = WCMD_strdupW(firstcmd);
1035 WCMD_execute (firstcmd, (*cmdList)->redirects, variable, value, cmdList);
1036 HeapFree(GetProcessHeap(), 0, command);
1037 }
1038
1039
1040 /* If it didn't move the position, step to next command */
1041 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1042
1043 /* Process any other parts of the command */
1044 if (*cmdList) {
1045 BOOL processThese = TRUE;
1046
1047 if (isIF) processThese = conditionTRUE;
1048
1049 while (*cmdList) {
1050 const WCHAR ifElse[] = {'e','l','s','e',' ','\0'};
1051
1052 /* execute all appropriate commands */
1053 curPosition = *cmdList;
1054
1055 WINE_TRACE("Processing cmdList(%p) - delim(%d) bd(%d / %d)\n",
1056 *cmdList,
1057 (*cmdList)->prevDelim,
1058 (*cmdList)->bracketDepth, myDepth);
1059
1060 /* Execute any statements appended to the line */
1061 /* FIXME: Only if previous call worked for && or failed for || */
1062 if ((*cmdList)->prevDelim == CMD_ONFAILURE ||
1063 (*cmdList)->prevDelim != CMD_ONSUCCESS) {
1064 if (processThese && (*cmdList)->command) {
1065 WCMD_execute ((*cmdList)->command, (*cmdList)->redirects, variable,
1066 value, cmdList);
1067 }
1068 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1069
1070 /* Execute any appended to the statement with (...) */
1071 } else if ((*cmdList)->bracketDepth > myDepth) {
1072 if (processThese) {
1073 *cmdList = WCMD_process_commands(*cmdList, TRUE, variable, value);
1074 WINE_TRACE("Back from processing commands, (next = %p)\n", *cmdList);
1075 }
1076 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1077
1078 /* End of the command - does 'ELSE ' follow as the next command? */
1079 } else {
1080 if (isIF && CompareString (LOCALE_USER_DEFAULT,
1081 NORM_IGNORECASE | SORT_STRINGSORT,
1082 (*cmdList)->command, 5, ifElse, -1) == 2) {
1083
1084 /* Swap between if and else processing */
1085 processThese = !processThese;
1086
1087 /* Process the ELSE part */
1088 if (processThese) {
1089 WCHAR *cmd = ((*cmdList)->command) + strlenW(ifElse);
1090
1091 /* Skip leading whitespace between condition and the command */
1092 while (*cmd && (*cmd==' ' || *cmd=='\t')) cmd++;
1093 if (*cmd) {
1094 WCMD_execute (cmd, (*cmdList)->redirects, variable, value, cmdList);
1095 }
1096 }
1097 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1098 } else {
1099 WINE_TRACE("Found end of this IF statement (next = %p)\n", *cmdList);
1100 break;
1101 }
1102 }
1103 }
1104 }
1105 return;
1106 }
1107
1108 /**************************************************************************
1109 * WCMD_give_help
1110 *
1111 * Simple on-line help. Help text is stored in the resource file.
1112 */
1113
1114 void WCMD_give_help (WCHAR *command) {
1115
1116 int i;
1117
1118 command = WCMD_strtrim_leading_spaces(command);
1119 if (strlenW(command) == 0) {
1120 WCMD_output_asis (WCMD_LoadMessage(WCMD_ALLHELP));
1121 }
1122 else {
1123 for (i=0; i<=WCMD_EXIT; i++) {
1124 if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1125 param1, -1, inbuilt[i], -1) == 2) {
1126 WCMD_output_asis (WCMD_LoadMessage(i));
1127 return;
1128 }
1129 }
1130 WCMD_output (WCMD_LoadMessage(WCMD_NOCMDHELP), param1);
1131 }
1132 return;
1133 }
1134
1135 /****************************************************************************
1136 * WCMD_go_to
1137 *
1138 * Batch file jump instruction. Not the most efficient algorithm ;-)
1139 * Prints error message if the specified label cannot be found - the file pointer is
1140 * then at EOF, effectively stopping the batch file.
1141 * FIXME: DOS is supposed to allow labels with spaces - we don't.
1142 */
1143
1144 void WCMD_goto (CMD_LIST **cmdList) {
1145
1146 WCHAR string[MAX_PATH];
1147
1148 /* Do not process any more parts of a processed multipart or multilines command */
1149 if (cmdList) *cmdList = NULL;
1150
1151 if (param1[0] == 0x00) {
1152 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1153 return;
1154 }
1155 if (context != NULL) {
1156 WCHAR *paramStart = param1;
1157 static const WCHAR eofW[] = {':','e','o','f','\0'};
1158
1159 /* Handle special :EOF label */
1160 if (lstrcmpiW (eofW, param1) == 0) {
1161 context -> skip_rest = TRUE;
1162 return;
1163 }
1164
1165 /* Support goto :label as well as goto label */
1166 if (*paramStart == ':') paramStart++;
1167
1168 SetFilePointer (context -> h, 0, NULL, FILE_BEGIN);
1169 while (WCMD_fgets (string, sizeof(string)/sizeof(WCHAR), context -> h)) {
1170 if ((string[0] == ':') && (lstrcmpiW (&string[1], paramStart) == 0)) return;
1171 }
1172 WCMD_output (WCMD_LoadMessage(WCMD_NOTARGET));
1173 }
1174 return;
1175 }
1176
1177 /*****************************************************************************
1178 * WCMD_pushd
1179 *
1180 * Push a directory onto the stack
1181 */
1182
1183 void WCMD_pushd (WCHAR *command) {
1184 struct env_stack *curdir;
1185 WCHAR *thisdir;
1186 static const WCHAR parmD[] = {'/','D','\0'};
1187
1188 if (strchrW(command, '/') != NULL) {
1189 SetLastError(ERROR_INVALID_PARAMETER);
1190 WCMD_print_error();
1191 return;
1192 }
1193
1194 curdir = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
1195 thisdir = LocalAlloc (LMEM_FIXED, 1024 * sizeof(WCHAR));
1196 if( !curdir || !thisdir ) {
1197 LocalFree(curdir);
1198 LocalFree(thisdir);
1199 WINE_ERR ("out of memory\n");
1200 return;
1201 }
1202
1203 /* Change directory using CD code with /D parameter */
1204 strcpyW(quals, parmD);
1205 GetCurrentDirectoryW (1024, thisdir);
1206 errorlevel = 0;
1207 WCMD_setshow_default(command);
1208 if (errorlevel) {
1209 LocalFree(curdir);
1210 LocalFree(thisdir);
1211 return;
1212 } else {
1213 curdir -> next = pushd_directories;
1214 curdir -> strings = thisdir;
1215 if (pushd_directories == NULL) {
1216 curdir -> u.stackdepth = 1;
1217 } else {
1218 curdir -> u.stackdepth = pushd_directories -> u.stackdepth + 1;
1219 }
1220 pushd_directories = curdir;
1221 }
1222 }
1223
1224
1225 /*****************************************************************************
1226 * WCMD_popd
1227 *
1228 * Pop a directory from the stack
1229 */
1230
1231 void WCMD_popd (void) {
1232 struct env_stack *temp = pushd_directories;
1233
1234 if (!pushd_directories)
1235 return;
1236
1237 /* pop the old environment from the stack, and make it the current dir */
1238 pushd_directories = temp->next;
1239 SetCurrentDirectoryW(temp->strings);
1240 LocalFree (temp->strings);
1241 LocalFree (temp);
1242 }
1243
1244 /****************************************************************************
1245 * WCMD_if
1246 *
1247 * Batch file conditional.
1248 *
1249 * On entry, cmdlist will point to command containing the IF, and optionally
1250 * the first command to execute (if brackets not found)
1251 * If &&'s were found, this may be followed by a record flagged as isAmpersand
1252 * If ('s were found, execute all within that bracket
1253 * Command may optionally be followed by an ELSE - need to skip instructions
1254 * in the else using the same logic
1255 *
1256 * FIXME: Much more syntax checking needed!
1257 */
1258
1259 void WCMD_if (WCHAR *p, CMD_LIST **cmdList) {
1260
1261 int negate = 0, test = 0;
1262 WCHAR condition[MAX_PATH], *command, *s;
1263 static const WCHAR notW[] = {'n','o','t','\0'};
1264 static const WCHAR errlvlW[] = {'e','r','r','o','r','l','e','v','e','l','\0'};
1265 static const WCHAR existW[] = {'e','x','i','s','t','\0'};
1266 static const WCHAR defdW[] = {'d','e','f','i','n','e','d','\0'};
1267 static const WCHAR eqeqW[] = {'=','=','\0'};
1268
1269 if (!lstrcmpiW (param1, notW)) {
1270 negate = 1;
1271 strcpyW (condition, param2);
1272 }
1273 else {
1274 strcpyW (condition, param1);
1275 }
1276 WINE_TRACE("Condition: %s\n", wine_dbgstr_w(condition));
1277
1278 if (!lstrcmpiW (condition, errlvlW)) {
1279 if (errorlevel >= atoiW(WCMD_parameter (p, 1+negate, NULL))) test = 1;
1280 WCMD_parameter (p, 2+negate, &command);
1281 }
1282 else if (!lstrcmpiW (condition, existW)) {
1283 if (GetFileAttributes(WCMD_parameter (p, 1+negate, NULL)) != INVALID_FILE_ATTRIBUTES) {
1284 test = 1;
1285 }
1286 WCMD_parameter (p, 2+negate, &command);
1287 }
1288 else if (!lstrcmpiW (condition, defdW)) {
1289 if (GetEnvironmentVariable(WCMD_parameter (p, 1+negate, NULL), NULL, 0) > 0) {
1290 test = 1;
1291 }
1292 WCMD_parameter (p, 2+negate, &command);
1293 }
1294 else if ((s = strstrW (p, eqeqW))) {
1295 s += 2;
1296 if (!lstrcmpiW (condition, WCMD_parameter (s, 0, NULL))) test = 1;
1297 WCMD_parameter (s, 1, &command);
1298 }
1299 else {
1300 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
1301 return;
1302 }
1303
1304 /* Process rest of IF statement which is on the same line
1305 Note: This may process all or some of the cmdList (eg a GOTO) */
1306 WCMD_part_execute(cmdList, command, NULL, NULL, TRUE, (test != negate));
1307 }
1308
1309 /****************************************************************************
1310 * WCMD_move
1311 *
1312 * Move a file, directory tree or wildcarded set of files.
1313 */
1314
1315 void WCMD_move (void) {
1316
1317 int status;
1318 WIN32_FIND_DATA fd;
1319 HANDLE hff;
1320 WCHAR input[MAX_PATH];
1321 WCHAR output[MAX_PATH];
1322 WCHAR drive[10];
1323 WCHAR dir[MAX_PATH];
1324 WCHAR fname[MAX_PATH];
1325 WCHAR ext[MAX_PATH];
1326
1327 if (param1[0] == 0x00) {
1328 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1329 return;
1330 }
1331
1332 /* If no destination supplied, assume current directory */
1333 if (param2[0] == 0x00) {
1334 strcpyW(param2, dotW);
1335 }
1336
1337 /* If 2nd parm is directory, then use original filename */
1338 /* Convert partial path to full path */
1339 GetFullPathName (param1, sizeof(input)/sizeof(WCHAR), input, NULL);
1340 GetFullPathName (param2, sizeof(output)/sizeof(WCHAR), output, NULL);
1341 WINE_TRACE("Move from '%s'('%s') to '%s'\n", wine_dbgstr_w(input),
1342 wine_dbgstr_w(param1), wine_dbgstr_w(output));
1343
1344 /* Split into components */
1345 WCMD_splitpath(input, drive, dir, fname, ext);
1346
1347 hff = FindFirstFile (input, &fd);
1348 while (hff != INVALID_HANDLE_VALUE) {
1349 WCHAR dest[MAX_PATH];
1350 WCHAR src[MAX_PATH];
1351 DWORD attribs;
1352
1353 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd.cFileName));
1354
1355 /* Build src & dest name */
1356 strcpyW(src, drive);
1357 strcatW(src, dir);
1358
1359 /* See if dest is an existing directory */
1360 attribs = GetFileAttributes(output);
1361 if (attribs != INVALID_FILE_ATTRIBUTES &&
1362 (attribs & FILE_ATTRIBUTE_DIRECTORY)) {
1363 strcpyW(dest, output);
1364 strcatW(dest, slashW);
1365 strcatW(dest, fd.cFileName);
1366 } else {
1367 strcpyW(dest, output);
1368 }
1369
1370 strcatW(src, fd.cFileName);
1371
1372 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src));
1373 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest));
1374
1375 /* Check if file is read only, otherwise move it */
1376 attribs = GetFileAttributes(src);
1377 if ((attribs != INVALID_FILE_ATTRIBUTES) &&
1378 (attribs & FILE_ATTRIBUTE_READONLY)) {
1379 SetLastError(ERROR_ACCESS_DENIED);
1380 status = 0;
1381 } else {
1382 BOOL ok = TRUE;
1383
1384 /* If destination exists, prompt unless /Y supplied */
1385 if (GetFileAttributes(dest) != INVALID_FILE_ATTRIBUTES) {
1386 BOOL force = FALSE;
1387 WCHAR copycmd[MAXSTRING];
1388 int len;
1389
1390 /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
1391 if (strstrW (quals, parmNoY))
1392 force = FALSE;
1393 else if (strstrW (quals, parmY))
1394 force = TRUE;
1395 else {
1396 const WCHAR copyCmdW[] = {'C','O','P','Y','C','M','D','\0'};
1397 len = GetEnvironmentVariable (copyCmdW, copycmd, sizeof(copycmd)/sizeof(WCHAR));
1398 force = (len && len < (sizeof(copycmd)/sizeof(WCHAR))
1399 && ! lstrcmpiW (copycmd, parmY));
1400 }
1401
1402 /* Prompt if overwriting */
1403 if (!force) {
1404 WCHAR question[MAXSTRING];
1405 WCHAR yesChar[10];
1406
1407 strcpyW(yesChar, WCMD_LoadMessage(WCMD_YES));
1408
1409 /* Ask for confirmation */
1410 wsprintf(question, WCMD_LoadMessage(WCMD_OVERWRITE), dest);
1411 ok = WCMD_ask_confirm(question, FALSE, NULL);
1412
1413 /* So delete the destination prior to the move */
1414 if (ok) {
1415 if (!DeleteFile (dest)) {
1416 WCMD_print_error ();
1417 errorlevel = 1;
1418 ok = FALSE;
1419 }
1420 }
1421 }
1422 }
1423
1424 if (ok) {
1425 status = MoveFile (src, dest);
1426 } else {
1427 status = 1; /* Anything other than 0 to prevent error msg below */
1428 }
1429 }
1430
1431 if (!status) {
1432 WCMD_print_error ();
1433 errorlevel = 1;
1434 }
1435
1436 /* Step on to next match */
1437 if (FindNextFile(hff, &fd) == 0) {
1438 FindClose(hff);
1439 hff = INVALID_HANDLE_VALUE;
1440 break;
1441 }
1442 }
1443 }
1444
1445 /****************************************************************************
1446 * WCMD_pause
1447 *
1448 * Wait for keyboard input.
1449 */
1450
1451 void WCMD_pause (void) {
1452
1453 DWORD count;
1454 WCHAR string[32];
1455
1456 WCMD_output (anykey);
1457 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), string,
1458 sizeof(string)/sizeof(WCHAR), &count, NULL);
1459 }
1460
1461 /****************************************************************************
1462 * WCMD_remove_dir
1463 *
1464 * Delete a directory.
1465 */
1466
1467 void WCMD_remove_dir (WCHAR *command) {
1468
1469 int argno = 0;
1470 int argsProcessed = 0;
1471 WCHAR *argN = command;
1472 static const WCHAR parmS[] = {'/','S','\0'};
1473 static const WCHAR parmQ[] = {'/','Q','\0'};
1474
1475 /* Loop through all args */
1476 while (argN) {
1477 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
1478 if (argN && argN[0] != '/') {
1479 WINE_TRACE("rd: Processing arg %s (quals:%s)\n", wine_dbgstr_w(thisArg),
1480 wine_dbgstr_w(quals));
1481 argsProcessed++;
1482
1483 /* If subdirectory search not supplied, just try to remove
1484 and report error if it fails (eg if it contains a file) */
1485 if (strstrW (quals, parmS) == NULL) {
1486 if (!RemoveDirectory (thisArg)) WCMD_print_error ();
1487
1488 /* Otherwise use ShFileOp to recursively remove a directory */
1489 } else {
1490
1491 SHFILEOPSTRUCT lpDir;
1492
1493 /* Ask first */
1494 if (strstrW (quals, parmQ) == NULL) {
1495 BOOL ok;
1496 WCHAR question[MAXSTRING];
1497 static const WCHAR fmt[] = {'%','s',' ','\0'};
1498
1499 /* Ask for confirmation */
1500 wsprintf(question, fmt, thisArg);
1501 ok = WCMD_ask_confirm(question, TRUE, NULL);
1502
1503 /* Abort if answer is 'N' */
1504 if (!ok) return;
1505 }
1506
1507 /* Do the delete */
1508 lpDir.hwnd = NULL;
1509 lpDir.pTo = NULL;
1510 lpDir.pFrom = thisArg;
1511 lpDir.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI;
1512 lpDir.wFunc = FO_DELETE;
1513 if (SHFileOperation(&lpDir)) WCMD_print_error ();
1514 }
1515 }
1516 }
1517
1518 /* Handle no valid args */
1519 if (argsProcessed == 0) {
1520 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1521 return;
1522 }
1523
1524 }
1525
1526 /****************************************************************************
1527 * WCMD_rename
1528 *
1529 * Rename a file.
1530 */
1531
1532 void WCMD_rename (void) {
1533
1534 int status;
1535 HANDLE hff;
1536 WIN32_FIND_DATA fd;
1537 WCHAR input[MAX_PATH];
1538 WCHAR *dotDst = NULL;
1539 WCHAR drive[10];
1540 WCHAR dir[MAX_PATH];
1541 WCHAR fname[MAX_PATH];
1542 WCHAR ext[MAX_PATH];
1543 DWORD attribs;
1544
1545 errorlevel = 0;
1546
1547 /* Must be at least two args */
1548 if (param1[0] == 0x00 || param2[0] == 0x00) {
1549 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1550 errorlevel = 1;
1551 return;
1552 }
1553
1554 /* Destination cannot contain a drive letter or directory separator */
1555 if ((strchrW(param1,':') != NULL) || (strchrW(param1,'\\') != NULL)) {
1556 SetLastError(ERROR_INVALID_PARAMETER);
1557 WCMD_print_error();
1558 errorlevel = 1;
1559 return;
1560 }
1561
1562 /* Convert partial path to full path */
1563 GetFullPathName (param1, sizeof(input)/sizeof(WCHAR), input, NULL);
1564 WINE_TRACE("Rename from '%s'('%s') to '%s'\n", wine_dbgstr_w(input),
1565 wine_dbgstr_w(param1), wine_dbgstr_w(param2));
1566 dotDst = strchrW(param2, '.');
1567
1568 /* Split into components */
1569 WCMD_splitpath(input, drive, dir, fname, ext);
1570
1571 hff = FindFirstFile (input, &fd);
1572 while (hff != INVALID_HANDLE_VALUE) {
1573 WCHAR dest[MAX_PATH];
1574 WCHAR src[MAX_PATH];
1575 WCHAR *dotSrc = NULL;
1576 int dirLen;
1577
1578 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd.cFileName));
1579
1580 /* FIXME: If dest name or extension is *, replace with filename/ext
1581 part otherwise use supplied name. This supports:
1582 ren *.fred *.jim
1583 ren jim.* fred.* etc
1584 However, windows has a more complex algorithm supporting eg
1585 ?'s and *'s mid name */
1586 dotSrc = strchrW(fd.cFileName, '.');
1587
1588 /* Build src & dest name */
1589 strcpyW(src, drive);
1590 strcatW(src, dir);
1591 strcpyW(dest, src);
1592 dirLen = strlenW(src);
1593 strcatW(src, fd.cFileName);
1594
1595 /* Build name */
1596 if (param2[0] == '*') {
1597 strcatW(dest, fd.cFileName);
1598 if (dotSrc) dest[dirLen + (dotSrc - fd.cFileName)] = 0x00;
1599 } else {
1600 strcatW(dest, param2);
1601 if (dotDst) dest[dirLen + (dotDst - param2)] = 0x00;
1602 }
1603
1604 /* Build Extension */
1605 if (dotDst && (*(dotDst+1)=='*')) {
1606 if (dotSrc) strcatW(dest, dotSrc);
1607 } else if (dotDst) {
1608 if (dotDst) strcatW(dest, dotDst);
1609 }
1610
1611 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src));
1612 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest));
1613
1614 /* Check if file is read only, otherwise move it */
1615 attribs = GetFileAttributes(src);
1616 if ((attribs != INVALID_FILE_ATTRIBUTES) &&
1617 (attribs & FILE_ATTRIBUTE_READONLY)) {
1618 SetLastError(ERROR_ACCESS_DENIED);
1619 status = 0;
1620 } else {
1621 status = MoveFile (src, dest);
1622 }
1623
1624 if (!status) {
1625 WCMD_print_error ();
1626 errorlevel = 1;
1627 }
1628
1629 /* Step on to next match */
1630 if (FindNextFile(hff, &fd) == 0) {
1631 FindClose(hff);
1632 hff = INVALID_HANDLE_VALUE;
1633 break;
1634 }
1635 }
1636 }
1637
1638 /*****************************************************************************
1639 * WCMD_dupenv
1640 *
1641 * Make a copy of the environment.
1642 */
1643 static WCHAR *WCMD_dupenv( const WCHAR *env )
1644 {
1645 WCHAR *env_copy;
1646 int len;
1647
1648 if( !env )
1649 return NULL;
1650
1651 len = 0;
1652 while ( env[len] )
1653 len += (strlenW(&env[len]) + 1);
1654
1655 env_copy = LocalAlloc (LMEM_FIXED, (len+1) * sizeof (WCHAR) );
1656 if (!env_copy)
1657 {
1658 WINE_ERR("out of memory\n");
1659 return env_copy;
1660 }
1661 memcpy (env_copy, env, len*sizeof (WCHAR));
1662 env_copy[len] = 0;
1663
1664 return env_copy;
1665 }
1666
1667 /*****************************************************************************
1668 * WCMD_setlocal
1669 *
1670 * setlocal pushes the environment onto a stack
1671 * Save the environment as unicode so we don't screw anything up.
1672 */
1673 void WCMD_setlocal (const WCHAR *s) {
1674 WCHAR *env;
1675 struct env_stack *env_copy;
1676 WCHAR cwd[MAX_PATH];
1677
1678 /* DISABLEEXTENSIONS ignored */
1679
1680 env_copy = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
1681 if( !env_copy )
1682 {
1683 WINE_ERR ("out of memory\n");
1684 return;
1685 }
1686
1687 env = GetEnvironmentStringsW ();
1688
1689 env_copy->strings = WCMD_dupenv (env);
1690 if (env_copy->strings)
1691 {
1692 env_copy->next = saved_environment;
1693 saved_environment = env_copy;
1694
1695 /* Save the current drive letter */
1696 GetCurrentDirectory (MAX_PATH, cwd);
1697 env_copy->u.cwd = cwd[0];
1698 }
1699 else
1700 LocalFree (env_copy);
1701
1702 FreeEnvironmentStringsW (env);
1703
1704 }
1705
1706 /*****************************************************************************
1707 * WCMD_endlocal
1708 *
1709 * endlocal pops the environment off a stack
1710 * Note: When searching for '=', search from WCHAR position 1, to handle
1711 * special internal environment variables =C:, =D: etc
1712 */
1713 void WCMD_endlocal (void) {
1714 WCHAR *env, *old, *p;
1715 struct env_stack *temp;
1716 int len, n;
1717
1718 if (!saved_environment)
1719 return;
1720
1721 /* pop the old environment from the stack */
1722 temp = saved_environment;
1723 saved_environment = temp->next;
1724
1725 /* delete the current environment, totally */
1726 env = GetEnvironmentStringsW ();
1727 old = WCMD_dupenv (GetEnvironmentStringsW ());
1728 len = 0;
1729 while (old[len]) {
1730 n = strlenW(&old[len]) + 1;
1731 p = strchrW(&old[len] + 1, '=');
1732 if (p)
1733 {
1734 *p++ = 0;
1735 SetEnvironmentVariableW (&old[len], NULL);
1736 }
1737 len += n;
1738 }
1739 LocalFree (old);
1740 FreeEnvironmentStringsW (env);
1741
1742 /* restore old environment */
1743 env = temp->strings;
1744 len = 0;
1745 while (env[len]) {
1746 n = strlenW(&env[len]) + 1;
1747 p = strchrW(&env[len] + 1, '=');
1748 if (p)
1749 {
1750 *p++ = 0;
1751 SetEnvironmentVariableW (&env[len], p);
1752 }
1753 len += n;
1754 }
1755
1756 /* Restore current drive letter */
1757 if (IsCharAlpha(temp->u.cwd)) {
1758 WCHAR envvar[4];
1759 WCHAR cwd[MAX_PATH];
1760 static const WCHAR fmt[] = {'=','%','c',':','\0'};
1761
1762 wsprintf(envvar, fmt, temp->u.cwd);
1763 if (GetEnvironmentVariable(envvar, cwd, MAX_PATH)) {
1764 WINE_TRACE("Resetting cwd to %s\n", wine_dbgstr_w(cwd));
1765 SetCurrentDirectory(cwd);
1766 }
1767 }
1768
1769 LocalFree (env);
1770 LocalFree (temp);
1771 }
1772
1773 /*****************************************************************************
1774 * WCMD_setshow_attrib
1775 *
1776 * Display and optionally sets DOS attributes on a file or directory
1777 *
1778 * FIXME: Wine currently uses the Unix stat() function to get file attributes.
1779 * As a result only the Readonly flag is correctly reported, the Archive bit
1780 * is always set and the rest are not implemented. We do the Right Thing anyway.
1781 *
1782 * FIXME: No SET functionality.
1783 *
1784 */
1785
1786 void WCMD_setshow_attrib (void) {
1787
1788 DWORD count;
1789 HANDLE hff;
1790 WIN32_FIND_DATA fd;
1791 WCHAR flags[9] = {' ',' ',' ',' ',' ',' ',' ',' ','\0'};
1792
1793 if (param1[0] == '-') {
1794 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
1795 return;
1796 }
1797
1798 if (strlenW(param1) == 0) {
1799 static const WCHAR slashStarW[] = {'\\','*','\0'};
1800
1801 GetCurrentDirectory (sizeof(param1)/sizeof(WCHAR), param1);
1802 strcatW (param1, slashStarW);
1803 }
1804
1805 hff = FindFirstFile (param1, &fd);
1806 if (hff == INVALID_HANDLE_VALUE) {
1807 WCMD_output (WCMD_LoadMessage(WCMD_FILENOTFOUND), param1);
1808 }
1809 else {
1810 do {
1811 if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
1812 static const WCHAR fmt[] = {'%','s',' ',' ',' ','%','s','\n','\0'};
1813 if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
1814 flags[0] = 'H';
1815 }
1816 if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
1817 flags[1] = 'S';
1818 }
1819 if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
1820 flags[2] = 'A';
1821 }
1822 if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
1823 flags[3] = 'R';
1824 }
1825 if (fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
1826 flags[4] = 'T';
1827 }
1828 if (fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) {
1829 flags[5] = 'C';
1830 }
1831 WCMD_output (fmt, flags, fd.cFileName);
1832 for (count=0; count < 8; count++) flags[count] = ' ';
1833 }
1834 } while (FindNextFile(hff, &fd) != 0);
1835 }
1836 FindClose (hff);
1837 }
1838
1839 /*****************************************************************************
1840 * WCMD_setshow_default
1841 *
1842 * Set/Show the current default directory
1843 */
1844
1845 void WCMD_setshow_default (WCHAR *command) {
1846
1847 BOOL status;
1848 WCHAR string[1024];
1849 WCHAR cwd[1024];
1850 WCHAR *pos;
1851 WIN32_FIND_DATA fd;
1852 HANDLE hff;
1853 static const WCHAR parmD[] = {'/','D','\0'};
1854
1855 WINE_TRACE("Request change to directory '%s'\n", wine_dbgstr_w(command));
1856
1857 /* Skip /D and trailing whitespace if on the front of the command line */
1858 if (CompareString (LOCALE_USER_DEFAULT,
1859 NORM_IGNORECASE | SORT_STRINGSORT,
1860 command, 2, parmD, -1) == 2) {
1861 command += 2;
1862 while (*command && *command==' ') command++;
1863 }
1864
1865 GetCurrentDirectory (sizeof(cwd)/sizeof(WCHAR), cwd);
1866 if (strlenW(command) == 0) {
1867 strcatW (cwd, newline);
1868 WCMD_output (cwd);
1869 }
1870 else {
1871 /* Remove any double quotes, which may be in the
1872 middle, eg. cd "C:\Program Files"\Microsoft is ok */
1873 pos = string;
1874 while (*command) {
1875 if (*command != '"') *pos++ = *command;
1876 command++;
1877 }
1878 *pos = 0x00;
1879
1880 /* Search for appropriate directory */
1881 WINE_TRACE("Looking for directory '%s'\n", wine_dbgstr_w(string));
1882 hff = FindFirstFile (string, &fd);
1883 while (hff != INVALID_HANDLE_VALUE) {
1884 if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1885 WCHAR fpath[MAX_PATH];
1886 WCHAR drive[10];
1887 WCHAR dir[MAX_PATH];
1888 WCHAR fname[MAX_PATH];
1889 WCHAR ext[MAX_PATH];
1890 static const WCHAR fmt[] = {'%','s','%','s','%','s','\0'};
1891
1892 /* Convert path into actual directory spec */
1893 GetFullPathName (string, sizeof(fpath)/sizeof(WCHAR), fpath, NULL);
1894 WCMD_splitpath(fpath, drive, dir, fname, ext);
1895
1896 /* Rebuild path */
1897 wsprintf(string, fmt, drive, dir, fd.cFileName);
1898
1899 FindClose(hff);
1900 hff = INVALID_HANDLE_VALUE;
1901 break;
1902 }
1903
1904 /* Step on to next match */
1905 if (FindNextFile(hff, &fd) == 0) {
1906 FindClose(hff);
1907 hff = INVALID_HANDLE_VALUE;
1908 break;
1909 }
1910 }
1911
1912 /* Change to that directory */
1913 WINE_TRACE("Really changing to directory '%s'\n", wine_dbgstr_w(string));
1914
1915 status = SetCurrentDirectory (string);
1916 if (!status) {
1917 errorlevel = 1;
1918 WCMD_print_error ();
1919 return;
1920 } else {
1921
1922 /* Save away the actual new directory, to store as current location */
1923 GetCurrentDirectoryW (sizeof(string)/sizeof(WCHAR), string);
1924
1925 /* Restore old directory if drive letter would change, and
1926 CD x:\directory /D (or pushd c:\directory) not supplied */
1927 if ((strstrW(quals, parmD) == NULL) &&
1928 (param1[1] == ':') && (toupper(param1[0]) != toupper(cwd[0]))) {
1929 SetCurrentDirectory(cwd);
1930 }
1931 }
1932
1933 /* Set special =C: type environment variable, for drive letter of
1934 change of directory, even if path was restored due to missing
1935 /D (allows changing drive letter when not resident on that
1936 drive */
1937 if ((string[1] == ':') && IsCharAlpha (string[0])) {
1938 WCHAR env[4];
1939 strcpyW(env, equalW);
1940 memcpy(env+1, string, 2 * sizeof(WCHAR));
1941 env[3] = 0x00;
1942 WINE_TRACE("Setting '%s' to '%s'\n", wine_dbgstr_w(env), wine_dbgstr_w(string));
1943 SetEnvironmentVariable(env, string);
1944 }
1945
1946 }
1947 return;
1948 }
1949
1950 /****************************************************************************
1951 * WCMD_setshow_date
1952 *
1953 * Set/Show the system date
1954 * FIXME: Can't change date yet
1955 */
1956
1957 void WCMD_setshow_date (void) {
1958
1959 WCHAR curdate[64], buffer[64];
1960 DWORD count;
1961 static const WCHAR parmT[] = {'/','T','\0'};
1962
1963 if (strlenW(param1) == 0) {
1964 if (GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL,
1965 curdate, sizeof(curdate)/sizeof(WCHAR))) {
1966 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTDATE), curdate);
1967 if (strstrW (quals, parmT) == NULL) {
1968 WCMD_output (WCMD_LoadMessage(WCMD_NEWDATE));
1969 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE),
1970 buffer, sizeof(buffer)/sizeof(WCHAR), &count, NULL);
1971 if (count > 2) {
1972 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
1973 }
1974 }
1975 }
1976 else WCMD_print_error ();
1977 }
1978 else {
1979 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
1980 }
1981 }
1982
1983 /****************************************************************************
1984 * WCMD_compare
1985 */
1986 static int WCMD_compare( const void *a, const void *b )
1987 {
1988 int r;
1989 const WCHAR * const *str_a = a, * const *str_b = b;
1990 r = CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1991 *str_a, -1, *str_b, -1 );
1992 if( r == CSTR_LESS_THAN ) return -1;
1993 if( r == CSTR_GREATER_THAN ) return 1;
1994 return 0;
1995 }
1996
1997 /****************************************************************************
1998 * WCMD_setshow_sortenv
1999 *
2000 * sort variables into order for display
2001 * Optionally only display those who start with a stub
2002 * returns the count displayed
2003 */
2004 static int WCMD_setshow_sortenv(const WCHAR *s, const WCHAR *stub)
2005 {
2006 UINT count=0, len=0, i, displayedcount=0, stublen=0;
2007 const WCHAR **str;
2008
2009 if (stub) stublen = strlenW(stub);
2010
2011 /* count the number of strings, and the total length */
2012 while ( s[len] ) {
2013 len += (strlenW(&s[len]) + 1);
2014 count++;
2015 }
2016
2017 /* add the strings to an array */
2018 str = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, count * sizeof (WCHAR*) );
2019 if( !str )
2020 return 0;
2021 str[0] = s;
2022 for( i=1; i<count; i++ )
2023 str[i] = str[i-1] + strlenW(str[i-1]) + 1;
2024
2025 /* sort the array */
2026 qsort( str, count, sizeof (WCHAR*), WCMD_compare );
2027
2028 /* print it */
2029 for( i=0; i<count; i++ ) {
2030 if (!stub || CompareString (LOCALE_USER_DEFAULT,
2031 NORM_IGNORECASE | SORT_STRINGSORT,
2032 str[i], stublen, stub, -1) == 2) {
2033 /* Don't display special internal variables */
2034 if (str[i][0] != '=') {
2035 WCMD_output_asis(str[i]);
2036 WCMD_output_asis(newline);
2037 displayedcount++;
2038 }
2039 }
2040 }
2041
2042 LocalFree( str );
2043 return displayedcount;
2044 }
2045
2046 /****************************************************************************
2047 * WCMD_setshow_env
2048 *
2049 * Set/Show the environment variables
2050 */
2051
2052 void WCMD_setshow_env (WCHAR *s) {
2053
2054 LPVOID env;
2055 WCHAR *p;
2056 int status;
2057 static const WCHAR parmP[] = {'/','P','\0'};
2058
2059 errorlevel = 0;
2060 if (param1[0] == 0x00 && quals[0] == 0x00) {
2061 env = GetEnvironmentStrings ();
2062 WCMD_setshow_sortenv( env, NULL );
2063 return;
2064 }
2065
2066 /* See if /P supplied, and if so echo the prompt, and read in a reply */
2067 if (CompareString (LOCALE_USER_DEFAULT,
2068 NORM_IGNORECASE | SORT_STRINGSORT,
2069 s, 2, parmP, -1) == 2) {
2070 WCHAR string[MAXSTRING];
2071 DWORD count;
2072
2073 s += 2;
2074 while (*s && *s==' ') s++;
2075 if (*s=='\"')
2076 WCMD_opt_s_strip_quotes(s);
2077
2078 /* If no parameter, or no '=' sign, return an error */
2079 if (!(*s) || ((p = strchrW (s, '=')) == NULL )) {
2080 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
2081 return;
2082 }
2083
2084 /* Output the prompt */
2085 *p++ = '\0';
2086 if (strlenW(p) != 0) WCMD_output(p);
2087
2088 /* Read the reply */
2089 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), string,
2090 sizeof(string)/sizeof(WCHAR), &count, NULL);
2091 if (count > 1) {
2092 string[count-1] = '\0'; /* ReadFile output is not null-terminated! */
2093 if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
2094 WINE_TRACE("set /p: Setting var '%s' to '%s'\n", wine_dbgstr_w(s),
2095 wine_dbgstr_w(string));
2096 status = SetEnvironmentVariable (s, string);
2097 }
2098
2099 } else {
2100 DWORD gle;
2101
2102 if (*s=='\"')
2103 WCMD_opt_s_strip_quotes(s);
2104 p = strchrW (s, '=');
2105 if (p == NULL) {
2106 env = GetEnvironmentStrings ();
2107 if (WCMD_setshow_sortenv( env, s ) == 0) {
2108 WCMD_output (WCMD_LoadMessage(WCMD_MISSINGENV), s);
2109 errorlevel = 1;
2110 }
2111 return;
2112 }
2113 *p++ = '\0';
2114
2115 if (strlenW(p) == 0) p = NULL;
2116 status = SetEnvironmentVariable (s, p);
2117 gle = GetLastError();
2118 if ((!status) & (gle == ERROR_ENVVAR_NOT_FOUND)) {
2119 errorlevel = 1;
2120 } else if ((!status)) WCMD_print_error();
2121 }
2122 }
2123
2124 /****************************************************************************
2125 * WCMD_setshow_path
2126 *
2127 * Set/Show the path environment variable
2128 */
2129
2130 void WCMD_setshow_path (WCHAR *command) {
2131
2132 WCHAR string[1024];
2133 DWORD status;
2134 static const WCHAR pathW[] = {'P','A','T','H','\0'};
2135 static const WCHAR pathEqW[] = {'P','A','T','H','=','\0'};
2136
2137 if (strlenW(param1) == 0) {
2138 status = GetEnvironmentVariable (pathW, string, sizeof(string)/sizeof(WCHAR));
2139 if (status != 0) {
2140 WCMD_output_asis ( pathEqW);
2141 WCMD_output_asis ( string);
2142 WCMD_output_asis ( newline);
2143 }
2144 else {
2145 WCMD_output (WCMD_LoadMessage(WCMD_NOPATH));
2146 }
2147 }
2148 else {
2149 if (*command == '=') command++; /* Skip leading '=' */
2150 status = SetEnvironmentVariable (pathW, command);
2151 if (!status) WCMD_print_error();
2152 }
2153 }
2154
2155 /****************************************************************************
2156 * WCMD_setshow_prompt
2157 *
2158 * Set or show the command prompt.
2159 */
2160
2161 void WCMD_setshow_prompt (void) {
2162
2163 WCHAR *s;
2164 static const WCHAR promptW[] = {'P','R','O','M','P','T','\0'};
2165
2166 if (strlenW(param1) == 0) {
2167 SetEnvironmentVariable (promptW, NULL);
2168 }
2169 else {
2170 s = param1;
2171 while ((*s == '=') || (*s == ' ')) s++;
2172 if (strlenW(s) == 0) {
2173 SetEnvironmentVariable (promptW, NULL);
2174 }
2175 else SetEnvironmentVariable (promptW, s);
2176 }
2177 }
2178
2179 /****************************************************************************
2180 * WCMD_setshow_time
2181 *
2182 * Set/Show the system time
2183 * FIXME: Can't change time yet
2184 */
2185
2186 void WCMD_setshow_time (void) {
2187
2188 WCHAR curtime[64], buffer[64];
2189 DWORD count;
2190 SYSTEMTIME st;
2191 static const WCHAR parmT[] = {'/','T','\0'};
2192
2193 if (strlenW(param1) == 0) {
2194 GetLocalTime(&st);
2195 if (GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, NULL,
2196 curtime, sizeof(curtime)/sizeof(WCHAR))) {
2197 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTTIME), curtime);
2198 if (strstrW (quals, parmT) == NULL) {
2199 WCMD_output (WCMD_LoadMessage(WCMD_NEWTIME));
2200 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer,
2201 sizeof(buffer)/sizeof(WCHAR), &count, NULL);
2202 if (count > 2) {
2203 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
2204 }
2205 }
2206 }
2207 else WCMD_print_error ();
2208 }
2209 else {
2210 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
2211 }
2212 }
2213
2214 /****************************************************************************
2215 * WCMD_shift
2216 *
2217 * Shift batch parameters.
2218 * Optional /n says where to start shifting (n=0-8)
2219 */
2220
2221 void WCMD_shift (WCHAR *command) {
2222 int start;
2223
2224 if (context != NULL) {
2225 WCHAR *pos = strchrW(command, '/');
2226 int i;
2227
2228 if (pos == NULL) {
2229 start = 0;
2230 } else if (*(pos+1)>='0' && *(pos+1)<='8') {
2231 start = (*(pos+1) - '0');
2232 } else {
2233 SetLastError(ERROR_INVALID_PARAMETER);
2234 WCMD_print_error();
2235 return;
2236 }
2237
2238 WINE_TRACE("Shifting variables, starting at %d\n", start);
2239 for (i=start;i<=8;i++) {
2240 context -> shift_count[i] = context -> shift_count[i+1] + 1;
2241 }
2242 context -> shift_count[9] = context -> shift_count[9] + 1;
2243 }
2244
2245 }
2246
2247 /****************************************************************************
2248 * WCMD_title
2249 *
2250 * Set the console title
2251 */
2252 void WCMD_title (WCHAR *command) {
2253 SetConsoleTitle(command);
2254 }
2255
2256 /****************************************************************************
2257 * WCMD_type
2258 *
2259 * Copy a file to standard output.
2260 */
2261
2262 void WCMD_type (WCHAR *command) {
2263
2264 int argno = 0;
2265 WCHAR *argN = command;
2266 BOOL writeHeaders = FALSE;
2267
2268 if (param1[0] == 0x00) {
2269 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
2270 return;
2271 }
2272
2273 if (param2[0] != 0x00) writeHeaders = TRUE;
2274
2275 /* Loop through all args */
2276 errorlevel = 0;
2277 while (argN) {
2278 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
2279
2280 HANDLE h;
2281 WCHAR buffer[512];
2282 DWORD count;
2283
2284 if (!argN) break;
2285
2286 WINE_TRACE("type: Processing arg '%s'\n", wine_dbgstr_w(thisArg));
2287 h = CreateFile (thisArg, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
2288 FILE_ATTRIBUTE_NORMAL, NULL);
2289 if (h == INVALID_HANDLE_VALUE) {
2290 WCMD_print_error ();
2291 WCMD_output (WCMD_LoadMessage(WCMD_READFAIL), thisArg);
2292 errorlevel = 1;
2293 } else {
2294 if (writeHeaders) {
2295 static const WCHAR fmt[] = {'\n','%','s','\n','\n','\0'};
2296 WCMD_output(fmt, thisArg);
2297 }
2298 while (WCMD_ReadFile (h, buffer, sizeof(buffer)/sizeof(WCHAR) - 1, &count, NULL)) {
2299 if (count == 0) break; /* ReadFile reports success on EOF! */
2300 buffer[count] = 0;
2301 WCMD_output_asis (buffer);
2302 }
2303 CloseHandle (h);
2304 if (!writeHeaders)
2305 WCMD_output_asis (newline);
2306 }
2307 }
2308 }
2309
2310 /****************************************************************************
2311 * WCMD_more
2312 *
2313 * Output either a file or stdin to screen in pages
2314 */
2315
2316 void WCMD_more (WCHAR *command) {
2317
2318 int argno = 0;
2319 WCHAR *argN = command;
2320 BOOL useinput = FALSE;
2321 WCHAR moreStr[100];
2322 WCHAR moreStrPage[100];
2323 WCHAR buffer[512];
2324 DWORD count;
2325 static const WCHAR moreStart[] = {'-','-',' ','\0'};
2326 static const WCHAR moreFmt[] = {'%','s',' ','-','-','\n','\0'};
2327 static const WCHAR moreFmt2[] = {'%','s',' ','(','%','2','.','2','d','%','%',
2328 ')',' ','-','-','\n','\0'};
2329 static const WCHAR conInW[] = {'C','O','N','I','N','$','\0'};
2330
2331 /* Prefix the NLS more with '-- ', then load the text */
2332 errorlevel = 0;
2333 strcpyW(moreStr, moreStart);
2334 LoadString (hinst, WCMD_MORESTR, &moreStr[3],
2335 (sizeof(moreStr)/sizeof(WCHAR))-3);
2336
2337 if (param1[0] == 0x00) {
2338
2339 /* Wine implements pipes via temporary files, and hence stdin is
2340 effectively reading from the file. This means the prompts for
2341 more are satisfied by the next line from the input (file). To
2342 avoid this, ensure stdin is to the console */
2343 HANDLE hstdin = GetStdHandle(STD_INPUT_HANDLE);
2344 HANDLE hConIn = CreateFile(conInW, GENERIC_READ | GENERIC_WRITE,
2345 FILE_SHARE_READ, NULL, OPEN_EXISTING,
2346 FILE_ATTRIBUTE_NORMAL, 0);
2347 WINE_TRACE("No parms - working probably in pipe mode\n");
2348 SetStdHandle(STD_INPUT_HANDLE, hConIn);
2349
2350 /* Warning: No easy way of ending the stream (ctrl+z on windows) so
2351 once you get in this bit unless due to a pipe, its going to end badly... */
2352 useinput = TRUE;
2353 wsprintf(moreStrPage, moreFmt, moreStr);
2354
2355 WCMD_enter_paged_mode(moreStrPage);
2356 while (WCMD_ReadFile (hstdin, buffer, (sizeof(buffer)/sizeof(WCHAR))-1, &count, NULL)) {
2357 if (count == 0) break; /* ReadFile reports success on EOF! */
2358 buffer[count] = 0;
2359 WCMD_output_asis (buffer);
2360 }
2361 WCMD_leave_paged_mode();
2362
2363 /* Restore stdin to what it was */
2364 SetStdHandle(STD_INPUT_HANDLE, hstdin);
2365 CloseHandle(hConIn);
2366
2367 return;
2368 } else {
2369 BOOL needsPause = FALSE;
2370
2371 /* Loop through all args */
2372 WINE_TRACE("Parms supplied - working through each file\n");
2373 WCMD_enter_paged_mode(moreStrPage);
2374
2375 while (argN) {
2376 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
2377 HANDLE h;
2378
2379 if (!argN) break;
2380
2381 if (needsPause) {
2382
2383 /* Wait */
2384 wsprintf(moreStrPage, moreFmt2, moreStr, 100);
2385 WCMD_leave_paged_mode();
2386 WCMD_output_asis(moreStrPage);
2387 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer,
2388 sizeof(buffer)/sizeof(WCHAR), &count, NULL);
2389 WCMD_enter_paged_mode(moreStrPage);
2390 }
2391
2392
2393 WINE_TRACE("more: Processing arg '%s'\n", wine_dbgstr_w(thisArg));
2394 h = CreateFile (thisArg, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
2395 FILE_ATTRIBUTE_NORMAL, NULL);
2396 if (h == INVALID_HANDLE_VALUE) {
2397 WCMD_print_error ();
2398 WCMD_output (WCMD_LoadMessage(WCMD_READFAIL), thisArg);
2399 errorlevel = 1;
2400 } else {
2401 ULONG64 curPos = 0;
2402 ULONG64 fileLen = 0;
2403 WIN32_FILE_ATTRIBUTE_DATA fileInfo;
2404
2405 /* Get the file size */
2406 GetFileAttributesEx(thisArg, GetFileExInfoStandard, (void*)&fileInfo);
2407 fileLen = (((ULONG64)fileInfo.nFileSizeHigh) << 32) + fileInfo.nFileSizeLow;
2408
2409 needsPause = TRUE;
2410 while (WCMD_ReadFile (h, buffer, (sizeof(buffer)/sizeof(WCHAR))-1, &count, NULL)) {
2411 if (count == 0) break; /* ReadFile reports success on EOF! */
2412 buffer[count] = 0;
2413 curPos += count;
2414
2415 /* Update % count (would be used in WCMD_output_asis as prompt) */
2416 wsprintf(moreStrPage, moreFmt2, moreStr, (int) min(99, (curPos * 100)/fileLen));
2417
2418 WCMD_output_asis (buffer);
2419 }
2420 CloseHandle (h);
2421 }
2422 }
2423
2424 WCMD_leave_paged_mode();
2425 }
2426 }
2427
2428 /****************************************************************************
2429 * WCMD_verify
2430 *
2431 * Display verify flag.
2432 * FIXME: We don't actually do anything with the verify flag other than toggle
2433 * it...
2434 */
2435
2436 void WCMD_verify (WCHAR *command) {
2437
2438 int count;
2439
2440 count = strlenW(command);
2441 if (count == 0) {
2442 if (verify_mode) WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT), onW);
2443 else WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT), offW);
2444 return;
2445 }
2446 if (lstrcmpiW(command, onW) == 0) {
2447 verify_mode = 1;
2448 return;
2449 }
2450 else if (lstrcmpiW(command, offW) == 0) {
2451 verify_mode = 0;
2452 return;
2453 }
2454 else WCMD_output (WCMD_LoadMessage(WCMD_VERIFYERR));
2455 }
2456
2457 /****************************************************************************
2458 * WCMD_version
2459 *
2460 * Display version info.
2461 */
2462
2463 void WCMD_version (void) {
2464
2465 WCMD_output (version_string);
2466
2467 }
2468
2469 /****************************************************************************
2470 * WCMD_volume
2471 *
2472 * Display volume info and/or set volume label. Returns 0 if error.
2473 */
2474
2475 int WCMD_volume (int mode, WCHAR *path) {
2476
2477 DWORD count, serial;
2478 WCHAR string[MAX_PATH], label[MAX_PATH], curdir[MAX_PATH];
2479 BOOL status;
2480
2481 if (strlenW(path) == 0) {
2482 status = GetCurrentDirectory (sizeof(curdir)/sizeof(WCHAR), curdir);
2483 if (!status) {
2484 WCMD_print_error ();
2485 return 0;
2486 }
2487 status = GetVolumeInformation (NULL, label, sizeof(label)/sizeof(WCHAR),
2488 &serial, NULL, NULL, NULL, 0);
2489 }
2490 else {
2491 static const WCHAR fmt[] = {'%','s','\\','\0'};
2492 if ((path[1] != ':') || (strlenW(path) != 2)) {
2493 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
2494 return 0;
2495 }
2496 wsprintf (curdir, fmt, path);
2497 status = GetVolumeInformation (curdir, label, sizeof(label)/sizeof(WCHAR),
2498 &serial, NULL,
2499 NULL, NULL, 0);
2500 }
2501 if (!status) {
2502 WCMD_print_error ();
2503 return 0;
2504 }
2505 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMEDETAIL),
2506 curdir[0], label, HIWORD(serial), LOWORD(serial));
2507 if (mode) {
2508 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMEPROMPT));
2509 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), string,
2510 sizeof(string)/sizeof(WCHAR), &count, NULL);
2511 if (count > 1) {
2512 string[count-1] = '\0'; /* ReadFile output is not null-terminated! */
2513 if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
2514 }
2515 if (strlenW(path) != 0) {
2516 if (!SetVolumeLabel (curdir, string)) WCMD_print_error ();
2517 }
2518 else {
2519 if (!SetVolumeLabel (NULL, string)) WCMD_print_error ();
2520 }
2521 }
2522 return 1;
2523 }
2524
2525 /**************************************************************************
2526 * WCMD_exit
2527 *
2528 * Exit either the process, or just this batch program
2529 *
2530 */
2531
2532 void WCMD_exit (CMD_LIST **cmdList) {
2533
2534 static const WCHAR parmB[] = {'/','B','\0'};
2535 int rc = atoiW(param1); /* Note: atoi of empty parameter is 0 */
2536
2537 if (context && lstrcmpiW(quals, parmB) == 0) {
2538 errorlevel = rc;
2539 context -> skip_rest = TRUE;
2540 *cmdList = NULL;
2541 } else {
2542 ExitProcess(rc);
2543 }
2544 }
2545
2546
2547 /*****************************************************************************
2548 * WCMD_assoc
2549 *
2550 * Lists or sets file associations (assoc = TRUE)
2551 * Lists or sets file types (assoc = FALSE)
2552 */
2553 void WCMD_assoc (WCHAR *command, BOOL assoc) {
2554
2555 HKEY key;
2556 DWORD accessOptions = KEY_READ;
2557 WCHAR *newValue;
2558 LONG rc = ERROR_SUCCESS;
2559 WCHAR keyValue[MAXSTRING];
2560 DWORD valueLen = MAXSTRING;
2561 HKEY readKey;
2562 static const WCHAR shOpCmdW[] = {'\\','S','h','e','l','l','\\',
2563 'O','p','e','n','\\','C','o','m','m','a','n','d','\0'};
2564
2565 /* See if parameter includes '=' */
2566 errorlevel = 0;
2567 newValue = strchrW(command, '=');
2568 if (newValue) accessOptions |= KEY_WRITE;
2569
2570 /* Open a key to HKEY_CLASSES_ROOT for enumerating */
2571 if (RegOpenKeyEx(HKEY_CLASSES_ROOT, nullW, 0,
2572 accessOptions, &key) != ERROR_SUCCESS) {
2573 WINE_FIXME("Unexpected failure opening HKCR key: %d\n", GetLastError());
2574 return;
2575 }
2576
2577 /* If no parameters then list all associations */
2578 if (*command == 0x00) {
2579 int index = 0;
2580
2581 /* Enumerate all the keys */
2582 while (rc != ERROR_NO_MORE_ITEMS) {
2583 WCHAR keyName[MAXSTRING];
2584 DWORD nameLen;
2585
2586 /* Find the next value */
2587 nameLen = MAXSTRING;
2588 rc = RegEnumKeyEx(key, index++,
2589 keyName, &nameLen,
2590 NULL, NULL, NULL, NULL);
2591
2592 if (rc == ERROR_SUCCESS) {
2593
2594 /* Only interested in extension ones if assoc, or others
2595 if not assoc */
2596 if ((keyName[0] == '.' && assoc) ||
2597 (!(keyName[0] == '.') && (!assoc)))
2598 {
2599 WCHAR subkey[MAXSTRING];
2600 strcpyW(subkey, keyName);
2601 if (!assoc) strcatW(subkey, shOpCmdW);
2602
2603 if (RegOpenKeyEx(key, subkey, 0,
2604 accessOptions, &readKey) == ERROR_SUCCESS) {
2605
2606 valueLen = sizeof(keyValue)/sizeof(WCHAR);
2607 rc = RegQueryValueEx(readKey, NULL, NULL, NULL,
2608 (LPBYTE)keyValue, &valueLen);
2609 WCMD_output_asis(keyName);
2610 WCMD_output_asis(equalW);
2611 /* If no default value found, leave line empty after '=' */
2612 if (rc == ERROR_SUCCESS) {
2613 WCMD_output_asis(keyValue);
2614 }
2615 WCMD_output_asis(newline);
2616 RegCloseKey(readKey);
2617 }
2618 }
2619 }
2620 }
2621
2622 } else {
2623
2624 /* Parameter supplied - if no '=' on command line, its a query */
2625 if (newValue == NULL) {
2626 WCHAR *space;
2627 WCHAR subkey[MAXSTRING];
2628
2629 /* Query terminates the parameter at the first space */
2630 strcpyW(keyValue, command);
2631 space = strchrW(keyValue, ' ');
2632 if (space) *space=0x00;
2633
2634 /* Set up key name */
2635 strcpyW(subkey, keyValue);
2636 if (!assoc) strcatW(subkey, shOpCmdW);
2637
2638 if (RegOpenKeyEx(key, subkey, 0,
2639 accessOptions, &readKey) == ERROR_SUCCESS) {
2640
2641 rc = RegQueryValueEx(readKey, NULL, NULL, NULL,
2642 (LPBYTE)keyValue, &valueLen);
2643 WCMD_output_asis(command);
2644 WCMD_output_asis(equalW);
2645 /* If no default value found, leave line empty after '=' */
2646 if (rc == ERROR_SUCCESS) WCMD_output_asis(keyValue);
2647 WCMD_output_asis(newline);
2648 RegCloseKey(readKey);
2649
2650 } else {
2651 WCHAR msgbuffer[MAXSTRING];
2652 WCHAR outbuffer[MAXSTRING];
2653
2654 /* Load the translated 'File association not found' */
2655 if (assoc) {
2656 LoadString (hinst, WCMD_NOASSOC, msgbuffer, sizeof(msgbuffer)/sizeof(WCHAR));
2657 } else {
2658 LoadString (hinst, WCMD_NOFTYPE, msgbuffer, sizeof(msgbuffer)/sizeof(WCHAR));
2659 }
2660 wsprintf(outbuffer, msgbuffer, keyValue);
2661 WCMD_output_asis(outbuffer);
2662 errorlevel = 2;
2663 }
2664
2665 /* Not a query - its a set or clear of a value */
2666 } else {
2667
2668 WCHAR subkey[MAXSTRING];
2669
2670 /* Get pointer to new value */
2671 *newValue = 0x00;
2672 newValue++;
2673
2674 /* Set up key name */
2675 strcpyW(subkey, command);
2676 if (!assoc) strcatW(subkey, shOpCmdW);
2677
2678 /* If nothing after '=' then clear value - only valid for ASSOC */
2679 if (*newValue == 0x00) {
2680
2681 if (assoc) rc = RegDeleteKey(key, command);
2682 if (assoc && rc == ERROR_SUCCESS) {
2683 WINE_TRACE("HKCR Key '%s' deleted\n", wine_dbgstr_w(command));
2684
2685 } else if (assoc && rc != ERROR_FILE_NOT_FOUND) {
2686 WCMD_print_error();
2687 errorlevel = 2;
2688
2689 } else {
2690 WCHAR msgbuffer[MAXSTRING];
2691 WCHAR outbuffer[MAXSTRING];
2692
2693 /* Load the translated 'File association not found' */
2694 if (assoc) {
2695 LoadString (hinst, WCMD_NOASSOC, msgbuffer,
2696 sizeof(msgbuffer)/sizeof(WCHAR));
2697 } else {
2698 LoadString (hinst, WCMD_NOFTYPE, msgbuffer,
2699 sizeof(msgbuffer)/sizeof(WCHAR));
2700 }
2701 wsprintf(outbuffer, msgbuffer, keyValue);
2702 WCMD_output_asis(outbuffer);
2703 errorlevel = 2;
2704 }
2705
2706 /* It really is a set value = contents */
2707 } else {
2708 rc = RegCreateKeyEx(key, subkey, 0, NULL, REG_OPTION_NON_VOLATILE,
2709 accessOptions, NULL, &readKey, NULL);
2710 if (rc == ERROR_SUCCESS) {
2711 rc = RegSetValueEx(readKey, NULL, 0, REG_SZ,
2712 (LPBYTE)newValue, strlenW(newValue));
2713 RegCloseKey(readKey);
2714 }
2715
2716 if (rc != ERROR_SUCCESS) {
2717 WCMD_print_error();
2718 errorlevel = 2;
2719 } else {
2720 WCMD_output_asis(command);
2721 WCMD_output_asis(equalW);
2722 WCMD_output_asis(newValue);
2723 WCMD_output_asis(newline);
2724 }
2725 }
2726 }
2727 }
2728
2729 /* Clean up */
2730 RegCloseKey(key);
2731 }
2732
2733 /****************************************************************************
2734 * WCMD_color
2735 *
2736 * Clear the terminal screen.
2737 */
2738
2739 void WCMD_color (void) {
2740
2741 /* Emulate by filling the screen from the top left to bottom right with
2742 spaces, then moving the cursor to the top left afterwards */
2743 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
2744 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
2745
2746 if (param1[0] != 0x00 && strlenW(param1) > 2) {
2747 WCMD_output (WCMD_LoadMessage(WCMD_ARGERR));
2748 return;
2749 }
2750
2751 if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
2752 {
2753 COORD topLeft;
2754 DWORD screenSize;
2755 DWORD color = 0;
2756
2757 screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
2758
2759 topLeft.X = 0;
2760 topLeft.Y = 0;
2761
2762 /* Convert the color hex digits */
2763 if (param1[0] == 0x00) {
2764 color = defaultColor;
2765 } else {
2766 color = strtoulW(param1, NULL, 16);
2767 }
2768
2769 /* Fail if fg == bg color */
2770 if (((color & 0xF0) >> 4) == (color & 0x0F)) {
2771 errorlevel = 1;
2772 return;
2773 }
2774
2775 /* Set the current screen contents and ensure all future writes
2776 remain this color */
2777 FillConsoleOutputAttribute(hStdOut, color, screenSize, topLeft, &screenSize);
2778 SetConsoleTextAttribute(hStdOut, color);
2779 }
2780 }
DirectPlay implementation for GSoC