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 deviceW
[] = {'\\','\\','.','\\','\0'};
51 const WCHAR inbuilt
[][10] = {
52 {'C','A','L','L','\0'},
54 {'C','H','D','I','R','\0'},
56 {'C','O','P','Y','\0'},
57 {'C','T','T','Y','\0'},
58 {'D','A','T','E','\0'},
61 {'E','C','H','O','\0'},
62 {'E','R','A','S','E','\0'},
64 {'G','O','T','O','\0'},
65 {'H','E','L','P','\0'},
67 {'L','A','B','E','L','\0'},
69 {'M','K','D','I','R','\0'},
70 {'M','O','V','E','\0'},
71 {'P','A','T','H','\0'},
72 {'P','A','U','S','E','\0'},
73 {'P','R','O','M','P','T','\0'},
76 {'R','E','N','A','M','E','\0'},
78 {'R','M','D','I','R','\0'},
80 {'S','H','I','F','T','\0'},
81 {'S','T','A','R','T','\0'},
82 {'T','I','M','E','\0'},
83 {'T','I','T','L','E','\0'},
84 {'T','Y','P','E','\0'},
85 {'V','E','R','I','F','Y','\0'},
88 {'E','N','D','L','O','C','A','L','\0'},
89 {'S','E','T','L','O','C','A','L','\0'},
90 {'P','U','S','H','D','\0'},
91 {'P','O','P','D','\0'},
92 {'A','S','S','O','C','\0'},
93 {'C','O','L','O','R','\0'},
94 {'F','T','Y','P','E','\0'},
95 {'M','O','R','E','\0'},
96 {'C','H','O','I','C','E','\0'},
97 {'M','K','L','I','N','K','\0'},
98 {'E','X','I','T','\0'}
100 static const WCHAR externals
[][10] = {
101 {'A','T','T','R','I','B','\0'},
102 {'X','C','O','P','Y','\0'}
104 static const WCHAR onW
[] = {'O','N','\0'};
105 static const WCHAR offW
[] = {'O','F','F','\0'};
106 static const WCHAR parmY
[] = {'/','Y','\0'};
107 static const WCHAR parmNoY
[] = {'/','-','Y','\0'};
108 static const WCHAR eqeqW
[] = {'=','=','\0'};
110 static HINSTANCE hinst
;
111 struct env_stack
*saved_environment
;
112 static BOOL verify_mode
= FALSE
;
114 /* set /a routines work from single character operators, but some of the
115 operators are multiple character ones, especially the assignment ones.
116 Temporarily represent these using the values below on the operator stack */
117 #define OP_POSITIVE 'P'
118 #define OP_NEGATIVE 'N'
119 #define OP_ASSSIGNMUL 'a'
120 #define OP_ASSSIGNDIV 'b'
121 #define OP_ASSSIGNMOD 'c'
122 #define OP_ASSSIGNADD 'd'
123 #define OP_ASSSIGNSUB 'e'
124 #define OP_ASSSIGNAND 'f'
125 #define OP_ASSSIGNNOT 'g'
126 #define OP_ASSSIGNOR 'h'
127 #define OP_ASSSIGNSHL 'i'
128 #define OP_ASSSIGNSHR 'j'
130 /* This maintains a stack of operators, holding both the operator precedence
131 and the single character representation of the operator in question */
132 typedef struct _OPSTACK
136 struct _OPSTACK
*next
;
139 /* This maintains a stack of values, where each value can either be a
140 numeric value, or a string representing an environment variable */
141 typedef struct _VARSTACK
146 struct _VARSTACK
*next
;
149 /* This maintains a mapping between the calculated operator and the
150 single character representation for the assignment operators. */
155 } calcassignments
[] =
157 {'*', OP_ASSSIGNMUL
},
158 {'/', OP_ASSSIGNDIV
},
159 {'%', OP_ASSSIGNMOD
},
160 {'+', OP_ASSSIGNADD
},
161 {'-', OP_ASSSIGNSUB
},
162 {'&', OP_ASSSIGNAND
},
163 {'^', OP_ASSSIGNNOT
},
165 {'<', OP_ASSSIGNSHL
},
166 {'>', OP_ASSSIGNSHR
},
170 /**************************************************************************
173 * Issue a message and ask for confirmation, waiting on a valid answer.
175 * Returns True if Y (or A) answer is selected
176 * If optionAll contains a pointer, ALL is allowed, and if answered
180 static BOOL
WCMD_ask_confirm (const WCHAR
*message
, BOOL showSureText
,
184 WCHAR confirm
[MAXSTRING
];
185 WCHAR options
[MAXSTRING
];
186 WCHAR Ybuffer
[MAXSTRING
];
187 WCHAR Nbuffer
[MAXSTRING
];
188 WCHAR Abuffer
[MAXSTRING
];
189 WCHAR answer
[MAX_PATH
] = {'\0'};
192 /* Load the translated valid answers */
194 LoadStringW(hinst
, WCMD_CONFIRM
, confirm
, ARRAY_SIZE(confirm
));
195 msgid
= optionAll
? WCMD_YESNOALL
: WCMD_YESNO
;
196 LoadStringW(hinst
, msgid
, options
, ARRAY_SIZE(options
));
197 LoadStringW(hinst
, WCMD_YES
, Ybuffer
, ARRAY_SIZE(Ybuffer
));
198 LoadStringW(hinst
, WCMD_NO
, Nbuffer
, ARRAY_SIZE(Nbuffer
));
199 LoadStringW(hinst
, WCMD_ALL
, Abuffer
, ARRAY_SIZE(Abuffer
));
201 /* Loop waiting on a valid answer */
206 WCMD_output_asis (message
);
208 WCMD_output_asis (confirm
);
209 WCMD_output_asis (options
);
210 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), answer
, ARRAY_SIZE(answer
), &count
);
211 answer
[0] = towupper(answer
[0]);
212 if (answer
[0] == Ybuffer
[0])
214 if (answer
[0] == Nbuffer
[0])
216 if (optionAll
&& answer
[0] == Abuffer
[0])
224 /****************************************************************************
227 * Clear the terminal screen.
230 void WCMD_clear_screen (void) {
232 /* Emulate by filling the screen from the top left to bottom right with
233 spaces, then moving the cursor to the top left afterwards */
234 CONSOLE_SCREEN_BUFFER_INFO consoleInfo
;
235 HANDLE hStdOut
= GetStdHandle(STD_OUTPUT_HANDLE
);
237 if (GetConsoleScreenBufferInfo(hStdOut
, &consoleInfo
))
240 DWORD screenSize
, written
;
242 screenSize
= consoleInfo
.dwSize
.X
* (consoleInfo
.dwSize
.Y
+ 1);
246 FillConsoleOutputCharacterW(hStdOut
, ' ', screenSize
, topLeft
, &written
);
247 FillConsoleOutputAttribute(hStdOut
, consoleInfo
.wAttributes
, screenSize
, topLeft
, &written
);
248 SetConsoleCursorPosition(hStdOut
, topLeft
);
252 /****************************************************************************
255 * Change the default i/o device (ie redirect STDin/STDout).
258 void WCMD_change_tty (void) {
260 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
264 /****************************************************************************
269 void WCMD_choice (const WCHAR
* args
) {
271 static const WCHAR bellW
[] = {7,0};
272 static const WCHAR commaW
[] = {',',0};
273 static const WCHAR bracket_open
[] = {'[',0};
274 static const WCHAR bracket_close
[] = {']','?',0};
279 WCHAR
*my_command
= NULL
;
280 WCHAR opt_default
= 0;
281 DWORD opt_timeout
= 0;
288 have_console
= GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), &oldmode
);
291 my_command
= heap_strdupW(WCMD_skip_leading_spaces((WCHAR
*) args
));
293 ptr
= WCMD_skip_leading_spaces(my_command
);
294 while (*ptr
== '/') {
295 switch (towupper(ptr
[1])) {
298 /* the colon is optional */
302 if (!*ptr
|| iswspace(*ptr
)) {
303 WINE_FIXME("bad parameter %s for /C\n", wine_dbgstr_w(ptr
));
304 heap_free(my_command
);
308 /* remember the allowed keys (overwrite previous /C option) */
310 while (*ptr
&& (!iswspace(*ptr
)))
314 /* terminate allowed chars */
316 ptr
= WCMD_skip_leading_spaces(&ptr
[1]);
318 WINE_TRACE("answer-list: %s\n", wine_dbgstr_w(opt_c
));
323 ptr
= WCMD_skip_leading_spaces(&ptr
[2]);
328 ptr
= WCMD_skip_leading_spaces(&ptr
[2]);
333 /* the colon is optional */
337 opt_default
= *ptr
++;
339 if (!opt_default
|| (*ptr
!= ',')) {
340 WINE_FIXME("bad option %s for /T\n", opt_default
? wine_dbgstr_w(ptr
) : "");
341 heap_free(my_command
);
347 while (((answer
[count
] = *ptr
)) && iswdigit(*ptr
) && (count
< 15)) {
353 opt_timeout
= wcstol(answer
, NULL
, 10);
355 ptr
= WCMD_skip_leading_spaces(ptr
);
359 WINE_FIXME("bad parameter: %s\n", wine_dbgstr_w(ptr
));
360 heap_free(my_command
);
366 WINE_FIXME("timeout not supported: %c,%d\n", opt_default
, opt_timeout
);
369 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), 0);
371 /* use default keys, when needed: localized versions of "Y"es and "No" */
373 LoadStringW(hinst
, WCMD_YES
, buffer
, ARRAY_SIZE(buffer
));
374 LoadStringW(hinst
, WCMD_NO
, buffer
+ 1, ARRAY_SIZE(buffer
) - 1);
379 /* print the question, when needed */
381 WCMD_output_asis(ptr
);
385 WINE_TRACE("case insensitive answer-list: %s\n", wine_dbgstr_w(opt_c
));
389 /* print a list of all allowed answers inside brackets */
390 WCMD_output_asis(bracket_open
);
393 while ((answer
[0] = *ptr
++)) {
394 WCMD_output_asis(answer
);
396 WCMD_output_asis(commaW
);
398 WCMD_output_asis(bracket_close
);
403 /* FIXME: Add support for option /T */
404 answer
[1] = 0; /* terminate single character string */
405 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), answer
, 1, &count
);
408 answer
[0] = towupper(answer
[0]);
410 ptr
= wcschr(opt_c
, answer
[0]);
412 WCMD_output_asis(answer
);
413 WCMD_output_asis(newlineW
);
415 SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE
), oldmode
);
417 errorlevel
= (ptr
- opt_c
) + 1;
418 WINE_TRACE("answer: %d\n", errorlevel
);
419 heap_free(my_command
);
424 /* key not allowed: play the bell */
425 WINE_TRACE("key not allowed: %s\n", wine_dbgstr_w(answer
));
426 WCMD_output_asis(bellW
);
431 /****************************************************************************
434 * Adds an EOF onto the end of a file
435 * Returns TRUE on success
437 static BOOL
WCMD_AppendEOF(WCHAR
*filename
)
444 WINE_TRACE("Appending EOF to %s\n", wine_dbgstr_w(filename
));
445 h
= CreateFileW(filename
, GENERIC_WRITE
, 0, NULL
,
446 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
448 if (h
== INVALID_HANDLE_VALUE
) {
449 WINE_ERR("Failed to open %s (%d)\n", wine_dbgstr_w(filename
), GetLastError());
452 SetFilePointer (h
, 0, NULL
, FILE_END
);
453 if (!WriteFile(h
, &eof
, 1, &bytes_written
, NULL
)) {
454 WINE_ERR("Failed to append EOF to %s (%d)\n", wine_dbgstr_w(filename
), GetLastError());
463 /****************************************************************************
466 * Checks if the two paths reference to the same file
468 static BOOL
WCMD_IsSameFile(const WCHAR
*name1
, const WCHAR
*name2
)
471 HANDLE file1
= INVALID_HANDLE_VALUE
, file2
= INVALID_HANDLE_VALUE
;
472 BY_HANDLE_FILE_INFORMATION info1
, info2
;
474 file1
= CreateFileW(name1
, 0, FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE
, 0, OPEN_EXISTING
, 0, 0);
475 if (file1
== INVALID_HANDLE_VALUE
|| !GetFileInformationByHandle(file1
, &info1
))
478 file2
= CreateFileW(name2
, 0, FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE
, 0, OPEN_EXISTING
, 0, 0);
479 if (file2
== INVALID_HANDLE_VALUE
|| !GetFileInformationByHandle(file2
, &info2
))
482 ret
= info1
.dwVolumeSerialNumber
== info2
.dwVolumeSerialNumber
483 && info1
.nFileIndexHigh
== info2
.nFileIndexHigh
484 && info1
.nFileIndexLow
== info2
.nFileIndexLow
;
486 if (file1
!= INVALID_HANDLE_VALUE
)
488 if (file2
!= INVALID_HANDLE_VALUE
)
493 /****************************************************************************
497 * optionally reading only until EOF (ascii copy)
498 * optionally appending onto an existing file (append)
499 * Returns TRUE on success
501 static BOOL
WCMD_ManualCopy(WCHAR
*srcname
, WCHAR
*dstname
, BOOL ascii
, BOOL append
)
505 DWORD bytesread
, byteswritten
;
507 WINE_TRACE("Manual Copying %s to %s (append?%d)\n",
508 wine_dbgstr_w(srcname
), wine_dbgstr_w(dstname
), append
);
510 in
= CreateFileW(srcname
, GENERIC_READ
, 0, NULL
,
511 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
512 if (in
== INVALID_HANDLE_VALUE
) {
513 WINE_ERR("Failed to open %s (%d)\n", wine_dbgstr_w(srcname
), GetLastError());
517 /* Open the output file, overwriting if not appending */
518 out
= CreateFileW(dstname
, GENERIC_WRITE
, 0, NULL
,
519 append
?OPEN_EXISTING
:CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
520 if (out
== INVALID_HANDLE_VALUE
) {
521 WINE_ERR("Failed to open %s (%d)\n", wine_dbgstr_w(dstname
), GetLastError());
526 /* Move to end of destination if we are going to append to it */
528 SetFilePointer(out
, 0, NULL
, FILE_END
);
531 /* Loop copying data from source to destination until EOF read */
534 char buffer
[MAXSTRING
];
536 ok
= ReadFile(in
, buffer
, MAXSTRING
, &bytesread
, NULL
);
539 /* Stop at first EOF */
541 char *ptr
= (char *)memchr((void *)buffer
, '\x1a', bytesread
);
542 if (ptr
) bytesread
= (ptr
- buffer
);
546 ok
= WriteFile(out
, buffer
, bytesread
, &byteswritten
, NULL
);
547 if (!ok
|| byteswritten
!= bytesread
) {
548 WINE_ERR("Unexpected failure writing to %s, rc=%d\n",
549 wine_dbgstr_w(dstname
), GetLastError());
553 WINE_ERR("Unexpected failure reading from %s, rc=%d\n",
554 wine_dbgstr_w(srcname
), GetLastError());
556 } while (ok
&& bytesread
> 0);
563 /****************************************************************************
566 * Copy a file or wildcarded set.
567 * For ascii/binary type copies, it gets complex:
568 * Syntax on command line is
569 * ... /a | /b filename /a /b {[ + filename /a /b]} [dest /a /b]
570 * Where first /a or /b sets 'mode in operation' until another is found
571 * once another is found, it applies to the file preceding the /a or /b
572 * In addition each filename can contain wildcards
573 * To make matters worse, the + may be in the same parameter (i.e. no
574 * whitespace) or with whitespace separating it
576 * ASCII mode on read == read and stop at first EOF
577 * ASCII mode on write == append EOF to destination
578 * Binary == copy as-is
580 * Design of this is to build up a list of files which will be copied into a
581 * list, then work through the list file by file.
582 * If no destination is specified, it defaults to the name of the first file in
583 * the list, but the current directory.
587 void WCMD_copy(WCHAR
* args
) {
589 BOOL opt_d
, opt_v
, opt_n
, opt_z
, opt_y
, opt_noty
;
594 HANDLE hff
= INVALID_HANDLE_VALUE
;
595 int binarymode
= -1; /* -1 means use the default, 1 is binary, 0 ascii */
596 BOOL concatnextfilename
= FALSE
; /* True if we have just processed a + */
597 BOOL anyconcats
= FALSE
; /* Have we found any + options */
598 BOOL appendfirstsource
= FALSE
; /* Use first found filename as destination */
599 BOOL writtenoneconcat
= FALSE
; /* Remember when the first concatenated file done */
600 BOOL prompt
; /* Prompt before overwriting */
601 WCHAR destname
[MAX_PATH
]; /* Used in calculating the destination name */
602 BOOL destisdirectory
= FALSE
; /* Is the destination a directory? */
606 BOOL dstisdevice
= FALSE
;
607 static const WCHAR copyCmdW
[] = {'C','O','P','Y','C','M','D','\0'};
609 typedef struct _COPY_FILES
611 struct _COPY_FILES
*next
;
616 COPY_FILES
*sourcelist
= NULL
;
617 COPY_FILES
*lastcopyentry
= NULL
;
618 COPY_FILES
*destination
= NULL
;
619 COPY_FILES
*thiscopy
= NULL
;
620 COPY_FILES
*prevcopy
= NULL
;
622 /* Assume we were successful! */
625 /* If no args supplied at all, report an error */
626 if (param1
[0] == 0x00) {
627 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NOARG
));
632 opt_d
= opt_v
= opt_n
= opt_z
= opt_y
= opt_noty
= FALSE
;
634 /* Walk through all args, building up a list of files to process */
635 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
636 while (*(thisparam
)) {
640 WINE_TRACE("Working on parameter '%s'\n", wine_dbgstr_w(thisparam
));
642 /* Handle switches */
643 if (*thisparam
== '/') {
644 while (*thisparam
== '/') {
646 if (towupper(*thisparam
) == 'D') {
648 if (opt_d
) WINE_FIXME("copy /D support not implemented yet\n");
649 } else if (towupper(*thisparam
) == 'Y') {
651 } else if (towupper(*thisparam
) == '-' && towupper(*(thisparam
+1)) == 'Y') {
653 } else if (towupper(*thisparam
) == 'V') {
655 if (opt_v
) WINE_FIXME("copy /V support not implemented yet\n");
656 } else if (towupper(*thisparam
) == 'N') {
658 if (opt_n
) WINE_FIXME("copy /N support not implemented yet\n");
659 } else if (towupper(*thisparam
) == 'Z') {
661 if (opt_z
) WINE_FIXME("copy /Z support not implemented yet\n");
662 } else if (towupper(*thisparam
) == 'A') {
663 if (binarymode
!= 0) {
665 WINE_TRACE("Subsequent files will be handled as ASCII\n");
666 if (destination
!= NULL
) {
667 WINE_TRACE("file %s will be written as ASCII\n", wine_dbgstr_w(destination
->name
));
668 destination
->binarycopy
= binarymode
;
669 } else if (lastcopyentry
!= NULL
) {
670 WINE_TRACE("file %s will be read as ASCII\n", wine_dbgstr_w(lastcopyentry
->name
));
671 lastcopyentry
->binarycopy
= binarymode
;
674 } else if (towupper(*thisparam
) == 'B') {
675 if (binarymode
!= 1) {
677 WINE_TRACE("Subsequent files will be handled as binary\n");
678 if (destination
!= NULL
) {
679 WINE_TRACE("file %s will be written as binary\n", wine_dbgstr_w(destination
->name
));
680 destination
->binarycopy
= binarymode
;
681 } else if (lastcopyentry
!= NULL
) {
682 WINE_TRACE("file %s will be read as binary\n", wine_dbgstr_w(lastcopyentry
->name
));
683 lastcopyentry
->binarycopy
= binarymode
;
687 WINE_FIXME("Unexpected copy switch %s\n", wine_dbgstr_w(thisparam
));
692 /* This parameter was purely switches, get the next one */
693 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
697 /* We have found something which is not a switch. If could be anything of the form
698 sourcefilename (which could be destination too)
699 + (when filename + filename syntex used)
700 sourcefilename+sourcefilename
702 +/b[tests show windows then ignores to end of parameter]
705 if (*thisparam
=='+') {
706 if (lastcopyentry
== NULL
) {
707 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
711 concatnextfilename
= TRUE
;
715 /* Move to next thing to process */
717 if (*thisparam
== 0x00)
718 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
722 /* We have found something to process - build a COPY_FILE block to store it */
723 thiscopy
= heap_xalloc(sizeof(COPY_FILES
));
725 WINE_TRACE("Not a switch, but probably a filename/list %s\n", wine_dbgstr_w(thisparam
));
726 thiscopy
->concatenate
= concatnextfilename
;
727 thiscopy
->binarycopy
= binarymode
;
728 thiscopy
->next
= NULL
;
730 /* Time to work out the name. Allocate at least enough space (deliberately too much to
731 leave space to append \* to the end) , then copy in character by character. Strip off
732 quotes if we find them. */
733 len
= lstrlenW(thisparam
) + (sizeof(WCHAR
) * 5); /* 5 spare characters, null + \*.* */
734 thiscopy
->name
= heap_xalloc(len
*sizeof(WCHAR
));
735 memset(thiscopy
->name
, 0x00, len
);
738 pos2
= thiscopy
->name
;
740 while (*pos1
&& (inquotes
|| (*pos1
!= '+' && *pos1
!= '/'))) {
742 inquotes
= !inquotes
;
744 } else *pos2
++ = *pos1
++;
747 WINE_TRACE("Calculated file name %s\n", wine_dbgstr_w(thiscopy
->name
));
749 /* This is either the first source, concatenated subsequent source or destination */
750 if (sourcelist
== NULL
) {
751 WINE_TRACE("Adding as first source part\n");
752 sourcelist
= thiscopy
;
753 lastcopyentry
= thiscopy
;
754 } else if (concatnextfilename
) {
755 WINE_TRACE("Adding to source file list to be concatenated\n");
756 lastcopyentry
->next
= thiscopy
;
757 lastcopyentry
= thiscopy
;
758 } else if (destination
== NULL
) {
759 destination
= thiscopy
;
761 /* We have processed sources and destinations and still found more to do - invalid */
762 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
766 concatnextfilename
= FALSE
;
768 /* We either need to process the rest of the parameter or move to the next */
769 if (*pos1
== '/' || *pos1
== '+') {
773 thisparam
= WCMD_parameter(args
, argno
++, &rawarg
, TRUE
, FALSE
);
777 /* Ensure we have at least one source file */
779 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
784 /* Default whether automatic overwriting is on. If we are interactive then
785 we prompt by default, otherwise we overwrite by default
786 /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
787 if (opt_noty
) prompt
= TRUE
;
788 else if (opt_y
) prompt
= FALSE
;
790 /* By default, we will force the overwrite in batch mode and ask for
791 * confirmation in interactive mode. */
792 prompt
= interactive
;
793 /* If COPYCMD is set, then we force the overwrite with /Y and ask for
794 * confirmation with /-Y. If COPYCMD is neither of those, then we use the
795 * default behavior. */
796 len
= GetEnvironmentVariableW(copyCmdW
, copycmd
, ARRAY_SIZE(copycmd
));
797 if (len
&& len
< ARRAY_SIZE(copycmd
)) {
798 if (!lstrcmpiW (copycmd
, parmY
))
800 else if (!lstrcmpiW (copycmd
, parmNoY
))
805 /* Calculate the destination now - if none supplied, it's current dir +
806 filename of first file in list*/
807 if (destination
== NULL
) {
809 WINE_TRACE("No destination supplied, so need to calculate it\n");
810 lstrcpyW(destname
, dotW
);
811 lstrcatW(destname
, slashW
);
813 destination
= heap_xalloc(sizeof(COPY_FILES
));
814 if (destination
== NULL
) goto exitreturn
;
815 destination
->concatenate
= FALSE
; /* Not used for destination */
816 destination
->binarycopy
= binarymode
;
817 destination
->next
= NULL
; /* Not used for destination */
818 destination
->name
= NULL
; /* To be filled in */
819 destisdirectory
= TRUE
;
825 WINE_TRACE("Destination supplied, processing to see if file or directory\n");
827 /* Convert to fully qualified path/filename */
828 GetFullPathNameW(destination
->name
, ARRAY_SIZE(destname
), destname
, &filenamepart
);
829 WINE_TRACE("Full dest name is '%s'\n", wine_dbgstr_w(destname
));
831 /* If parameter is a directory, ensure it ends in \ */
832 attributes
= GetFileAttributesW(destname
);
833 if (ends_with_backslash( destname
) ||
834 ((attributes
!= INVALID_FILE_ATTRIBUTES
) &&
835 (attributes
& FILE_ATTRIBUTE_DIRECTORY
))) {
837 destisdirectory
= TRUE
;
838 if (!ends_with_backslash( destname
)) lstrcatW(destname
, slashW
);
839 WINE_TRACE("Directory, so full name is now '%s'\n", wine_dbgstr_w(destname
));
843 /* Normally, the destination is the current directory unless we are
844 concatenating, in which case it's current directory plus first filename.
846 In addition by default it is a binary copy unless concatenating, when
847 the copy defaults to an ascii copy (stop at EOF). We do not know the
848 first source part yet (until we search) so flag as needing filling in. */
851 /* We have found an a+b type syntax, so destination has to be a filename
852 and we need to default to ascii copying. If we have been supplied a
853 directory as the destination, we need to defer calculating the name */
854 if (destisdirectory
) appendfirstsource
= TRUE
;
855 if (destination
->binarycopy
== -1) destination
->binarycopy
= 0;
857 } else if (!destisdirectory
) {
858 /* We have been asked to copy to a filename. Default to ascii IF the
859 source contains wildcards (true even if only one match) */
860 if (wcspbrk(sourcelist
->name
, wildcardsW
) != NULL
) {
861 anyconcats
= TRUE
; /* We really are concatenating to a single file */
862 if (destination
->binarycopy
== -1) {
863 destination
->binarycopy
= 0;
866 if (destination
->binarycopy
== -1) {
867 destination
->binarycopy
= 1;
872 /* Save away the destination name*/
873 heap_free(destination
->name
);
874 destination
->name
= heap_strdupW(destname
);
875 WINE_TRACE("Resolved destination is '%s' (calc later %d)\n",
876 wine_dbgstr_w(destname
), appendfirstsource
);
878 /* Remember if the destination is a device */
879 if (wcsncmp(destination
->name
, deviceW
, lstrlenW(deviceW
)) == 0) {
880 WINE_TRACE("Destination is a device\n");
884 /* Now we need to walk the set of sources, and process each name we come to.
885 If anyconcats is true, we are writing to one file, otherwise we are using
886 the source name each time.
887 If destination exists, prompt for overwrite the first time (if concatenating
888 we ask each time until yes is answered)
889 The first source file we come across must exist (when wildcards expanded)
890 and if concatenating with overwrite prompts, each source file must exist
891 until a yes is answered. */
893 thiscopy
= sourcelist
;
896 while (thiscopy
!= NULL
) {
898 WCHAR srcpath
[MAX_PATH
];
899 const WCHAR
*srcname
;
902 BOOL srcisdevice
= FALSE
;
904 /* If it was not explicit, we now know whether we are concatenating or not and
905 hence whether to copy as binary or ascii */
906 if (thiscopy
->binarycopy
== -1) thiscopy
->binarycopy
= !anyconcats
;
908 /* Convert to fully qualified path/filename in srcpath, file filenamepart pointing
909 to where the filename portion begins (used for wildcard expansion). */
910 GetFullPathNameW(thiscopy
->name
, ARRAY_SIZE(srcpath
), srcpath
, &filenamepart
);
911 WINE_TRACE("Full src name is '%s'\n", wine_dbgstr_w(srcpath
));
913 /* If parameter is a directory, ensure it ends in \* */
914 attributes
= GetFileAttributesW(srcpath
);
915 if (ends_with_backslash( srcpath
)) {
917 /* We need to know where the filename part starts, so append * and
918 recalculate the full resulting path */
919 lstrcatW(thiscopy
->name
, starW
);
920 GetFullPathNameW(thiscopy
->name
, ARRAY_SIZE(srcpath
), srcpath
, &filenamepart
);
921 WINE_TRACE("Directory, so full name is now '%s'\n", wine_dbgstr_w(srcpath
));
923 } else if ((wcspbrk(srcpath
, wildcardsW
) == NULL
) &&
924 (attributes
!= INVALID_FILE_ATTRIBUTES
) &&
925 (attributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
927 /* We need to know where the filename part starts, so append \* and
928 recalculate the full resulting path */
929 lstrcatW(thiscopy
->name
, slashstarW
);
930 GetFullPathNameW(thiscopy
->name
, ARRAY_SIZE(srcpath
), srcpath
, &filenamepart
);
931 WINE_TRACE("Directory, so full name is now '%s'\n", wine_dbgstr_w(srcpath
));
934 WINE_TRACE("Copy source (calculated): path: '%s' (Concats: %d)\n",
935 wine_dbgstr_w(srcpath
), anyconcats
);
937 /* If the source is a device, just use it, otherwise search */
938 if (wcsncmp(srcpath
, deviceW
, lstrlenW(deviceW
)) == 0) {
939 WINE_TRACE("Source is a device\n");
941 srcname
= &srcpath
[4]; /* After the \\.\ prefix */
944 /* Loop through all source files */
945 WINE_TRACE("Searching for: '%s'\n", wine_dbgstr_w(srcpath
));
946 hff
= FindFirstFileW(srcpath
, &fd
);
947 if (hff
!= INVALID_HANDLE_VALUE
) {
948 srcname
= fd
.cFileName
;
952 if (srcisdevice
|| hff
!= INVALID_HANDLE_VALUE
) {
954 WCHAR outname
[MAX_PATH
];
956 BOOL appendtofirstfile
= FALSE
;
958 /* Skip . and .., and directories */
959 if (!srcisdevice
&& fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) {
960 WINE_TRACE("Skipping directories\n");
963 /* Build final destination name */
964 lstrcpyW(outname
, destination
->name
);
965 if (destisdirectory
|| appendfirstsource
) lstrcatW(outname
, srcname
);
967 /* Build source name */
968 if (!srcisdevice
) lstrcpyW(filenamepart
, srcname
);
970 /* Do we just overwrite (we do if we are writing to a device) */
972 if (dstisdevice
|| (anyconcats
&& writtenoneconcat
)) {
976 WINE_TRACE("Copying from : '%s'\n", wine_dbgstr_w(srcpath
));
977 WINE_TRACE("Copying to : '%s'\n", wine_dbgstr_w(outname
));
978 WINE_TRACE("Flags: srcbinary(%d), dstbinary(%d), over(%d), prompt(%d)\n",
979 thiscopy
->binarycopy
, destination
->binarycopy
, overwrite
, prompt
);
981 if (!writtenoneconcat
) {
982 appendtofirstfile
= anyconcats
&& WCMD_IsSameFile(srcpath
, outname
);
985 /* Prompt before overwriting */
986 if (appendtofirstfile
) {
988 } else if (!overwrite
) {
989 DWORD attributes
= GetFileAttributesW(outname
);
990 if (attributes
!= INVALID_FILE_ATTRIBUTES
) {
992 question
= WCMD_format_string(WCMD_LoadMessage(WCMD_OVERWRITE
), outname
);
993 overwrite
= WCMD_ask_confirm(question
, FALSE
, NULL
);
996 else overwrite
= TRUE
;
999 /* If we needed to save away the first filename, do it */
1000 if (appendfirstsource
&& overwrite
) {
1001 heap_free(destination
->name
);
1002 destination
->name
= heap_strdupW(outname
);
1003 WINE_TRACE("Final resolved destination name : '%s'\n", wine_dbgstr_w(outname
));
1004 appendfirstsource
= FALSE
;
1005 destisdirectory
= FALSE
;
1008 /* Do the copy as appropriate */
1010 if (anyconcats
&& WCMD_IsSameFile(srcpath
, outname
)) {
1011 /* Silently skip if the destination file is also a source file */
1013 } else if (anyconcats
&& writtenoneconcat
) {
1014 if (thiscopy
->binarycopy
) {
1015 status
= WCMD_ManualCopy(srcpath
, outname
, FALSE
, TRUE
);
1017 status
= WCMD_ManualCopy(srcpath
, outname
, TRUE
, TRUE
);
1019 } else if (!thiscopy
->binarycopy
) {
1020 status
= WCMD_ManualCopy(srcpath
, outname
, TRUE
, FALSE
);
1021 } else if (srcisdevice
) {
1022 status
= WCMD_ManualCopy(srcpath
, outname
, FALSE
, FALSE
);
1024 status
= CopyFileW(srcpath
, outname
, FALSE
);
1027 WCMD_print_error ();
1030 WINE_TRACE("Copied successfully\n");
1031 if (anyconcats
) writtenoneconcat
= TRUE
;
1033 /* Append EOF if ascii destination and we are not going to add more onto the end
1034 Note: Testing shows windows has an optimization whereas if you have a binary
1035 copy of a file to a single destination (ie concatenation) then it does not add
1036 the EOF, hence the check on the source copy type below. */
1037 if (!destination
->binarycopy
&& !anyconcats
&& !thiscopy
->binarycopy
) {
1038 if (!WCMD_AppendEOF(outname
)) {
1039 WCMD_print_error ();
1046 } while (!srcisdevice
&& FindNextFileW(hff
, &fd
) != 0);
1047 if (!srcisdevice
) FindClose (hff
);
1049 /* Error if the first file was not found */
1050 if (!anyconcats
|| !writtenoneconcat
) {
1051 WCMD_print_error ();
1056 /* Step on to the next supplied source */
1057 thiscopy
= thiscopy
-> next
;
1060 /* Append EOF if ascii destination and we were concatenating */
1061 if (!errorlevel
&& !destination
->binarycopy
&& anyconcats
&& writtenoneconcat
) {
1062 if (!WCMD_AppendEOF(destination
->name
)) {
1063 WCMD_print_error ();
1068 /* Exit out of the routine, freeing any remaining allocated memory */
1071 thiscopy
= sourcelist
;
1072 while (thiscopy
!= NULL
) {
1073 prevcopy
= thiscopy
;
1074 /* Free up this block*/
1075 thiscopy
= thiscopy
-> next
;
1076 heap_free(prevcopy
->name
);
1077 heap_free(prevcopy
);
1080 /* Free up the destination memory */
1082 heap_free(destination
->name
);
1083 heap_free(destination
);
1089 /****************************************************************************
1092 * Create a directory (and, if needed, any intermediate directories).
1094 * Modifies its argument by replacing slashes temporarily with nulls.
1097 static BOOL
create_full_path(WCHAR
* path
)
1101 /* don't mess with drive letter portion of path, if any */
1106 /* Strip trailing slashes. */
1107 for (p
= path
+ lstrlenW(path
) - 1; p
!= start
&& *p
== '\\'; p
--)
1110 /* Step through path, creating intermediate directories as needed. */
1111 /* First component includes drive letter, if any. */
1115 /* Skip to end of component */
1116 while (*p
== '\\') p
++;
1117 while (*p
&& *p
!= '\\') p
++;
1119 /* path is now the original full path */
1120 return CreateDirectoryW(path
, NULL
);
1122 /* Truncate path, create intermediate directory, and restore path */
1124 rv
= CreateDirectoryW(path
, NULL
);
1126 if (!rv
&& GetLastError() != ERROR_ALREADY_EXISTS
)
1133 void WCMD_create_dir (WCHAR
*args
) {
1137 if (param1
[0] == 0x00) {
1138 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
1141 /* Loop through all args */
1143 WCHAR
*thisArg
= WCMD_parameter(args
, argno
++, &argN
, FALSE
, FALSE
);
1145 if (!create_full_path(thisArg
)) {
1146 WCMD_print_error ();
1152 /* Parse the /A options given by the user on the commandline
1153 * into a bitmask of wanted attributes (*wantSet),
1154 * and a bitmask of unwanted attributes (*wantClear).
1156 static void WCMD_delete_parse_attributes(DWORD
*wantSet
, DWORD
*wantClear
) {
1157 static const WCHAR parmA
[] = {'/','A','\0'};
1160 /* both are strictly 'out' parameters */
1164 /* For each /A argument */
1165 for (p
=wcsstr(quals
, parmA
); p
!= NULL
; p
=wcsstr(p
, parmA
)) {
1166 /* Skip /A itself */
1169 /* Skip optional : */
1172 /* For each of the attribute specifier chars to this /A option */
1173 for (; *p
!= 0 && *p
!= '/'; p
++) {
1174 BOOL negate
= FALSE
;
1182 /* Convert the attribute specifier to a bit in one of the masks */
1184 case 'R': mask
= FILE_ATTRIBUTE_READONLY
; break;
1185 case 'H': mask
= FILE_ATTRIBUTE_HIDDEN
; break;
1186 case 'S': mask
= FILE_ATTRIBUTE_SYSTEM
; break;
1187 case 'A': mask
= FILE_ATTRIBUTE_ARCHIVE
; break;
1189 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
1199 /* If filename part of parameter is * or *.*,
1200 * and neither /Q nor /P options were given,
1201 * prompt the user whether to proceed.
1202 * Returns FALSE if user says no, TRUE otherwise.
1203 * *pPrompted is set to TRUE if the user is prompted.
1204 * (If /P supplied, del will prompt for individual files later.)
1206 static BOOL
WCMD_delete_confirm_wildcard(const WCHAR
*filename
, BOOL
*pPrompted
) {
1207 static const WCHAR parmP
[] = {'/','P','\0'};
1208 static const WCHAR parmQ
[] = {'/','Q','\0'};
1210 if ((wcsstr(quals
, parmQ
) == NULL
) && (wcsstr(quals
, parmP
) == NULL
)) {
1211 static const WCHAR anyExt
[]= {'.','*','\0'};
1213 WCHAR dir
[MAX_PATH
];
1214 WCHAR fname
[MAX_PATH
];
1215 WCHAR ext
[MAX_PATH
];
1216 WCHAR fpath
[MAX_PATH
];
1218 /* Convert path into actual directory spec */
1219 GetFullPathNameW(filename
, ARRAY_SIZE(fpath
), fpath
, NULL
);
1220 _wsplitpath(fpath
, drive
, dir
, fname
, ext
);
1222 /* Only prompt for * and *.*, not *a, a*, *.a* etc */
1223 if ((lstrcmpW(fname
, starW
) == 0) &&
1224 (*ext
== 0x00 || (lstrcmpW(ext
, anyExt
) == 0))) {
1226 WCHAR question
[MAXSTRING
];
1227 static const WCHAR fmt
[] = {'%','s',' ','\0'};
1229 /* Caller uses this to suppress "file not found" warning later */
1232 /* Ask for confirmation */
1233 wsprintfW(question
, fmt
, fpath
);
1234 return WCMD_ask_confirm(question
, TRUE
, NULL
);
1237 /* No scary wildcard, or question suppressed, so it's ok to delete the file(s) */
1241 /* Helper function for WCMD_delete().
1242 * Deletes a single file, directory, or wildcard.
1243 * If /S was given, does it recursively.
1244 * Returns TRUE if a file was deleted.
1246 static BOOL
WCMD_delete_one (const WCHAR
*thisArg
) {
1248 static const WCHAR parmP
[] = {'/','P','\0'};
1249 static const WCHAR parmS
[] = {'/','S','\0'};
1250 static const WCHAR parmF
[] = {'/','F','\0'};
1252 DWORD unwanted_attrs
;
1254 WCHAR argCopy
[MAX_PATH
];
1255 WIN32_FIND_DATAW fd
;
1257 WCHAR fpath
[MAX_PATH
];
1259 BOOL handleParm
= TRUE
;
1261 WCMD_delete_parse_attributes(&wanted_attrs
, &unwanted_attrs
);
1263 lstrcpyW(argCopy
, thisArg
);
1264 WINE_TRACE("del: Processing arg %s (quals:%s)\n",
1265 wine_dbgstr_w(argCopy
), wine_dbgstr_w(quals
));
1267 if (!WCMD_delete_confirm_wildcard(argCopy
, &found
)) {
1268 /* Skip this arg if user declines to delete *.* */
1272 /* First, try to delete in the current directory */
1273 hff
= FindFirstFileW(argCopy
, &fd
);
1274 if (hff
== INVALID_HANDLE_VALUE
) {
1280 /* Support del <dirname> by just deleting all files dirname\* */
1282 && (wcschr(argCopy
,'*') == NULL
)
1283 && (wcschr(argCopy
,'?') == NULL
)
1284 && (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
))
1286 WCHAR modifiedParm
[MAX_PATH
];
1287 static const WCHAR slashStar
[] = {'\\','*','\0'};
1289 lstrcpyW(modifiedParm
, argCopy
);
1290 lstrcatW(modifiedParm
, slashStar
);
1293 WCMD_delete_one(modifiedParm
);
1295 } else if (handleParm
) {
1297 /* Build the filename to delete as <supplied directory>\<findfirst filename> */
1298 lstrcpyW (fpath
, argCopy
);
1300 p
= wcsrchr (fpath
, '\\');
1303 lstrcatW (fpath
, fd
.cFileName
);
1305 else lstrcpyW (fpath
, fd
.cFileName
);
1306 if (!(fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
1309 /* Handle attribute matching (/A) */
1310 ok
= ((fd
.dwFileAttributes
& wanted_attrs
) == wanted_attrs
)
1311 && ((fd
.dwFileAttributes
& unwanted_attrs
) == 0);
1313 /* /P means prompt for each file */
1314 if (ok
&& wcsstr (quals
, parmP
) != NULL
) {
1317 /* Ask for confirmation */
1318 question
= WCMD_format_string(WCMD_LoadMessage(WCMD_DELPROMPT
), fpath
);
1319 ok
= WCMD_ask_confirm(question
, FALSE
, NULL
);
1320 LocalFree(question
);
1323 /* Only proceed if ok to */
1326 /* If file is read only, and /A:r or /F supplied, delete it */
1327 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
&&
1328 ((wanted_attrs
& FILE_ATTRIBUTE_READONLY
) ||
1329 wcsstr (quals
, parmF
) != NULL
)) {
1330 SetFileAttributesW(fpath
, fd
.dwFileAttributes
& ~FILE_ATTRIBUTE_READONLY
);
1333 /* Now do the delete */
1334 if (!DeleteFileW(fpath
)) WCMD_print_error ();
1338 } while (FindNextFileW(hff
, &fd
) != 0);
1342 /* Now recurse into all subdirectories handling the parameter in the same way */
1343 if (wcsstr (quals
, parmS
) != NULL
) {
1345 WCHAR thisDir
[MAX_PATH
];
1349 WCHAR dir
[MAX_PATH
];
1350 WCHAR fname
[MAX_PATH
];
1351 WCHAR ext
[MAX_PATH
];
1353 /* Convert path into actual directory spec */
1354 GetFullPathNameW(argCopy
, ARRAY_SIZE(thisDir
), thisDir
, NULL
);
1355 _wsplitpath(thisDir
, drive
, dir
, fname
, ext
);
1357 lstrcpyW(thisDir
, drive
);
1358 lstrcatW(thisDir
, dir
);
1359 cPos
= lstrlenW(thisDir
);
1361 WINE_TRACE("Searching recursively in '%s'\n", wine_dbgstr_w(thisDir
));
1363 /* Append '*' to the directory */
1364 thisDir
[cPos
] = '*';
1365 thisDir
[cPos
+1] = 0x00;
1367 hff
= FindFirstFileW(thisDir
, &fd
);
1369 /* Remove residual '*' */
1370 thisDir
[cPos
] = 0x00;
1372 if (hff
!= INVALID_HANDLE_VALUE
) {
1373 DIRECTORY_STACK
*allDirs
= NULL
;
1374 DIRECTORY_STACK
*lastEntry
= NULL
;
1377 if ((fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) &&
1378 (lstrcmpW(fd
.cFileName
, dotdotW
) != 0) &&
1379 (lstrcmpW(fd
.cFileName
, dotW
) != 0)) {
1381 DIRECTORY_STACK
*nextDir
;
1382 WCHAR subParm
[MAX_PATH
];
1384 /* Work out search parameter in sub dir */
1385 lstrcpyW (subParm
, thisDir
);
1386 lstrcatW (subParm
, fd
.cFileName
);
1387 lstrcatW (subParm
, slashW
);
1388 lstrcatW (subParm
, fname
);
1389 lstrcatW (subParm
, ext
);
1390 WINE_TRACE("Recursive, Adding to search list '%s'\n", wine_dbgstr_w(subParm
));
1392 /* Allocate memory, add to list */
1393 nextDir
= heap_xalloc(sizeof(DIRECTORY_STACK
));
1394 if (allDirs
== NULL
) allDirs
= nextDir
;
1395 if (lastEntry
!= NULL
) lastEntry
->next
= nextDir
;
1396 lastEntry
= nextDir
;
1397 nextDir
->next
= NULL
;
1398 nextDir
->dirName
= heap_strdupW(subParm
);
1400 } while (FindNextFileW(hff
, &fd
) != 0);
1403 /* Go through each subdir doing the delete */
1404 while (allDirs
!= NULL
) {
1405 DIRECTORY_STACK
*tempDir
;
1407 tempDir
= allDirs
->next
;
1408 found
|= WCMD_delete_one (allDirs
->dirName
);
1410 heap_free(allDirs
->dirName
);
1420 /****************************************************************************
1423 * Delete a file or wildcarded set.
1426 * - Testing shows /A is repeatable, eg. /a-r /ar matches all files
1427 * - Each set is a pattern, eg /ahr /as-r means
1428 * readonly+hidden OR nonreadonly system files
1429 * - The '-' applies to a single field, ie /a:-hr means read only
1433 BOOL
WCMD_delete (WCHAR
*args
) {
1436 BOOL argsProcessed
= FALSE
;
1437 BOOL foundAny
= FALSE
;
1441 for (argno
=0; ; argno
++) {
1446 thisArg
= WCMD_parameter (args
, argno
, &argN
, FALSE
, FALSE
);
1448 break; /* no more parameters */
1450 continue; /* skip options */
1452 argsProcessed
= TRUE
;
1453 found
= WCMD_delete_one(thisArg
);
1455 WCMD_output_stderr(WCMD_LoadMessage(WCMD_FILENOTFOUND
), thisArg
);
1459 /* Handle no valid args */
1461 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
1469 * Returns a trimmed version of s with all leading and trailing whitespace removed
1473 static WCHAR
*WCMD_strtrim(const WCHAR
*s
)
1475 DWORD len
= lstrlenW(s
);
1476 const WCHAR
*start
= s
;
1479 result
= heap_xalloc((len
+ 1) * sizeof(WCHAR
));
1481 while (iswspace(*start
)) start
++;
1483 const WCHAR
*end
= s
+ len
- 1;
1484 while (end
> start
&& iswspace(*end
)) end
--;
1485 memcpy(result
, start
, (end
- start
+ 2) * sizeof(WCHAR
));
1486 result
[end
- start
+ 1] = '\0';
1494 /****************************************************************************
1497 * Echo input to the screen (or not). We don't try to emulate the bugs
1498 * in DOS (try typing "ECHO ON AGAIN" for an example).
1501 void WCMD_echo (const WCHAR
*args
)
1504 const WCHAR
*origcommand
= args
;
1507 if ( args
[0]==' ' || args
[0]=='\t' || args
[0]=='.'
1508 || args
[0]==':' || args
[0]==';' || args
[0]=='/')
1511 trimmed
= WCMD_strtrim(args
);
1512 if (!trimmed
) return;
1514 count
= lstrlenW(trimmed
);
1515 if (count
== 0 && origcommand
[0]!='.' && origcommand
[0]!=':'
1516 && origcommand
[0]!=';' && origcommand
[0]!='/') {
1517 if (echo_mode
) WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT
), onW
);
1518 else WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT
), offW
);
1523 if (lstrcmpiW(trimmed
, onW
) == 0)
1525 else if (lstrcmpiW(trimmed
, offW
) == 0)
1528 WCMD_output_asis (args
);
1529 WCMD_output_asis (newlineW
);
1534 /*****************************************************************************
1537 * Execute a command, and any && or bracketed follow on to the command. The
1538 * first command to be executed may not be at the front of the
1539 * commands->thiscommand string (eg. it may point after a DO or ELSE)
1541 static void WCMD_part_execute(CMD_LIST
**cmdList
, const WCHAR
*firstcmd
,
1542 BOOL isIF
, BOOL executecmds
)
1544 CMD_LIST
*curPosition
= *cmdList
;
1545 int myDepth
= (*cmdList
)->bracketDepth
;
1547 WINE_TRACE("cmdList(%p), firstCmd(%s), doIt(%d), isIF(%d)\n", cmdList
,
1548 wine_dbgstr_w(firstcmd
), executecmds
, isIF
);
1550 /* Skip leading whitespace between condition and the command */
1551 while (firstcmd
&& *firstcmd
&& (*firstcmd
==' ' || *firstcmd
=='\t')) firstcmd
++;
1553 /* Process the first command, if there is one */
1554 if (executecmds
&& firstcmd
&& *firstcmd
) {
1555 WCHAR
*command
= heap_strdupW(firstcmd
);
1556 WCMD_execute (firstcmd
, (*cmdList
)->redirects
, cmdList
, FALSE
);
1561 /* If it didn't move the position, step to next command */
1562 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1564 /* Process any other parts of the command */
1566 BOOL processThese
= executecmds
;
1569 static const WCHAR ifElse
[] = {'e','l','s','e'};
1571 /* execute all appropriate commands */
1572 curPosition
= *cmdList
;
1574 WINE_TRACE("Processing cmdList(%p) - delim(%d) bd(%d / %d) processThese(%d)\n",
1576 (*cmdList
)->prevDelim
,
1577 (*cmdList
)->bracketDepth
,
1581 /* Execute any statements appended to the line */
1582 /* FIXME: Only if previous call worked for && or failed for || */
1583 if ((*cmdList
)->prevDelim
== CMD_ONFAILURE
||
1584 (*cmdList
)->prevDelim
== CMD_ONSUCCESS
) {
1585 if (processThese
&& (*cmdList
)->command
) {
1586 WCMD_execute ((*cmdList
)->command
, (*cmdList
)->redirects
,
1589 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1591 /* Execute any appended to the statement with (...) */
1592 } else if ((*cmdList
)->bracketDepth
> myDepth
) {
1594 *cmdList
= WCMD_process_commands(*cmdList
, TRUE
, FALSE
);
1596 WINE_TRACE("Skipping command %p due to stack depth\n", *cmdList
);
1598 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1600 /* End of the command - does 'ELSE ' follow as the next command? */
1602 if (isIF
&& WCMD_keyword_ws_found(ifElse
, ARRAY_SIZE(ifElse
), (*cmdList
)->command
)) {
1603 /* Swap between if and else processing */
1604 processThese
= !executecmds
;
1606 /* Process the ELSE part */
1608 const int keyw_len
= ARRAY_SIZE(ifElse
) + 1;
1609 WCHAR
*cmd
= ((*cmdList
)->command
) + keyw_len
;
1611 /* Skip leading whitespace between condition and the command */
1612 while (*cmd
&& (*cmd
==' ' || *cmd
=='\t')) cmd
++;
1614 WCMD_execute (cmd
, (*cmdList
)->redirects
, cmdList
, FALSE
);
1617 /* Loop skipping all commands until we get back to the current
1618 depth, including skipping commands and their subsequent
1619 pipes (eg cmd | prog) */
1621 *cmdList
= (*cmdList
)->nextcommand
;
1622 } while (*cmdList
&&
1623 ((*cmdList
)->bracketDepth
> myDepth
||
1624 (*cmdList
)->prevDelim
));
1626 /* After the else is complete, we need to now process subsequent commands */
1627 processThese
= TRUE
;
1629 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1631 /* If we were in an IF statement and we didn't find an else and yet we get back to
1632 the same bracket depth as the IF, then the IF statement is over. This is required
1633 to handle nested ifs properly */
1634 } else if (isIF
&& (*cmdList
)->bracketDepth
== myDepth
) {
1635 WINE_TRACE("Found end of this nested IF statement, ending this if\n");
1637 } else if (!processThese
) {
1638 if (curPosition
== *cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
1639 WINE_TRACE("Skipping this command, as in not process mode (next = %p)\n", *cmdList
);
1641 WINE_TRACE("Found end of this IF statement (next = %p)\n", *cmdList
);
1650 /*****************************************************************************
1651 * WCMD_parse_forf_options
1653 * Parses the for /f 'options', extracting the values and validating the
1654 * keywords. Note all keywords are optional.
1656 * options [I] The unparsed parameter string
1657 * eol [O] Set to the comment character (eol=x)
1658 * skip [O] Set to the number of lines to skip (skip=xx)
1659 * delims [O] Set to the token delimiters (delims=)
1660 * tokens [O] Set to the requested tokens, as provided (tokens=)
1661 * usebackq [O] Set to TRUE if usebackq found
1663 * Returns TRUE on success, FALSE on syntax error
1666 static BOOL
WCMD_parse_forf_options(WCHAR
*options
, WCHAR
*eol
, int *skip
,
1667 WCHAR
*delims
, WCHAR
*tokens
, BOOL
*usebackq
)
1670 WCHAR
*pos
= options
;
1671 int len
= lstrlenW(pos
);
1672 static const WCHAR eolW
[] = {'e','o','l','='};
1673 static const WCHAR skipW
[] = {'s','k','i','p','='};
1674 static const WCHAR tokensW
[] = {'t','o','k','e','n','s','='};
1675 static const WCHAR delimsW
[] = {'d','e','l','i','m','s','='};
1676 static const WCHAR usebackqW
[] = {'u','s','e','b','a','c','k','q'};
1677 static const WCHAR forf_defaultdelims
[] = {' ', '\t', '\0'};
1678 static const WCHAR forf_defaulttokens
[] = {'1', '\0'};
1680 /* Initialize to defaults */
1681 lstrcpyW(delims
, forf_defaultdelims
);
1682 lstrcpyW(tokens
, forf_defaulttokens
);
1687 /* Strip (optional) leading and trailing quotes */
1688 if ((*pos
== '"') && (pos
[len
-1] == '"')) {
1693 /* Process each keyword */
1694 while (pos
&& *pos
) {
1695 if (*pos
== ' ' || *pos
== '\t') {
1698 /* Save End of line character (Ignore line if first token (based on delims) starts with it) */
1699 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1700 pos
, ARRAY_SIZE(eolW
), eolW
, ARRAY_SIZE(eolW
)) == CSTR_EQUAL
) {
1701 *eol
= *(pos
+ ARRAY_SIZE(eolW
));
1702 pos
= pos
+ ARRAY_SIZE(eolW
) + 1;
1703 WINE_TRACE("Found eol as %c(%x)\n", *eol
, *eol
);
1705 /* Save number of lines to skip (Can be in base 10, hex (0x...) or octal (0xx) */
1706 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1707 pos
, ARRAY_SIZE(skipW
), skipW
, ARRAY_SIZE(skipW
)) == CSTR_EQUAL
) {
1708 WCHAR
*nextchar
= NULL
;
1709 pos
= pos
+ ARRAY_SIZE(skipW
);
1710 *skip
= wcstoul(pos
, &nextchar
, 0);
1711 WINE_TRACE("Found skip as %d lines\n", *skip
);
1714 /* Save if usebackq semantics are in effect */
1715 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
, pos
,
1716 ARRAY_SIZE(usebackqW
), usebackqW
, ARRAY_SIZE(usebackqW
)) == CSTR_EQUAL
) {
1718 pos
= pos
+ ARRAY_SIZE(usebackqW
);
1719 WINE_TRACE("Found usebackq\n");
1721 /* Save the supplied delims. Slightly odd as space can be a delimiter but only
1722 if you finish the optionsroot string with delims= otherwise the space is
1723 just a token delimiter! */
1724 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1725 pos
, ARRAY_SIZE(delimsW
), delimsW
, ARRAY_SIZE(delimsW
)) == CSTR_EQUAL
) {
1728 pos
= pos
+ ARRAY_SIZE(delimsW
);
1729 while (*pos
&& *pos
!= ' ') {
1733 if (*pos
==' ' && *(pos
+1)==0) delims
[i
++] = *pos
;
1734 delims
[i
++] = 0; /* Null terminate the delims */
1735 WINE_TRACE("Found delims as '%s'\n", wine_dbgstr_w(delims
));
1737 /* Save the tokens being requested */
1738 } else if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
1739 pos
, ARRAY_SIZE(tokensW
), tokensW
, ARRAY_SIZE(tokensW
)) == CSTR_EQUAL
) {
1742 pos
= pos
+ ARRAY_SIZE(tokensW
);
1743 while (*pos
&& *pos
!= ' ') {
1747 tokens
[i
++] = 0; /* Null terminate the tokens */
1748 WINE_TRACE("Found tokens as '%s'\n", wine_dbgstr_w(tokens
));
1751 WINE_WARN("Unexpected data in optionsroot: '%s'\n", wine_dbgstr_w(pos
));
1758 /*****************************************************************************
1759 * WCMD_add_dirstowalk
1761 * When recursing through directories (for /r), we need to add to the list of
1762 * directories still to walk, any subdirectories of the one we are processing.
1765 * options [I] The remaining list of directories still to process
1767 * Note this routine inserts the subdirectories found between the entry being
1768 * processed, and any other directory still to be processed, mimicking what
1771 static void WCMD_add_dirstowalk(DIRECTORY_STACK
*dirsToWalk
) {
1772 DIRECTORY_STACK
*remainingDirs
= dirsToWalk
;
1773 WCHAR fullitem
[MAX_PATH
];
1774 WIN32_FIND_DATAW fd
;
1777 /* Build a generic search and add all directories on the list of directories
1779 lstrcpyW(fullitem
, dirsToWalk
->dirName
);
1780 lstrcatW(fullitem
, slashstarW
);
1781 hff
= FindFirstFileW(fullitem
, &fd
);
1782 if (hff
!= INVALID_HANDLE_VALUE
) {
1784 WINE_TRACE("Looking for subdirectories\n");
1785 if ((fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) &&
1786 (lstrcmpW(fd
.cFileName
, dotdotW
) != 0) &&
1787 (lstrcmpW(fd
.cFileName
, dotW
) != 0))
1789 /* Allocate memory, add to list */
1790 DIRECTORY_STACK
*toWalk
= heap_xalloc(sizeof(DIRECTORY_STACK
));
1791 WINE_TRACE("(%p->%p)\n", remainingDirs
, remainingDirs
->next
);
1792 toWalk
->next
= remainingDirs
->next
;
1793 remainingDirs
->next
= toWalk
;
1794 remainingDirs
= toWalk
;
1795 toWalk
->dirName
= heap_xalloc(sizeof(WCHAR
) * (lstrlenW(dirsToWalk
->dirName
) + 2 + lstrlenW(fd
.cFileName
)));
1796 lstrcpyW(toWalk
->dirName
, dirsToWalk
->dirName
);
1797 lstrcatW(toWalk
->dirName
, slashW
);
1798 lstrcatW(toWalk
->dirName
, fd
.cFileName
);
1799 WINE_TRACE("Added to stack %s (%p->%p)\n", wine_dbgstr_w(toWalk
->dirName
),
1800 toWalk
, toWalk
->next
);
1802 } while (FindNextFileW(hff
, &fd
) != 0);
1803 WINE_TRACE("Finished adding all subdirectories\n");
1808 /**************************************************************************
1809 * WCMD_for_nexttoken
1811 * Parse the token= line, identifying the next highest number not processed
1812 * so far. Count how many tokens are referred (including duplicates) and
1813 * optionally return that, plus optionally indicate if the tokens= line
1817 * lasttoken [I] - Identifies the token index of the last one
1818 * returned so far (-1 used for first loop)
1819 * tokenstr [I] - The specified tokens= line
1820 * firstCmd [O] - Optionally indicate how many tokens are listed
1821 * doAll [O] - Optionally indicate if line ends with *
1822 * duplicates [O] - Optionally indicate if there is any evidence of
1823 * overlaying tokens in the string
1824 * Note the caller should keep a running track of duplicates as the tokens
1825 * are recursively passed. If any have duplicates, then the * token should
1828 static int WCMD_for_nexttoken(int lasttoken
, WCHAR
*tokenstr
,
1829 int *totalfound
, BOOL
*doall
,
1832 WCHAR
*pos
= tokenstr
;
1835 if (totalfound
) *totalfound
= 0;
1836 if (doall
) *doall
= FALSE
;
1837 if (duplicates
) *duplicates
= FALSE
;
1839 WINE_TRACE("Find next token after %d in %s\n", lasttoken
,
1840 wine_dbgstr_w(tokenstr
));
1842 /* Loop through the token string, parsing it. Valid syntax is:
1843 token=m or x-y with comma delimiter and optionally * to finish*/
1845 int nextnumber1
, nextnumber2
= -1;
1848 /* Remember if the next character is a star, it indicates a need to
1849 show all remaining tokens and should be the last character */
1851 if (doall
) *doall
= TRUE
;
1852 if (totalfound
) (*totalfound
)++;
1853 /* If we have not found a next token to return, then indicate
1854 time to process the star */
1855 if (nexttoken
== -1) {
1856 if (lasttoken
== -1) {
1857 /* Special case the syntax of tokens=* which just means get whole line */
1860 nexttoken
= lasttoken
;
1866 /* Get the next number */
1867 nextnumber1
= wcstoul(pos
, &nextchar
, 10);
1869 /* If it is followed by a minus, it's a range, so get the next one as well */
1870 if (*nextchar
== '-') {
1871 nextnumber2
= wcstoul(nextchar
+1, &nextchar
, 10);
1873 /* We want to return the lowest number that is higher than lasttoken
1874 but only if range is positive */
1875 if (nextnumber2
>= nextnumber1
&&
1876 lasttoken
< nextnumber2
) {
1879 if (nexttoken
== -1) {
1880 nextvalue
= max(nextnumber1
, (lasttoken
+1));
1882 nextvalue
= min(nexttoken
, max(nextnumber1
, (lasttoken
+1)));
1885 /* Flag if duplicates identified */
1886 if (nexttoken
== nextvalue
&& duplicates
) *duplicates
= TRUE
;
1888 nexttoken
= nextvalue
;
1891 /* Update the running total for the whole range */
1892 if (nextnumber2
>= nextnumber1
&& totalfound
) {
1893 *totalfound
= *totalfound
+ 1 + (nextnumber2
- nextnumber1
);
1897 } else if (pos
!= nextchar
) {
1898 if (totalfound
) (*totalfound
)++;
1900 /* See if the number found is one we have already seen */
1901 if (nextnumber1
== nexttoken
&& duplicates
) *duplicates
= TRUE
;
1903 /* We want to return the lowest number that is higher than lasttoken */
1904 if (lasttoken
< nextnumber1
&&
1905 ((nexttoken
== -1) || (nextnumber1
< nexttoken
))) {
1906 nexttoken
= nextnumber1
;
1911 /* Step on to the next character, usually over comma */
1918 if (nexttoken
== -1) {
1919 WINE_TRACE("No next token found, previous was %d\n", lasttoken
);
1920 nexttoken
= lasttoken
;
1921 } else if (nexttoken
==lasttoken
&& doall
&& *doall
) {
1922 WINE_TRACE("Request for all remaining tokens now\n");
1924 WINE_TRACE("Found next token after %d was %d\n", lasttoken
, nexttoken
);
1926 if (totalfound
) WINE_TRACE("Found total tokens to be %d\n", *totalfound
);
1927 if (duplicates
&& *duplicates
) WINE_TRACE("Duplicate numbers found\n");
1931 /**************************************************************************
1934 * When parsing file or string contents (for /f), once the string to parse
1935 * has been identified, handle the various options and call the do part
1939 * cmdStart [I] - Identifies the list of commands making up the
1940 * for loop body (especially if brackets in use)
1941 * firstCmd [I] - The textual start of the command after the DO
1942 * which is within the first item of cmdStart
1943 * cmdEnd [O] - Identifies where to continue after the DO
1944 * variable [I] - The variable identified on the for line
1945 * buffer [I] - The string to parse
1946 * doExecuted [O] - Set to TRUE if the DO is ever executed once
1947 * forf_skip [I/O] - How many lines to skip first
1948 * forf_eol [I] - The 'end of line' (comment) character
1949 * forf_delims [I] - The delimiters to use when breaking the string apart
1950 * forf_tokens [I] - The tokens to use when breaking the string apart
1952 static void WCMD_parse_line(CMD_LIST
*cmdStart
,
1953 const WCHAR
*firstCmd
,
1955 const WCHAR variable
,
1961 WCHAR
*forf_tokens
) {
1964 FOR_CONTEXT oldcontext
;
1965 int varidx
, varoffset
;
1966 int nexttoken
, lasttoken
= -1;
1967 BOOL starfound
= FALSE
;
1968 BOOL thisduplicate
= FALSE
;
1969 BOOL anyduplicates
= FALSE
;
1972 /* Skip lines if requested */
1978 /* Save away any existing for variable context (e.g. nested for loops) */
1979 oldcontext
= forloopcontext
;
1981 /* Extract the parameters based on the tokens= value (There will always
1982 be some value, as if it is not supplied, it defaults to tokens=1).
1984 Count how many tokens are named in the line, identify the lowest
1985 Empty (set to null terminated string) that number of named variables
1986 While lasttoken != nextlowest
1987 %letter = parameter number 'nextlowest'
1988 letter++ (if >26 or >52 abort)
1989 Go through token= string finding next lowest number
1990 If token ends in * set %letter = raw position of token(nextnumber+1)
1993 nexttoken
= WCMD_for_nexttoken(lasttoken
, forf_tokens
, &totalfound
,
1994 &starfound
, &thisduplicate
);
1995 varidx
= FOR_VAR_IDX(variable
);
1997 /* Empty out variables */
1999 varidx
>= 0 && varoffset
<totalfound
&& (((varidx
%26) + varoffset
) < 26);
2001 forloopcontext
.variable
[varidx
+ varoffset
] = (WCHAR
*)nullW
;
2004 /* Loop extracting the tokens
2005 Note: nexttoken of 0 means there were no tokens requested, to handle
2006 the special case of tokens=* */
2008 WINE_TRACE("Parsing buffer into tokens: '%s'\n", wine_dbgstr_w(buffer
));
2009 while (varidx
>= 0 && (nexttoken
> 0 && (nexttoken
> lasttoken
))) {
2010 anyduplicates
|= thisduplicate
;
2012 /* Extract the token number requested and set into the next variable context */
2013 parm
= WCMD_parameter_with_delims(buffer
, (nexttoken
-1), NULL
, TRUE
, FALSE
, forf_delims
);
2014 WINE_TRACE("Parsed token %d(%d) as parameter %s\n", nexttoken
,
2015 varidx
+ varoffset
, wine_dbgstr_w(parm
));
2017 if (parm
) forloopcontext
.variable
[varidx
+ varoffset
] = heap_strdupW(parm
);
2019 if (((varidx
%26)+varoffset
) >= 26) break;
2022 /* Find the next token */
2023 lasttoken
= nexttoken
;
2024 nexttoken
= WCMD_for_nexttoken(lasttoken
, forf_tokens
, NULL
,
2025 &starfound
, &thisduplicate
);
2028 /* If all the rest of the tokens were requested, and there is still space in
2029 the variable range, write them now */
2030 if (!anyduplicates
&& starfound
&& varidx
>= 0 && (((varidx
%26) + varoffset
) < 26)) {
2032 WCMD_parameter_with_delims(buffer
, (nexttoken
-1), &parm
, FALSE
, FALSE
, forf_delims
);
2033 WINE_TRACE("Parsed allremaining tokens (%d) as parameter %s\n",
2034 varidx
+ varoffset
, wine_dbgstr_w(parm
));
2035 if (parm
) forloopcontext
.variable
[varidx
+ varoffset
] = heap_strdupW(parm
);
2038 /* Execute the body of the foor loop with these values */
2039 if (forloopcontext
.variable
[varidx
] && forloopcontext
.variable
[varidx
][0] != forf_eol
) {
2040 CMD_LIST
*thisCmdStart
= cmdStart
;
2042 WCMD_part_execute(&thisCmdStart
, firstCmd
, FALSE
, TRUE
);
2043 *cmdEnd
= thisCmdStart
;
2046 /* Free the duplicated strings, and restore the context */
2049 for (i
=varidx
; i
<MAX_FOR_VARIABLES
; i
++) {
2050 if ((forloopcontext
.variable
[i
] != oldcontext
.variable
[i
]) &&
2051 (forloopcontext
.variable
[i
] != nullW
)) {
2052 heap_free(forloopcontext
.variable
[i
]);
2057 /* Restore the original for variable contextx */
2058 forloopcontext
= oldcontext
;
2061 /**************************************************************************
2062 * WCMD_forf_getinputhandle
2064 * Return a file handle which can be used for reading the input lines,
2065 * either to a specific file (which may be quote delimited as we have to
2066 * read the parameters in raw mode) or to a command which we need to
2067 * execute. The command being executed runs in its own shell and stores
2068 * its data in a temporary file.
2071 * usebackq [I] - Indicates whether usebackq is in effect or not
2072 * itemStr [I] - The item to be handled, either a filename or
2073 * whole command string to execute
2074 * iscmd [I] - Identifies whether this is a command or not
2076 * Returns a file handle which can be used to read the input lines from.
2078 static HANDLE
WCMD_forf_getinputhandle(BOOL usebackq
, WCHAR
*itemstr
, BOOL iscmd
) {
2079 WCHAR temp_str
[MAX_PATH
];
2080 WCHAR temp_file
[MAX_PATH
];
2081 WCHAR temp_cmd
[MAXSTRING
];
2082 WCHAR
*trimmed
= NULL
;
2083 HANDLE hinput
= INVALID_HANDLE_VALUE
;
2084 static const WCHAR redirOutW
[] = {'>','%','s','\0'};
2085 static const WCHAR cmdW
[] = {'C','M','D','\0'};
2086 static const WCHAR cmdslashcW
[] = {'C','M','D','.','E','X','E',' ',
2087 '/','C',' ','%','s','\0'};
2089 /* Remove leading and trailing character (but there may be trailing whitespace too) */
2090 if ((iscmd
&& (itemstr
[0] == '`' && usebackq
)) ||
2091 (iscmd
&& (itemstr
[0] == '\'' && !usebackq
)) ||
2092 (!iscmd
&& (itemstr
[0] == '"' && usebackq
)))
2094 trimmed
= WCMD_strtrim(itemstr
);
2098 itemstr
[lstrlenW(itemstr
)-1] = 0x00;
2103 /* Get temp filename */
2104 GetTempPathW(ARRAY_SIZE(temp_str
), temp_str
);
2105 GetTempFileNameW(temp_str
, cmdW
, 0, temp_file
);
2107 /* Redirect output to the temporary file */
2108 wsprintfW(temp_str
, redirOutW
, temp_file
);
2109 wsprintfW(temp_cmd
, cmdslashcW
, itemstr
);
2110 WINE_TRACE("Issuing '%s' with redirs '%s'\n",
2111 wine_dbgstr_w(temp_cmd
), wine_dbgstr_w(temp_str
));
2112 WCMD_execute (temp_cmd
, temp_str
, NULL
, FALSE
);
2114 /* Open the file, read line by line and process */
2115 hinput
= CreateFileW(temp_file
, GENERIC_READ
, FILE_SHARE_READ
,
2116 NULL
, OPEN_EXISTING
, FILE_FLAG_DELETE_ON_CLOSE
, NULL
);
2119 /* Open the file, read line by line and process */
2120 WINE_TRACE("Reading input to parse from '%s'\n", wine_dbgstr_w(itemstr
));
2121 hinput
= CreateFileW(itemstr
, GENERIC_READ
, FILE_SHARE_READ
,
2122 NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2128 /**************************************************************************
2131 * Batch file loop processing.
2133 * On entry: cmdList contains the syntax up to the set
2134 * next cmdList and all in that bracket contain the set data
2135 * next cmdlist contains the DO cmd
2136 * following that is either brackets or && entries (as per if)
2140 void WCMD_for (WCHAR
*p
, CMD_LIST
**cmdList
) {
2142 WIN32_FIND_DATAW fd
;
2145 static const WCHAR inW
[] = {'i','n'};
2146 static const WCHAR doW
[] = {'d','o'};
2147 CMD_LIST
*setStart
, *thisSet
, *cmdStart
, *cmdEnd
;
2150 WCHAR
*oldvariablevalue
;
2153 WCHAR optionsRoot
[MAX_PATH
];
2154 DIRECTORY_STACK
*dirsToWalk
= NULL
;
2155 BOOL expandDirs
= FALSE
;
2156 BOOL useNumbers
= FALSE
;
2157 BOOL doFileset
= FALSE
;
2158 BOOL doRecurse
= FALSE
;
2159 BOOL doExecuted
= FALSE
; /* Has the 'do' part been executed */
2160 LONG numbers
[3] = {0,0,0}; /* Defaults to 0 in native */
2162 CMD_LIST
*thisCmdStart
;
2163 int parameterNo
= 0;
2166 WCHAR forf_delims
[256];
2167 WCHAR forf_tokens
[MAXSTRING
];
2168 BOOL forf_usebackq
= FALSE
;
2170 /* Handle optional qualifiers (multiple are allowed) */
2171 WCHAR
*thisArg
= WCMD_parameter(p
, parameterNo
++, NULL
, FALSE
, FALSE
);
2174 while (thisArg
&& *thisArg
== '/') {
2175 WINE_TRACE("Processing qualifier at %s\n", wine_dbgstr_w(thisArg
));
2177 switch (towupper(*thisArg
)) {
2178 case 'D': expandDirs
= TRUE
; break;
2179 case 'L': useNumbers
= TRUE
; break;
2181 /* Recursive is special case - /R can have an optional path following it */
2182 /* filenamesets are another special case - /F can have an optional options following it */
2186 /* When recursing directories, use current directory as the starting point unless
2187 subsequently overridden */
2188 doRecurse
= (towupper(*thisArg
) == 'R');
2189 if (doRecurse
) GetCurrentDirectoryW(ARRAY_SIZE(optionsRoot
), optionsRoot
);
2191 doFileset
= (towupper(*thisArg
) == 'F');
2193 /* Retrieve next parameter to see if is root/options (raw form required
2194 with for /f, or unquoted in for /r) */
2195 thisArg
= WCMD_parameter(p
, parameterNo
, NULL
, doFileset
, FALSE
);
2197 /* Next parm is either qualifier, path/options or variable -
2198 only care about it if it is the path/options */
2199 if (thisArg
&& *thisArg
!= '/' && *thisArg
!= '%') {
2201 lstrcpyW(optionsRoot
, thisArg
);
2206 WINE_FIXME("for qualifier '%c' unhandled\n", *thisArg
);
2209 /* Step to next token */
2210 thisArg
= WCMD_parameter(p
, parameterNo
++, NULL
, FALSE
, FALSE
);
2213 /* Ensure line continues with variable */
2214 if (*thisArg
!= '%') {
2215 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
2219 /* With for /f parse the options if provided */
2221 if (!WCMD_parse_forf_options(optionsRoot
, &forf_eol
, &forf_skip
,
2222 forf_delims
, forf_tokens
, &forf_usebackq
))
2224 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
2228 /* Set up the list of directories to recurse if we are going to */
2229 } else if (doRecurse
) {
2230 /* Allocate memory, add to list */
2231 dirsToWalk
= heap_xalloc(sizeof(DIRECTORY_STACK
));
2232 dirsToWalk
->next
= NULL
;
2233 dirsToWalk
->dirName
= heap_strdupW(optionsRoot
);
2234 WINE_TRACE("Starting with root directory %s\n", wine_dbgstr_w(dirsToWalk
->dirName
));
2237 /* Variable should follow */
2238 lstrcpyW(variable
, thisArg
);
2239 WINE_TRACE("Variable identified as %s\n", wine_dbgstr_w(variable
));
2240 varidx
= FOR_VAR_IDX(variable
[1]);
2242 /* Ensure line continues with IN */
2243 thisArg
= WCMD_parameter(p
, parameterNo
++, NULL
, FALSE
, FALSE
);
2245 || !(CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
2246 thisArg
, ARRAY_SIZE(inW
), inW
, ARRAY_SIZE(inW
)) == CSTR_EQUAL
)) {
2247 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
2251 /* Save away where the set of data starts and the variable */
2252 thisDepth
= (*cmdList
)->bracketDepth
;
2253 *cmdList
= (*cmdList
)->nextcommand
;
2254 setStart
= (*cmdList
);
2256 /* Skip until the close bracket */
2257 WINE_TRACE("Searching %p as the set\n", *cmdList
);
2259 (*cmdList
)->command
!= NULL
&&
2260 (*cmdList
)->bracketDepth
> thisDepth
) {
2261 WINE_TRACE("Skipping %p which is part of the set\n", *cmdList
);
2262 *cmdList
= (*cmdList
)->nextcommand
;
2265 /* Skip the close bracket, if there is one */
2266 if (*cmdList
) *cmdList
= (*cmdList
)->nextcommand
;
2268 /* Syntax error if missing close bracket, or nothing following it
2269 and once we have the complete set, we expect a DO */
2270 WINE_TRACE("Looking for 'do ' in %p\n", *cmdList
);
2271 if ((*cmdList
== NULL
) || !WCMD_keyword_ws_found(doW
, ARRAY_SIZE(doW
), (*cmdList
)->command
)) {
2272 WCMD_output_stderr (WCMD_LoadMessage(WCMD_SYNTAXERR
));
2278 /* Loop repeatedly per-directory we are potentially walking, when in for /r
2279 mode, or once for the rest of the time. */
2282 /* Save away the starting position for the commands (and offset for the
2284 cmdStart
= *cmdList
;
2285 firstCmd
= (*cmdList
)->command
+ 3; /* Skip 'do ' */
2288 /* If we are recursing directories (ie /R), add all sub directories now, then
2289 prefix the root when searching for the item */
2290 if (dirsToWalk
) WCMD_add_dirstowalk(dirsToWalk
);
2293 /* Loop through all set entries */
2295 thisSet
->command
!= NULL
&&
2296 thisSet
->bracketDepth
>= thisDepth
) {
2298 /* Loop through all entries on the same line */
2301 WCHAR buffer
[MAXSTRING
];
2303 WINE_TRACE("Processing for set %p\n", thisSet
);
2305 while (*(staticitem
= WCMD_parameter (thisSet
->command
, i
, &itemStart
, TRUE
, FALSE
))) {
2308 * If the parameter within the set has a wildcard then search for matching files
2309 * otherwise do a literal substitution.
2311 static const WCHAR wildcards
[] = {'*','?','\0'};
2313 /* Take a copy of the item returned from WCMD_parameter as it is held in a
2314 static buffer which can be overwritten during parsing of the for body */
2315 WCHAR item
[MAXSTRING
];
2316 lstrcpyW(item
, staticitem
);
2318 thisCmdStart
= cmdStart
;
2321 WINE_TRACE("Processing for item %d '%s'\n", itemNum
, wine_dbgstr_w(item
));
2323 if (!useNumbers
&& !doFileset
) {
2324 WCHAR fullitem
[MAX_PATH
];
2327 /* Now build the item to use / search for in the specified directory,
2328 as it is fully qualified in the /R case */
2330 lstrcpyW(fullitem
, dirsToWalk
->dirName
);
2331 lstrcatW(fullitem
, slashW
);
2332 lstrcatW(fullitem
, item
);
2334 WCHAR
*prefix
= wcsrchr(item
, '\\');
2335 if (prefix
) prefixlen
= (prefix
- item
) + 1;
2336 lstrcpyW(fullitem
, item
);
2339 if (wcspbrk (fullitem
, wildcards
)) {
2340 hff
= FindFirstFileW(fullitem
, &fd
);
2341 if (hff
!= INVALID_HANDLE_VALUE
) {
2343 BOOL isDirectory
= FALSE
;
2345 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) isDirectory
= TRUE
;
2347 /* Handle as files or dirs appropriately, but ignore . and .. */
2348 if (isDirectory
== expandDirs
&&
2349 (lstrcmpW(fd
.cFileName
, dotdotW
) != 0) &&
2350 (lstrcmpW(fd
.cFileName
, dotW
) != 0))
2352 thisCmdStart
= cmdStart
;
2353 WINE_TRACE("Processing FOR filename %s\n", wine_dbgstr_w(fd
.cFileName
));
2356 lstrcpyW(fullitem
, dirsToWalk
->dirName
);
2357 lstrcatW(fullitem
, slashW
);
2358 lstrcatW(fullitem
, fd
.cFileName
);
2360 if (prefixlen
) lstrcpynW(fullitem
, item
, prefixlen
+ 1);
2361 fullitem
[prefixlen
] = 0x00;
2362 lstrcatW(fullitem
, fd
.cFileName
);
2366 /* Save away any existing for variable context (e.g. nested for loops)
2367 and restore it after executing the body of this for loop */
2369 oldvariablevalue
= forloopcontext
.variable
[varidx
];
2370 forloopcontext
.variable
[varidx
] = fullitem
;
2372 WCMD_part_execute (&thisCmdStart
, firstCmd
, FALSE
, TRUE
);
2373 if (varidx
>= 0) forloopcontext
.variable
[varidx
] = oldvariablevalue
;
2375 cmdEnd
= thisCmdStart
;
2377 } while (FindNextFileW(hff
, &fd
) != 0);
2383 /* Save away any existing for variable context (e.g. nested for loops)
2384 and restore it after executing the body of this for loop */
2386 oldvariablevalue
= forloopcontext
.variable
[varidx
];
2387 forloopcontext
.variable
[varidx
] = fullitem
;
2389 WCMD_part_execute (&thisCmdStart
, firstCmd
, FALSE
, TRUE
);
2390 if (varidx
>= 0) forloopcontext
.variable
[varidx
] = oldvariablevalue
;
2392 cmdEnd
= thisCmdStart
;
2395 } else if (useNumbers
) {
2396 /* Convert the first 3 numbers to signed longs and save */
2397 if (itemNum
<=3) numbers
[itemNum
-1] = wcstol(item
, NULL
, 10);
2398 /* else ignore them! */
2400 /* Filesets - either a list of files, or a command to run and parse the output */
2401 } else if (doFileset
&& ((!forf_usebackq
&& *itemStart
!= '"') ||
2402 (forf_usebackq
&& *itemStart
!= '\''))) {
2407 WINE_TRACE("Processing for filespec from item %d '%s'\n", itemNum
,
2408 wine_dbgstr_w(item
));
2410 /* If backquote or single quote, we need to launch that command
2411 and parse the results - use a temporary file */
2412 if ((forf_usebackq
&& *itemStart
== '`') ||
2413 (!forf_usebackq
&& *itemStart
== '\'')) {
2415 /* Use itemstart because the command is the whole set, not just the first token */
2416 itemparm
= itemStart
;
2419 /* Use item because the file to process is just the first item in the set */
2422 input
= WCMD_forf_getinputhandle(forf_usebackq
, itemparm
, (itemparm
==itemStart
));
2424 /* Process the input file */
2425 if (input
== INVALID_HANDLE_VALUE
) {
2426 WCMD_print_error ();
2427 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), item
);
2429 return; /* FOR loop aborts at first failure here */
2433 /* Read line by line until end of file */
2434 while (WCMD_fgets(buffer
, ARRAY_SIZE(buffer
), input
)) {
2435 WCMD_parse_line(cmdStart
, firstCmd
, &cmdEnd
, variable
[1], buffer
, &doExecuted
,
2436 &forf_skip
, forf_eol
, forf_delims
, forf_tokens
);
2439 CloseHandle (input
);
2442 /* When we have processed the item as a whole command, abort future set processing */
2443 if (itemparm
==itemStart
) {
2448 /* Filesets - A string literal */
2449 } else if (doFileset
&& ((!forf_usebackq
&& *itemStart
== '"') ||
2450 (forf_usebackq
&& *itemStart
== '\''))) {
2452 /* Remove leading and trailing character, ready to parse with delims= delimiters
2453 Note that the last quote is removed from the set and the string terminates
2454 there to mimic windows */
2455 WCHAR
*strend
= wcsrchr(itemStart
, forf_usebackq
?'\'':'"');
2461 /* Copy the item away from the global buffer used by WCMD_parameter */
2462 lstrcpyW(buffer
, itemStart
);
2463 WCMD_parse_line(cmdStart
, firstCmd
, &cmdEnd
, variable
[1], buffer
, &doExecuted
,
2464 &forf_skip
, forf_eol
, forf_delims
, forf_tokens
);
2466 /* Only one string can be supplied in the whole set, abort future set processing */
2471 WINE_TRACE("Post-command, cmdEnd = %p\n", cmdEnd
);
2475 /* Move onto the next set line */
2476 if (thisSet
) thisSet
= thisSet
->nextcommand
;
2479 /* If /L is provided, now run the for loop */
2482 static const WCHAR fmt
[] = {'%','d','\0'};
2484 WINE_TRACE("FOR /L provided range from %d to %d step %d\n",
2485 numbers
[0], numbers
[2], numbers
[1]);
2487 (numbers
[1]<0)? i
>=numbers
[2] : i
<=numbers
[2];
2490 swprintf(thisNum
, ARRAY_SIZE(thisNum
), fmt
, i
);
2491 WINE_TRACE("Processing FOR number %s\n", wine_dbgstr_w(thisNum
));
2493 thisCmdStart
= cmdStart
;
2496 /* Save away any existing for variable context (e.g. nested for loops)
2497 and restore it after executing the body of this for loop */
2499 oldvariablevalue
= forloopcontext
.variable
[varidx
];
2500 forloopcontext
.variable
[varidx
] = thisNum
;
2502 WCMD_part_execute (&thisCmdStart
, firstCmd
, FALSE
, TRUE
);
2503 if (varidx
>= 0) forloopcontext
.variable
[varidx
] = oldvariablevalue
;
2505 cmdEnd
= thisCmdStart
;
2508 /* If we are walking directories, move on to any which remain */
2509 if (dirsToWalk
!= NULL
) {
2510 DIRECTORY_STACK
*nextDir
= dirsToWalk
->next
;
2511 heap_free(dirsToWalk
->dirName
);
2512 heap_free(dirsToWalk
);
2513 dirsToWalk
= nextDir
;
2514 if (dirsToWalk
) WINE_TRACE("Moving to next directory to iterate: %s\n",
2515 wine_dbgstr_w(dirsToWalk
->dirName
));
2516 else WINE_TRACE("Finished all directories.\n");
2519 } while (dirsToWalk
!= NULL
);
2521 /* Now skip over the do part if we did not perform the for loop so far.
2522 We store in cmdEnd the next command after the do block, but we only
2523 know this if something was run. If it has not been, we need to calculate
2526 thisCmdStart
= cmdStart
;
2527 WINE_TRACE("Skipping for loop commands due to no valid iterations\n");
2528 WCMD_part_execute(&thisCmdStart
, firstCmd
, FALSE
, FALSE
);
2529 cmdEnd
= thisCmdStart
;
2532 /* When the loop ends, either something like a GOTO or EXIT /b has terminated
2533 all processing, OR it should be pointing to the end of && processing OR
2534 it should be pointing at the NULL end of bracket for the DO. The return
2535 value needs to be the NEXT command to execute, which it either is, or
2536 we need to step over the closing bracket */
2538 if (cmdEnd
&& cmdEnd
->command
== NULL
) *cmdList
= cmdEnd
->nextcommand
;
2541 /**************************************************************************
2544 * Simple on-line help. Help text is stored in the resource file.
2547 void WCMD_give_help (const WCHAR
*args
)
2551 args
= WCMD_skip_leading_spaces((WCHAR
*) args
);
2553 WCMD_output_asis (WCMD_LoadMessage(WCMD_ALLHELP
));
2556 /* Display help message for builtin commands */
2557 for (i
=0; i
<=WCMD_EXIT
; i
++) {
2558 if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
2559 args
, -1, inbuilt
[i
], -1) == CSTR_EQUAL
) {
2560 WCMD_output_asis (WCMD_LoadMessage(i
));
2564 /* Launch the command with the /? option for external commands shipped with cmd.exe */
2565 for (i
= 0; i
<= ARRAY_SIZE(externals
); i
++) {
2566 if (CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
2567 args
, -1, externals
[i
], -1) == CSTR_EQUAL
) {
2569 static const WCHAR helpW
[] = {' ', '/','?','\0'};
2570 lstrcpyW(cmd
, args
);
2571 lstrcatW(cmd
, helpW
);
2572 WCMD_run_program(cmd
, FALSE
);
2576 WCMD_output (WCMD_LoadMessage(WCMD_NOCMDHELP
), args
);
2581 /****************************************************************************
2584 * Batch file jump instruction. Not the most efficient algorithm ;-)
2585 * Prints error message if the specified label cannot be found - the file pointer is
2586 * then at EOF, effectively stopping the batch file.
2587 * FIXME: DOS is supposed to allow labels with spaces - we don't.
2590 void WCMD_goto (CMD_LIST
**cmdList
) {
2592 WCHAR string
[MAX_PATH
];
2593 WCHAR
*labelend
= NULL
;
2594 const WCHAR labelEndsW
[] = {'>','<','|','&',' ',':','\t','\0'};
2596 /* Do not process any more parts of a processed multipart or multilines command */
2597 if (cmdList
) *cmdList
= NULL
;
2599 if (context
!= NULL
) {
2600 WCHAR
*paramStart
= param1
, *str
;
2601 static const WCHAR eofW
[] = {':','e','o','f','\0'};
2603 if (param1
[0] == 0x00) {
2604 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
2608 /* Handle special :EOF label */
2609 if (lstrcmpiW (eofW
, param1
) == 0) {
2610 context
-> skip_rest
= TRUE
;
2614 /* Support goto :label as well as goto label plus remove trailing chars */
2615 if (*paramStart
== ':') paramStart
++;
2616 labelend
= wcspbrk(paramStart
, labelEndsW
);
2617 if (labelend
) *labelend
= 0x00;
2618 WINE_TRACE("goto label: '%s'\n", wine_dbgstr_w(paramStart
));
2620 /* Loop through potentially twice - once from current file position
2621 through to the end, and second time from start to current file
2625 LARGE_INTEGER startli
;
2626 for (loop
=0; loop
<2; loop
++) {
2628 /* On first loop, save the file size */
2629 startli
.QuadPart
= 0;
2630 startli
.u
.LowPart
= SetFilePointer(context
-> h
, startli
.u
.LowPart
,
2631 &startli
.u
.HighPart
, FILE_CURRENT
);
2633 /* On second loop, start at the beginning of the file */
2634 WINE_TRACE("Label not found, trying from beginning of file\n");
2635 if (loop
==1) SetFilePointer (context
-> h
, 0, NULL
, FILE_BEGIN
);
2638 while (WCMD_fgets (string
, ARRAY_SIZE(string
), context
-> h
)) {
2641 /* Ignore leading whitespace or no-echo character */
2642 while (*str
=='@' || iswspace (*str
)) str
++;
2644 /* If the first real character is a : then this is a label */
2648 /* Skip spaces between : and label */
2649 while (iswspace (*str
)) str
++;
2650 WINE_TRACE("str before brk %s\n", wine_dbgstr_w(str
));
2652 /* Label ends at whitespace or redirection characters */
2653 labelend
= wcspbrk(str
, labelEndsW
);
2654 if (labelend
) *labelend
= 0x00;
2655 WINE_TRACE("comparing found label %s\n", wine_dbgstr_w(str
));
2657 if (lstrcmpiW (str
, paramStart
) == 0) return;
2660 /* See if we have gone beyond the end point if second time through */
2662 LARGE_INTEGER curli
;
2664 curli
.u
.LowPart
= SetFilePointer(context
-> h
, curli
.u
.LowPart
,
2665 &curli
.u
.HighPart
, FILE_CURRENT
);
2666 if (curli
.QuadPart
> startli
.QuadPart
) {
2667 WINE_TRACE("Reached wrap point, label not found\n");
2675 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOTARGET
));
2676 context
-> skip_rest
= TRUE
;
2681 /*****************************************************************************
2684 * Push a directory onto the stack
2687 void WCMD_pushd (const WCHAR
*args
)
2689 struct env_stack
*curdir
;
2691 static const WCHAR parmD
[] = {'/','D','\0'};
2693 if (wcschr(args
, '/') != NULL
) {
2694 SetLastError(ERROR_INVALID_PARAMETER
);
2699 curdir
= LocalAlloc (LMEM_FIXED
, sizeof (struct env_stack
));
2700 thisdir
= LocalAlloc (LMEM_FIXED
, 1024 * sizeof(WCHAR
));
2701 if( !curdir
|| !thisdir
) {
2704 WINE_ERR ("out of memory\n");
2708 /* Change directory using CD code with /D parameter */
2709 lstrcpyW(quals
, parmD
);
2710 GetCurrentDirectoryW (1024, thisdir
);
2712 WCMD_setshow_default(args
);
2718 curdir
-> next
= pushd_directories
;
2719 curdir
-> strings
= thisdir
;
2720 if (pushd_directories
== NULL
) {
2721 curdir
-> u
.stackdepth
= 1;
2723 curdir
-> u
.stackdepth
= pushd_directories
-> u
.stackdepth
+ 1;
2725 pushd_directories
= curdir
;
2730 /*****************************************************************************
2733 * Pop a directory from the stack
2736 void WCMD_popd (void) {
2737 struct env_stack
*temp
= pushd_directories
;
2739 if (!pushd_directories
)
2742 /* pop the old environment from the stack, and make it the current dir */
2743 pushd_directories
= temp
->next
;
2744 SetCurrentDirectoryW(temp
->strings
);
2745 LocalFree (temp
->strings
);
2749 /*******************************************************************
2750 * evaluate_if_comparison
2752 * Evaluates an "if" comparison operation
2755 * leftOperand [I] left operand, non NULL
2756 * operator [I] "if" binary comparison operator, non NULL
2757 * rightOperand [I] right operand, non NULL
2758 * caseInsensitive [I] 0 for case sensitive comparison, anything else for insensitive
2761 * Success: 1 if operator applied to the operands evaluates to TRUE
2762 * 0 if operator applied to the operands evaluates to FALSE
2763 * Failure: -1 if operator is not recognized
2765 static int evaluate_if_comparison(const WCHAR
*leftOperand
, const WCHAR
*operator,
2766 const WCHAR
*rightOperand
, int caseInsensitive
)
2768 WCHAR
*endptr_leftOp
, *endptr_rightOp
;
2769 long int leftOperand_int
, rightOperand_int
;
2771 static const WCHAR lssW
[] = {'l','s','s','\0'};
2772 static const WCHAR leqW
[] = {'l','e','q','\0'};
2773 static const WCHAR equW
[] = {'e','q','u','\0'};
2774 static const WCHAR neqW
[] = {'n','e','q','\0'};
2775 static const WCHAR geqW
[] = {'g','e','q','\0'};
2776 static const WCHAR gtrW
[] = {'g','t','r','\0'};
2778 /* == is a special case, as it always compares strings */
2779 if (!lstrcmpiW(operator, eqeqW
))
2780 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) == 0
2781 : lstrcmpW (leftOperand
, rightOperand
) == 0;
2783 /* Check if we have plain integers (in decimal, octal or hexadecimal notation) */
2784 leftOperand_int
= wcstol(leftOperand
, &endptr_leftOp
, 0);
2785 rightOperand_int
= wcstol(rightOperand
, &endptr_rightOp
, 0);
2786 int_operands
= (!*endptr_leftOp
) && (!*endptr_rightOp
);
2788 /* Perform actual (integer or string) comparison */
2789 if (!lstrcmpiW(operator, lssW
)) {
2791 return leftOperand_int
< rightOperand_int
;
2793 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) < 0
2794 : lstrcmpW (leftOperand
, rightOperand
) < 0;
2797 if (!lstrcmpiW(operator, leqW
)) {
2799 return leftOperand_int
<= rightOperand_int
;
2801 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) <= 0
2802 : lstrcmpW (leftOperand
, rightOperand
) <= 0;
2805 if (!lstrcmpiW(operator, equW
)) {
2807 return leftOperand_int
== rightOperand_int
;
2809 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) == 0
2810 : lstrcmpW (leftOperand
, rightOperand
) == 0;
2813 if (!lstrcmpiW(operator, neqW
)) {
2815 return leftOperand_int
!= rightOperand_int
;
2817 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) != 0
2818 : lstrcmpW (leftOperand
, rightOperand
) != 0;
2821 if (!lstrcmpiW(operator, geqW
)) {
2823 return leftOperand_int
>= rightOperand_int
;
2825 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) >= 0
2826 : lstrcmpW (leftOperand
, rightOperand
) >= 0;
2829 if (!lstrcmpiW(operator, gtrW
)) {
2831 return leftOperand_int
> rightOperand_int
;
2833 return caseInsensitive
? lstrcmpiW(leftOperand
, rightOperand
) > 0
2834 : lstrcmpW (leftOperand
, rightOperand
) > 0;
2840 int evaluate_if_condition(WCHAR
*p
, WCHAR
**command
, int *test
, int *negate
)
2842 WCHAR condition
[MAX_PATH
];
2843 static const WCHAR notW
[] = {'n','o','t','\0'};
2844 static const WCHAR errlvlW
[] = {'e','r','r','o','r','l','e','v','e','l','\0'};
2845 static const WCHAR existW
[] = {'e','x','i','s','t','\0'};
2846 static const WCHAR defdW
[] = {'d','e','f','i','n','e','d','\0'};
2847 static const WCHAR parmI
[] = {'/','I','\0'};
2848 int caseInsensitive
= (wcsstr(quals
, parmI
) != NULL
);
2850 *negate
= !lstrcmpiW(param1
,notW
);
2851 lstrcpyW(condition
, (*negate
? param2
: param1
));
2852 WINE_TRACE("Condition: %s\n", wine_dbgstr_w(condition
));
2854 if (!lstrcmpiW (condition
, errlvlW
)) {
2855 WCHAR
*param
= WCMD_parameter(p
, 1+(*negate
), NULL
, FALSE
, FALSE
);
2857 long int param_int
= wcstol(param
, &endptr
, 10);
2858 if (*endptr
) goto syntax_err
;
2859 *test
= ((long int)errorlevel
>= param_int
);
2860 WCMD_parameter(p
, 2+(*negate
), command
, FALSE
, FALSE
);
2862 else if (!lstrcmpiW (condition
, existW
)) {
2863 WIN32_FIND_DATAW fd
;
2865 WCHAR
*param
= WCMD_parameter(p
, 1+(*negate
), NULL
, FALSE
, FALSE
);
2866 int len
= lstrlenW(param
);
2868 /* FindFirstFile does not like a directory path ending in '\', append a '.' */
2869 if (len
&& param
[len
-1] == '\\') lstrcatW(param
, dotW
);
2871 hff
= FindFirstFileW(param
, &fd
);
2872 *test
= (hff
!= INVALID_HANDLE_VALUE
);
2873 if (*test
) FindClose(hff
);
2875 WCMD_parameter(p
, 2+(*negate
), command
, FALSE
, FALSE
);
2877 else if (!lstrcmpiW (condition
, defdW
)) {
2878 *test
= (GetEnvironmentVariableW(WCMD_parameter(p
, 1+(*negate
), NULL
, FALSE
, FALSE
),
2880 WCMD_parameter(p
, 2+(*negate
), command
, FALSE
, FALSE
);
2882 else { /* comparison operation */
2883 WCHAR leftOperand
[MAXSTRING
], rightOperand
[MAXSTRING
], operator[MAXSTRING
];
2886 lstrcpyW(leftOperand
, WCMD_parameter(p
, (*negate
)+caseInsensitive
, ¶mStart
, TRUE
, FALSE
));
2890 /* Note: '==' can't be returned by WCMD_parameter since '=' is a separator */
2891 p
= paramStart
+ lstrlenW(leftOperand
);
2892 while (*p
== ' ' || *p
== '\t')
2895 if (!wcsncmp(p
, eqeqW
, lstrlenW(eqeqW
)))
2896 lstrcpyW(operator, eqeqW
);
2898 lstrcpyW(operator, WCMD_parameter(p
, 0, ¶mStart
, FALSE
, FALSE
));
2899 if (!*operator) goto syntax_err
;
2901 p
+= lstrlenW(operator);
2903 lstrcpyW(rightOperand
, WCMD_parameter(p
, 0, ¶mStart
, TRUE
, FALSE
));
2907 *test
= evaluate_if_comparison(leftOperand
, operator, rightOperand
, caseInsensitive
);
2911 p
= paramStart
+ lstrlenW(rightOperand
);
2912 WCMD_parameter(p
, 0, command
, FALSE
, FALSE
);
2921 /****************************************************************************
2924 * Batch file conditional.
2926 * On entry, cmdlist will point to command containing the IF, and optionally
2927 * the first command to execute (if brackets not found)
2928 * If &&'s were found, this may be followed by a record flagged as isAmpersand
2929 * If ('s were found, execute all within that bracket
2930 * Command may optionally be followed by an ELSE - need to skip instructions
2931 * in the else using the same logic
2933 * FIXME: Much more syntax checking needed!
2935 void WCMD_if (WCHAR
*p
, CMD_LIST
**cmdList
)
2937 int negate
; /* Negate condition */
2938 int test
; /* Condition evaluation result */
2941 if (evaluate_if_condition(p
, &command
, &test
, &negate
) == -1)
2944 /* Process rest of IF statement which is on the same line
2945 Note: This may process all or some of the cmdList (eg a GOTO) */
2946 WCMD_part_execute(cmdList
, command
, TRUE
, (test
!= negate
));
2950 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
2953 /****************************************************************************
2956 * Move a file, directory tree or wildcarded set of files.
2959 void WCMD_move (void)
2962 WIN32_FIND_DATAW fd
;
2964 WCHAR input
[MAX_PATH
];
2965 WCHAR output
[MAX_PATH
];
2967 WCHAR dir
[MAX_PATH
];
2968 WCHAR fname
[MAX_PATH
];
2969 WCHAR ext
[MAX_PATH
];
2971 if (param1
[0] == 0x00) {
2972 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
2976 /* If no destination supplied, assume current directory */
2977 if (param2
[0] == 0x00) {
2978 lstrcpyW(param2
, dotW
);
2981 /* If 2nd parm is directory, then use original filename */
2982 /* Convert partial path to full path */
2983 GetFullPathNameW(param1
, ARRAY_SIZE(input
), input
, NULL
);
2984 GetFullPathNameW(param2
, ARRAY_SIZE(output
), output
, NULL
);
2985 WINE_TRACE("Move from '%s'('%s') to '%s'\n", wine_dbgstr_w(input
),
2986 wine_dbgstr_w(param1
), wine_dbgstr_w(output
));
2988 /* Split into components */
2989 _wsplitpath(input
, drive
, dir
, fname
, ext
);
2991 hff
= FindFirstFileW(input
, &fd
);
2992 if (hff
== INVALID_HANDLE_VALUE
)
2996 WCHAR dest
[MAX_PATH
];
2997 WCHAR src
[MAX_PATH
];
3001 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd
.cFileName
));
3003 /* Build src & dest name */
3004 lstrcpyW(src
, drive
);
3007 /* See if dest is an existing directory */
3008 attribs
= GetFileAttributesW(output
);
3009 if (attribs
!= INVALID_FILE_ATTRIBUTES
&&
3010 (attribs
& FILE_ATTRIBUTE_DIRECTORY
)) {
3011 lstrcpyW(dest
, output
);
3012 lstrcatW(dest
, slashW
);
3013 lstrcatW(dest
, fd
.cFileName
);
3015 lstrcpyW(dest
, output
);
3018 lstrcatW(src
, fd
.cFileName
);
3020 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src
));
3021 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest
));
3023 /* If destination exists, prompt unless /Y supplied */
3024 if (GetFileAttributesW(dest
) != INVALID_FILE_ATTRIBUTES
) {
3026 WCHAR copycmd
[MAXSTRING
];
3029 /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
3030 if (wcsstr (quals
, parmNoY
))
3032 else if (wcsstr (quals
, parmY
))
3035 static const WCHAR copyCmdW
[] = {'C','O','P','Y','C','M','D','\0'};
3036 len
= GetEnvironmentVariableW(copyCmdW
, copycmd
, ARRAY_SIZE(copycmd
));
3037 force
= (len
&& len
< ARRAY_SIZE(copycmd
) && !lstrcmpiW(copycmd
, parmY
));
3040 /* Prompt if overwriting */
3044 /* Ask for confirmation */
3045 question
= WCMD_format_string(WCMD_LoadMessage(WCMD_OVERWRITE
), dest
);
3046 ok
= WCMD_ask_confirm(question
, FALSE
, NULL
);
3047 LocalFree(question
);
3049 /* So delete the destination prior to the move */
3051 if (!DeleteFileW(dest
)) {
3052 WCMD_print_error ();
3061 status
= MoveFileW(src
, dest
);
3067 WCMD_print_error ();
3070 } while (FindNextFileW(hff
, &fd
) != 0);
3075 /****************************************************************************
3078 * Suspend execution of a batch script until a key is typed
3081 void WCMD_pause (void)
3087 HANDLE hIn
= GetStdHandle(STD_INPUT_HANDLE
);
3089 have_console
= GetConsoleMode(hIn
, &oldmode
);
3091 SetConsoleMode(hIn
, 0);
3093 WCMD_output_asis(anykey
);
3094 WCMD_ReadFile(hIn
, &key
, 1, &count
);
3096 SetConsoleMode(hIn
, oldmode
);
3099 /****************************************************************************
3102 * Delete a directory.
3105 void WCMD_remove_dir (WCHAR
*args
) {
3108 int argsProcessed
= 0;
3110 static const WCHAR parmS
[] = {'/','S','\0'};
3111 static const WCHAR parmQ
[] = {'/','Q','\0'};
3113 /* Loop through all args */
3115 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
3116 if (argN
&& argN
[0] != '/') {
3117 WINE_TRACE("rd: Processing arg %s (quals:%s)\n", wine_dbgstr_w(thisArg
),
3118 wine_dbgstr_w(quals
));
3121 /* If subdirectory search not supplied, just try to remove
3122 and report error if it fails (eg if it contains a file) */
3123 if (wcsstr (quals
, parmS
) == NULL
) {
3124 if (!RemoveDirectoryW(thisArg
)) WCMD_print_error ();
3126 /* Otherwise use ShFileOp to recursively remove a directory */
3129 SHFILEOPSTRUCTW lpDir
;
3132 if (wcsstr (quals
, parmQ
) == NULL
) {
3134 WCHAR question
[MAXSTRING
];
3135 static const WCHAR fmt
[] = {'%','s',' ','\0'};
3137 /* Ask for confirmation */
3138 wsprintfW(question
, fmt
, thisArg
);
3139 ok
= WCMD_ask_confirm(question
, TRUE
, NULL
);
3141 /* Abort if answer is 'N' */
3148 lpDir
.pFrom
= thisArg
;
3149 lpDir
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
| FOF_NOERRORUI
;
3150 lpDir
.wFunc
= FO_DELETE
;
3152 /* SHFileOperationW needs file list with a double null termination */
3153 thisArg
[lstrlenW(thisArg
) + 1] = 0x00;
3155 if (SHFileOperationW(&lpDir
)) WCMD_print_error ();
3160 /* Handle no valid args */
3161 if (argsProcessed
== 0) {
3162 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
3168 /****************************************************************************
3174 void WCMD_rename (void)
3178 WIN32_FIND_DATAW fd
;
3179 WCHAR input
[MAX_PATH
];
3180 WCHAR
*dotDst
= NULL
;
3182 WCHAR dir
[MAX_PATH
];
3183 WCHAR fname
[MAX_PATH
];
3184 WCHAR ext
[MAX_PATH
];
3188 /* Must be at least two args */
3189 if (param1
[0] == 0x00 || param2
[0] == 0x00) {
3190 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
3195 /* Destination cannot contain a drive letter or directory separator */
3196 if ((wcschr(param2
,':') != NULL
) || (wcschr(param2
,'\\') != NULL
)) {
3197 SetLastError(ERROR_INVALID_PARAMETER
);
3203 /* Convert partial path to full path */
3204 GetFullPathNameW(param1
, ARRAY_SIZE(input
), input
, NULL
);
3205 WINE_TRACE("Rename from '%s'('%s') to '%s'\n", wine_dbgstr_w(input
),
3206 wine_dbgstr_w(param1
), wine_dbgstr_w(param2
));
3207 dotDst
= wcschr(param2
, '.');
3209 /* Split into components */
3210 _wsplitpath(input
, drive
, dir
, fname
, ext
);
3212 hff
= FindFirstFileW(input
, &fd
);
3213 if (hff
== INVALID_HANDLE_VALUE
)
3217 WCHAR dest
[MAX_PATH
];
3218 WCHAR src
[MAX_PATH
];
3219 WCHAR
*dotSrc
= NULL
;
3222 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd
.cFileName
));
3224 /* FIXME: If dest name or extension is *, replace with filename/ext
3225 part otherwise use supplied name. This supports:
3227 ren jim.* fred.* etc
3228 However, windows has a more complex algorithm supporting eg
3229 ?'s and *'s mid name */
3230 dotSrc
= wcschr(fd
.cFileName
, '.');
3232 /* Build src & dest name */
3233 lstrcpyW(src
, drive
);
3235 lstrcpyW(dest
, src
);
3236 dirLen
= lstrlenW(src
);
3237 lstrcatW(src
, fd
.cFileName
);
3240 if (param2
[0] == '*') {
3241 lstrcatW(dest
, fd
.cFileName
);
3242 if (dotSrc
) dest
[dirLen
+ (dotSrc
- fd
.cFileName
)] = 0x00;
3244 lstrcatW(dest
, param2
);
3245 if (dotDst
) dest
[dirLen
+ (dotDst
- param2
)] = 0x00;
3248 /* Build Extension */
3249 if (dotDst
&& (*(dotDst
+1)=='*')) {
3250 if (dotSrc
) lstrcatW(dest
, dotSrc
);
3251 } else if (dotDst
) {
3252 lstrcatW(dest
, dotDst
);
3255 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src
));
3256 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest
));
3258 status
= MoveFileW(src
, dest
);
3261 WCMD_print_error ();
3264 } while (FindNextFileW(hff
, &fd
) != 0);
3269 /*****************************************************************************
3272 * Make a copy of the environment.
3274 static WCHAR
*WCMD_dupenv( const WCHAR
*env
)
3284 len
+= (lstrlenW(&env
[len
]) + 1);
3286 env_copy
= LocalAlloc (LMEM_FIXED
, (len
+1) * sizeof (WCHAR
) );
3289 WINE_ERR("out of memory\n");
3292 memcpy (env_copy
, env
, len
*sizeof (WCHAR
));
3298 /*****************************************************************************
3301 * setlocal pushes the environment onto a stack
3302 * Save the environment as unicode so we don't screw anything up.
3304 void WCMD_setlocal (const WCHAR
*s
) {
3306 struct env_stack
*env_copy
;
3307 WCHAR cwd
[MAX_PATH
];
3309 static const WCHAR ondelayW
[] = {'E','N','A','B','L','E','D','E','L','A',
3310 'Y','E','D','E','X','P','A','N','S','I',
3312 static const WCHAR offdelayW
[] = {'D','I','S','A','B','L','E','D','E','L',
3313 'A','Y','E','D','E','X','P','A','N','S',
3316 /* setlocal does nothing outside of batch programs */
3317 if (!context
) return;
3319 /* DISABLEEXTENSIONS ignored */
3321 /* ENABLEDELAYEDEXPANSION / DISABLEDELAYEDEXPANSION could be parm1 or parm2
3322 (if both ENABLEEXTENSIONS and ENABLEDELAYEDEXPANSION supplied for example) */
3323 if (!wcsicmp(param1
, ondelayW
) || !wcsicmp(param2
, ondelayW
)) {
3325 } else if (!wcsicmp(param1
, offdelayW
) || !wcsicmp(param2
, offdelayW
)) {
3328 newdelay
= delayedsubst
;
3330 WINE_TRACE("Setting delayed expansion to %d\n", newdelay
);
3332 env_copy
= LocalAlloc (LMEM_FIXED
, sizeof (struct env_stack
));
3335 WINE_ERR ("out of memory\n");
3339 env
= GetEnvironmentStringsW ();
3340 env_copy
->strings
= WCMD_dupenv (env
);
3341 if (env_copy
->strings
)
3343 env_copy
->batchhandle
= context
->h
;
3344 env_copy
->next
= saved_environment
;
3345 env_copy
->delayedsubst
= delayedsubst
;
3346 delayedsubst
= newdelay
;
3347 saved_environment
= env_copy
;
3349 /* Save the current drive letter */
3350 GetCurrentDirectoryW(MAX_PATH
, cwd
);
3351 env_copy
->u
.cwd
= cwd
[0];
3354 LocalFree (env_copy
);
3356 FreeEnvironmentStringsW (env
);
3360 /*****************************************************************************
3363 * endlocal pops the environment off a stack
3364 * Note: When searching for '=', search from WCHAR position 1, to handle
3365 * special internal environment variables =C:, =D: etc
3367 void WCMD_endlocal (void) {
3368 WCHAR
*env
, *old
, *p
;
3369 struct env_stack
*temp
;
3372 /* setlocal does nothing outside of batch programs */
3373 if (!context
) return;
3375 /* setlocal needs a saved environment from within the same context (batch
3376 program) as it was saved in */
3377 if (!saved_environment
|| saved_environment
->batchhandle
!= context
->h
)
3380 /* pop the old environment from the stack */
3381 temp
= saved_environment
;
3382 saved_environment
= temp
->next
;
3384 /* delete the current environment, totally */
3385 env
= GetEnvironmentStringsW ();
3386 old
= WCMD_dupenv (env
);
3389 n
= lstrlenW(&old
[len
]) + 1;
3390 p
= wcschr(&old
[len
] + 1, '=');
3394 SetEnvironmentVariableW (&old
[len
], NULL
);
3399 FreeEnvironmentStringsW (env
);
3401 /* restore old environment */
3402 env
= temp
->strings
;
3404 delayedsubst
= temp
->delayedsubst
;
3405 WINE_TRACE("Delayed expansion now %d\n", delayedsubst
);
3407 n
= lstrlenW(&env
[len
]) + 1;
3408 p
= wcschr(&env
[len
] + 1, '=');
3412 SetEnvironmentVariableW (&env
[len
], p
);
3417 /* Restore current drive letter */
3418 if (IsCharAlphaW(temp
->u
.cwd
)) {
3420 WCHAR cwd
[MAX_PATH
];
3421 static const WCHAR fmt
[] = {'=','%','c',':','\0'};
3423 wsprintfW(envvar
, fmt
, temp
->u
.cwd
);
3424 if (GetEnvironmentVariableW(envvar
, cwd
, MAX_PATH
)) {
3425 WINE_TRACE("Resetting cwd to %s\n", wine_dbgstr_w(cwd
));
3426 SetCurrentDirectoryW(cwd
);
3434 /*****************************************************************************
3435 * WCMD_setshow_default
3437 * Set/Show the current default directory
3440 void WCMD_setshow_default (const WCHAR
*args
) {
3446 WIN32_FIND_DATAW fd
;
3448 static const WCHAR parmD
[] = {'/','D','\0'};
3450 WINE_TRACE("Request change to directory '%s'\n", wine_dbgstr_w(args
));
3452 /* Skip /D and trailing whitespace if on the front of the command line */
3453 if (lstrlenW(args
) >= 2 &&
3454 CompareStringW(LOCALE_USER_DEFAULT
,
3455 NORM_IGNORECASE
| SORT_STRINGSORT
,
3456 args
, 2, parmD
, -1) == CSTR_EQUAL
) {
3458 while (*args
&& (*args
==' ' || *args
=='\t'))
3462 GetCurrentDirectoryW(ARRAY_SIZE(cwd
), cwd
);
3465 lstrcatW (cwd
, newlineW
);
3466 WCMD_output_asis (cwd
);
3469 /* Remove any double quotes, which may be in the
3470 middle, eg. cd "C:\Program Files"\Microsoft is ok */
3473 if (*args
!= '"') *pos
++ = *args
;
3476 while (pos
> string
&& (*(pos
-1) == ' ' || *(pos
-1) == '\t'))
3480 /* Search for appropriate directory */
3481 WINE_TRACE("Looking for directory '%s'\n", wine_dbgstr_w(string
));
3482 hff
= FindFirstFileW(string
, &fd
);
3483 if (hff
!= INVALID_HANDLE_VALUE
) {
3485 if (fd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) {
3486 WCHAR fpath
[MAX_PATH
];
3488 WCHAR dir
[MAX_PATH
];
3489 WCHAR fname
[MAX_PATH
];
3490 WCHAR ext
[MAX_PATH
];
3491 static const WCHAR fmt
[] = {'%','s','%','s','%','s','\0'};
3493 /* Convert path into actual directory spec */
3494 GetFullPathNameW(string
, ARRAY_SIZE(fpath
), fpath
, NULL
);
3495 _wsplitpath(fpath
, drive
, dir
, fname
, ext
);
3498 wsprintfW(string
, fmt
, drive
, dir
, fd
.cFileName
);
3501 } while (FindNextFileW(hff
, &fd
) != 0);
3505 /* Change to that directory */
3506 WINE_TRACE("Really changing to directory '%s'\n", wine_dbgstr_w(string
));
3508 status
= SetCurrentDirectoryW(string
);
3511 WCMD_print_error ();
3515 /* Save away the actual new directory, to store as current location */
3516 GetCurrentDirectoryW(ARRAY_SIZE(string
), string
);
3518 /* Restore old directory if drive letter would change, and
3519 CD x:\directory /D (or pushd c:\directory) not supplied */
3520 if ((wcsstr(quals
, parmD
) == NULL
) &&
3521 (param1
[1] == ':') && (toupper(param1
[0]) != toupper(cwd
[0]))) {
3522 SetCurrentDirectoryW(cwd
);
3526 /* Set special =C: type environment variable, for drive letter of
3527 change of directory, even if path was restored due to missing
3528 /D (allows changing drive letter when not resident on that
3530 if ((string
[1] == ':') && IsCharAlphaW(string
[0])) {
3532 lstrcpyW(env
, equalW
);
3533 memcpy(env
+1, string
, 2 * sizeof(WCHAR
));
3535 WINE_TRACE("Setting '%s' to '%s'\n", wine_dbgstr_w(env
), wine_dbgstr_w(string
));
3536 SetEnvironmentVariableW(env
, string
);
3543 /****************************************************************************
3546 * Set/Show the system date
3547 * FIXME: Can't change date yet
3550 void WCMD_setshow_date (void) {
3552 WCHAR curdate
[64], buffer
[64];
3554 static const WCHAR parmT
[] = {'/','T','\0'};
3557 if (GetDateFormatW(LOCALE_USER_DEFAULT
, 0, NULL
, NULL
, curdate
, ARRAY_SIZE(curdate
))) {
3558 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTDATE
), curdate
);
3559 if (wcsstr (quals
, parmT
) == NULL
) {
3560 WCMD_output (WCMD_LoadMessage(WCMD_NEWDATE
));
3561 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), buffer
, ARRAY_SIZE(buffer
), &count
);
3563 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
3567 else WCMD_print_error ();
3570 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
3574 /****************************************************************************
3576 * Note: Native displays 'fred' before 'fred ', so need to only compare up to
3579 static int __cdecl
WCMD_compare( const void *a
, const void *b
)
3582 const WCHAR
* const *str_a
= a
, * const *str_b
= b
;
3583 r
= CompareStringW( LOCALE_USER_DEFAULT
, NORM_IGNORECASE
| SORT_STRINGSORT
,
3584 *str_a
, wcscspn(*str_a
, equalW
), *str_b
, wcscspn(*str_b
, equalW
) );
3585 if( r
== CSTR_LESS_THAN
) return -1;
3586 if( r
== CSTR_GREATER_THAN
) return 1;
3590 /****************************************************************************
3591 * WCMD_setshow_sortenv
3593 * sort variables into order for display
3594 * Optionally only display those who start with a stub
3595 * returns the count displayed
3597 static int WCMD_setshow_sortenv(const WCHAR
*s
, const WCHAR
*stub
)
3599 UINT count
=0, len
=0, i
, displayedcount
=0, stublen
=0;
3602 if (stub
) stublen
= lstrlenW(stub
);
3604 /* count the number of strings, and the total length */
3606 len
+= (lstrlenW(&s
[len
]) + 1);
3610 /* add the strings to an array */
3611 str
= LocalAlloc (LMEM_FIXED
| LMEM_ZEROINIT
, count
* sizeof (WCHAR
*) );
3615 for( i
=1; i
<count
; i
++ )
3616 str
[i
] = str
[i
-1] + lstrlenW(str
[i
-1]) + 1;
3618 /* sort the array */
3619 qsort( str
, count
, sizeof (WCHAR
*), WCMD_compare
);
3622 for( i
=0; i
<count
; i
++ ) {
3623 if (!stub
|| CompareStringW(LOCALE_USER_DEFAULT
,
3624 NORM_IGNORECASE
| SORT_STRINGSORT
,
3625 str
[i
], stublen
, stub
, -1) == CSTR_EQUAL
) {
3626 /* Don't display special internal variables */
3627 if (str
[i
][0] != '=') {
3628 WCMD_output_asis(str
[i
]);
3629 WCMD_output_asis(newlineW
);
3636 return displayedcount
;
3639 /****************************************************************************
3640 * WCMD_getprecedence
3641 * Return the precedence of a particular operator
3643 static int WCMD_getprecedence(const WCHAR in
)
3684 /****************************************************************************
3686 * Push either a number or name (environment variable) onto the supplied
3689 static void WCMD_pushnumber(WCHAR
*var
, int num
, VARSTACK
**varstack
) {
3690 VARSTACK
*thisstack
= heap_xalloc(sizeof(VARSTACK
));
3691 thisstack
->isnum
= (var
== NULL
);
3693 thisstack
->variable
= var
;
3694 WINE_TRACE("Pushed variable %s\n", wine_dbgstr_w(var
));
3696 thisstack
->value
= num
;
3697 WINE_TRACE("Pushed number %d\n", num
);
3699 thisstack
->next
= *varstack
;
3700 *varstack
= thisstack
;
3703 /****************************************************************************
3705 * Returns the value of the top number or environment variable on the stack
3706 * and leaves the item on the stack.
3708 static int WCMD_peeknumber(VARSTACK
**varstack
) {
3713 thisvar
= *varstack
;
3714 if (!thisvar
->isnum
) {
3715 WCHAR tmpstr
[MAXSTRING
];
3716 if (GetEnvironmentVariableW(thisvar
->variable
, tmpstr
, MAXSTRING
)) {
3717 result
= wcstol(tmpstr
,NULL
,0);
3719 WINE_TRACE("Envvar %s converted to %d\n", wine_dbgstr_w(thisvar
->variable
), result
);
3721 result
= thisvar
->value
;
3724 WINE_TRACE("Peeked number %d\n", result
);
3728 /****************************************************************************
3730 * Returns the value of the top number or environment variable on the stack
3731 * and removes the item from the stack.
3733 static int WCMD_popnumber(VARSTACK
**varstack
) {
3738 thisvar
= *varstack
;
3739 result
= WCMD_peeknumber(varstack
);
3740 if (!thisvar
->isnum
) heap_free(thisvar
->variable
);
3741 *varstack
= thisvar
->next
;
3744 WINE_TRACE("Popped number %d\n", result
);
3748 /****************************************************************************
3750 * Push an operator onto the supplied stack
3752 static void WCMD_pushoperator(WCHAR op
, int precedence
, OPSTACK
**opstack
) {
3753 OPSTACK
*thisstack
= heap_xalloc(sizeof(OPSTACK
));
3754 thisstack
->precedence
= precedence
;
3756 thisstack
->next
= *opstack
;
3757 WINE_TRACE("Pushed operator %c\n", op
);
3758 *opstack
= thisstack
;
3761 /****************************************************************************
3763 * Returns the operator from the top of the stack and removes the item from
3766 static WCHAR
WCMD_popoperator(OPSTACK
**opstack
) {
3772 result
= thisop
->op
;
3773 *opstack
= thisop
->next
;
3776 WINE_TRACE("Popped operator %c\n", result
);
3780 /****************************************************************************
3782 * Actions the top operator on the stack against the first and sometimes
3783 * second value on the variable stack, and pushes the result
3784 * Returns non-zero on error.
3786 static int WCMD_reduce(OPSTACK
**opstack
, VARSTACK
**varstack
) {
3791 if (!*opstack
|| !*varstack
) {
3792 WINE_TRACE("No operators for the reduce\n");
3793 return WCMD_NOOPERATOR
;
3796 /* Remove the top operator */
3797 thisop
= WCMD_popoperator(opstack
);
3798 WINE_TRACE("Reducing the stacks - processing operator %c\n", thisop
);
3800 /* One variable operators */
3801 var1
= WCMD_popnumber(varstack
);
3803 case '!': WCMD_pushnumber(NULL
, !var1
, varstack
);
3805 case '~': WCMD_pushnumber(NULL
, ~var1
, varstack
);
3807 case OP_POSITIVE
: WCMD_pushnumber(NULL
, var1
, varstack
);
3809 case OP_NEGATIVE
: WCMD_pushnumber(NULL
, -var1
, varstack
);
3813 /* Two variable operators */
3815 WINE_TRACE("No operands left for the reduce?\n");
3816 return WCMD_NOOPERAND
;
3823 break; /* Handled above */
3824 case '*': var2
= WCMD_popnumber(varstack
);
3825 WCMD_pushnumber(NULL
, var2
*var1
, varstack
);
3827 case '/': var2
= WCMD_popnumber(varstack
);
3828 if (var1
== 0) return WCMD_DIVIDEBYZERO
;
3829 WCMD_pushnumber(NULL
, var2
/var1
, varstack
);
3831 case '+': var2
= WCMD_popnumber(varstack
);
3832 WCMD_pushnumber(NULL
, var2
+var1
, varstack
);
3834 case '-': var2
= WCMD_popnumber(varstack
);
3835 WCMD_pushnumber(NULL
, var2
-var1
, varstack
);
3837 case '&': var2
= WCMD_popnumber(varstack
);
3838 WCMD_pushnumber(NULL
, var2
&var1
, varstack
);
3840 case '%': var2
= WCMD_popnumber(varstack
);
3841 if (var1
== 0) return WCMD_DIVIDEBYZERO
;
3842 WCMD_pushnumber(NULL
, var2
%var1
, varstack
);
3844 case '^': var2
= WCMD_popnumber(varstack
);
3845 WCMD_pushnumber(NULL
, var2
^var1
, varstack
);
3847 case '<': var2
= WCMD_popnumber(varstack
);
3848 /* Shift left has to be a positive number, 0-31 otherwise 0 is returned,
3849 which differs from the compiler (for example gcc) so being explicit. */
3850 if (var1
< 0 || var1
>= (8 * sizeof(INT
))) {
3851 WCMD_pushnumber(NULL
, 0, varstack
);
3853 WCMD_pushnumber(NULL
, var2
<<var1
, varstack
);
3856 case '>': var2
= WCMD_popnumber(varstack
);
3857 WCMD_pushnumber(NULL
, var2
>>var1
, varstack
);
3859 case '|': var2
= WCMD_popnumber(varstack
);
3860 WCMD_pushnumber(NULL
, var2
|var1
, varstack
);
3876 /* The left of an equals must be one variable */
3877 if (!(*varstack
) || (*varstack
)->isnum
) {
3878 return WCMD_NOOPERAND
;
3881 /* Make the number stack grow by inserting the value of the variable */
3882 var2
= WCMD_peeknumber(varstack
);
3883 WCMD_pushnumber(NULL
, var2
, varstack
);
3884 WCMD_pushnumber(NULL
, var1
, varstack
);
3886 /* Make the operand stack grow by pushing the assign operator plus the
3887 operator to perform */
3888 while (calcassignments
[i
].op
!= ' ' &&
3889 calcassignments
[i
].calculatedop
!= thisop
) {
3892 if (calcassignments
[i
].calculatedop
== ' ') {
3893 WINE_ERR("Unexpected operator %c\n", thisop
);
3894 return WCMD_NOOPERATOR
;
3896 WCMD_pushoperator('=', WCMD_getprecedence('='), opstack
);
3897 WCMD_pushoperator(calcassignments
[i
].op
,
3898 WCMD_getprecedence(calcassignments
[i
].op
), opstack
);
3904 WCHAR intFormat
[] = {'%','d','\0'};
3905 WCHAR result
[MAXSTRING
];
3907 /* Build the result, then push it onto the stack */
3908 swprintf(result
, ARRAY_SIZE(result
), intFormat
, var1
);
3909 WINE_TRACE("Assigning %s a value %s\n", wine_dbgstr_w((*varstack
)->variable
),
3910 wine_dbgstr_w(result
));
3911 SetEnvironmentVariableW((*varstack
)->variable
, result
);
3912 var2
= WCMD_popnumber(varstack
);
3913 WCMD_pushnumber(NULL
, var1
, varstack
);
3917 default: WINE_ERR("Unrecognized operator %c\n", thisop
);
3924 /****************************************************************************
3925 * WCMD_handleExpression
3926 * Handles an expression provided to set /a - If it finds brackets, it uses
3927 * recursion to process the parts in brackets.
3929 static int WCMD_handleExpression(WCHAR
**expr
, int *ret
, int depth
)
3931 static const WCHAR mathDelims
[] = {' ','\t','(',')','!','~','-','*','/','%',
3932 '+','<','>','&','^','|','=',',','\0' };
3935 BOOL lastwasnumber
= FALSE
; /* FALSE makes a minus at the start of the expression easier to handle */
3936 OPSTACK
*opstackhead
= NULL
;
3937 VARSTACK
*varstackhead
= NULL
;
3938 WCHAR foundhalf
= 0;
3941 WINE_TRACE("Handling expression '%s'\n", wine_dbgstr_w(*expr
));
3944 /* Iterate through until whole expression is processed */
3945 while (pos
&& *pos
) {
3948 /* Skip whitespace to get to the next character to process*/
3949 while (*pos
&& (*pos
==' ' || *pos
=='\t')) pos
++;
3950 if (!*pos
) goto exprreturn
;
3952 /* If we have found anything other than an operator then it's a number/variable */
3953 if (wcschr(mathDelims
, *pos
) == NULL
) {
3954 WCHAR
*parmstart
, *parm
, *dupparm
;
3957 /* Cannot have an expression with var/number twice, without an operator
3958 in-between, nor or number following a half constructed << or >> operator */
3959 if (lastwasnumber
|| foundhalf
) {
3960 rc
= WCMD_NOOPERATOR
;
3961 goto exprerrorreturn
;
3963 lastwasnumber
= TRUE
;
3965 if (iswdigit(*pos
)) {
3966 /* For a number - just push it onto the stack */
3967 int num
= wcstoul(pos
, &nextpos
, 0);
3968 WCMD_pushnumber(NULL
, num
, &varstackhead
);
3971 /* Verify the number was validly formed */
3972 if (*nextpos
&& (wcschr(mathDelims
, *nextpos
) == NULL
)) {
3973 rc
= WCMD_BADHEXOCT
;
3974 goto exprerrorreturn
;
3978 /* For a variable - just push it onto the stack */
3979 parm
= WCMD_parameter_with_delims(pos
, 0, &parmstart
, FALSE
, FALSE
, mathDelims
);
3980 dupparm
= heap_strdupW(parm
);
3981 WCMD_pushnumber(dupparm
, 0, &varstackhead
);
3982 pos
= parmstart
+ lstrlenW(dupparm
);
3987 /* We have found an operator. Some operators are one character, some two, and the minus
3988 and plus signs need special processing as they can be either operators or just influence
3989 the parameter which follows them */
3990 if (foundhalf
&& (*pos
!= foundhalf
)) {
3991 /* Badly constructed operator pair */
3992 rc
= WCMD_NOOPERATOR
;
3993 goto exprerrorreturn
;
3996 treatasnumber
= FALSE
; /* We are processing an operand */
3999 /* > and < are special as they are double character operators (and spaces can be between them!)
4000 If we see these for the first time, set a flag, and second time around we continue.
4001 Note these double character operators are stored as just one of the characters on the stack */
4003 case '<': if (!foundhalf
) {
4008 /* We have found the rest, so clear up the knowledge of the half completed part and
4009 drop through to normal operator processing */
4013 case '=': if (*pos
=='=') {
4014 /* = is special cased as if the last was an operator then we may have e.g. += or
4015 *= etc which we need to handle by replacing the operator that is on the stack
4016 with a calculated assignment equivalent */
4017 if (!lastwasnumber
&& opstackhead
) {
4019 while (calcassignments
[i
].op
!= ' ' && calcassignments
[i
].op
!= opstackhead
->op
) {
4022 if (calcassignments
[i
].op
== ' ') {
4023 rc
= WCMD_NOOPERAND
;
4024 goto exprerrorreturn
;
4026 /* Remove the operator on the stack, it will be replaced with a ?= equivalent
4027 when the general operator handling happens further down. */
4028 *pos
= calcassignments
[i
].calculatedop
;
4029 WCMD_popoperator(&opstackhead
);
4035 /* + and - are slightly special as they can be a numeric prefix, if they follow an operator
4036 so if they do, convert the +/- (arithmetic) to +/- (numeric prefix for positive/negative) */
4037 case '+': if (!lastwasnumber
&& *pos
=='+') *pos
= OP_POSITIVE
;
4039 case '-': if (!lastwasnumber
&& *pos
=='-') *pos
= OP_NEGATIVE
;
4042 /* Normal operators - push onto stack unless precedence means we have to calculate it now */
4043 case '!': /* drop through */
4044 case '~': /* drop through */
4045 case '/': /* drop through */
4046 case '%': /* drop through */
4047 case '&': /* drop through */
4048 case '^': /* drop through */
4049 case '*': /* drop through */
4051 /* General code for handling most of the operators - look at the
4052 precedence of the top item on the stack, and see if we need to
4053 action the stack before we push something else onto it. */
4055 int precedence
= WCMD_getprecedence(*pos
);
4056 WINE_TRACE("Found operator %c precedence %d (head is %d)\n", *pos
,
4057 precedence
, !opstackhead
?-1:opstackhead
->precedence
);
4059 /* In general, for things with the same precedence, reduce immediately
4060 except for assignments and unary operators which do not */
4061 while (!rc
&& opstackhead
&&
4062 ((opstackhead
->precedence
> precedence
) ||
4063 ((opstackhead
->precedence
== precedence
) &&
4064 (precedence
!= 1) && (precedence
!= 8)))) {
4065 rc
= WCMD_reduce(&opstackhead
, &varstackhead
);
4067 if (rc
) goto exprerrorreturn
;
4068 WCMD_pushoperator(*pos
, precedence
, &opstackhead
);
4073 /* comma means start a new expression, ie calculate what we have */
4076 int prevresult
= -1;
4077 WINE_TRACE("Found expression delimiter - reducing existing stacks\n");
4078 while (!rc
&& opstackhead
) {
4079 rc
= WCMD_reduce(&opstackhead
, &varstackhead
);
4081 if (rc
) goto exprerrorreturn
;
4082 /* If we have anything other than one number left, error
4083 otherwise throw the number away */
4084 if (!varstackhead
|| varstackhead
->next
) {
4085 rc
= WCMD_NOOPERATOR
;
4086 goto exprerrorreturn
;
4088 prevresult
= WCMD_popnumber(&varstackhead
);
4089 WINE_TRACE("Expression resolved to %d\n", prevresult
);
4090 heap_free(varstackhead
);
4091 varstackhead
= NULL
;
4096 /* Open bracket - use iteration to parse the inner expression, then continue */
4100 rc
= WCMD_handleExpression(&pos
, &exprresult
, depth
+1);
4101 if (rc
) goto exprerrorreturn
;
4102 WCMD_pushnumber(NULL
, exprresult
, &varstackhead
);
4106 /* Close bracket - we have finished this depth, calculate and return */
4109 treatasnumber
= TRUE
; /* Things in brackets result in a number */
4112 goto exprerrorreturn
;
4118 WINE_ERR("Unrecognized operator %c\n", *pos
);
4121 lastwasnumber
= treatasnumber
;
4127 /* We need to reduce until we have a single number (or variable) on the
4128 stack and set the return value to that */
4129 while (!rc
&& opstackhead
) {
4130 rc
= WCMD_reduce(&opstackhead
, &varstackhead
);
4132 if (rc
) goto exprerrorreturn
;
4134 /* If we have anything other than one number left, error
4135 otherwise throw the number away */
4136 if (!varstackhead
|| varstackhead
->next
) {
4137 rc
= WCMD_NOOPERATOR
;
4138 goto exprerrorreturn
;
4141 /* Now get the number (and convert if it's just a variable name) */
4142 *ret
= WCMD_popnumber(&varstackhead
);
4145 /* Free all remaining memory */
4146 while (opstackhead
) WCMD_popoperator(&opstackhead
);
4147 while (varstackhead
) WCMD_popnumber(&varstackhead
);
4149 WINE_TRACE("Returning result %d, rc %d\n", *ret
, rc
);
4153 /****************************************************************************
4156 * Set/Show the environment variables
4159 void WCMD_setshow_env (WCHAR
*s
) {
4164 static const WCHAR parmP
[] = {'/','P','\0'};
4165 static const WCHAR parmA
[] = {'/','A','\0'};
4166 WCHAR string
[MAXSTRING
];
4168 if (param1
[0] == 0x00 && quals
[0] == 0x00) {
4169 env
= GetEnvironmentStringsW();
4170 WCMD_setshow_sortenv( env
, NULL
);
4174 /* See if /P supplied, and if so echo the prompt, and read in a reply */
4175 if (CompareStringW(LOCALE_USER_DEFAULT
,
4176 NORM_IGNORECASE
| SORT_STRINGSORT
,
4177 s
, 2, parmP
, -1) == CSTR_EQUAL
) {
4181 while (*s
&& (*s
==' ' || *s
=='\t')) s
++;
4182 /* set /P "var=value"jim ignores anything after the last quote */
4185 lastquote
= WCMD_strip_quotes(s
);
4186 if (lastquote
) *lastquote
= 0x00;
4187 WINE_TRACE("set: Stripped command line '%s'\n", wine_dbgstr_w(s
));
4190 /* If no parameter, or no '=' sign, return an error */
4191 if (!(*s
) || ((p
= wcschr (s
, '=')) == NULL
)) {
4192 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
4196 /* Output the prompt */
4198 if (*p
) WCMD_output_asis(p
);
4200 /* Read the reply */
4201 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), string
, ARRAY_SIZE(string
), &count
);
4203 string
[count
-1] = '\0'; /* ReadFile output is not null-terminated! */
4204 if (string
[count
-2] == '\r') string
[count
-2] = '\0'; /* Under Windoze we get CRLF! */
4205 WINE_TRACE("set /p: Setting var '%s' to '%s'\n", wine_dbgstr_w(s
),
4206 wine_dbgstr_w(string
));
4207 SetEnvironmentVariableW(s
, string
);
4210 /* See if /A supplied, and if so calculate the results of all the expressions */
4211 } else if (CompareStringW(LOCALE_USER_DEFAULT
,
4212 NORM_IGNORECASE
| SORT_STRINGSORT
,
4213 s
, 2, parmA
, -1) == CSTR_EQUAL
) {
4214 /* /A supplied, so evaluate expressions and set variables appropriately */
4215 /* Syntax is set /a var=1,var2=var+4 etc, and it echos back the result */
4216 /* of the final computation */
4222 /* Remove all quotes before doing any calculations */
4223 thisexpr
= heap_xalloc((lstrlenW(s
+2)+1) * sizeof(WCHAR
));
4227 if (*src
!= '"') *dst
++ = *src
;
4232 /* Now calculate the results of the expression */
4234 rc
= WCMD_handleExpression(&src
, &result
, 0);
4235 heap_free(thisexpr
);
4237 /* If parsing failed, issue the error message */
4239 WCMD_output_stderr(WCMD_LoadMessage(rc
));
4243 /* If we have no context (interactive or cmd.exe /c) print the final result */
4245 static const WCHAR fmt
[] = {'%','d','\0'};
4246 swprintf(string
, ARRAY_SIZE(string
), fmt
, result
);
4247 WCMD_output_asis(string
);
4253 /* set "var=value"jim ignores anything after the last quote */
4256 lastquote
= WCMD_strip_quotes(s
);
4257 if (lastquote
) *lastquote
= 0x00;
4258 WINE_TRACE("set: Stripped command line '%s'\n", wine_dbgstr_w(s
));
4261 p
= wcschr (s
, '=');
4263 env
= GetEnvironmentStringsW();
4264 if (WCMD_setshow_sortenv( env
, s
) == 0) {
4265 WCMD_output_stderr(WCMD_LoadMessage(WCMD_MISSINGENV
), s
);
4273 WINE_TRACE("set: Setting var '%s' to '%s'\n", wine_dbgstr_w(s
),
4275 status
= SetEnvironmentVariableW(s
, p
);
4276 gle
= GetLastError();
4277 if ((!status
) & (gle
== ERROR_ENVVAR_NOT_FOUND
)) {
4279 } else if (!status
) WCMD_print_error();
4280 else errorlevel
= 0;
4284 /****************************************************************************
4287 * Set/Show the path environment variable
4290 void WCMD_setshow_path (const WCHAR
*args
) {
4294 static const WCHAR pathW
[] = {'P','A','T','H','\0'};
4295 static const WCHAR pathEqW
[] = {'P','A','T','H','=','\0'};
4297 if (!*param1
&& !*param2
) {
4298 status
= GetEnvironmentVariableW(pathW
, string
, ARRAY_SIZE(string
));
4300 WCMD_output_asis ( pathEqW
);
4301 WCMD_output_asis ( string
);
4302 WCMD_output_asis ( newlineW
);
4305 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOPATH
));
4309 if (*args
== '=') args
++; /* Skip leading '=' */
4310 status
= SetEnvironmentVariableW(pathW
, args
);
4311 if (!status
) WCMD_print_error();
4315 /****************************************************************************
4316 * WCMD_setshow_prompt
4318 * Set or show the command prompt.
4321 void WCMD_setshow_prompt (void) {
4324 static const WCHAR promptW
[] = {'P','R','O','M','P','T','\0'};
4327 SetEnvironmentVariableW(promptW
, NULL
);
4331 while ((*s
== '=') || (*s
== ' ') || (*s
== '\t')) s
++;
4333 SetEnvironmentVariableW(promptW
, NULL
);
4335 else SetEnvironmentVariableW(promptW
, s
);
4339 /****************************************************************************
4342 * Set/Show the system time
4343 * FIXME: Can't change time yet
4346 void WCMD_setshow_time (void) {
4348 WCHAR curtime
[64], buffer
[64];
4351 static const WCHAR parmT
[] = {'/','T','\0'};
4355 if (GetTimeFormatW(LOCALE_USER_DEFAULT
, 0, &st
, NULL
, curtime
, ARRAY_SIZE(curtime
))) {
4356 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTTIME
), curtime
);
4357 if (wcsstr (quals
, parmT
) == NULL
) {
4358 WCMD_output (WCMD_LoadMessage(WCMD_NEWTIME
));
4359 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), buffer
, ARRAY_SIZE(buffer
), &count
);
4361 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
4365 else WCMD_print_error ();
4368 WCMD_output_stderr (WCMD_LoadMessage(WCMD_NYI
));
4372 /****************************************************************************
4375 * Shift batch parameters.
4376 * Optional /n says where to start shifting (n=0-8)
4379 void WCMD_shift (const WCHAR
*args
) {
4382 if (context
!= NULL
) {
4383 WCHAR
*pos
= wcschr(args
, '/');
4388 } else if (*(pos
+1)>='0' && *(pos
+1)<='8') {
4389 start
= (*(pos
+1) - '0');
4391 SetLastError(ERROR_INVALID_PARAMETER
);
4396 WINE_TRACE("Shifting variables, starting at %d\n", start
);
4397 for (i
=start
;i
<=8;i
++) {
4398 context
-> shift_count
[i
] = context
-> shift_count
[i
+1] + 1;
4400 context
-> shift_count
[9] = context
-> shift_count
[9] + 1;
4405 /****************************************************************************
4408 void WCMD_start(WCHAR
*args
)
4410 static const WCHAR exeW
[] = {'\\','c','o','m','m','a','n','d',
4411 '\\','s','t','a','r','t','.','e','x','e',0};
4412 static const WCHAR startDelims
[] = { ' ', '\t', '/', '\0' };
4413 static const WCHAR prefixQuote
[] = {'"','\\','"','\0'};
4414 static const WCHAR postfixQuote
[] = {'\\','"','"','\0'};
4417 WCHAR file
[MAX_PATH
];
4418 WCHAR
*cmdline
, *cmdline_params
;
4420 PROCESS_INFORMATION pi
;
4422 GetWindowsDirectoryW( file
, MAX_PATH
);
4423 lstrcatW( file
, exeW
);
4424 cmdline
= heap_xalloc( (lstrlenW(file
) + lstrlenW(args
) + 8) * sizeof(WCHAR
) );
4425 lstrcpyW( cmdline
, file
);
4426 lstrcatW( cmdline
, spaceW
);
4427 cmdline_params
= cmdline
+ lstrlenW(cmdline
);
4429 /* The start built-in has some special command-line parsing properties
4430 * which will be outlined here.
4432 * both '\t' and ' ' are argument separators
4433 * '/' has a special double role as both separator and switch prefix, e.g.
4439 * are valid ways to pass multiple options to start. In the latter case
4440 * '/i' is not a part of the title but parsed as a switch.
4442 * However, '=', ';' and ',' are not separators:
4443 * > start "deus"=ex,machina
4445 * will in fact open a console titled 'deus=ex,machina'
4447 * The title argument parsing code is only interested in quotes themselves,
4448 * it does not respect escaping of any kind and all quotes are dropped
4449 * from the resulting title, therefore:
4451 * > start "\"" hello"/low
4453 * actually opens a console titled '\ hello' with low priorities.
4455 * To not break compatibility with wine programs relying on
4456 * wine's separate 'start.exe', this program's peculiar console
4457 * title parsing is actually implemented in 'cmd.exe' which is the
4458 * application native Windows programs will use to invoke 'start'.
4460 * WCMD_parameter_with_delims will take care of everything for us.
4463 for (argno
=0; ; argno
++) {
4464 WCHAR
*thisArg
, *argN
;
4467 thisArg
= WCMD_parameter_with_delims(args
, argno
, &argN
, FALSE
, FALSE
, startDelims
);
4469 /* No more parameters */
4473 /* Found the title */
4474 if (argN
[0] == '"') {
4475 TRACE("detected console title: %s\n", wine_dbgstr_w(thisArg
));
4478 /* Copy all of the cmdline processed */
4479 memcpy(cmdline_params
, args
, sizeof(WCHAR
) * (argN
- args
));
4480 cmdline_params
[argN
- args
] = '\0';
4482 /* Add quoted title */
4483 lstrcatW(cmdline_params
, prefixQuote
);
4484 lstrcatW(cmdline_params
, thisArg
);
4485 lstrcatW(cmdline_params
, postfixQuote
);
4487 /* Concatenate remaining command-line */
4488 thisArg
= WCMD_parameter_with_delims(args
, argno
, &argN
, TRUE
, FALSE
, startDelims
);
4489 lstrcatW(cmdline_params
, argN
+ lstrlenW(thisArg
));
4494 /* Skipping a regular argument? */
4495 else if (argN
!= args
&& argN
[-1] == '/') {
4498 /* Not an argument nor the title, start of program arguments,
4499 * stop looking for title.
4505 /* build command-line if not built yet */
4507 lstrcatW( cmdline
, args
);
4510 memset( &st
, 0, sizeof(STARTUPINFOW
) );
4511 st
.cb
= sizeof(STARTUPINFOW
);
4513 if (CreateProcessW( file
, cmdline
, NULL
, NULL
, TRUE
, 0, NULL
, NULL
, &st
, &pi
))
4515 WaitForSingleObject( pi
.hProcess
, INFINITE
);
4516 GetExitCodeProcess( pi
.hProcess
, &errorlevel
);
4517 if (errorlevel
== STILL_ACTIVE
) errorlevel
= 0;
4518 CloseHandle(pi
.hProcess
);
4519 CloseHandle(pi
.hThread
);
4523 SetLastError(ERROR_FILE_NOT_FOUND
);
4524 WCMD_print_error ();
4530 /****************************************************************************
4533 * Set the console title
4535 void WCMD_title (const WCHAR
*args
) {
4536 SetConsoleTitleW(args
);
4539 /****************************************************************************
4542 * Copy a file to standard output.
4545 void WCMD_type (WCHAR
*args
) {
4549 BOOL writeHeaders
= FALSE
;
4551 if (param1
[0] == 0x00) {
4552 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
4556 if (param2
[0] != 0x00) writeHeaders
= TRUE
;
4558 /* Loop through all args */
4561 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
4569 WINE_TRACE("type: Processing arg '%s'\n", wine_dbgstr_w(thisArg
));
4570 h
= CreateFileW(thisArg
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
4571 FILE_ATTRIBUTE_NORMAL
, NULL
);
4572 if (h
== INVALID_HANDLE_VALUE
) {
4573 WCMD_print_error ();
4574 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), thisArg
);
4578 static const WCHAR fmt
[] = {'\n','%','1','\n','\n','\n','\0'};
4579 WCMD_output_stderr(fmt
, thisArg
);
4581 while (WCMD_ReadFile(h
, buffer
, ARRAY_SIZE(buffer
) - 1, &count
)) {
4582 if (count
== 0) break; /* ReadFile reports success on EOF! */
4584 WCMD_output_asis (buffer
);
4591 /****************************************************************************
4594 * Output either a file or stdin to screen in pages
4597 void WCMD_more (WCHAR
*args
) {
4602 WCHAR moreStrPage
[100];
4605 static const WCHAR moreStart
[] = {'-','-',' ','\0'};
4606 static const WCHAR moreFmt
[] = {'%','s',' ','-','-','\n','\0'};
4607 static const WCHAR moreFmt2
[] = {'%','s',' ','(','%','2','.','2','d','%','%',
4608 ')',' ','-','-','\n','\0'};
4609 static const WCHAR conInW
[] = {'C','O','N','I','N','$','\0'};
4611 /* Prefix the NLS more with '-- ', then load the text */
4613 lstrcpyW(moreStr
, moreStart
);
4614 LoadStringW(hinst
, WCMD_MORESTR
, &moreStr
[3], ARRAY_SIZE(moreStr
)-3);
4616 if (param1
[0] == 0x00) {
4618 /* Wine implements pipes via temporary files, and hence stdin is
4619 effectively reading from the file. This means the prompts for
4620 more are satisfied by the next line from the input (file). To
4621 avoid this, ensure stdin is to the console */
4622 HANDLE hstdin
= GetStdHandle(STD_INPUT_HANDLE
);
4623 HANDLE hConIn
= CreateFileW(conInW
, GENERIC_READ
| GENERIC_WRITE
,
4624 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
4625 FILE_ATTRIBUTE_NORMAL
, 0);
4626 WINE_TRACE("No parms - working probably in pipe mode\n");
4627 SetStdHandle(STD_INPUT_HANDLE
, hConIn
);
4629 /* Warning: No easy way of ending the stream (ctrl+z on windows) so
4630 once you get in this bit unless due to a pipe, it's going to end badly... */
4631 wsprintfW(moreStrPage
, moreFmt
, moreStr
);
4633 WCMD_enter_paged_mode(moreStrPage
);
4634 while (WCMD_ReadFile(hstdin
, buffer
, ARRAY_SIZE(buffer
)-1, &count
)) {
4635 if (count
== 0) break; /* ReadFile reports success on EOF! */
4637 WCMD_output_asis (buffer
);
4639 WCMD_leave_paged_mode();
4641 /* Restore stdin to what it was */
4642 SetStdHandle(STD_INPUT_HANDLE
, hstdin
);
4643 CloseHandle(hConIn
);
4647 BOOL needsPause
= FALSE
;
4649 /* Loop through all args */
4650 WINE_TRACE("Parms supplied - working through each file\n");
4651 WCMD_enter_paged_mode(moreStrPage
);
4654 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
4662 wsprintfW(moreStrPage
, moreFmt2
, moreStr
, 100);
4663 WCMD_leave_paged_mode();
4664 WCMD_output_asis(moreStrPage
);
4665 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), buffer
, ARRAY_SIZE(buffer
), &count
);
4666 WCMD_enter_paged_mode(moreStrPage
);
4670 WINE_TRACE("more: Processing arg '%s'\n", wine_dbgstr_w(thisArg
));
4671 h
= CreateFileW(thisArg
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
4672 FILE_ATTRIBUTE_NORMAL
, NULL
);
4673 if (h
== INVALID_HANDLE_VALUE
) {
4674 WCMD_print_error ();
4675 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), thisArg
);
4679 ULONG64 fileLen
= 0;
4680 WIN32_FILE_ATTRIBUTE_DATA fileInfo
;
4682 /* Get the file size */
4683 GetFileAttributesExW(thisArg
, GetFileExInfoStandard
, (void*)&fileInfo
);
4684 fileLen
= (((ULONG64
)fileInfo
.nFileSizeHigh
) << 32) + fileInfo
.nFileSizeLow
;
4687 while (WCMD_ReadFile(h
, buffer
, ARRAY_SIZE(buffer
)-1, &count
)) {
4688 if (count
== 0) break; /* ReadFile reports success on EOF! */
4692 /* Update % count (would be used in WCMD_output_asis as prompt) */
4693 wsprintfW(moreStrPage
, moreFmt2
, moreStr
, (int) min(99, (curPos
* 100)/fileLen
));
4695 WCMD_output_asis (buffer
);
4701 WCMD_leave_paged_mode();
4705 /****************************************************************************
4708 * Display verify flag.
4709 * FIXME: We don't actually do anything with the verify flag other than toggle
4713 void WCMD_verify (const WCHAR
*args
) {
4717 count
= lstrlenW(args
);
4719 if (verify_mode
) WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT
), onW
);
4720 else WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT
), offW
);
4723 if (lstrcmpiW(args
, onW
) == 0) {
4727 else if (lstrcmpiW(args
, offW
) == 0) {
4728 verify_mode
= FALSE
;
4731 else WCMD_output_stderr(WCMD_LoadMessage(WCMD_VERIFYERR
));
4734 /****************************************************************************
4737 * Display version info.
4740 void WCMD_version (void) {
4742 WCMD_output_asis (version_string
);
4746 /****************************************************************************
4749 * Display volume information (set_label = FALSE)
4750 * Additionally set volume label (set_label = TRUE)
4751 * Returns 1 on success, 0 otherwise
4754 int WCMD_volume(BOOL set_label
, const WCHAR
*path
)
4756 DWORD count
, serial
;
4757 WCHAR string
[MAX_PATH
], label
[MAX_PATH
], curdir
[MAX_PATH
];
4761 status
= GetCurrentDirectoryW(ARRAY_SIZE(curdir
), curdir
);
4763 WCMD_print_error ();
4766 status
= GetVolumeInformationW(NULL
, label
, ARRAY_SIZE(label
), &serial
, NULL
, NULL
, NULL
, 0);
4769 static const WCHAR fmt
[] = {'%','s','\\','\0'};
4770 if ((path
[1] != ':') || (lstrlenW(path
) != 2)) {
4771 WCMD_output_stderr(WCMD_LoadMessage(WCMD_SYNTAXERR
));
4774 wsprintfW (curdir
, fmt
, path
);
4775 status
= GetVolumeInformationW(curdir
, label
, ARRAY_SIZE(label
), &serial
, NULL
, NULL
, NULL
, 0);
4778 WCMD_print_error ();
4781 if (label
[0] != '\0') {
4782 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMELABEL
),
4786 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMENOLABEL
),
4789 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMESERIALNO
),
4790 HIWORD(serial
), LOWORD(serial
));
4792 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMEPROMPT
));
4793 WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE
), string
, ARRAY_SIZE(string
), &count
);
4795 string
[count
-1] = '\0'; /* ReadFile output is not null-terminated! */
4796 if (string
[count
-2] == '\r') string
[count
-2] = '\0'; /* Under Windoze we get CRLF! */
4799 if (!SetVolumeLabelW(curdir
, string
)) WCMD_print_error ();
4802 if (!SetVolumeLabelW(NULL
, string
)) WCMD_print_error ();
4808 /**************************************************************************
4811 * Exit either the process, or just this batch program
4815 void WCMD_exit (CMD_LIST
**cmdList
) {
4817 static const WCHAR parmB
[] = {'/','B','\0'};
4818 int rc
= wcstol(param1
, NULL
, 10); /* Note: wcstol of empty parameter is 0 */
4820 if (context
&& lstrcmpiW(quals
, parmB
) == 0) {
4822 context
-> skip_rest
= TRUE
;
4830 /*****************************************************************************
4833 * Lists or sets file associations (assoc = TRUE)
4834 * Lists or sets file types (assoc = FALSE)
4836 void WCMD_assoc (const WCHAR
*args
, BOOL assoc
) {
4839 DWORD accessOptions
= KEY_READ
;
4841 LONG rc
= ERROR_SUCCESS
;
4842 WCHAR keyValue
[MAXSTRING
];
4843 DWORD valueLen
= MAXSTRING
;
4845 static const WCHAR shOpCmdW
[] = {'\\','S','h','e','l','l','\\',
4846 'O','p','e','n','\\','C','o','m','m','a','n','d','\0'};
4848 /* See if parameter includes '=' */
4850 newValue
= wcschr(args
, '=');
4851 if (newValue
) accessOptions
|= KEY_WRITE
;
4853 /* Open a key to HKEY_CLASSES_ROOT for enumerating */
4854 if (RegOpenKeyExW(HKEY_CLASSES_ROOT
, nullW
, 0,
4855 accessOptions
, &key
) != ERROR_SUCCESS
) {
4856 WINE_FIXME("Unexpected failure opening HKCR key: %d\n", GetLastError());
4860 /* If no parameters then list all associations */
4861 if (*args
== 0x00) {
4864 /* Enumerate all the keys */
4865 while (rc
!= ERROR_NO_MORE_ITEMS
) {
4866 WCHAR keyName
[MAXSTRING
];
4869 /* Find the next value */
4870 nameLen
= MAXSTRING
;
4871 rc
= RegEnumKeyExW(key
, index
++, keyName
, &nameLen
, NULL
, NULL
, NULL
, NULL
);
4873 if (rc
== ERROR_SUCCESS
) {
4875 /* Only interested in extension ones if assoc, or others
4877 if ((keyName
[0] == '.' && assoc
) ||
4878 (!(keyName
[0] == '.') && (!assoc
)))
4880 WCHAR subkey
[MAXSTRING
];
4881 lstrcpyW(subkey
, keyName
);
4882 if (!assoc
) lstrcatW(subkey
, shOpCmdW
);
4884 if (RegOpenKeyExW(key
, subkey
, 0, accessOptions
, &readKey
) == ERROR_SUCCESS
) {
4886 valueLen
= ARRAY_SIZE(keyValue
);
4887 rc
= RegQueryValueExW(readKey
, NULL
, NULL
, NULL
, (LPBYTE
)keyValue
, &valueLen
);
4888 WCMD_output_asis(keyName
);
4889 WCMD_output_asis(equalW
);
4890 /* If no default value found, leave line empty after '=' */
4891 if (rc
== ERROR_SUCCESS
) {
4892 WCMD_output_asis(keyValue
);
4894 WCMD_output_asis(newlineW
);
4895 RegCloseKey(readKey
);
4903 /* Parameter supplied - if no '=' on command line, it's a query */
4904 if (newValue
== NULL
) {
4906 WCHAR subkey
[MAXSTRING
];
4908 /* Query terminates the parameter at the first space */
4909 lstrcpyW(keyValue
, args
);
4910 space
= wcschr(keyValue
, ' ');
4911 if (space
) *space
=0x00;
4913 /* Set up key name */
4914 lstrcpyW(subkey
, keyValue
);
4915 if (!assoc
) lstrcatW(subkey
, shOpCmdW
);
4917 if (RegOpenKeyExW(key
, subkey
, 0, accessOptions
, &readKey
) == ERROR_SUCCESS
) {
4919 rc
= RegQueryValueExW(readKey
, NULL
, NULL
, NULL
, (LPBYTE
)keyValue
, &valueLen
);
4920 WCMD_output_asis(args
);
4921 WCMD_output_asis(equalW
);
4922 /* If no default value found, leave line empty after '=' */
4923 if (rc
== ERROR_SUCCESS
) WCMD_output_asis(keyValue
);
4924 WCMD_output_asis(newlineW
);
4925 RegCloseKey(readKey
);
4928 WCHAR msgbuffer
[MAXSTRING
];
4930 /* Load the translated 'File association not found' */
4932 LoadStringW(hinst
, WCMD_NOASSOC
, msgbuffer
, ARRAY_SIZE(msgbuffer
));
4934 LoadStringW(hinst
, WCMD_NOFTYPE
, msgbuffer
, ARRAY_SIZE(msgbuffer
));
4936 WCMD_output_stderr(msgbuffer
, keyValue
);
4940 /* Not a query - it's a set or clear of a value */
4943 WCHAR subkey
[MAXSTRING
];
4945 /* Get pointer to new value */
4949 /* Set up key name */
4950 lstrcpyW(subkey
, args
);
4951 if (!assoc
) lstrcatW(subkey
, shOpCmdW
);
4953 /* If nothing after '=' then clear value - only valid for ASSOC */
4954 if (*newValue
== 0x00) {
4956 if (assoc
) rc
= RegDeleteKeyW(key
, args
);
4957 if (assoc
&& rc
== ERROR_SUCCESS
) {
4958 WINE_TRACE("HKCR Key '%s' deleted\n", wine_dbgstr_w(args
));
4960 } else if (assoc
&& rc
!= ERROR_FILE_NOT_FOUND
) {
4965 WCHAR msgbuffer
[MAXSTRING
];
4967 /* Load the translated 'File association not found' */
4969 LoadStringW(hinst
, WCMD_NOASSOC
, msgbuffer
, ARRAY_SIZE(msgbuffer
));
4971 LoadStringW(hinst
, WCMD_NOFTYPE
, msgbuffer
, ARRAY_SIZE(msgbuffer
));
4973 WCMD_output_stderr(msgbuffer
, args
);
4977 /* It really is a set value = contents */
4979 rc
= RegCreateKeyExW(key
, subkey
, 0, NULL
, REG_OPTION_NON_VOLATILE
,
4980 accessOptions
, NULL
, &readKey
, NULL
);
4981 if (rc
== ERROR_SUCCESS
) {
4982 rc
= RegSetValueExW(readKey
, NULL
, 0, REG_SZ
,
4984 sizeof(WCHAR
) * (lstrlenW(newValue
) + 1));
4985 RegCloseKey(readKey
);
4988 if (rc
!= ERROR_SUCCESS
) {
4992 WCMD_output_asis(args
);
4993 WCMD_output_asis(equalW
);
4994 WCMD_output_asis(newValue
);
4995 WCMD_output_asis(newlineW
);
5005 /****************************************************************************
5008 * Colors the terminal screen.
5011 void WCMD_color (void) {
5013 CONSOLE_SCREEN_BUFFER_INFO consoleInfo
;
5014 HANDLE hStdOut
= GetStdHandle(STD_OUTPUT_HANDLE
);
5016 if (param1
[0] != 0x00 && lstrlenW(param1
) > 2) {
5017 WCMD_output_stderr(WCMD_LoadMessage(WCMD_ARGERR
));
5021 if (GetConsoleScreenBufferInfo(hStdOut
, &consoleInfo
))
5027 screenSize
= consoleInfo
.dwSize
.X
* (consoleInfo
.dwSize
.Y
+ 1);
5032 /* Convert the color hex digits */
5033 if (param1
[0] == 0x00) {
5034 color
= defaultColor
;
5036 color
= wcstoul(param1
, NULL
, 16);
5039 /* Fail if fg == bg color */
5040 if (((color
& 0xF0) >> 4) == (color
& 0x0F)) {
5045 /* Set the current screen contents and ensure all future writes
5046 remain this color */
5047 FillConsoleOutputAttribute(hStdOut
, color
, screenSize
, topLeft
, &screenSize
);
5048 SetConsoleTextAttribute(hStdOut
, color
);
5052 /****************************************************************************
5056 void WCMD_mklink(WCHAR
*args
)
5061 BOOL junction
= FALSE
;
5064 WCHAR file1
[MAX_PATH
];
5065 WCHAR file2
[MAX_PATH
];
5066 static const WCHAR optD
[] = {'/', 'D', '\0'};
5067 static const WCHAR optH
[] = {'/', 'H', '\0'};
5068 static const WCHAR optJ
[] = {'/', 'J', '\0'};
5070 if (param1
[0] == 0x00 || param2
[0] == 0x00) {
5071 WCMD_output_stderr(WCMD_LoadMessage(WCMD_NOARG
));
5078 WCHAR
*thisArg
= WCMD_parameter (args
, argno
++, &argN
, FALSE
, FALSE
);
5082 WINE_TRACE("mklink: Processing arg '%s'\n", wine_dbgstr_w(thisArg
));
5084 if(lstrcmpiW(thisArg
, optD
) == 0)
5086 else if(lstrcmpiW(thisArg
, optH
) == 0)
5088 else if(lstrcmpiW(thisArg
, optJ
) == 0)
5092 lstrcpyW(file1
, thisArg
);
5094 lstrcpyW(file2
, thisArg
);
5099 ret
= CreateHardLinkW(file1
, file2
, NULL
);
5101 ret
= CreateSymbolicLinkW(file1
, file2
, isdir
);
5103 WINE_TRACE("Juction links currently not supported.\n");
5106 WCMD_output_stderr(WCMD_LoadMessage(WCMD_READFAIL
), file1
);