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