2 * CMD - Wine-compatible command line interface - built-in functions.
4 * Copyright (C) 1999 D A Pickles
5 * Copyright (C) 2007 J Edmeades
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.
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.
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
24 * - No support for pipes, shell parameters
25 * - Lots of functionality missing from builtins
26 * - Messages etc need international support
29 #define WIN32_LEAN_AND_MEAN
33 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(cmd
);
37 extern int defaultColor
;
38 extern BOOL echo_mode
;
39 extern BOOL interactive
;
41 struct env_stack
*pushd_directories
;
42 const WCHAR dotW
[] = {'.','\0'};
43 const WCHAR dotdotW
[] = {'.','.','\0'};
44 const WCHAR nullW
[] = {'\0'};
45 const WCHAR starW
[] = {'*','\0'};
46 const WCHAR slashW
[] = {'\\','\0'};
47 const WCHAR equalW
[] = {'=','\0'};
48 const WCHAR wildcardsW
[] = {'*','?','\0'};
49 const WCHAR slashstarW
[] = {'\\','*','\0'};
50 const WCHAR inbuilt
[][10] = {
51 {'C','A','L','L','\0'},
53 {'C','H','D','I','R','\0'},
55 {'C','O','P','Y','\0'},
56 {'C','T','T','Y','\0'},
57 {'D','A','T','E','\0'},
60 {'E','C','H','O','\0'},
61 {'E','R','A','S','E','\0'},
63 {'G','O','T','O','\0'},
64 {'H','E','L','P','\0'},
66 {'L','A','B','E','L','\0'},
68 {'M','K','D','I','R','\0'},
69 {'M','O','V','E','\0'},
70 {'P','A','T','H','\0'},
71 {'P','A','U','S','E','\0'},
72 {'P','R','O','M','P','T','\0'},
75 {'R','E','N','A','M','E','\0'},
77 {'R','M','D','I','R','\0'},
79 {'S','H','I','F','T','\0'},
80 {'S','T','A','R','T','\0'},
81 {'T','I','M','E','\0'},
82 {'T','I','T','L','E','\0'},
83 {'T','Y','P','E','\0'},
84 {'V','E','R','I','F','Y','\0'},
87 {'E','N','D','L','O','C','A','L','\0'},
88 {'S','E','T','L','O','C','A','L','\0'},
89 {'P','U','S','H','D','\0'},
90 {'P','O','P','D','\0'},
91 {'A','S','S','O','C','\0'},
92 {'C','O','L','O','R','\0'},
93 {'F','T','Y','P','E','\0'},
94 {'M','O','R','E','\0'},
95 {'C','H','O','I','C','E','\0'},
96 {'E','X','I','T','\0'}
98 static const WCHAR externals
[][10] = {
99 {'A','T','T','R','I','B','\0'},
100 {'X','C','O','P','Y','\0'}
102 static const WCHAR fslashW
[] = {'/','\0'};
103 static const WCHAR onW
[] = {'O','N','\0'};
104 static const WCHAR offW
[] = {'O','F','F','\0'};
105 static const WCHAR parmY
[] = {'/','Y','\0'};
106 static const WCHAR parmNoY
[] = {'/','-','Y','\0'};
107 static const WCHAR eqeqW
[] = {'=','=','\0'};
109 static HINSTANCE hinst
;
110 struct env_stack
*saved_environment
;
111 static BOOL verify_mode
= FALSE
;
113 /**************************************************************************
116 * Issue a message and ask for confirmation, waiting on a valid answer.
118 * Returns True if Y (or A) answer is selected
119 * If optionAll contains a pointer, ALL is allowed, and if answered
123 static BOOL
WCMD_ask_confirm (const WCHAR
*message
, BOOL showSureText
,
127 WCHAR confirm
[MAXSTRING
];
128 WCHAR options
[MAXSTRING
];
129 WCHAR Ybuffer
[MAXSTRING
];
130 WCHAR Nbuffer
[MAXSTRING
];
131 WCHAR Abuffer
[MAXSTRING
];
132 WCHAR answer
[MAX_PATH
] = {'\0'};
135 /* Load the translated valid answers */
137 LoadStringW(hinst
, WCMD_CONFIRM
, confirm
, sizeof(confirm
)/sizeof(WCHAR
));
138 msgid
= optionAll
? WCMD_YESNOALL
: WCMD_YESNO
;
139 LoadStringW(hinst
, msgid
, options
, sizeof(options
)/sizeof(WCHAR
));
140 LoadStringW(hinst
, WCMD_YES
, Ybuffer
, sizeof(Ybuffer
)/sizeof(WCHAR
));
141 LoadStringW(hinst
, WCMD_NO
, Nbuffer
, sizeof(Nbuffer
)/sizeof(WCHAR
));
142 LoadStringW(hinst
, WCMD_ALL
, Abuffer
, sizeof(Abuffer
)/sizeof(WCHAR
));
144 /* Loop waiting on a valid answer */
149 WCMD_output_asis (message
);
151 WCMD_output_asis (confirm
);
152 WCMD_output_asis (options
);
153 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), answer
, sizeof(answer
)/sizeof(WCHAR
), &count
);
154 answer
[0] = toupperW(answer
[0]);
155 if (answer
[0] == Ybuffer
[0])
157 if (answer
[0] == Nbuffer
[0])
159 if (optionAll
&& answer
[0] == Abuffer
[0])
167 /****************************************************************************
170 * Clear the terminal screen.
173 void WCMD_clear_screen (void) {
175 /* Emulate by filling the screen from the top left to bottom right with
176 spaces, then moving the cursor to the top left afterwards */
177 CONSOLE_SCREEN_BUFFER_INFO consoleInfo
;
178 HANDLE hStdOut
= GetStdHandle(STD_OUTPUT_HANDLE
);
180 if (GetConsoleScreenBufferInfo(hStdOut
, &consoleInfo
))
185 screenSize
= consoleInfo
.dwSize
.X
* (consoleInfo
.dwSize
.Y
+ 1);
189 FillConsoleOutputCharacterW(hStdOut
, ' ', screenSize
, topLeft
, &screenSize
);
190 SetConsoleCursorPosition(hStdOut
, topLeft
);
194 /****************************************************************************
197 * Change the default i/o device (ie redirect STDin/STDout).
200 void WCMD_change_tty (void) {
202 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
206 /****************************************************************************
211 void WCMD_choice (const WCHAR
* args
) {
213 static const WCHAR bellW
[] = {7,0};
214 static const WCHAR commaW
[] = {',',0};
215 static const WCHAR bracket_open
[] = {'[',0};
216 static const WCHAR bracket_close
[] = {']','?',0};
221 WCHAR
*my_command
= NULL
;
222 WCHAR opt_default
= 0;
223 DWORD opt_timeout
= 0;
230 have_console
= GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), &oldmode
);
233 my_command
= WCMD_strdupW(WCMD_skip_leading_spaces((WCHAR
*) args
));
237 ptr
= WCMD_skip_leading_spaces(my_command
);
238 while (*ptr
== '/') {
239 switch (toupperW(ptr
[1])) {
242 /* the colon is optional */
246 if (!*ptr
|| isspaceW(*ptr
)) {
247 WINE_FIXME("bad parameter %s for /C\n", wine_dbgstr_w(ptr
));
248 HeapFree(GetProcessHeap(), 0, my_command
);
252 /* remember the allowed keys (overwrite previous /C option) */
254 while (*ptr
&& (!isspaceW(*ptr
)))
258 /* terminate allowed chars */
260 ptr
= WCMD_skip_leading_spaces(&ptr
[1]);
262 WINE_TRACE("answer-list: %s\n", wine_dbgstr_w(opt_c
));
267 ptr
= WCMD_skip_leading_spaces(&ptr
[2]);
272 ptr
= WCMD_skip_leading_spaces(&ptr
[2]);
277 /* the colon is optional */
281 opt_default
= *ptr
++;
283 if (!opt_default
|| (*ptr
!= ',')) {
284 WINE_FIXME("bad option %s for /T\n", opt_default
? wine_dbgstr_w(ptr
) : "");
285 HeapFree(GetProcessHeap(), 0, my_command
);
291 while (((answer
[count
] = *ptr
)) && isdigitW(*ptr
) && (count
< 15)) {
297 opt_timeout
= atoiW(answer
);
299 ptr
= WCMD_skip_leading_spaces(ptr
);
303 WINE_FIXME("bad parameter: %s\n", wine_dbgstr_w(ptr
));
304 HeapFree(GetProcessHeap(), 0, my_command
);
310 WINE_FIXME("timeout not supported: %c,%d\n", opt_default
, opt_timeout
);
313 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), 0);
315 /* use default keys, when needed: localized versions of "Y"es and "No" */
317 LoadStringW(hinst
, WCMD_YES
, buffer
, sizeof(buffer
)/sizeof(WCHAR
));
318 LoadStringW(hinst
, WCMD_NO
, buffer
+ 1, sizeof(buffer
)/sizeof(WCHAR
) - 1);
323 /* print the question, when needed */
325 WCMD_output_asis(ptr
);
329 WINE_TRACE("case insensitive answer-list: %s\n", wine_dbgstr_w(opt_c
));
333 /* print a list of all allowed answers inside brackets */
334 WCMD_output_asis(bracket_open
);
337 while ((answer
[0] = *ptr
++)) {
338 WCMD_output_asis(answer
);
340 WCMD_output_asis(commaW
);
342 WCMD_output_asis(bracket_close
);
347 /* FIXME: Add support for option /T */
348 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), answer
, 1, &count
);
351 answer
[0] = toupperW(answer
[0]);
353 ptr
= strchrW(opt_c
, answer
[0]);
355 WCMD_output_asis(answer
);
356 WCMD_output_asis(newlineW
);
358 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), oldmode
);
360 errorlevel
= (ptr
- opt_c
) + 1;
361 WINE_TRACE("answer: %d\n", errorlevel
);
362 HeapFree(GetProcessHeap(), 0, my_command
);
367 /* key not allowed: play the bell */
368 WINE_TRACE("key not allowed: %s\n", wine_dbgstr_w(answer
));
369 WCMD_output_asis(bellW
);
374 /****************************************************************************
377 * Adds an EOF onto the end of a file
378 * Returns TRUE on success
380 static BOOL
WCMD_AppendEOF(WCHAR
*filename
)
386 WINE_TRACE("Appending EOF to %s\n", wine_dbgstr_w(filename
));
387 h
= CreateFileW(filename
, GENERIC_WRITE
, 0, NULL
,
388 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
391 WINE_ERR("Failed to open %s (%d)\n", wine_dbgstr_w(filename
), GetLastError());
394 SetFilePointer (h
, 0, NULL
, FILE_END
);
395 if (!WriteFile(h
, &eof
, 1, NULL
, NULL
)) {
396 WINE_ERR("Failed to append EOF to %s (%d)\n", wine_dbgstr_w(filename
), GetLastError());
404 /****************************************************************************
408 * optionally reading only until EOF (ascii copy)
409 * optionally appending onto an existing file (append)
410 * Returns TRUE on success
412 static BOOL
WCMD_ManualCopy(WCHAR
*srcname
, WCHAR
*dstname
, BOOL ascii
, BOOL append
)
416 DWORD bytesread
, byteswritten
;
418 WINE_TRACE("ASCII Copying %s to %s (append?%d)\n",
419 wine_dbgstr_w(srcname
), wine_dbgstr_w(dstname
), append
);
421 in
= CreateFileW(srcname
, GENERIC_READ
, 0, NULL
,
422 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
424 WINE_ERR("Failed to open %s (%d)\n", wine_dbgstr_w(srcname
), GetLastError());
428 /* Open the output file, overwriting if not appending */
429 out
= CreateFileW(dstname
, GENERIC_WRITE
, 0, NULL
,
430 append
?OPEN_EXISTING
:CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
432 WINE_ERR("Failed to open %s (%d)\n", wine_dbgstr_w(dstname
), GetLastError());
436 /* Move to end of destination if we are going to append to it */
438 SetFilePointer(out
, 0, NULL
, FILE_END
);
441 /* Loop copying data from source to destination until EOF read */
445 char buffer
[MAXSTRING
];
447 ok
= ReadFile(in
, buffer
, MAXSTRING
, &bytesread
, NULL
);
450 /* Stop at first EOF */
452 char *ptr
= (char *)memchr((void *)buffer
, '\x1a', bytesread
);
453 if (ptr
) bytesread
= (ptr
- buffer
);
457 ok
= WriteFile(out
, buffer
, bytesread
, &byteswritten
, NULL
);
458 if (!ok
|| byteswritten
!= bytesread
) {
459 WINE_ERR("Unexpected failure writing to %s, rc=%d\n",
460 wine_dbgstr_w(dstname
), GetLastError());
464 WINE_ERR("Unexpected failure reading from %s, rc=%d\n",
465 wine_dbgstr_w(srcname
), GetLastError());
467 } while (ok
&& bytesread
> 0);
474 /****************************************************************************
477 * Copy a file or wildcarded set.
478 * For ascii/binary type copies, it gets complex:
479 * Syntax on command line is
480 * ... /a | /b filename /a /b {[ + filename /a /b]} [dest /a /b]
481 * Where first /a or /b sets 'mode in operation' until another is found
482 * once another is found, it applies to the file preceding the /a or /b
483 * In addition each filename can contain wildcards
484 * To make matters worse, the + may be in the same parameter (i.e. no
485 * whitespace) or with whitespace separating it
487 * ASCII mode on read == read and stop at first EOF
488 * ASCII mode on write == append EOF to destination
489 * Binary == copy as-is
491 * Design of this is to build up a list of files which will be copied into a
492 * list, then work through the list file by file.
493 * If no destination is specified, it defaults to the name of the first file in
494 * the list, but the current directory.
498 void WCMD_copy(WCHAR
* args
) {
500 BOOL opt_d
, opt_v
, opt_n
, opt_z
, opt_y
, opt_noty
;
506 int binarymode
= -1; /* -1 means use the default, 1 is binary, 0 ascii */
507 BOOL concatnextfilename
= FALSE
; /* True if we have just processed a + */
508 BOOL anyconcats
= FALSE
; /* Have we found any + options */
509 BOOL appendfirstsource
= FALSE
; /* Use first found filename as destination */
510 BOOL writtenoneconcat
= FALSE
; /* Remember when the first concatenated file done */
511 BOOL prompt
; /* Prompt before overwriting */
512 WCHAR destname
[MAX_PATH
]; /* Used in calculating the destination name */
513 BOOL destisdirectory
= FALSE
; /* Is the destination a directory? */
517 static const WCHAR copyCmdW
[] = {'C','O','P','Y','C','M','D','\0'};
519 typedef struct _COPY_FILES
521 struct _COPY_FILES
*next
;
526 COPY_FILES
*sourcelist
= NULL
;
527 COPY_FILES
*lastcopyentry
= NULL
;
528 COPY_FILES
*destination
= NULL
;
529 COPY_FILES
*thiscopy
= NULL
;
530 COPY_FILES
*prevcopy
= NULL
;
532 /* Assume we were successful! */
535 /* If no args supplied at all, report an error */
536 if (param1
[0] == 0x00) {
537 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NOARG
));
542 opt_d
= opt_v
= opt_n
= opt_z
= opt_y
= opt_noty
= FALSE
;
544 /* Walk through all args, building up a list of files to process */
545 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
546 while (*(thisparam
)) {
550 WINE_TRACE("Working on parameter '%s'\n", wine_dbgstr_w(thisparam
));
552 /* Handle switches */
553 if (*thisparam
== '/') {
554 while (*thisparam
== '/') {
556 if (toupperW(*thisparam
) == 'D') {
558 if (opt_d
) WINE_FIXME("copy /D support not implemented yet\n");
559 } else if (toupperW(*thisparam
) == 'Y') {
561 } else if (toupperW(*thisparam
) == '-' && toupperW(*(thisparam
+1)) == 'Y') {
563 } else if (toupperW(*thisparam
) == 'V') {
565 if (opt_v
) WINE_FIXME("copy /V support not implemented yet\n");
566 } else if (toupperW(*thisparam
) == 'N') {
568 if (opt_n
) WINE_FIXME("copy /N support not implemented yet\n");
569 } else if (toupperW(*thisparam
) == 'Z') {
571 if (opt_z
) WINE_FIXME("copy /Z support not implemented yet\n");
572 } else if (toupperW(*thisparam
) == 'A') {
573 if (binarymode
!= 0) {
575 WINE_TRACE("Subsequent files will be handled as ASCII\n");
576 if (destination
!= NULL
) {
577 WINE_TRACE("file %s will be written as ASCII\n", wine_dbgstr_w(destination
->name
));
578 destination
->binarycopy
= binarymode
;
579 } else if (lastcopyentry
!= NULL
) {
580 WINE_TRACE("file %s will be read as ASCII\n", wine_dbgstr_w(lastcopyentry
->name
));
581 lastcopyentry
->binarycopy
= binarymode
;
584 } else if (toupperW(*thisparam
) == 'B') {
585 if (binarymode
!= 1) {
587 WINE_TRACE("Subsequent files will be handled as binary\n");
588 if (destination
!= NULL
) {
589 WINE_TRACE("file %s will be written as binary\n", wine_dbgstr_w(destination
->name
));
590 destination
->binarycopy
= binarymode
;
591 } else if (lastcopyentry
!= NULL
) {
592 WINE_TRACE("file %s will be read as binary\n", wine_dbgstr_w(lastcopyentry
->name
));
593 lastcopyentry
->binarycopy
= binarymode
;
597 WINE_FIXME("Unexpected copy switch %s\n", wine_dbgstr_w(thisparam
));
602 /* This parameter was purely switches, get the next one */
603 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
607 /* We have found something which is not a switch. If could be anything of the form
608 sourcefilename (which could be destination too)
609 + (when filename + filename syntex used)
610 sourcefilename+sourcefilename
612 +/b[tests show windows then ignores to end of parameter]
615 if (*thisparam
=='+') {
616 if (lastcopyentry
== NULL
) {
617 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
621 concatnextfilename
= TRUE
;
625 /* Move to next thing to process */
627 if (*thisparam
== 0x00)
628 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
632 /* We have found something to process - build a COPY_FILE block to store it */
633 thiscopy
= HeapAlloc(GetProcessHeap(),0,sizeof(COPY_FILES
));
634 if (thiscopy
== NULL
) goto exitreturn
;
637 WINE_TRACE("Not a switch, but probably a filename/list %s\n", wine_dbgstr_w(thisparam
));
638 thiscopy
->concatenate
= concatnextfilename
;
639 thiscopy
->binarycopy
= binarymode
;
640 thiscopy
->next
= NULL
;
642 /* Time to work out the name. Allocate at least enough space (deliberately too much to
643 leave space to append \* to the end) , then copy in character by character. Strip off
644 quotes if we find them. */
645 len
= strlenW(thisparam
) + (sizeof(WCHAR
) * 5); /* 5 spare characters, null + \*.* */
646 thiscopy
->name
= HeapAlloc(GetProcessHeap(),0,len
*sizeof(WCHAR
));
647 memset(thiscopy
->name
, 0x00, len
);
650 pos2
= thiscopy
->name
;
652 while (*pos1
&& (inquotes
|| (*pos1
!= '+' && *pos1
!= '/'))) {
654 inquotes
= !inquotes
;
656 } else *pos2
++ = *pos1
++;
659 WINE_TRACE("Calculated file name %s\n", wine_dbgstr_w(thiscopy
->name
));
661 /* This is either the first source, concatenated subsequent source or destination */
662 if (sourcelist
== NULL
) {
663 WINE_TRACE("Adding as first source part\n");
664 sourcelist
= thiscopy
;
665 lastcopyentry
= thiscopy
;
666 } else if (concatnextfilename
) {
667 WINE_TRACE("Adding to source file list to be concatenated\n");
668 lastcopyentry
->next
= thiscopy
;
669 lastcopyentry
= thiscopy
;
670 } else if (destination
== NULL
) {
671 destination
= thiscopy
;
673 /* We have processed sources and destinations and still found more to do - invalid */
674 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
678 concatnextfilename
= FALSE
;
680 /* We either need to process the rest of the parameter or move to the next */
681 if (*pos1
== '/' || *pos1
== '+') {
685 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
689 /* Ensure we have at least one source file */
691 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
696 /* Default whether automatic overwriting is on. If we are interactive then
697 we prompt by default, otherwise we overwrite by default
698 /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
699 if (opt_noty
) prompt
= TRUE
;
700 else if (opt_y
) prompt
= FALSE
;
702 /* By default, we will force the overwrite in batch mode and ask for
703 * confirmation in interactive mode. */
704 prompt
= interactive
;
705 /* If COPYCMD is set, then we force the overwrite with /Y and ask for
706 * confirmation with /-Y. If COPYCMD is neither of those, then we use the
707 * default behavior. */
708 len
= GetEnvironmentVariableW(copyCmdW
, copycmd
, sizeof(copycmd
)/sizeof(WCHAR
));
709 if (len
&& len
< (sizeof(copycmd
)/sizeof(WCHAR
))) {
710 if (!lstrcmpiW (copycmd
, parmY
))
712 else if (!lstrcmpiW (copycmd
, parmNoY
))
717 /* Calculate the destination now - if none supplied, its current dir +
718 filename of first file in list*/
719 if (destination
== NULL
) {
721 WINE_TRACE("No destination supplied, so need to calculate it\n");
722 strcpyW(destname
, dotW
);
723 strcatW(destname
, slashW
);
725 destination
= HeapAlloc(GetProcessHeap(),0,sizeof(COPY_FILES
));
726 if (destination
== NULL
) goto exitreturn
;
727 destination
->concatenate
= FALSE
; /* Not used for destination */
728 destination
->binarycopy
= binarymode
;
729 destination
->next
= NULL
; /* Not used for destination */
730 destination
->name
= NULL
; /* To be filled in */
731 destisdirectory
= TRUE
;
737 WINE_TRACE("Destination supplied, processing to see if file or directory\n");
739 /* Convert to fully qualified path/filename */
740 GetFullPathNameW(destination
->name
, sizeof(destname
)/sizeof(WCHAR
), destname
, &filenamepart
);
741 WINE_TRACE("Full dest name is '%s'\n", wine_dbgstr_w(destname
));
743 /* If parameter is a directory, ensure it ends in \ */
744 attributes
= GetFileAttributesW(destname
);
745 if ((destname
[strlenW(destname
) - 1] == '\\') ||
746 ((attributes
!= INVALID_FILE_ATTRIBUTES
) &&
747 (attributes
& FILE_ATTRIBUTE_DIRECTORY
))) {
749 destisdirectory
= TRUE
;
750 if (!(destname
[strlenW(destname
) - 1] == '\\')) strcatW(destname
, slashW
);
751 WINE_TRACE("Directory, so full name is now '%s'\n", wine_dbgstr_w(destname
));
755 /* Normally, the destination is the current directory unless we are
756 concatenating, in which case its current directory plus first filename.
758 In addition by default it is a binary copy unless concatenating, when
759 the copy defaults to an ascii copy (stop at EOF). We do not know the
760 first source part yet (until we search) so flag as needing filling in. */
763 /* We have found an a+b type syntax, so destination has to be a filename
764 and we need to default to ascii copying. If we have been supplied a
765 directory as the destination, we need to defer calculating the name */
766 if (destisdirectory
) appendfirstsource
= TRUE
;
767 if (destination
->binarycopy
== -1) destination
->binarycopy
= 0;
769 } else if (!destisdirectory
) {
770 /* We have been asked to copy to a filename. Default to ascii IF the
771 source contains wildcards (true even if only one match) */
772 if (strpbrkW(sourcelist
->name
, wildcardsW
) != NULL
) {
773 anyconcats
= TRUE
; /* We really are concatenating to a single file */
774 if (destination
->binarycopy
== -1) {
775 destination
->binarycopy
= 0;
778 if (destination
->binarycopy
== -1) {
779 destination
->binarycopy
= 1;
784 /* Save away the destination name*/
785 HeapFree(GetProcessHeap(), 0, destination
->name
);
786 destination
->name
= WCMD_strdupW(destname
);
787 WINE_TRACE("Resolved destination is '%s' (calc later %d)\n",
788 wine_dbgstr_w(destname
), appendfirstsource
);
790 /* Now we need to walk the set of sources, and process each name we come to.
791 If anyconcats is true, we are writing to one file, otherwise we are using
792 the source name each time.
793 If destination exists, prompt for overwrite the first time (if concatenating
794 we ask each time until yes is answered)
795 The first source file we come across must exist (when wildcards expanded)
796 and if concatenating with overwrite prompts, each source file must exist
797 until a yes is answered. */
799 thiscopy
= sourcelist
;
802 while (thiscopy
!= NULL
) {
804 WCHAR srcpath
[MAX_PATH
];
808 /* If it was not explicit, we now know whether we are concatenating or not and
809 hence whether to copy as binary or ascii */
810 if (thiscopy
->binarycopy
== -1) thiscopy
->binarycopy
= !anyconcats
;
812 /* Convert to fully qualified path/filename in srcpath, file filenamepart pointing
813 to where the filename portion begins (used for wildcart expansion. */
814 GetFullPathNameW(thiscopy
->name
, sizeof(srcpath
)/sizeof(WCHAR
), srcpath
, &filenamepart
);
815 WINE_TRACE("Full src name is '%s'\n", wine_dbgstr_w(srcpath
));
817 /* If parameter is a directory, ensure it ends in \* */
818 attributes
= GetFileAttributesW(srcpath
);
819 if (srcpath
[strlenW(srcpath
) - 1] == '\\') {
821 /* We need to know where the filename part starts, so append * and
822 recalculate the full resulting path */
823 strcatW(thiscopy
->name
, starW
);
824 GetFullPathNameW(thiscopy
->name
, sizeof(srcpath
)/sizeof(WCHAR
), srcpath
, &filenamepart
);
825 WINE_TRACE("Directory, so full name is now '%s'\n", wine_dbgstr_w(srcpath
));
827 } else if ((strpbrkW(srcpath
, wildcardsW
) == NULL
) &&
828 (attributes
!= INVALID_FILE_ATTRIBUTES
) &&
829 (attributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
831 /* We need to know where the filename part starts, so append \* and
832 recalculate the full resulting path */
833 strcatW(thiscopy
->name
, slashstarW
);
834 GetFullPathNameW(thiscopy
->name
, sizeof(srcpath
)/sizeof(WCHAR
), srcpath
, &filenamepart
);
835 WINE_TRACE("Directory, so full name is now '%s'\n", wine_dbgstr_w(srcpath
));
838 WINE_TRACE("Copy source (calculated): path: '%s' (Concats: %d)\n",
839 wine_dbgstr_w(srcpath
), anyconcats
);
841 /* Loop through all source files */
842 WINE_TRACE("Searching for: '%s'\n", wine_dbgstr_w(srcpath
));
843 hff
= FindFirstFileW(srcpath
, &fd
);
844 if (hff
!= INVALID_HANDLE_VALUE
) {
846 WCHAR outname
[MAX_PATH
];
849 /* Skip . and .., and directories */
850 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) {
851 WINE_TRACE("Skipping directories\n");
854 /* Build final destination name */
855 strcpyW(outname
, destination
->name
);
856 if (destisdirectory
|| appendfirstsource
) strcatW(outname
, fd
.cFileName
);
858 /* Build source name */
859 strcpyW(filenamepart
, fd
.cFileName
);
861 /* Do we just overwrite */
863 if (anyconcats
&& writtenoneconcat
) {
867 WINE_TRACE("Copying from : '%s'\n", wine_dbgstr_w(srcpath
));
868 WINE_TRACE("Copying to : '%s'\n", wine_dbgstr_w(outname
));
869 WINE_TRACE("Flags: srcbinary(%d), dstbinary(%d), over(%d), prompt(%d)\n",
870 thiscopy
->binarycopy
, destination
->binarycopy
, overwrite
, prompt
);
872 /* Prompt before overwriting */
874 DWORD attributes
= GetFileAttributesW(outname
);
875 if (attributes
!= INVALID_FILE_ATTRIBUTES
) {
877 question
= WCMD_format_string(WCMD_LoadMessage(WCMD_OVERWRITE
), outname
);
878 overwrite
= WCMD_ask_confirm(question
, FALSE
, NULL
);
881 else overwrite
= TRUE
;
884 /* If we needed tyo save away the first filename, do it */
885 if (appendfirstsource
&& overwrite
) {
886 HeapFree(GetProcessHeap(), 0, destination
->name
);
887 destination
->name
= WCMD_strdupW(outname
);
888 WINE_TRACE("Final resolved destination name : '%s'\n", wine_dbgstr_w(outname
));
889 appendfirstsource
= FALSE
;
890 destisdirectory
= FALSE
;
893 /* Do the copy as appropriate */
895 if (anyconcats
&& writtenoneconcat
) {
896 if (thiscopy
->binarycopy
) {
897 status
= WCMD_ManualCopy(srcpath
, outname
, FALSE
, TRUE
);
899 status
= WCMD_ManualCopy(srcpath
, outname
, TRUE
, TRUE
);
901 } else if (!thiscopy
->binarycopy
) {
902 status
= WCMD_ManualCopy(srcpath
, outname
, TRUE
, FALSE
);
904 status
= CopyFileW(srcpath
, outname
, FALSE
);
910 WINE_TRACE("Copied successfully\n");
911 if (anyconcats
) writtenoneconcat
= TRUE
;
913 /* Append EOF if ascii destination and we are not going to add more onto the end
914 Note: Testing shows windows has an optimization whereas if you have a binary
915 copy of a file to a single destination (ie concatenation) then it does not add
916 the EOF, hence the check on the source copy type below. */
917 if (!destination
->binarycopy
&& !anyconcats
&& !thiscopy
->binarycopy
) {
918 if (!WCMD_AppendEOF(outname
)) {
926 } while (FindNextFileW(hff
, &fd
) != 0);
929 /* Error if the first file was not found */
930 if (!anyconcats
|| (anyconcats
&& !writtenoneconcat
)) {
936 /* Step on to the next supplied source */
937 thiscopy
= thiscopy
-> next
;
940 /* Append EOF if ascii destination and we were concatenating */
941 if (!errorlevel
&& !destination
->binarycopy
&& anyconcats
&& writtenoneconcat
) {
942 if (!WCMD_AppendEOF(destination
->name
)) {
948 /* Exit out of the routine, freeing any remaining allocated memory */
951 thiscopy
= sourcelist
;
952 while (thiscopy
!= NULL
) {
954 /* Free up this block*/
955 thiscopy
= thiscopy
-> next
;
956 HeapFree(GetProcessHeap(), 0, prevcopy
->name
);
957 HeapFree(GetProcessHeap(), 0, prevcopy
);
960 /* Free up the destination memory */
962 HeapFree(GetProcessHeap(), 0, destination
->name
);
963 HeapFree(GetProcessHeap(), 0, destination
);
969 /****************************************************************************
972 * Create a directory (and, if needed, any intermediate directories).
974 * Modifies its argument by replacing slashes temporarily with nulls.
977 static BOOL
create_full_path(WCHAR
* path
)
981 /* don't mess with drive letter portion of path, if any */
986 /* Strip trailing slashes. */
987 for (p
= path
+ strlenW(path
) - 1; p
!= start
&& *p
== '\\'; p
--)
990 /* Step through path, creating intermediate directories as needed. */
991 /* First component includes drive letter, if any. */
995 /* Skip to end of component */
996 while (*p
== '\\') p
++;
997 while (*p
&& *p
!= '\\') p
++;
999 /* path is now the original full path */
1000 return CreateDirectoryW(path
, NULL
);
1002 /* Truncate path, create intermediate directory, and restore path */
1004 rv
= CreateDirectoryW(path
, NULL
);
1006 if (!rv
&& GetLastError() != ERROR_ALREADY_EXISTS
)
1013 void WCMD_create_dir (WCHAR
*args
) {
1017 if (param1
[0] == 0x00) {
1018 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
1021 /* Loop through all args */
1023 WCHAR
*thisArg
= WCMD_parameter(args
, argno
++, &argN
, FALSE
, FALSE
);
1025 if (!create_full_path(thisArg
)) {
1026 WCMD_print_error ();
1032 /* Parse the /A options given by the user on the commandline
1033 * into a bitmask of wanted attributes (*wantSet),
1034 * and a bitmask of unwanted attributes (*wantClear).
1036 static void WCMD_delete_parse_attributes(DWORD
*wantSet
, DWORD
*wantClear
) {
1037 static const WCHAR parmA
[] = {'/','A','\0'};
1040 /* both are strictly 'out' parameters */
1044 /* For each /A argument */
1045 for (p
=strstrW(quals
, parmA
); p
!= NULL
; p
=strstrW(p
, parmA
)) {
1046 /* Skip /A itself */
1049 /* Skip optional : */
1052 /* For each of the attribute specifier chars to this /A option */
1053 for (; *p
!= 0 && *p
!= '/'; p
++) {
1054 BOOL negate
= FALSE
;
1062 /* Convert the attribute specifier to a bit in one of the masks */
1064 case 'R': mask
= FILE_ATTRIBUTE_READONLY
; break;
1065 case 'H': mask
= FILE_ATTRIBUTE_HIDDEN
; break;
1066 case 'S': mask
= FILE_ATTRIBUTE_SYSTEM
; break;
1067 case 'A': mask
= FILE_ATTRIBUTE_ARCHIVE
; break;
1069 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
1079 /* If filename part of parameter is * or *.*,
1080 * and neither /Q nor /P options were given,
1081 * prompt the user whether to proceed.
1082 * Returns FALSE if user says no, TRUE otherwise.
1083 * *pPrompted is set to TRUE if the user is prompted.
1084 * (If /P supplied, del will prompt for individual files later.)
1086 static BOOL
WCMD_delete_confirm_wildcard(const WCHAR
*filename
, BOOL
*pPrompted
) {
1087 static const WCHAR parmP
[] = {'/','P','\0'};
1088 static const WCHAR parmQ
[] = {'/','Q','\0'};
1090 if ((strstrW(quals
, parmQ
) == NULL
) && (strstrW(quals
, parmP
) == NULL
)) {
1091 static const WCHAR anyExt
[]= {'.','*','\0'};
1093 WCHAR dir
[MAX_PATH
];
1094 WCHAR fname
[MAX_PATH
];
1095 WCHAR ext
[MAX_PATH
];
1096 WCHAR fpath
[MAX_PATH
];
1098 /* Convert path into actual directory spec */
1099 GetFullPathNameW(filename
, sizeof(fpath
)/sizeof(WCHAR
), fpath
, NULL
);
1100 WCMD_splitpath(fpath
, drive
, dir
, fname
, ext
);
1102 /* Only prompt for * and *.*, not *a, a*, *.a* etc */
1103 if ((strcmpW(fname
, starW
) == 0) &&
1104 (*ext
== 0x00 || (strcmpW(ext
, anyExt
) == 0))) {
1106 WCHAR question
[MAXSTRING
];
1107 static const WCHAR fmt
[] = {'%','s',' ','\0'};
1109 /* Caller uses this to suppress "file not found" warning later */
1112 /* Ask for confirmation */
1113 wsprintfW(question
, fmt
, fpath
);
1114 return WCMD_ask_confirm(question
, TRUE
, NULL
);
1117 /* No scary wildcard, or question suppressed, so it's ok to delete the file(s) */
1121 /* Helper function for WCMD_delete().
1122 * Deletes a single file, directory, or wildcard.
1123 * If /S was given, does it recursively.
1124 * Returns TRUE if a file was deleted.
1126 static BOOL
WCMD_delete_one (const WCHAR
*thisArg
) {
1128 static const WCHAR parmP
[] = {'/','P','\0'};
1129 static const WCHAR parmS
[] = {'/','S','\0'};
1130 static const WCHAR parmF
[] = {'/','F','\0'};
1132 DWORD unwanted_attrs
;
1134 WCHAR argCopy
[MAX_PATH
];
1135 WIN32_FIND_DATAW fd
;
1137 WCHAR fpath
[MAX_PATH
];
1139 BOOL handleParm
= TRUE
;
1141 WCMD_delete_parse_attributes(&wanted_attrs
, &unwanted_attrs
);
1143 strcpyW(argCopy
, thisArg
);
1144 WINE_TRACE("del: Processing arg %s (quals:%s)\n",
1145 wine_dbgstr_w(argCopy
), wine_dbgstr_w(quals
));
1147 if (!WCMD_delete_confirm_wildcard(argCopy
, &found
)) {
1148 /* Skip this arg if user declines to delete *.* */
1152 /* First, try to delete in the current directory */
1153 hff
= FindFirstFileW(argCopy
, &fd
);
1154 if (hff
== INVALID_HANDLE_VALUE
) {
1160 /* Support del <dirname> by just deleting all files dirname\* */
1162 && (strchrW(argCopy
,'*') == NULL
)
1163 && (strchrW(argCopy
,'?') == NULL
)
1164 && (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
))
1166 WCHAR modifiedParm
[MAX_PATH
];
1167 static const WCHAR slashStar
[] = {'\\','*','\0'};
1169 strcpyW(modifiedParm
, argCopy
);
1170 strcatW(modifiedParm
, slashStar
);
1173 WCMD_delete_one(modifiedParm
);
1175 } else if (handleParm
) {
1177 /* Build the filename to delete as <supplied directory>\<findfirst filename> */
1178 strcpyW (fpath
, argCopy
);
1180 p
= strrchrW (fpath
, '\\');
1183 strcatW (fpath
, fd
.cFileName
);
1185 else strcpyW (fpath
, fd
.cFileName
);
1186 if (!(fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
1189 /* Handle attribute matching (/A) */
1190 ok
= ((fd
.dwFileAttributes
& wanted_attrs
) == wanted_attrs
)
1191 && ((fd
.dwFileAttributes
& unwanted_attrs
) == 0);
1193 /* /P means prompt for each file */
1194 if (ok
&& strstrW (quals
, parmP
) != NULL
) {
1197 /* Ask for confirmation */
1198 question
= WCMD_format_string(WCMD_LoadMessage(WCMD_DELPROMPT
), fpath
);
1199 ok
= WCMD_ask_confirm(question
, FALSE
, NULL
);
1200 LocalFree(question
);
1203 /* Only proceed if ok to */
1206 /* If file is read only, and /A:r or /F supplied, delete it */
1207 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
&&
1208 ((wanted_attrs
& FILE_ATTRIBUTE_READONLY
) ||
1209 strstrW (quals
, parmF
) != NULL
)) {
1210 SetFileAttributesW(fpath
, fd
.dwFileAttributes
& ~FILE_ATTRIBUTE_READONLY
);
1213 /* Now do the delete */
1214 if (!DeleteFileW(fpath
)) WCMD_print_error ();
1218 } while (FindNextFileW(hff
, &fd
) != 0);
1222 /* Now recurse into all subdirectories handling the parameter in the same way */
1223 if (strstrW (quals
, parmS
) != NULL
) {
1225 WCHAR thisDir
[MAX_PATH
];
1229 WCHAR dir
[MAX_PATH
];
1230 WCHAR fname
[MAX_PATH
];
1231 WCHAR ext
[MAX_PATH
];
1233 /* Convert path into actual directory spec */
1234 GetFullPathNameW(argCopy
, sizeof(thisDir
)/sizeof(WCHAR
), thisDir
, NULL
);
1235 WCMD_splitpath(thisDir
, drive
, dir
, fname
, ext
);
1237 strcpyW(thisDir
, drive
);
1238 strcatW(thisDir
, dir
);
1239 cPos
= strlenW(thisDir
);
1241 WINE_TRACE("Searching recursively in '%s'\n", wine_dbgstr_w(thisDir
));
1243 /* Append '*' to the directory */
1244 thisDir
[cPos
] = '*';
1245 thisDir
[cPos
+1] = 0x00;
1247 hff
= FindFirstFileW(thisDir
, &fd
);
1249 /* Remove residual '*' */
1250 thisDir
[cPos
] = 0x00;
1252 if (hff
!= INVALID_HANDLE_VALUE
) {
1253 DIRECTORY_STACK
*allDirs
= NULL
;
1254 DIRECTORY_STACK
*lastEntry
= NULL
;
1257 if ((fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) &&
1258 (strcmpW(fd
.cFileName
, dotdotW
) != 0) &&
1259 (strcmpW(fd
.cFileName
, dotW
) != 0)) {
1261 DIRECTORY_STACK
*nextDir
;
1262 WCHAR subParm
[MAX_PATH
];
1264 /* Work out search parameter in sub dir */
1265 strcpyW (subParm
, thisDir
);
1266 strcatW (subParm
, fd
.cFileName
);
1267 strcatW (subParm
, slashW
);
1268 strcatW (subParm
, fname
);
1269 strcatW (subParm
, ext
);
1270 WINE_TRACE("Recursive, Adding to search list '%s'\n", wine_dbgstr_w(subParm
));
1272 /* Allocate memory, add to list */
1273 nextDir
= HeapAlloc(GetProcessHeap(),0,sizeof(DIRECTORY_STACK
));
1274 if (allDirs
== NULL
) allDirs
= nextDir
;
1275 if (lastEntry
!= NULL
) lastEntry
->next
= nextDir
;
1276 lastEntry
= nextDir
;
1277 nextDir
->next
= NULL
;
1278 nextDir
->dirName
= HeapAlloc(GetProcessHeap(),0,
1279 (strlenW(subParm
)+1) * sizeof(WCHAR
));
1280 strcpyW(nextDir
->dirName
, subParm
);
1282 } while (FindNextFileW(hff
, &fd
) != 0);
1285 /* Go through each subdir doing the delete */
1286 while (allDirs
!= NULL
) {
1287 DIRECTORY_STACK
*tempDir
;
1289 tempDir
= allDirs
->next
;
1290 found
|= WCMD_delete_one (allDirs
->dirName
);
1292 HeapFree(GetProcessHeap(),0,allDirs
->dirName
);
1293 HeapFree(GetProcessHeap(),0,allDirs
);
1302 /****************************************************************************
1305 * Delete a file or wildcarded set.
1308 * - Testing shows /A is repeatable, eg. /a-r /ar matches all files
1309 * - Each set is a pattern, eg /ahr /as-r means
1310 * readonly+hidden OR nonreadonly system files
1311 * - The '-' applies to a single field, ie /a:-hr means read only
1315 BOOL
WCMD_delete (WCHAR
*args
) {
1318 BOOL argsProcessed
= FALSE
;
1319 BOOL foundAny
= FALSE
;
1323 for (argno
=0; ; argno
++) {
1328 thisArg
= WCMD_parameter (args
, argno
, &argN
, FALSE
, FALSE
);
1330 break; /* no more parameters */
1332 continue; /* skip options */
1334 argsProcessed
= TRUE
;
1335 found
= WCMD_delete_one(thisArg
);
1338 WCMD_output_stderr(WCMD_LoadMessage(WCMD_FILENOTFOUND
), thisArg
);
1343 /* Handle no valid args */
1345 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
1353 * Returns a trimmed version of s with all leading and trailing whitespace removed
1357 static WCHAR
*WCMD_strtrim(const WCHAR
*s
)
1359 DWORD len
= strlenW(s
);
1360 const WCHAR
*start
= s
;
1363 if (!(result
= HeapAlloc(GetProcessHeap(), 0, (len
+ 1) * sizeof(WCHAR
))))
1366 while (isspaceW(*start
)) start
++;
1368 const WCHAR
*end
= s
+ len
- 1;
1369 while (end
> start
&& isspaceW(*end
)) end
--;
1370 memcpy(result
, start
, (end
- start
+ 2) * sizeof(WCHAR
));
1371 result
[end
- start
+ 1] = '\0';
1379 /****************************************************************************
1382 * Echo input to the screen (or not). We don't try to emulate the bugs
1383 * in DOS (try typing "ECHO ON AGAIN" for an example).
1386 void WCMD_echo (const WCHAR
*args
)
1389 const WCHAR
*origcommand
= args
;
1392 if ( args
[0]==' ' || args
[0]=='\t' || args
[0]=='.'
1393 || args
[0]==':' || args
[0]==';')
1396 trimmed
= WCMD_strtrim(args
);
1397 if (!trimmed
) return;
1399 count
= strlenW(trimmed
);
1400 if (count
== 0 && origcommand
[0]!='.' && origcommand
[0]!=':'
1401 && origcommand
[0]!=';') {
1402 if (echo_mode
) WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT
), onW
);
1403 else WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT
), offW
);
1407 if (lstrcmpiW(trimmed
, onW
) == 0)
1409 else if (lstrcmpiW(trimmed
, offW
) == 0)
1412 WCMD_output_asis (args
);
1413 WCMD_output_asis (newlineW
);
1415 HeapFree(GetProcessHeap(), 0, trimmed
);
1418 /*****************************************************************************
1421 * Execute a command, and any && or bracketed follow on to the command. The
1422 * first command to be executed may not be at the front of the
1423 * commands->thiscommand string (eg. it may point after a DO or ELSE)
1425 static void WCMD_part_execute(CMD_LIST
**cmdList
, const WCHAR
*firstcmd
,
1426 const WCHAR
*variable
, const WCHAR
*value
,
1427 BOOL isIF
, BOOL executecmds
)
1429 CMD_LIST
*curPosition
= *cmdList
;
1430 int myDepth
= (*cmdList
)->bracketDepth
;
1432 WINE_TRACE("cmdList(%p), firstCmd(%p), with variable '%s'='%s', doIt(%d)\n",
1433 cmdList
, wine_dbgstr_w(firstcmd
),
1434 wine_dbgstr_w(variable
), wine_dbgstr_w(value
),
1437 /* Skip leading whitespace between condition and the command */
1438 while (firstcmd
&& *firstcmd
&& (*firstcmd
==' ' || *firstcmd
=='\t')) firstcmd
++;
1440 /* Process the first command, if there is one */
1441 if (executecmds
&& firstcmd
&& *firstcmd
) {
1442 WCHAR
*command
= WCMD_strdupW(firstcmd
);
1443 WCMD_execute (firstcmd
, (*cmdList
)->redirects
, variable
, value
, cmdList
, FALSE
);
1444 HeapFree(GetProcessHeap(), 0, command
);
1448 /* If it didn't move the position, step to next command */
1449 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1451 /* Process any other parts of the command */
1453 BOOL processThese
= executecmds
;
1456 static const WCHAR ifElse
[] = {'e','l','s','e'};
1458 /* execute all appropriate commands */
1459 curPosition
= *cmdList
;
1461 WINE_TRACE("Processing cmdList(%p) - delim(%d) bd(%d / %d)\n",
1463 (*cmdList
)->prevDelim
,
1464 (*cmdList
)->bracketDepth
, myDepth
);
1466 /* Execute any statements appended to the line */
1467 /* FIXME: Only if previous call worked for && or failed for || */
1468 if ((*cmdList
)->prevDelim
== CMD_ONFAILURE
||
1469 (*cmdList
)->prevDelim
== CMD_ONSUCCESS
) {
1470 if (processThese
&& (*cmdList
)->command
) {
1471 WCMD_execute ((*cmdList
)->command
, (*cmdList
)->redirects
, variable
,
1472 value
, cmdList
, FALSE
);
1474 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1476 /* Execute any appended to the statement with (...) */
1477 } else if ((*cmdList
)->bracketDepth
> myDepth
) {
1479 *cmdList
= WCMD_process_commands(*cmdList
, TRUE
, variable
, value
, FALSE
);
1480 WINE_TRACE("Back from processing commands, (next = %p)\n", *cmdList
);
1482 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1484 /* End of the command - does 'ELSE ' follow as the next command? */
1487 && WCMD_keyword_ws_found(ifElse
, sizeof(ifElse
)/sizeof(ifElse
[0]),
1488 (*cmdList
)->command
)) {
1490 /* Swap between if and else processing */
1491 processThese
= !processThese
;
1493 /* Process the ELSE part */
1495 const int keyw_len
= sizeof(ifElse
)/sizeof(ifElse
[0]) + 1;
1496 WCHAR
*cmd
= ((*cmdList
)->command
) + keyw_len
;
1498 /* Skip leading whitespace between condition and the command */
1499 while (*cmd
&& (*cmd
==' ' || *cmd
=='\t')) cmd
++;
1501 WCMD_execute (cmd
, (*cmdList
)->redirects
, variable
, value
, cmdList
, FALSE
);
1504 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1506 WINE_TRACE("Found end of this IF statement (next = %p)\n", *cmdList
);
1515 /*****************************************************************************
1516 * WCMD_parse_forf_options
1518 * Parses the for /f 'options', extracting the values and validating the
1519 * keywords. Note all keywords are optional.
1521 * options [I] The unparsed parameter string
1522 * eol [O] Set to the comment character (eol=x)
1523 * skip [O] Set to the number of lines to skip (skip=xx)
1524 * delims [O] Set to the token delimiters (delims=)
1525 * tokens [O] Set to the requested tokens, as provided (tokens=)
1526 * usebackq [O] Set to TRUE if usebackq found
1528 * Returns TRUE on success, FALSE on syntax error
1531 static BOOL
WCMD_parse_forf_options(WCHAR
*options
, WCHAR
*eol
, int *skip
,
1532 WCHAR
*delims
, WCHAR
*tokens
, BOOL
*usebackq
)
1535 WCHAR
*pos
= options
;
1536 int len
= strlenW(pos
);
1537 static const WCHAR eolW
[] = {'e','o','l','='};
1538 static const WCHAR skipW
[] = {'s','k','i','p','='};
1539 static const WCHAR tokensW
[] = {'t','o','k','e','n','s','='};
1540 static const WCHAR delimsW
[] = {'d','e','l','i','m','s','='};
1541 static const WCHAR usebackqW
[] = {'u','s','e','b','a','c','k','q'};
1542 static const WCHAR forf_defaultdelims
[] = {' ', '\t', '\0'};
1543 static const WCHAR forf_defaulttokens
[] = {'1', '\0'};
1545 /* Initialize to defaults */
1546 strcpyW(delims
, forf_defaultdelims
);
1547 strcpyW(tokens
, forf_defaulttokens
);
1552 /* Strip (optional) leading and trailing quotes */
1553 if ((*pos
== '"') && (pos
[len
-1] == '"')) {
1558 /* Process each keyword */
1559 while (pos
&& *pos
) {
1560 if (*pos
== ' ' || *pos
== '\t') {
1563 /* Save End of line character (Ignore line if first token (based on delims) starts with it) */
1564 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1565 pos
, sizeof(eolW
)/sizeof(WCHAR
),
1566 eolW
, sizeof(eolW
)/sizeof(WCHAR
)) == CSTR_EQUAL
) {
1567 *eol
= *(pos
+ sizeof(eolW
)/sizeof(WCHAR
));
1568 pos
= pos
+ sizeof(eolW
)/sizeof(WCHAR
) + 1;
1569 WINE_TRACE("Found eol as %c(%x)\n", *eol
, *eol
);
1571 /* Save number of lines to skip (Can be in base 10, hex (0x...) or octal (0xx) */
1572 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1573 pos
, sizeof(skipW
)/sizeof(WCHAR
),
1574 skipW
, sizeof(skipW
)/sizeof(WCHAR
)) == CSTR_EQUAL
) {
1575 WCHAR
*nextchar
= NULL
;
1576 pos
= pos
+ sizeof(skipW
)/sizeof(WCHAR
);
1577 *skip
= strtoulW(pos
, &nextchar
, 0);
1578 WINE_TRACE("Found skip as %d lines\n", *skip
);
1581 /* Save if usebackq semantics are in effect */
1582 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1583 pos
, sizeof(usebackqW
)/sizeof(WCHAR
),
1584 usebackqW
, sizeof(usebackqW
)/sizeof(WCHAR
)) == CSTR_EQUAL
) {
1586 pos
= pos
+ sizeof(usebackqW
)/sizeof(WCHAR
);
1587 WINE_TRACE("Found usebackq\n");
1589 /* Save the supplied delims. Slightly odd as space can be a delimiter but only
1590 if you finish the optionsroot string with delims= otherwise the space is
1591 just a token delimiter! */
1592 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1593 pos
, sizeof(delimsW
)/sizeof(WCHAR
),
1594 delimsW
, sizeof(delimsW
)/sizeof(WCHAR
)) == CSTR_EQUAL
) {
1597 pos
= pos
+ sizeof(delimsW
)/sizeof(WCHAR
);
1598 while (*pos
&& *pos
!= ' ') {
1602 if (*pos
==' ' && *(pos
+1)==0) delims
[i
++] = *pos
;
1603 delims
[i
++] = 0; /* Null terminate the delims */
1604 WINE_TRACE("Found delims as '%s'\n", wine_dbgstr_w(delims
));
1606 /* Save the tokens being requested */
1607 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1608 pos
, sizeof(tokensW
)/sizeof(WCHAR
),
1609 tokensW
, sizeof(tokensW
)/sizeof(WCHAR
)) == CSTR_EQUAL
) {
1612 pos
= pos
+ sizeof(tokensW
)/sizeof(WCHAR
);
1613 while (*pos
&& *pos
!= ' ') {
1617 tokens
[i
++] = 0; /* Null terminate the tokens */
1618 WINE_FIXME("Found tokens as '%s'\n", wine_dbgstr_w(tokens
));
1621 WINE_WARN("Unexpected data in optionsroot: '%s'\n", wine_dbgstr_w(pos
));
1628 /*****************************************************************************
1629 * WCMD_add_dirstowalk
1631 * When recursing through directories (for /r), we need to add to the list of
1632 * directories still to walk, any subdirectories of the one we are processing.
1635 * options [I] The remaining list of directories still to process
1637 * Note this routine inserts the subdirectories found between the entry being
1638 * processed, and any other directory still to be processed, mimicing what
1641 static void WCMD_add_dirstowalk(DIRECTORY_STACK
*dirsToWalk
) {
1642 DIRECTORY_STACK
*remainingDirs
= dirsToWalk
;
1643 WCHAR fullitem
[MAX_PATH
];
1644 WIN32_FIND_DATAW fd
;
1647 /* Build a generic search and add all directories on the list of directories
1649 strcpyW(fullitem
, dirsToWalk
->dirName
);
1650 strcatW(fullitem
, slashstarW
);
1651 hff
= FindFirstFileW(fullitem
, &fd
);
1652 if (hff
!= INVALID_HANDLE_VALUE
) {
1654 WINE_TRACE("Looking for subdirectories\n");
1655 if ((fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) &&
1656 (strcmpW(fd
.cFileName
, dotdotW
) != 0) &&
1657 (strcmpW(fd
.cFileName
, dotW
) != 0))
1659 /* Allocate memory, add to list */
1660 DIRECTORY_STACK
*toWalk
= HeapAlloc(GetProcessHeap(), 0, sizeof(DIRECTORY_STACK
));
1661 WINE_TRACE("(%p->%p)\n", remainingDirs
, remainingDirs
->next
);
1662 toWalk
->next
= remainingDirs
->next
;
1663 remainingDirs
->next
= toWalk
;
1664 remainingDirs
= toWalk
;
1665 toWalk
->dirName
= HeapAlloc(GetProcessHeap(), 0,
1667 (strlenW(dirsToWalk
->dirName
) + 2 + strlenW(fd
.cFileName
)));
1668 strcpyW(toWalk
->dirName
, dirsToWalk
->dirName
);
1669 strcatW(toWalk
->dirName
, slashW
);
1670 strcatW(toWalk
->dirName
, fd
.cFileName
);
1671 WINE_TRACE("Added to stack %s (%p->%p)\n", wine_dbgstr_w(toWalk
->dirName
),
1672 toWalk
, toWalk
->next
);
1674 } while (FindNextFileW(hff
, &fd
) != 0);
1675 WINE_TRACE("Finished adding all subdirectories\n");
1680 /**************************************************************************
1683 * When parsing file or string contents (for /f), once the string to parse
1684 * has been identified, handle the various options and call the do part
1688 * cmdStart [I] - Identifies the list of commands making up the
1689 * for loop body (especially if brackets in use)
1690 * firstCmd [I] - The textual start of the command after the DO
1691 * which is within the first item of cmdStart
1692 * cmdEnd [O] - Identifies where to continue after the DO
1693 * variable [I] - The variable identified on the for line
1694 * buffer [I] - The string to parse
1695 * doExecuted [O] - Set to TRUE if the DO is ever executed once
1696 * forf_skip [I/O] - How many lines to skip first
1697 * forf_eol [I] - The 'end of line' (comment) character
1698 * forf_delims [I] - The delimiters to use when breaking the string apart
1700 static void WCMD_parse_line(CMD_LIST
*cmdStart
,
1701 const WCHAR
*firstCmd
,
1703 const WCHAR
*variable
,
1708 WCHAR
*forf_delims
) {
1710 WCHAR
*parm
, *where
;
1712 /* Skip lines if requested */
1718 /* Extract the parameter */
1719 parm
= WCMD_parameter_with_delims(buffer
, 0, &where
, FALSE
, FALSE
, forf_delims
);
1720 WINE_TRACE("Parsed parameter: %s from %s\n", wine_dbgstr_w(parm
),
1721 wine_dbgstr_w(buffer
));
1723 if (where
&& where
[0] != forf_eol
) {
1724 CMD_LIST
*thisCmdStart
= cmdStart
;
1726 WCMD_part_execute(&thisCmdStart
, firstCmd
, variable
, parm
, FALSE
, TRUE
);
1727 *cmdEnd
= thisCmdStart
;
1732 /**************************************************************************
1733 * WCMD_forf_getinputhandle
1735 * Return a file handle which can be used for reading the input lines,
1736 * either to a specific file (which may be quote delimited as we have to
1737 * read the parameters in raw mode) or to a command which we need to
1738 * execute. The command being executed runs in its own shell and stores
1739 * its data in a temporary file.
1742 * usebackq [I] - Indicates whether usebackq is in effect or not
1743 * itemStr [I] - The item to be handled, either a filename or
1744 * whole command string to execute
1745 * iscmd [I] - Identifies whether this is a command or not
1747 * Returns a file handle which can be used to read the input lines from.
1749 HANDLE
WCMD_forf_getinputhandle(BOOL usebackq
, WCHAR
*itemstr
, BOOL iscmd
) {
1750 WCHAR temp_str
[MAX_PATH
];
1751 WCHAR temp_file
[MAX_PATH
];
1752 WCHAR temp_cmd
[MAXSTRING
];
1753 HANDLE hinput
= INVALID_HANDLE_VALUE
;
1754 static const WCHAR redirOutW
[] = {'>','%','s','\0'};
1755 static const WCHAR cmdW
[] = {'C','M','D','\0'};
1756 static const WCHAR cmdslashcW
[] = {'C','M','D','.','E','X','E',' ',
1757 '/','C',' ','"','%','s','"','\0'};
1759 /* Remove leading and trailing character */
1760 if ((iscmd
&& (itemstr
[0] == '`' && usebackq
)) ||
1761 (iscmd
&& (itemstr
[0] == '\'' && !usebackq
)) ||
1762 (!iscmd
&& (itemstr
[0] == '"' && usebackq
)))
1764 itemstr
[strlenW(itemstr
)-1] = 0x00;
1769 /* Get temp filename */
1770 GetTempPathW(sizeof(temp_str
)/sizeof(WCHAR
), temp_str
);
1771 GetTempFileNameW(temp_str
, cmdW
, 0, temp_file
);
1773 /* Redirect output to the temporary file */
1774 wsprintfW(temp_str
, redirOutW
, temp_file
);
1775 wsprintfW(temp_cmd
, cmdslashcW
, itemstr
);
1776 WINE_TRACE("Issuing '%s' with redirs '%s'\n",
1777 wine_dbgstr_w(temp_cmd
), wine_dbgstr_w(temp_str
));
1778 WCMD_execute (temp_cmd
, temp_str
, NULL
, NULL
, NULL
, FALSE
);
1780 /* Open the file, read line by line and process */
1781 hinput
= CreateFileW(temp_file
, GENERIC_READ
, FILE_SHARE_READ
,
1782 NULL
, OPEN_EXISTING
, FILE_FLAG_DELETE_ON_CLOSE
, NULL
);
1785 /* Open the file, read line by line and process */
1786 WINE_TRACE("Reading input to parse from '%s'\n", wine_dbgstr_w(itemstr
));
1787 hinput
= CreateFileW(itemstr
, GENERIC_READ
, FILE_SHARE_READ
,
1788 NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1793 /**************************************************************************
1796 * Batch file loop processing.
1798 * On entry: cmdList contains the syntax up to the set
1799 * next cmdList and all in that bracket contain the set data
1800 * next cmdlist contains the DO cmd
1801 * following that is either brackets or && entries (as per if)
1805 void WCMD_for (WCHAR
*p
, CMD_LIST
**cmdList
) {
1807 WIN32_FIND_DATAW fd
;
1810 static const WCHAR inW
[] = {'i','n'};
1811 static const WCHAR doW
[] = {'d','o'};
1812 CMD_LIST
*setStart
, *thisSet
, *cmdStart
, *cmdEnd
;
1816 WCHAR optionsRoot
[MAX_PATH
];
1817 DIRECTORY_STACK
*dirsToWalk
= NULL
;
1818 BOOL expandDirs
= FALSE
;
1819 BOOL useNumbers
= FALSE
;
1820 BOOL doFileset
= FALSE
;
1821 BOOL doRecurse
= FALSE
;
1822 BOOL doExecuted
= FALSE
; /* Has the 'do' part been executed */
1823 LONG numbers
[3] = {0,0,0}; /* Defaults to 0 in native */
1825 CMD_LIST
*thisCmdStart
;
1826 int parameterNo
= 0;
1829 WCHAR forf_delims
[256];
1830 WCHAR forf_tokens
[MAXSTRING
];
1831 BOOL forf_usebackq
= FALSE
;
1833 /* Handle optional qualifiers (multiple are allowed) */
1834 WCHAR
*thisArg
= WCMD_parameter(p
, parameterNo
++, NULL
, FALSE
, FALSE
);
1837 while (thisArg
&& *thisArg
== '/') {
1838 WINE_TRACE("Processing qualifier at %s\n", wine_dbgstr_w(thisArg
));
1840 switch (toupperW(*thisArg
)) {
1841 case 'D': expandDirs
= TRUE
; break;
1842 case 'L': useNumbers
= TRUE
; break;
1844 /* Recursive is special case - /R can have an optional path following it */
1845 /* filenamesets are another special case - /F can have an optional options following it */
1849 /* When recursing directories, use current directory as the starting point unless
1850 subsequently overridden */
1851 doRecurse
= (toupperW(*thisArg
) == 'R');
1852 if (doRecurse
) GetCurrentDirectoryW(sizeof(optionsRoot
)/sizeof(WCHAR
), optionsRoot
);
1854 doFileset
= (toupperW(*thisArg
) == 'F');
1856 /* Retrieve next parameter to see if is root/options (raw form required
1857 with for /f, or unquoted in for /r) */
1858 thisArg
= WCMD_parameter(p
, parameterNo
, NULL
, doFileset
, FALSE
);
1860 /* Next parm is either qualifier, path/options or variable -
1861 only care about it if it is the path/options */
1862 if (thisArg
&& *thisArg
!= '/' && *thisArg
!= '%') {
1864 strcpyW(optionsRoot
, thisArg
);
1869 WINE_FIXME("for qualifier '%c' unhandled\n", *thisArg
);
1872 /* Step to next token */
1873 thisArg
= WCMD_parameter(p
, parameterNo
++, NULL
, FALSE
, FALSE
);
1876 /* Ensure line continues with variable */
1877 if (!*thisArg
|| *thisArg
!= '%') {
1878 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
1882 /* With for /f parse the options if provided */
1884 if (!WCMD_parse_forf_options(optionsRoot
, &forf_eol
, &forf_skip
,
1885 forf_delims
, forf_tokens
, &forf_usebackq
))
1887 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
1891 /* Set up the list of directories to recurse if we are going to */
1892 } else if (doRecurse
) {
1893 /* Allocate memory, add to list */
1894 dirsToWalk
= HeapAlloc(GetProcessHeap(), 0, sizeof(DIRECTORY_STACK
));
1895 dirsToWalk
->next
= NULL
;
1896 dirsToWalk
->dirName
= HeapAlloc(GetProcessHeap(),0,
1897 (strlenW(optionsRoot
) + 1) * sizeof(WCHAR
));
1898 strcpyW(dirsToWalk
->dirName
, optionsRoot
);
1899 WINE_TRACE("Starting with root directory %s\n", wine_dbgstr_w(dirsToWalk
->dirName
));
1902 /* Variable should follow */
1903 strcpyW(variable
, thisArg
);
1904 WINE_TRACE("Variable identified as %s\n", wine_dbgstr_w(variable
));
1906 /* Ensure line continues with IN */
1907 thisArg
= WCMD_parameter(p
, parameterNo
++, NULL
, FALSE
, FALSE
);
1909 || !(CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1910 thisArg
, sizeof(inW
)/sizeof(inW
[0]), inW
,
1911 sizeof(inW
)/sizeof(inW
[0])) == CSTR_EQUAL
)) {
1912 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
1916 /* Save away where the set of data starts and the variable */
1917 thisDepth
= (*cmdList
)->bracketDepth
;
1918 *cmdList
= (*cmdList
)->nextcommand
;
1919 setStart
= (*cmdList
);
1921 /* Skip until the close bracket */
1922 WINE_TRACE("Searching %p as the set\n", *cmdList
);
1924 (*cmdList
)->command
!= NULL
&&
1925 (*cmdList
)->bracketDepth
> thisDepth
) {
1926 WINE_TRACE("Skipping %p which is part of the set\n", *cmdList
);
1927 *cmdList
= (*cmdList
)->nextcommand
;
1930 /* Skip the close bracket, if there is one */
1931 if (*cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1933 /* Syntax error if missing close bracket, or nothing following it
1934 and once we have the complete set, we expect a DO */
1935 WINE_TRACE("Looking for 'do ' in %p\n", *cmdList
);
1936 if ((*cmdList
== NULL
)
1937 || !WCMD_keyword_ws_found(doW
, sizeof(doW
)/sizeof(doW
[0]), (*cmdList
)->command
)) {
1939 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
1945 /* Loop repeatedly per-directory we are potentially walking, when in for /r
1946 mode, or once for the rest of the time. */
1949 /* Save away the starting position for the commands (and offset for the
1951 cmdStart
= *cmdList
;
1952 firstCmd
= (*cmdList
)->command
+ 3; /* Skip 'do ' */
1955 /* If we are recursing directories (ie /R), add all sub directories now, then
1956 prefix the root when searching for the item */
1957 if (dirsToWalk
) WCMD_add_dirstowalk(dirsToWalk
);
1960 /* Loop through all set entries */
1962 thisSet
->command
!= NULL
&&
1963 thisSet
->bracketDepth
>= thisDepth
) {
1965 /* Loop through all entries on the same line */
1968 WCHAR buffer
[MAXSTRING
];
1970 WINE_TRACE("Processing for set %p\n", thisSet
);
1972 while (*(item
= WCMD_parameter (thisSet
->command
, i
, &itemStart
, TRUE
, FALSE
))) {
1975 * If the parameter within the set has a wildcard then search for matching files
1976 * otherwise do a literal substitution.
1978 static const WCHAR wildcards
[] = {'*','?','\0'};
1979 thisCmdStart
= cmdStart
;
1982 WINE_TRACE("Processing for item %d '%s'\n", itemNum
, wine_dbgstr_w(item
));
1984 if (!useNumbers
&& !doFileset
) {
1985 WCHAR fullitem
[MAX_PATH
];
1987 /* Now build the item to use / search for in the specified directory,
1988 as it is fully qualified in the /R case */
1990 strcpyW(fullitem
, dirsToWalk
->dirName
);
1991 strcatW(fullitem
, slashW
);
1992 strcatW(fullitem
, item
);
1994 strcpyW(fullitem
, item
);
1997 if (strpbrkW (fullitem
, wildcards
)) {
1999 hff
= FindFirstFileW(fullitem
, &fd
);
2000 if (hff
!= INVALID_HANDLE_VALUE
) {
2002 BOOL isDirectory
= FALSE
;
2004 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) isDirectory
= TRUE
;
2006 /* Handle as files or dirs appropriately, but ignore . and .. */
2007 if (isDirectory
== expandDirs
&&
2008 (strcmpW(fd
.cFileName
, dotdotW
) != 0) &&
2009 (strcmpW(fd
.cFileName
, dotW
) != 0))
2011 thisCmdStart
= cmdStart
;
2012 WINE_TRACE("Processing FOR filename %s\n", wine_dbgstr_w(fd
.cFileName
));
2015 strcpyW(fullitem
, dirsToWalk
->dirName
);
2016 strcatW(fullitem
, slashW
);
2017 strcatW(fullitem
, fd
.cFileName
);
2019 strcpyW(fullitem
, fd
.cFileName
);
2022 WCMD_part_execute (&thisCmdStart
, firstCmd
, variable
,
2023 fullitem
, FALSE
, TRUE
);
2024 cmdEnd
= thisCmdStart
;
2026 } while (FindNextFileW(hff
, &fd
) != 0);
2031 WCMD_part_execute(&thisCmdStart
, firstCmd
, variable
, fullitem
, FALSE
, TRUE
);
2032 cmdEnd
= thisCmdStart
;
2035 } else if (useNumbers
) {
2036 /* Convert the first 3 numbers to signed longs and save */
2037 if (itemNum
<=3) numbers
[itemNum
-1] = atolW(item
);
2038 /* else ignore them! */
2040 /* Filesets - either a list of files, or a command to run and parse the output */
2041 } else if (doFileset
&& ((!forf_usebackq
&& *itemStart
!= '"') ||
2042 (forf_usebackq
&& *itemStart
!= '\''))) {
2047 WINE_TRACE("Processing for filespec from item %d '%s'\n", itemNum
,
2048 wine_dbgstr_w(item
));
2050 /* If backquote or single quote, we need to launch that command
2051 and parse the results - use a temporary file */
2052 if ((forf_usebackq
&& *itemStart
== '`') ||
2053 (!forf_usebackq
&& *itemStart
== '\'')) {
2055 /* Use itemstart because the command is the whole set, not just the first token */
2056 itemparm
= itemStart
;
2059 /* Use item because the file to process is just the first item in the set */
2062 input
= WCMD_forf_getinputhandle(forf_usebackq
, itemparm
, (itemparm
==itemStart
));
2064 /* Process the input file */
2065 if (input
== INVALID_HANDLE_VALUE
) {
2066 WCMD_print_error ();
2067 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), item
);
2069 return; /* FOR loop aborts at first failure here */
2073 /* Read line by line until end of file */
2074 while (WCMD_fgets(buffer
, sizeof(buffer
)/sizeof(WCHAR
), input
)) {
2075 WCMD_parse_line(cmdStart
, firstCmd
, &cmdEnd
, variable
, buffer
, &doExecuted
,
2076 &forf_skip
, forf_eol
, forf_delims
);
2079 CloseHandle (input
);
2082 /* When we have processed the item as a whole command, abort future set processing */
2083 if (itemparm
==itemStart
) {
2088 /* Filesets - A string literal */
2089 } else if (doFileset
&& ((!forf_usebackq
&& *itemStart
== '"') ||
2090 (forf_usebackq
&& *itemStart
== '\''))) {
2092 /* Remove leading and trailing character, ready to parse with delims= delimiters
2093 Note that the last quote is removed from the set and the string terminates
2094 there to mimic windows */
2095 WCHAR
*strend
= strrchrW(itemStart
, forf_usebackq
?'\'':'"');
2101 /* Copy the item away from the global buffer used by WCMD_parameter */
2102 strcpyW(buffer
, itemStart
);
2103 WCMD_parse_line(cmdStart
, firstCmd
, &cmdEnd
, variable
, buffer
, &doExecuted
,
2104 &forf_skip
, forf_eol
, forf_delims
);
2106 /* Only one string can be supplied in the whole set, abort future set processing */
2111 WINE_TRACE("Post-command, cmdEnd = %p\n", cmdEnd
);
2115 /* Move onto the next set line */
2116 if (thisSet
) thisSet
= thisSet
->nextcommand
;
2119 /* If /L is provided, now run the for loop */
2122 static const WCHAR fmt
[] = {'%','d','\0'};
2124 WINE_TRACE("FOR /L provided range from %d to %d step %d\n",
2125 numbers
[0], numbers
[2], numbers
[1]);
2127 (numbers
[1]<0)? i
>=numbers
[2] : i
<=numbers
[2];
2130 sprintfW(thisNum
, fmt
, i
);
2131 WINE_TRACE("Processing FOR number %s\n", wine_dbgstr_w(thisNum
));
2133 thisCmdStart
= cmdStart
;
2135 WCMD_part_execute(&thisCmdStart
, firstCmd
, variable
, thisNum
, FALSE
, TRUE
);
2137 cmdEnd
= thisCmdStart
;
2140 /* If we are walking directories, move on to any which remain */
2141 if (dirsToWalk
!= NULL
) {
2142 DIRECTORY_STACK
*nextDir
= dirsToWalk
->next
;
2143 HeapFree(GetProcessHeap(), 0, dirsToWalk
->dirName
);
2144 HeapFree(GetProcessHeap(), 0, dirsToWalk
);
2145 dirsToWalk
= nextDir
;
2146 if (dirsToWalk
) WINE_TRACE("Moving to next directorty to iterate: %s\n",
2147 wine_dbgstr_w(dirsToWalk
->dirName
));
2148 else WINE_TRACE("Finished all directories.\n");
2151 } while (dirsToWalk
!= NULL
);
2153 /* Now skip over the do part if we did not perform the for loop so far.
2154 We store in cmdEnd the next command after the do block, but we only
2155 know this if something was run. If it has not been, we need to calculate
2158 thisCmdStart
= cmdStart
;
2159 WINE_TRACE("Skipping for loop commands due to no valid iterations\n");
2160 WCMD_part_execute(&thisCmdStart
, firstCmd
, NULL
, NULL
, FALSE
, FALSE
);
2161 cmdEnd
= thisCmdStart
;
2164 /* When the loop ends, either something like a GOTO or EXIT /b has terminated
2165 all processing, OR it should be pointing to the end of && processing OR
2166 it should be pointing at the NULL end of bracket for the DO. The return
2167 value needs to be the NEXT command to execute, which it either is, or
2168 we need to step over the closing bracket */
2170 if (cmdEnd
&& cmdEnd
->command
== NULL
) *cmdList
= cmdEnd
->nextcommand
;
2173 /**************************************************************************
2176 * Simple on-line help. Help text is stored in the resource file.
2179 void WCMD_give_help (const WCHAR
*args
)
2183 args
= WCMD_skip_leading_spaces((WCHAR
*) args
);
2184 if (strlenW(args
) == 0) {
2185 WCMD_output_asis (WCMD_LoadMessage(WCMD_ALLHELP
));
2188 /* Display help message for builtin commands */
2189 for (i
=0; i
<=WCMD_EXIT
; i
++) {
2190 if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
2191 args
, -1, inbuilt
[i
], -1) == CSTR_EQUAL
) {
2192 WCMD_output_asis (WCMD_LoadMessage(i
));
2196 /* Launch the command with the /? option for external commands shipped with cmd.exe */
2197 for (i
= 0; i
<= (sizeof(externals
)/sizeof(externals
[0])); i
++) {
2198 if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
2199 args
, -1, externals
[i
], -1) == CSTR_EQUAL
) {
2201 static const WCHAR helpW
[] = {' ', '/','?','\0'};
2203 strcatW(cmd
, helpW
);
2204 WCMD_run_program(cmd
, FALSE
);
2208 WCMD_output (WCMD_LoadMessage(WCMD_NOCMDHELP
), args
);
2213 /****************************************************************************
2216 * Batch file jump instruction. Not the most efficient algorithm ;-)
2217 * Prints error message if the specified label cannot be found - the file pointer is
2218 * then at EOF, effectively stopping the batch file.
2219 * FIXME: DOS is supposed to allow labels with spaces - we don't.
2222 void WCMD_goto (CMD_LIST
**cmdList
) {
2224 WCHAR string
[MAX_PATH
];
2225 WCHAR current
[MAX_PATH
];
2227 /* Do not process any more parts of a processed multipart or multilines command */
2228 if (cmdList
) *cmdList
= NULL
;
2230 if (context
!= NULL
) {
2231 WCHAR
*paramStart
= param1
, *str
;
2232 static const WCHAR eofW
[] = {':','e','o','f','\0'};
2234 if (param1
[0] == 0x00) {
2235 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
2239 /* Handle special :EOF label */
2240 if (lstrcmpiW (eofW
, param1
) == 0) {
2241 context
-> skip_rest
= TRUE
;
2245 /* Support goto :label as well as goto label */
2246 if (*paramStart
== ':') paramStart
++;
2248 SetFilePointer (context
-> h
, 0, NULL
, FILE_BEGIN
);
2249 while (WCMD_fgets (string
, sizeof(string
)/sizeof(WCHAR
), context
-> h
)) {
2251 while (isspaceW (*str
)) str
++;
2255 while (((current
[index
] = str
[index
])) && (!isspaceW (current
[index
])))
2258 /* ignore space at the end */
2260 if (lstrcmpiW (current
, paramStart
) == 0) return;
2263 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOTARGET
));
2268 /*****************************************************************************
2271 * Push a directory onto the stack
2274 void WCMD_pushd (const WCHAR
*args
)
2276 struct env_stack
*curdir
;
2278 static const WCHAR parmD
[] = {'/','D','\0'};
2280 if (strchrW(args
, '/') != NULL
) {
2281 SetLastError(ERROR_INVALID_PARAMETER
);
2286 curdir
= LocalAlloc (LMEM_FIXED
, sizeof (struct env_stack
));
2287 thisdir
= LocalAlloc (LMEM_FIXED
, 1024 * sizeof(WCHAR
));
2288 if( !curdir
|| !thisdir
) {
2291 WINE_ERR ("out of memory\n");
2295 /* Change directory using CD code with /D parameter */
2296 strcpyW(quals
, parmD
);
2297 GetCurrentDirectoryW (1024, thisdir
);
2299 WCMD_setshow_default(args
);
2305 curdir
-> next
= pushd_directories
;
2306 curdir
-> strings
= thisdir
;
2307 if (pushd_directories
== NULL
) {
2308 curdir
-> u
.stackdepth
= 1;
2310 curdir
-> u
.stackdepth
= pushd_directories
-> u
.stackdepth
+ 1;
2312 pushd_directories
= curdir
;
2317 /*****************************************************************************
2320 * Pop a directory from the stack
2323 void WCMD_popd (void) {
2324 struct env_stack
*temp
= pushd_directories
;
2326 if (!pushd_directories
)
2329 /* pop the old environment from the stack, and make it the current dir */
2330 pushd_directories
= temp
->next
;
2331 SetCurrentDirectoryW(temp
->strings
);
2332 LocalFree (temp
->strings
);
2336 /*******************************************************************
2337 * evaluate_if_comparison
2339 * Evaluates an "if" comparison operation
2342 * leftOperand [I] left operand, non NULL
2343 * operator [I] "if" binary comparison operator, non NULL
2344 * rightOperand [I] right operand, non NULL
2345 * caseInsensitive [I] 0 for case sensitive comparison, anything else for insensitive
2348 * Success: 1 if operator applied to the operands evaluates to TRUE
2349 * 0 if operator applied to the operands evaluates to FALSE
2350 * Failure: -1 if operator is not recognized
2352 static int evaluate_if_comparison(const WCHAR
*leftOperand
, const WCHAR
*operator,
2353 const WCHAR
*rightOperand
, int caseInsensitive
)
2355 WCHAR
*endptr_leftOp
, *endptr_rightOp
;
2356 long int leftOperand_int
, rightOperand_int
;
2358 static const WCHAR lssW
[] = {'l','s','s','\0'};
2359 static const WCHAR leqW
[] = {'l','e','q','\0'};
2360 static const WCHAR equW
[] = {'e','q','u','\0'};
2361 static const WCHAR neqW
[] = {'n','e','q','\0'};
2362 static const WCHAR geqW
[] = {'g','e','q','\0'};
2364 /* == is a special case, as it always compares strings */
2365 if (!lstrcmpiW(operator, eqeqW
))
2366 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) == 0
2367 : lstrcmpW (leftOperand
, rightOperand
) == 0;
2369 /* Check if we have plain integers (in decimal, octal or hexadecimal notation) */
2370 leftOperand_int
= strtolW(leftOperand
, &endptr_leftOp
, 0);
2371 rightOperand_int
= strtolW(rightOperand
, &endptr_rightOp
, 0);
2372 int_operands
= (!*endptr_leftOp
) && (!*endptr_rightOp
);
2374 /* Perform actual (integer or string) comparison */
2375 if (!lstrcmpiW(operator, lssW
)) {
2377 return leftOperand_int
< rightOperand_int
;
2379 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) < 0
2380 : lstrcmpW (leftOperand
, rightOperand
) < 0;
2383 if (!lstrcmpiW(operator, leqW
)) {
2385 return leftOperand_int
<= rightOperand_int
;
2387 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) <= 0
2388 : lstrcmpW (leftOperand
, rightOperand
) <= 0;
2391 if (!lstrcmpiW(operator, equW
)) {
2393 return leftOperand_int
== rightOperand_int
;
2395 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) == 0
2396 : lstrcmpW (leftOperand
, rightOperand
) == 0;
2399 if (!lstrcmpiW(operator, neqW
)) {
2401 return leftOperand_int
!= rightOperand_int
;
2403 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) != 0
2404 : lstrcmpW (leftOperand
, rightOperand
) != 0;
2407 if (!lstrcmpiW(operator, geqW
)) {
2409 return leftOperand_int
>= rightOperand_int
;
2411 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) >= 0
2412 : lstrcmpW (leftOperand
, rightOperand
) >= 0;
2418 /****************************************************************************
2421 * Batch file conditional.
2423 * On entry, cmdlist will point to command containing the IF, and optionally
2424 * the first command to execute (if brackets not found)
2425 * If &&'s were found, this may be followed by a record flagged as isAmpersand
2426 * If ('s were found, execute all within that bracket
2427 * Command may optionally be followed by an ELSE - need to skip instructions
2428 * in the else using the same logic
2430 * FIXME: Much more syntax checking needed!
2432 void WCMD_if (WCHAR
*p
, CMD_LIST
**cmdList
)
2434 int negate
; /* Negate condition */
2435 int test
; /* Condition evaluation result */
2436 WCHAR condition
[MAX_PATH
], *command
;
2437 static const WCHAR notW
[] = {'n','o','t','\0'};
2438 static const WCHAR errlvlW
[] = {'e','r','r','o','r','l','e','v','e','l','\0'};
2439 static const WCHAR existW
[] = {'e','x','i','s','t','\0'};
2440 static const WCHAR defdW
[] = {'d','e','f','i','n','e','d','\0'};
2441 static const WCHAR parmI
[] = {'/','I','\0'};
2442 int caseInsensitive
= (strstrW(quals
, parmI
) != NULL
);
2444 negate
= !lstrcmpiW(param1
,notW
);
2445 strcpyW(condition
, (negate
? param2
: param1
));
2446 WINE_TRACE("Condition: %s\n", wine_dbgstr_w(condition
));
2448 if (!lstrcmpiW (condition
, errlvlW
)) {
2449 WCHAR
*param
= WCMD_parameter(p
, 1+negate
, NULL
, FALSE
, FALSE
);
2451 long int param_int
= strtolW(param
, &endptr
, 10);
2452 if (*endptr
) goto syntax_err
;
2453 test
= ((long int)errorlevel
>= param_int
);
2454 WCMD_parameter(p
, 2+negate
, &command
, FALSE
, FALSE
);
2456 else if (!lstrcmpiW (condition
, existW
)) {
2457 test
= (GetFileAttributesW(WCMD_parameter(p
, 1+negate
, NULL
, FALSE
, FALSE
))
2458 != INVALID_FILE_ATTRIBUTES
);
2459 WCMD_parameter(p
, 2+negate
, &command
, FALSE
, FALSE
);
2461 else if (!lstrcmpiW (condition
, defdW
)) {
2462 test
= (GetEnvironmentVariableW(WCMD_parameter(p
, 1+negate
, NULL
, FALSE
, FALSE
),
2464 WCMD_parameter(p
, 2+negate
, &command
, FALSE
, FALSE
);
2466 else { /* comparison operation */
2467 WCHAR leftOperand
[MAXSTRING
], rightOperand
[MAXSTRING
], operator[MAXSTRING
];
2470 strcpyW(leftOperand
, WCMD_parameter(p
, negate
+caseInsensitive
, ¶mStart
, TRUE
, FALSE
));
2474 /* Note: '==' can't be returned by WCMD_parameter since '=' is a separator */
2475 p
= paramStart
+ strlenW(leftOperand
);
2476 while (*p
== ' ' || *p
== '\t')
2479 if (!strncmpW(p
, eqeqW
, strlenW(eqeqW
)))
2480 strcpyW(operator, eqeqW
);
2482 strcpyW(operator, WCMD_parameter(p
, 0, ¶mStart
, FALSE
, FALSE
));
2483 if (!*operator) goto syntax_err
;
2485 p
+= strlenW(operator);
2487 strcpyW(rightOperand
, WCMD_parameter(p
, 0, ¶mStart
, TRUE
, FALSE
));
2491 test
= evaluate_if_comparison(leftOperand
, operator, rightOperand
, caseInsensitive
);
2495 p
= paramStart
+ strlenW(rightOperand
);
2496 WCMD_parameter(p
, 0, &command
, FALSE
, FALSE
);
2499 /* Process rest of IF statement which is on the same line
2500 Note: This may process all or some of the cmdList (eg a GOTO) */
2501 WCMD_part_execute(cmdList
, command
, NULL
, NULL
, TRUE
, (test
!= negate
));
2505 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
2508 /****************************************************************************
2511 * Move a file, directory tree or wildcarded set of files.
2514 void WCMD_move (void)
2517 WIN32_FIND_DATAW fd
;
2519 WCHAR input
[MAX_PATH
];
2520 WCHAR output
[MAX_PATH
];
2522 WCHAR dir
[MAX_PATH
];
2523 WCHAR fname
[MAX_PATH
];
2524 WCHAR ext
[MAX_PATH
];
2526 if (param1
[0] == 0x00) {
2527 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
2531 /* If no destination supplied, assume current directory */
2532 if (param2
[0] == 0x00) {
2533 strcpyW(param2
, dotW
);
2536 /* If 2nd parm is directory, then use original filename */
2537 /* Convert partial path to full path */
2538 GetFullPathNameW(param1
, sizeof(input
)/sizeof(WCHAR
), input
, NULL
);
2539 GetFullPathNameW(param2
, sizeof(output
)/sizeof(WCHAR
), output
, NULL
);
2540 WINE_TRACE("Move from '%s'('%s') to '%s'\n", wine_dbgstr_w(input
),
2541 wine_dbgstr_w(param1
), wine_dbgstr_w(output
));
2543 /* Split into components */
2544 WCMD_splitpath(input
, drive
, dir
, fname
, ext
);
2546 hff
= FindFirstFileW(input
, &fd
);
2547 if (hff
== INVALID_HANDLE_VALUE
)
2551 WCHAR dest
[MAX_PATH
];
2552 WCHAR src
[MAX_PATH
];
2556 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd
.cFileName
));
2558 /* Build src & dest name */
2559 strcpyW(src
, drive
);
2562 /* See if dest is an existing directory */
2563 attribs
= GetFileAttributesW(output
);
2564 if (attribs
!= INVALID_FILE_ATTRIBUTES
&&
2565 (attribs
& FILE_ATTRIBUTE_DIRECTORY
)) {
2566 strcpyW(dest
, output
);
2567 strcatW(dest
, slashW
);
2568 strcatW(dest
, fd
.cFileName
);
2570 strcpyW(dest
, output
);
2573 strcatW(src
, fd
.cFileName
);
2575 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src
));
2576 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest
));
2578 /* If destination exists, prompt unless /Y supplied */
2579 if (GetFileAttributesW(dest
) != INVALID_FILE_ATTRIBUTES
) {
2581 WCHAR copycmd
[MAXSTRING
];
2584 /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
2585 if (strstrW (quals
, parmNoY
))
2587 else if (strstrW (quals
, parmY
))
2590 static const WCHAR copyCmdW
[] = {'C','O','P','Y','C','M','D','\0'};
2591 len
= GetEnvironmentVariableW(copyCmdW
, copycmd
, sizeof(copycmd
)/sizeof(WCHAR
));
2592 force
= (len
&& len
< (sizeof(copycmd
)/sizeof(WCHAR
))
2593 && ! lstrcmpiW (copycmd
, parmY
));
2596 /* Prompt if overwriting */
2600 /* Ask for confirmation */
2601 question
= WCMD_format_string(WCMD_LoadMessage(WCMD_OVERWRITE
), dest
);
2602 ok
= WCMD_ask_confirm(question
, FALSE
, NULL
);
2603 LocalFree(question
);
2605 /* So delete the destination prior to the move */
2607 if (!DeleteFileW(dest
)) {
2608 WCMD_print_error ();
2617 status
= MoveFileW(src
, dest
);
2619 status
= 1; /* Anything other than 0 to prevent error msg below */
2623 WCMD_print_error ();
2626 } while (FindNextFileW(hff
, &fd
) != 0);
2631 /****************************************************************************
2634 * Suspend execution of a batch script until a key is typed
2637 void WCMD_pause (void)
2643 HANDLE hIn
= GetStdHandle(STD_INPUT_HANDLE
);
2645 have_console
= GetConsoleMode(hIn
, &oldmode
);
2647 SetConsoleMode(hIn
, 0);
2649 WCMD_output_asis(anykey
);
2650 WCMD_ReadFile(hIn
, &key
, 1, &count
);
2652 SetConsoleMode(hIn
, oldmode
);
2655 /****************************************************************************
2658 * Delete a directory.
2661 void WCMD_remove_dir (WCHAR
*args
) {
2664 int argsProcessed
= 0;
2666 static const WCHAR parmS
[] = {'/','S','\0'};
2667 static const WCHAR parmQ
[] = {'/','Q','\0'};
2669 /* Loop through all args */
2671 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
2672 if (argN
&& argN
[0] != '/') {
2673 WINE_TRACE("rd: Processing arg %s (quals:%s)\n", wine_dbgstr_w(thisArg
),
2674 wine_dbgstr_w(quals
));
2677 /* If subdirectory search not supplied, just try to remove
2678 and report error if it fails (eg if it contains a file) */
2679 if (strstrW (quals
, parmS
) == NULL
) {
2680 if (!RemoveDirectoryW(thisArg
)) WCMD_print_error ();
2682 /* Otherwise use ShFileOp to recursively remove a directory */
2685 SHFILEOPSTRUCTW lpDir
;
2688 if (strstrW (quals
, parmQ
) == NULL
) {
2690 WCHAR question
[MAXSTRING
];
2691 static const WCHAR fmt
[] = {'%','s',' ','\0'};
2693 /* Ask for confirmation */
2694 wsprintfW(question
, fmt
, thisArg
);
2695 ok
= WCMD_ask_confirm(question
, TRUE
, NULL
);
2697 /* Abort if answer is 'N' */
2704 lpDir
.pFrom
= thisArg
;
2705 lpDir
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
| FOF_NOERRORUI
;
2706 lpDir
.wFunc
= FO_DELETE
;
2708 /* SHFileOperationW needs file list with a double null termination */
2709 thisArg
[lstrlenW(thisArg
) + 1] = 0x00;
2711 if (SHFileOperationW(&lpDir
)) WCMD_print_error ();
2716 /* Handle no valid args */
2717 if (argsProcessed
== 0) {
2718 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
2724 /****************************************************************************
2730 void WCMD_rename (void)
2734 WIN32_FIND_DATAW fd
;
2735 WCHAR input
[MAX_PATH
];
2736 WCHAR
*dotDst
= NULL
;
2738 WCHAR dir
[MAX_PATH
];
2739 WCHAR fname
[MAX_PATH
];
2740 WCHAR ext
[MAX_PATH
];
2744 /* Must be at least two args */
2745 if (param1
[0] == 0x00 || param2
[0] == 0x00) {
2746 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
2751 /* Destination cannot contain a drive letter or directory separator */
2752 if ((strchrW(param2
,':') != NULL
) || (strchrW(param2
,'\\') != NULL
)) {
2753 SetLastError(ERROR_INVALID_PARAMETER
);
2759 /* Convert partial path to full path */
2760 GetFullPathNameW(param1
, sizeof(input
)/sizeof(WCHAR
), input
, NULL
);
2761 WINE_TRACE("Rename from '%s'('%s') to '%s'\n", wine_dbgstr_w(input
),
2762 wine_dbgstr_w(param1
), wine_dbgstr_w(param2
));
2763 dotDst
= strchrW(param2
, '.');
2765 /* Split into components */
2766 WCMD_splitpath(input
, drive
, dir
, fname
, ext
);
2768 hff
= FindFirstFileW(input
, &fd
);
2769 if (hff
== INVALID_HANDLE_VALUE
)
2773 WCHAR dest
[MAX_PATH
];
2774 WCHAR src
[MAX_PATH
];
2775 WCHAR
*dotSrc
= NULL
;
2778 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd
.cFileName
));
2780 /* FIXME: If dest name or extension is *, replace with filename/ext
2781 part otherwise use supplied name. This supports:
2783 ren jim.* fred.* etc
2784 However, windows has a more complex algorithm supporting eg
2785 ?'s and *'s mid name */
2786 dotSrc
= strchrW(fd
.cFileName
, '.');
2788 /* Build src & dest name */
2789 strcpyW(src
, drive
);
2792 dirLen
= strlenW(src
);
2793 strcatW(src
, fd
.cFileName
);
2796 if (param2
[0] == '*') {
2797 strcatW(dest
, fd
.cFileName
);
2798 if (dotSrc
) dest
[dirLen
+ (dotSrc
- fd
.cFileName
)] = 0x00;
2800 strcatW(dest
, param2
);
2801 if (dotDst
) dest
[dirLen
+ (dotDst
- param2
)] = 0x00;
2804 /* Build Extension */
2805 if (dotDst
&& (*(dotDst
+1)=='*')) {
2806 if (dotSrc
) strcatW(dest
, dotSrc
);
2807 } else if (dotDst
) {
2808 if (dotDst
) strcatW(dest
, dotDst
);
2811 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src
));
2812 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest
));
2814 status
= MoveFileW(src
, dest
);
2817 WCMD_print_error ();
2820 } while (FindNextFileW(hff
, &fd
) != 0);
2825 /*****************************************************************************
2828 * Make a copy of the environment.
2830 static WCHAR
*WCMD_dupenv( const WCHAR
*env
)
2840 len
+= (strlenW(&env
[len
]) + 1);
2842 env_copy
= LocalAlloc (LMEM_FIXED
, (len
+1) * sizeof (WCHAR
) );
2845 WINE_ERR("out of memory\n");
2848 memcpy (env_copy
, env
, len
*sizeof (WCHAR
));
2854 /*****************************************************************************
2857 * setlocal pushes the environment onto a stack
2858 * Save the environment as unicode so we don't screw anything up.
2860 void WCMD_setlocal (const WCHAR
*s
) {
2862 struct env_stack
*env_copy
;
2863 WCHAR cwd
[MAX_PATH
];
2865 /* setlocal does nothing outside of batch programs */
2866 if (!context
) return;
2868 /* DISABLEEXTENSIONS ignored */
2870 env_copy
= LocalAlloc (LMEM_FIXED
, sizeof (struct env_stack
));
2873 WINE_ERR ("out of memory\n");
2877 env
= GetEnvironmentStringsW ();
2878 env_copy
->strings
= WCMD_dupenv (env
);
2879 if (env_copy
->strings
)
2881 env_copy
->batchhandle
= context
->h
;
2882 env_copy
->next
= saved_environment
;
2883 saved_environment
= env_copy
;
2885 /* Save the current drive letter */
2886 GetCurrentDirectoryW(MAX_PATH
, cwd
);
2887 env_copy
->u
.cwd
= cwd
[0];
2890 LocalFree (env_copy
);
2892 FreeEnvironmentStringsW (env
);
2896 /*****************************************************************************
2899 * endlocal pops the environment off a stack
2900 * Note: When searching for '=', search from WCHAR position 1, to handle
2901 * special internal environment variables =C:, =D: etc
2903 void WCMD_endlocal (void) {
2904 WCHAR
*env
, *old
, *p
;
2905 struct env_stack
*temp
;
2908 /* setlocal does nothing outside of batch programs */
2909 if (!context
) return;
2911 /* setlocal needs a saved environment from within the same context (batch
2912 program) as it was saved in */
2913 if (!saved_environment
|| saved_environment
->batchhandle
!= context
->h
)
2916 /* pop the old environment from the stack */
2917 temp
= saved_environment
;
2918 saved_environment
= temp
->next
;
2920 /* delete the current environment, totally */
2921 env
= GetEnvironmentStringsW ();
2922 old
= WCMD_dupenv (GetEnvironmentStringsW ());
2925 n
= strlenW(&old
[len
]) + 1;
2926 p
= strchrW(&old
[len
] + 1, '=');
2930 SetEnvironmentVariableW (&old
[len
], NULL
);
2935 FreeEnvironmentStringsW (env
);
2937 /* restore old environment */
2938 env
= temp
->strings
;
2941 n
= strlenW(&env
[len
]) + 1;
2942 p
= strchrW(&env
[len
] + 1, '=');
2946 SetEnvironmentVariableW (&env
[len
], p
);
2951 /* Restore current drive letter */
2952 if (IsCharAlphaW(temp
->u
.cwd
)) {
2954 WCHAR cwd
[MAX_PATH
];
2955 static const WCHAR fmt
[] = {'=','%','c',':','\0'};
2957 wsprintfW(envvar
, fmt
, temp
->u
.cwd
);
2958 if (GetEnvironmentVariableW(envvar
, cwd
, MAX_PATH
)) {
2959 WINE_TRACE("Resetting cwd to %s\n", wine_dbgstr_w(cwd
));
2960 SetCurrentDirectoryW(cwd
);
2968 /*****************************************************************************
2969 * WCMD_setshow_default
2971 * Set/Show the current default directory
2974 void WCMD_setshow_default (const WCHAR
*args
) {
2980 WIN32_FIND_DATAW fd
;
2982 static const WCHAR parmD
[] = {'/','D','\0'};
2984 WINE_TRACE("Request change to directory '%s'\n", wine_dbgstr_w(args
));
2986 /* Skip /D and trailing whitespace if on the front of the command line */
2987 if (CompareStringW(LOCALE_USER_DEFAULT
,
2988 NORM_IGNORECASE
| SORT_STRINGSORT
,
2989 args
, 2, parmD
, -1) == CSTR_EQUAL
) {
2991 while (*args
&& (*args
==' ' || *args
=='\t'))
2995 GetCurrentDirectoryW(sizeof(cwd
)/sizeof(WCHAR
), cwd
);
2996 if (strlenW(args
) == 0) {
2997 strcatW (cwd
, newlineW
);
2998 WCMD_output_asis (cwd
);
3001 /* Remove any double quotes, which may be in the
3002 middle, eg. cd "C:\Program Files"\Microsoft is ok */
3005 if (*args
!= '"') *pos
++ = *args
;
3008 while (pos
> string
&& (*(pos
-1) == ' ' || *(pos
-1) == '\t'))
3012 /* Search for appropriate directory */
3013 WINE_TRACE("Looking for directory '%s'\n", wine_dbgstr_w(string
));
3014 hff
= FindFirstFileW(string
, &fd
);
3015 if (hff
!= INVALID_HANDLE_VALUE
) {
3017 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) {
3018 WCHAR fpath
[MAX_PATH
];
3020 WCHAR dir
[MAX_PATH
];
3021 WCHAR fname
[MAX_PATH
];
3022 WCHAR ext
[MAX_PATH
];
3023 static const WCHAR fmt
[] = {'%','s','%','s','%','s','\0'};
3025 /* Convert path into actual directory spec */
3026 GetFullPathNameW(string
, sizeof(fpath
)/sizeof(WCHAR
), fpath
, NULL
);
3027 WCMD_splitpath(fpath
, drive
, dir
, fname
, ext
);
3030 wsprintfW(string
, fmt
, drive
, dir
, fd
.cFileName
);
3033 } while (FindNextFileW(hff
, &fd
) != 0);
3037 /* Change to that directory */
3038 WINE_TRACE("Really changing to directory '%s'\n", wine_dbgstr_w(string
));
3040 status
= SetCurrentDirectoryW(string
);
3043 WCMD_print_error ();
3047 /* Save away the actual new directory, to store as current location */
3048 GetCurrentDirectoryW (sizeof(string
)/sizeof(WCHAR
), string
);
3050 /* Restore old directory if drive letter would change, and
3051 CD x:\directory /D (or pushd c:\directory) not supplied */
3052 if ((strstrW(quals
, parmD
) == NULL
) &&
3053 (param1
[1] == ':') && (toupper(param1
[0]) != toupper(cwd
[0]))) {
3054 SetCurrentDirectoryW(cwd
);
3058 /* Set special =C: type environment variable, for drive letter of
3059 change of directory, even if path was restored due to missing
3060 /D (allows changing drive letter when not resident on that
3062 if ((string
[1] == ':') && IsCharAlphaW(string
[0])) {
3064 strcpyW(env
, equalW
);
3065 memcpy(env
+1, string
, 2 * sizeof(WCHAR
));
3067 WINE_TRACE("Setting '%s' to '%s'\n", wine_dbgstr_w(env
), wine_dbgstr_w(string
));
3068 SetEnvironmentVariableW(env
, string
);
3075 /****************************************************************************
3078 * Set/Show the system date
3079 * FIXME: Can't change date yet
3082 void WCMD_setshow_date (void) {
3084 WCHAR curdate
[64], buffer
[64];
3086 static const WCHAR parmT
[] = {'/','T','\0'};
3088 if (strlenW(param1
) == 0) {
3089 if (GetDateFormatW(LOCALE_USER_DEFAULT
, 0, NULL
, NULL
,
3090 curdate
, sizeof(curdate
)/sizeof(WCHAR
))) {
3091 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTDATE
), curdate
);
3092 if (strstrW (quals
, parmT
) == NULL
) {
3093 WCMD_output (WCMD_LoadMessage(WCMD_NEWDATE
));
3094 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), buffer
, sizeof(buffer
)/sizeof(WCHAR
), &count
);
3096 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
3100 else WCMD_print_error ();
3103 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
3107 /****************************************************************************
3109 * Note: Native displays 'fred' before 'fred ', so need to only compare up to
3112 static int WCMD_compare( const void *a
, const void *b
)
3115 const WCHAR
* const *str_a
= a
, * const *str_b
= b
;
3116 r
= CompareStringW( LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
3117 *str_a
, strcspnW(*str_a
, equalW
), *str_b
, strcspnW(*str_b
, equalW
) );
3118 if( r
== CSTR_LESS_THAN
) return -1;
3119 if( r
== CSTR_GREATER_THAN
) return 1;
3123 /****************************************************************************
3124 * WCMD_setshow_sortenv
3126 * sort variables into order for display
3127 * Optionally only display those who start with a stub
3128 * returns the count displayed
3130 static int WCMD_setshow_sortenv(const WCHAR
*s
, const WCHAR
*stub
)
3132 UINT count
=0, len
=0, i
, displayedcount
=0, stublen
=0;
3135 if (stub
) stublen
= strlenW(stub
);
3137 /* count the number of strings, and the total length */
3139 len
+= (strlenW(&s
[len
]) + 1);
3143 /* add the strings to an array */
3144 str
= LocalAlloc (LMEM_FIXED
| LMEM_ZEROINIT
, count
* sizeof (WCHAR
*) );
3148 for( i
=1; i
<count
; i
++ )
3149 str
[i
] = str
[i
-1] + strlenW(str
[i
-1]) + 1;
3151 /* sort the array */
3152 qsort( str
, count
, sizeof (WCHAR
*), WCMD_compare
);
3155 for( i
=0; i
<count
; i
++ ) {
3156 if (!stub
|| CompareStringW(LOCALE_USER_DEFAULT
,
3157 NORM_IGNORECASE
| SORT_STRINGSORT
,
3158 str
[i
], stublen
, stub
, -1) == CSTR_EQUAL
) {
3159 /* Don't display special internal variables */
3160 if (str
[i
][0] != '=') {
3161 WCMD_output_asis(str
[i
]);
3162 WCMD_output_asis(newlineW
);
3169 return displayedcount
;
3172 /****************************************************************************
3175 * Set/Show the environment variables
3178 void WCMD_setshow_env (WCHAR
*s
) {
3183 static const WCHAR parmP
[] = {'/','P','\0'};
3185 if (param1
[0] == 0x00 && quals
[0] == 0x00) {
3186 env
= GetEnvironmentStringsW();
3187 WCMD_setshow_sortenv( env
, NULL
);
3191 /* See if /P supplied, and if so echo the prompt, and read in a reply */
3192 if (CompareStringW(LOCALE_USER_DEFAULT
,
3193 NORM_IGNORECASE
| SORT_STRINGSORT
,
3194 s
, 2, parmP
, -1) == CSTR_EQUAL
) {
3195 WCHAR string
[MAXSTRING
];
3199 while (*s
&& (*s
==' ' || *s
=='\t')) s
++;
3201 WCMD_strip_quotes(s
);
3203 /* If no parameter, or no '=' sign, return an error */
3204 if (!(*s
) || ((p
= strchrW (s
, '=')) == NULL
)) {
3205 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
3209 /* Output the prompt */
3211 if (strlenW(p
) != 0) WCMD_output_asis(p
);
3213 /* Read the reply */
3214 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), string
, sizeof(string
)/sizeof(WCHAR
), &count
);
3216 string
[count
-1] = '\0'; /* ReadFile output is not null-terminated! */
3217 if (string
[count
-2] == '\r') string
[count
-2] = '\0'; /* Under Windoze we get CRLF! */
3218 WINE_TRACE("set /p: Setting var '%s' to '%s'\n", wine_dbgstr_w(s
),
3219 wine_dbgstr_w(string
));
3220 status
= SetEnvironmentVariableW(s
, string
);
3227 WCMD_strip_quotes(s
);
3228 p
= strchrW (s
, '=');
3230 env
= GetEnvironmentStringsW();
3231 if (WCMD_setshow_sortenv( env
, s
) == 0) {
3232 WCMD_output_stderr(WCMD_LoadMessage(WCMD_MISSINGENV
), s
);
3239 if (strlenW(p
) == 0) p
= NULL
;
3240 WINE_TRACE("set: Setting var '%s' to '%s'\n", wine_dbgstr_w(s
),
3242 status
= SetEnvironmentVariableW(s
, p
);
3243 gle
= GetLastError();
3244 if ((!status
) & (gle
== ERROR_ENVVAR_NOT_FOUND
)) {
3246 } else if ((!status
)) WCMD_print_error();
3247 else errorlevel
= 0;
3251 /****************************************************************************
3254 * Set/Show the path environment variable
3257 void WCMD_setshow_path (const WCHAR
*args
) {
3261 static const WCHAR pathW
[] = {'P','A','T','H','\0'};
3262 static const WCHAR pathEqW
[] = {'P','A','T','H','=','\0'};
3264 if (strlenW(param1
) == 0 && strlenW(param2
) == 0) {
3265 status
= GetEnvironmentVariableW(pathW
, string
, sizeof(string
)/sizeof(WCHAR
));
3267 WCMD_output_asis ( pathEqW
);
3268 WCMD_output_asis ( string
);
3269 WCMD_output_asis ( newlineW
);
3272 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOPATH
));
3276 if (*args
== '=') args
++; /* Skip leading '=' */
3277 status
= SetEnvironmentVariableW(pathW
, args
);
3278 if (!status
) WCMD_print_error();
3282 /****************************************************************************
3283 * WCMD_setshow_prompt
3285 * Set or show the command prompt.
3288 void WCMD_setshow_prompt (void) {
3291 static const WCHAR promptW
[] = {'P','R','O','M','P','T','\0'};
3293 if (strlenW(param1
) == 0) {
3294 SetEnvironmentVariableW(promptW
, NULL
);
3298 while ((*s
== '=') || (*s
== ' ') || (*s
== '\t')) s
++;
3299 if (strlenW(s
) == 0) {
3300 SetEnvironmentVariableW(promptW
, NULL
);
3302 else SetEnvironmentVariableW(promptW
, s
);
3306 /****************************************************************************
3309 * Set/Show the system time
3310 * FIXME: Can't change time yet
3313 void WCMD_setshow_time (void) {
3315 WCHAR curtime
[64], buffer
[64];
3318 static const WCHAR parmT
[] = {'/','T','\0'};
3320 if (strlenW(param1
) == 0) {
3322 if (GetTimeFormatW(LOCALE_USER_DEFAULT
, 0, &st
, NULL
,
3323 curtime
, sizeof(curtime
)/sizeof(WCHAR
))) {
3324 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTTIME
), curtime
);
3325 if (strstrW (quals
, parmT
) == NULL
) {
3326 WCMD_output (WCMD_LoadMessage(WCMD_NEWTIME
));
3327 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), buffer
, sizeof(buffer
)/sizeof(WCHAR
), &count
);
3329 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
3333 else WCMD_print_error ();
3336 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
3340 /****************************************************************************
3343 * Shift batch parameters.
3344 * Optional /n says where to start shifting (n=0-8)
3347 void WCMD_shift (const WCHAR
*args
) {
3350 if (context
!= NULL
) {
3351 WCHAR
*pos
= strchrW(args
, '/');
3356 } else if (*(pos
+1)>='0' && *(pos
+1)<='8') {
3357 start
= (*(pos
+1) - '0');
3359 SetLastError(ERROR_INVALID_PARAMETER
);
3364 WINE_TRACE("Shifting variables, starting at %d\n", start
);
3365 for (i
=start
;i
<=8;i
++) {
3366 context
-> shift_count
[i
] = context
-> shift_count
[i
+1] + 1;
3368 context
-> shift_count
[9] = context
-> shift_count
[9] + 1;
3373 /****************************************************************************
3376 void WCMD_start(const WCHAR
*args
)
3378 static const WCHAR exeW
[] = {'\\','c','o','m','m','a','n','d',
3379 '\\','s','t','a','r','t','.','e','x','e',0};
3380 WCHAR file
[MAX_PATH
];
3383 PROCESS_INFORMATION pi
;
3385 GetWindowsDirectoryW( file
, MAX_PATH
);
3386 strcatW( file
, exeW
);
3387 cmdline
= HeapAlloc( GetProcessHeap(), 0, (strlenW(file
) + strlenW(args
) + 2) * sizeof(WCHAR
) );
3388 strcpyW( cmdline
, file
);
3389 strcatW( cmdline
, spaceW
);
3390 strcatW( cmdline
, args
);
3392 memset( &st
, 0, sizeof(STARTUPINFOW
) );
3393 st
.cb
= sizeof(STARTUPINFOW
);
3395 if (CreateProcessW( file
, cmdline
, NULL
, NULL
, TRUE
, 0, NULL
, NULL
, &st
, &pi
))
3397 WaitForSingleObject( pi
.hProcess
, INFINITE
);
3398 GetExitCodeProcess( pi
.hProcess
, &errorlevel
);
3399 if (errorlevel
== STILL_ACTIVE
) errorlevel
= 0;
3400 CloseHandle(pi
.hProcess
);
3401 CloseHandle(pi
.hThread
);
3405 SetLastError(ERROR_FILE_NOT_FOUND
);
3406 WCMD_print_error ();
3409 HeapFree( GetProcessHeap(), 0, cmdline
);
3412 /****************************************************************************
3415 * Set the console title
3417 void WCMD_title (const WCHAR
*args
) {
3418 SetConsoleTitleW(args
);
3421 /****************************************************************************
3424 * Copy a file to standard output.
3427 void WCMD_type (WCHAR
*args
) {
3431 BOOL writeHeaders
= FALSE
;
3433 if (param1
[0] == 0x00) {
3434 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
3438 if (param2
[0] != 0x00) writeHeaders
= TRUE
;
3440 /* Loop through all args */
3443 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
3451 WINE_TRACE("type: Processing arg '%s'\n", wine_dbgstr_w(thisArg
));
3452 h
= CreateFileW(thisArg
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
3453 FILE_ATTRIBUTE_NORMAL
, NULL
);
3454 if (h
== INVALID_HANDLE_VALUE
) {
3455 WCMD_print_error ();
3456 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), thisArg
);
3460 static const WCHAR fmt
[] = {'\n','%','1','\n','\n','\0'};
3461 WCMD_output(fmt
, thisArg
);
3463 while (WCMD_ReadFile(h
, buffer
, sizeof(buffer
)/sizeof(WCHAR
) - 1, &count
)) {
3464 if (count
== 0) break; /* ReadFile reports success on EOF! */
3466 WCMD_output_asis (buffer
);
3473 /****************************************************************************
3476 * Output either a file or stdin to screen in pages
3479 void WCMD_more (WCHAR
*args
) {
3484 WCHAR moreStrPage
[100];
3487 static const WCHAR moreStart
[] = {'-','-',' ','\0'};
3488 static const WCHAR moreFmt
[] = {'%','s',' ','-','-','\n','\0'};
3489 static const WCHAR moreFmt2
[] = {'%','s',' ','(','%','2','.','2','d','%','%',
3490 ')',' ','-','-','\n','\0'};
3491 static const WCHAR conInW
[] = {'C','O','N','I','N','$','\0'};
3493 /* Prefix the NLS more with '-- ', then load the text */
3495 strcpyW(moreStr
, moreStart
);
3496 LoadStringW(hinst
, WCMD_MORESTR
, &moreStr
[3],
3497 (sizeof(moreStr
)/sizeof(WCHAR
))-3);
3499 if (param1
[0] == 0x00) {
3501 /* Wine implements pipes via temporary files, and hence stdin is
3502 effectively reading from the file. This means the prompts for
3503 more are satisfied by the next line from the input (file). To
3504 avoid this, ensure stdin is to the console */
3505 HANDLE hstdin
= GetStdHandle(STD_INPUT_HANDLE
);
3506 HANDLE hConIn
= CreateFileW(conInW
, GENERIC_READ
| GENERIC_WRITE
,
3507 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
3508 FILE_ATTRIBUTE_NORMAL
, 0);
3509 WINE_TRACE("No parms - working probably in pipe mode\n");
3510 SetStdHandle(STD_INPUT_HANDLE
, hConIn
);
3512 /* Warning: No easy way of ending the stream (ctrl+z on windows) so
3513 once you get in this bit unless due to a pipe, its going to end badly... */
3514 wsprintfW(moreStrPage
, moreFmt
, moreStr
);
3516 WCMD_enter_paged_mode(moreStrPage
);
3517 while (WCMD_ReadFile(hstdin
, buffer
, (sizeof(buffer
)/sizeof(WCHAR
))-1, &count
)) {
3518 if (count
== 0) break; /* ReadFile reports success on EOF! */
3520 WCMD_output_asis (buffer
);
3522 WCMD_leave_paged_mode();
3524 /* Restore stdin to what it was */
3525 SetStdHandle(STD_INPUT_HANDLE
, hstdin
);
3526 CloseHandle(hConIn
);
3530 BOOL needsPause
= FALSE
;
3532 /* Loop through all args */
3533 WINE_TRACE("Parms supplied - working through each file\n");
3534 WCMD_enter_paged_mode(moreStrPage
);
3537 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
3545 wsprintfW(moreStrPage
, moreFmt2
, moreStr
, 100);
3546 WCMD_leave_paged_mode();
3547 WCMD_output_asis(moreStrPage
);
3548 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), buffer
, sizeof(buffer
)/sizeof(WCHAR
), &count
);
3549 WCMD_enter_paged_mode(moreStrPage
);
3553 WINE_TRACE("more: Processing arg '%s'\n", wine_dbgstr_w(thisArg
));
3554 h
= CreateFileW(thisArg
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
3555 FILE_ATTRIBUTE_NORMAL
, NULL
);
3556 if (h
== INVALID_HANDLE_VALUE
) {
3557 WCMD_print_error ();
3558 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), thisArg
);
3562 ULONG64 fileLen
= 0;
3563 WIN32_FILE_ATTRIBUTE_DATA fileInfo
;
3565 /* Get the file size */
3566 GetFileAttributesExW(thisArg
, GetFileExInfoStandard
, (void*)&fileInfo
);
3567 fileLen
= (((ULONG64
)fileInfo
.nFileSizeHigh
) << 32) + fileInfo
.nFileSizeLow
;
3570 while (WCMD_ReadFile(h
, buffer
, (sizeof(buffer
)/sizeof(WCHAR
))-1, &count
)) {
3571 if (count
== 0) break; /* ReadFile reports success on EOF! */
3575 /* Update % count (would be used in WCMD_output_asis as prompt) */
3576 wsprintfW(moreStrPage
, moreFmt2
, moreStr
, (int) min(99, (curPos
* 100)/fileLen
));
3578 WCMD_output_asis (buffer
);
3584 WCMD_leave_paged_mode();
3588 /****************************************************************************
3591 * Display verify flag.
3592 * FIXME: We don't actually do anything with the verify flag other than toggle
3596 void WCMD_verify (const WCHAR
*args
) {
3600 count
= strlenW(args
);
3602 if (verify_mode
) WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT
), onW
);
3603 else WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT
), offW
);
3606 if (lstrcmpiW(args
, onW
) == 0) {
3610 else if (lstrcmpiW(args
, offW
) == 0) {
3611 verify_mode
= FALSE
;
3614 else WCMD_output_stderr(WCMD_LoadMessage(WCMD_VERIFYERR
));
3617 /****************************************************************************
3620 * Display version info.
3623 void WCMD_version (void) {
3625 WCMD_output_asis (version_string
);
3629 /****************************************************************************
3632 * Display volume information (set_label = FALSE)
3633 * Additionally set volume label (set_label = TRUE)
3634 * Returns 1 on success, 0 otherwise
3637 int WCMD_volume(BOOL set_label
, const WCHAR
*path
)
3639 DWORD count
, serial
;
3640 WCHAR string
[MAX_PATH
], label
[MAX_PATH
], curdir
[MAX_PATH
];
3643 if (strlenW(path
) == 0) {
3644 status
= GetCurrentDirectoryW(sizeof(curdir
)/sizeof(WCHAR
), curdir
);
3646 WCMD_print_error ();
3649 status
= GetVolumeInformationW(NULL
, label
, sizeof(label
)/sizeof(WCHAR
),
3650 &serial
, NULL
, NULL
, NULL
, 0);
3653 static const WCHAR fmt
[] = {'%','s','\\','\0'};
3654 if ((path
[1] != ':') || (strlenW(path
) != 2)) {
3655 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
3658 wsprintfW (curdir
, fmt
, path
);
3659 status
= GetVolumeInformationW(curdir
, label
, sizeof(label
)/sizeof(WCHAR
),
3664 WCMD_print_error ();
3667 if (label
[0] != '\0') {
3668 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMELABEL
),
3672 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMENOLABEL
),
3675 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMESERIALNO
),
3676 HIWORD(serial
), LOWORD(serial
));
3678 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMEPROMPT
));
3679 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), string
, sizeof(string
)/sizeof(WCHAR
), &count
);
3681 string
[count
-1] = '\0'; /* ReadFile output is not null-terminated! */
3682 if (string
[count
-2] == '\r') string
[count
-2] = '\0'; /* Under Windoze we get CRLF! */
3684 if (strlenW(path
) != 0) {
3685 if (!SetVolumeLabelW(curdir
, string
)) WCMD_print_error ();
3688 if (!SetVolumeLabelW(NULL
, string
)) WCMD_print_error ();
3694 /**************************************************************************
3697 * Exit either the process, or just this batch program
3701 void WCMD_exit (CMD_LIST
**cmdList
) {
3703 static const WCHAR parmB
[] = {'/','B','\0'};
3704 int rc
= atoiW(param1
); /* Note: atoi of empty parameter is 0 */
3706 if (context
&& lstrcmpiW(quals
, parmB
) == 0) {
3708 context
-> skip_rest
= TRUE
;
3716 /*****************************************************************************
3719 * Lists or sets file associations (assoc = TRUE)
3720 * Lists or sets file types (assoc = FALSE)
3722 void WCMD_assoc (const WCHAR
*args
, BOOL assoc
) {
3725 DWORD accessOptions
= KEY_READ
;
3727 LONG rc
= ERROR_SUCCESS
;
3728 WCHAR keyValue
[MAXSTRING
];
3729 DWORD valueLen
= MAXSTRING
;
3731 static const WCHAR shOpCmdW
[] = {'\\','S','h','e','l','l','\\',
3732 'O','p','e','n','\\','C','o','m','m','a','n','d','\0'};
3734 /* See if parameter includes '=' */
3736 newValue
= strchrW(args
, '=');
3737 if (newValue
) accessOptions
|= KEY_WRITE
;
3739 /* Open a key to HKEY_CLASSES_ROOT for enumerating */
3740 if (RegOpenKeyExW(HKEY_CLASSES_ROOT
, nullW
, 0,
3741 accessOptions
, &key
) != ERROR_SUCCESS
) {
3742 WINE_FIXME("Unexpected failure opening HKCR key: %d\n", GetLastError());
3746 /* If no parameters then list all associations */
3747 if (*args
== 0x00) {
3750 /* Enumerate all the keys */
3751 while (rc
!= ERROR_NO_MORE_ITEMS
) {
3752 WCHAR keyName
[MAXSTRING
];
3755 /* Find the next value */
3756 nameLen
= MAXSTRING
;
3757 rc
= RegEnumKeyExW(key
, index
++, keyName
, &nameLen
, NULL
, NULL
, NULL
, NULL
);
3759 if (rc
== ERROR_SUCCESS
) {
3761 /* Only interested in extension ones if assoc, or others
3763 if ((keyName
[0] == '.' && assoc
) ||
3764 (!(keyName
[0] == '.') && (!assoc
)))
3766 WCHAR subkey
[MAXSTRING
];
3767 strcpyW(subkey
, keyName
);
3768 if (!assoc
) strcatW(subkey
, shOpCmdW
);
3770 if (RegOpenKeyExW(key
, subkey
, 0, accessOptions
, &readKey
) == ERROR_SUCCESS
) {
3772 valueLen
= sizeof(keyValue
)/sizeof(WCHAR
);
3773 rc
= RegQueryValueExW(readKey
, NULL
, NULL
, NULL
, (LPBYTE
)keyValue
, &valueLen
);
3774 WCMD_output_asis(keyName
);
3775 WCMD_output_asis(equalW
);
3776 /* If no default value found, leave line empty after '=' */
3777 if (rc
== ERROR_SUCCESS
) {
3778 WCMD_output_asis(keyValue
);
3780 WCMD_output_asis(newlineW
);
3781 RegCloseKey(readKey
);
3789 /* Parameter supplied - if no '=' on command line, its a query */
3790 if (newValue
== NULL
) {
3792 WCHAR subkey
[MAXSTRING
];
3794 /* Query terminates the parameter at the first space */
3795 strcpyW(keyValue
, args
);
3796 space
= strchrW(keyValue
, ' ');
3797 if (space
) *space
=0x00;
3799 /* Set up key name */
3800 strcpyW(subkey
, keyValue
);
3801 if (!assoc
) strcatW(subkey
, shOpCmdW
);
3803 if (RegOpenKeyExW(key
, subkey
, 0, accessOptions
, &readKey
) == ERROR_SUCCESS
) {
3805 rc
= RegQueryValueExW(readKey
, NULL
, NULL
, NULL
, (LPBYTE
)keyValue
, &valueLen
);
3806 WCMD_output_asis(args
);
3807 WCMD_output_asis(equalW
);
3808 /* If no default value found, leave line empty after '=' */
3809 if (rc
== ERROR_SUCCESS
) WCMD_output_asis(keyValue
);
3810 WCMD_output_asis(newlineW
);
3811 RegCloseKey(readKey
);
3814 WCHAR msgbuffer
[MAXSTRING
];
3816 /* Load the translated 'File association not found' */
3818 LoadStringW(hinst
, WCMD_NOASSOC
, msgbuffer
, sizeof(msgbuffer
)/sizeof(WCHAR
));
3820 LoadStringW(hinst
, WCMD_NOFTYPE
, msgbuffer
, sizeof(msgbuffer
)/sizeof(WCHAR
));
3822 WCMD_output_stderr(msgbuffer
, keyValue
);
3826 /* Not a query - its a set or clear of a value */
3829 WCHAR subkey
[MAXSTRING
];
3831 /* Get pointer to new value */
3835 /* Set up key name */
3836 strcpyW(subkey
, args
);
3837 if (!assoc
) strcatW(subkey
, shOpCmdW
);
3839 /* If nothing after '=' then clear value - only valid for ASSOC */
3840 if (*newValue
== 0x00) {
3842 if (assoc
) rc
= RegDeleteKeyW(key
, args
);
3843 if (assoc
&& rc
== ERROR_SUCCESS
) {
3844 WINE_TRACE("HKCR Key '%s' deleted\n", wine_dbgstr_w(args
));
3846 } else if (assoc
&& rc
!= ERROR_FILE_NOT_FOUND
) {
3851 WCHAR msgbuffer
[MAXSTRING
];
3853 /* Load the translated 'File association not found' */
3855 LoadStringW(hinst
, WCMD_NOASSOC
, msgbuffer
,
3856 sizeof(msgbuffer
)/sizeof(WCHAR
));
3858 LoadStringW(hinst
, WCMD_NOFTYPE
, msgbuffer
,
3859 sizeof(msgbuffer
)/sizeof(WCHAR
));
3861 WCMD_output_stderr(msgbuffer
, keyValue
);
3865 /* It really is a set value = contents */
3867 rc
= RegCreateKeyExW(key
, subkey
, 0, NULL
, REG_OPTION_NON_VOLATILE
,
3868 accessOptions
, NULL
, &readKey
, NULL
);
3869 if (rc
== ERROR_SUCCESS
) {
3870 rc
= RegSetValueExW(readKey
, NULL
, 0, REG_SZ
,
3872 sizeof(WCHAR
) * (strlenW(newValue
) + 1));
3873 RegCloseKey(readKey
);
3876 if (rc
!= ERROR_SUCCESS
) {
3880 WCMD_output_asis(args
);
3881 WCMD_output_asis(equalW
);
3882 WCMD_output_asis(newValue
);
3883 WCMD_output_asis(newlineW
);
3893 /****************************************************************************
3896 * Colors the terminal screen.
3899 void WCMD_color (void) {
3901 CONSOLE_SCREEN_BUFFER_INFO consoleInfo
;
3902 HANDLE hStdOut
= GetStdHandle(STD_OUTPUT_HANDLE
);
3904 if (param1
[0] != 0x00 && strlenW(param1
) > 2) {
3905 WCMD_output_stderr(WCMD_LoadMessage(WCMD_ARGERR
));
3909 if (GetConsoleScreenBufferInfo(hStdOut
, &consoleInfo
))
3915 screenSize
= consoleInfo
.dwSize
.X
* (consoleInfo
.dwSize
.Y
+ 1);
3920 /* Convert the color hex digits */
3921 if (param1
[0] == 0x00) {
3922 color
= defaultColor
;
3924 color
= strtoulW(param1
, NULL
, 16);
3927 /* Fail if fg == bg color */
3928 if (((color
& 0xF0) >> 4) == (color
& 0x0F)) {
3933 /* Set the current screen contents and ensure all future writes
3934 remain this color */
3935 FillConsoleOutputAttribute(hStdOut
, color
, screenSize
, topLeft
, &screenSize
);
3936 SetConsoleTextAttribute(hStdOut
, color
);