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