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