| blob | 3b2a192c82859044175b8c14f3292045991bcfd7 |
1 /*
2 * CMD - Wine-compatible command line interface - built-in functions.
3 *
4 * Copyright (C) 1999 D A Pickles
5 * Copyright (C) 2007 J Edmeades
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
22 /*
23 * FIXME:
24 * - No support for pipes, shell parameters
25 * - Lots of functionality missing from builtins
26 * - Messages etc need international support
27 */
29 #define WIN32_LEAN_AND_MEAN
32 #include <shellapi.h>
89 L"EXIT"
90 };
93 L"XCOPY"
94 };
100 /* set /a routines work from single character operators, but some of the
101 operators are multiple character ones, especially the assignment ones.
102 Temporarily represent these using the values below on the operator stack */
116 /* This maintains a stack of operators, holding both the operator precedence
117 and the single character representation of the operator in question */
119 {
121 WCHAR op;
125 /* This maintains a stack of values, where each value can either be a
126 numeric value, or a string representing an environment variable */
128 {
129 BOOL isnum;
135 /* This maintains a mapping between the calculated operator and the
136 single character representation for the assignment operators. */
137 static struct
138 {
139 WCHAR op;
140 WCHAR calculatedop;
142 {
154 };
156 /**************************************************************************
157 * WCMD_ask_confirm
158 *
159 * Issue a message and ask for confirmation, waiting on a valid answer.
160 *
161 * Returns True if Y (or A) answer is selected
162 * If optionAll contains a pointer, ALL is allowed, and if answered
163 * set to TRUE
164 *
165 */
169 UINT msgid;
178 /* Load the translated valid answers */
187 /* Loop waiting on a valid answer */
191 {
204 {
207 }
208 }
209 }
211 /****************************************************************************
212 * WCMD_clear_screen
213 *
214 * Clear the terminal screen.
215 */
219 /* Emulate by filling the screen from the top left to bottom right with
220 spaces, then moving the cursor to the top left afterwards */
221 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
225 {
226 COORD topLeft;
236 }
237 }
239 /****************************************************************************
240 * WCMD_change_tty
241 *
242 * Change the default i/o device (ie redirect STDin/STDout).
243 */
249 }
251 /****************************************************************************
252 * WCMD_choice
253 *
254 */
264 DWORD count;
265 DWORD oldmode;
266 BOOL have_console;
280 /* the colon is optional */
282 ptr++;
288 }
290 /* remember the allowed keys (overwrite previous /C option) */
293 ptr++;
296 /* terminate allowed chars */
299 }
315 /* the colon is optional */
317 ptr++;
325 }
326 ptr++;
330 count++;
331 ptr++;
332 }
344 }
345 }
353 /* use default keys, when needed: localized versions of "Y"es and "No" */
359 }
361 /* print the question, when needed */
368 }
371 /* print a list of all allowed answers inside brackets */
379 }
381 }
385 /* FIXME: Add support for option /T */
388 {
392 }
408 }
409 else
410 {
411 /* key not allowed: play the bell */
414 }
415 }
416 }
418 /****************************************************************************
419 * WCMD_AppendEOF
420 *
421 * Adds an EOF onto the end of a file
422 * Returns TRUE on success
423 */
425 {
426 HANDLE h;
427 DWORD bytes_written;
444 }
446 }
448 }
450 /****************************************************************************
451 * WCMD_IsSameFile
452 *
453 * Checks if the two paths reference to the same file
454 */
456 {
461 file1 = CreateFileW(name1, 0, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
465 file2 = CreateFileW(name2, 0, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
472 end:
478 }
480 /****************************************************************************
481 * WCMD_ManualCopy
482 *
483 * Copies from a file
484 * optionally reading only until EOF (ascii copy)
485 * optionally appending onto an existing file (append)
486 * Returns TRUE on success
487 */
489 {
491 BOOL ok;
502 }
504 /* Open the output file, overwriting if not appending */
511 }
513 /* Move to end of destination if we are going to append to it */
516 }
518 /* Loop copying data from source to destination until EOF read */
519 do
520 {
526 /* Stop at first EOF */
530 }
537 }
538 }
542 }
548 }
550 /****************************************************************************
551 * WCMD_copy
552 *
553 * Copy a file or wildcarded set.
554 * For ascii/binary type copies, it gets complex:
555 * Syntax on command line is
556 * ... /a | /b filename /a /b {[ + filename /a /b]} [dest /a /b]
557 * Where first /a or /b sets 'mode in operation' until another is found
558 * once another is found, it applies to the file preceding the /a or /b
559 * In addition each filename can contain wildcards
560 * To make matters worse, the + may be in the same parameter (i.e. no
561 * whitespace) or with whitespace separating it
562 *
563 * ASCII mode on read == read and stop at first EOF
564 * ASCII mode on write == append EOF to destination
565 * Binary == copy as-is
566 *
567 * Design of this is to build up a list of files which will be copied into a
568 * list, then work through the list file by file.
569 * If no destination is specified, it defaults to the name of the first file in
570 * the list, but the current directory.
571 *
572 */
580 WIN32_FIND_DATAW fd;
590 BOOL status;
592 DWORD len;
596 {
598 BOOL concatenate;
608 /* Assume we were successful! */
611 /* If no args supplied at all, report an error */
616 }
620 /* Walk through all args, building up a list of files to process */
624 BOOL inquotes;
628 /* Handle switches */
631 thisparam++;
658 }
659 }
670 }
671 }
674 }
675 thisparam++;
676 }
678 /* This parameter was purely switches, get the next one */
681 }
683 /* We have found something which is not a switch. If could be anything of the form
684 sourcefilename (which could be destination too)
685 + (when filename + filename syntex used)
686 sourcefilename+sourcefilename
687 +sourcefilename
688 +/b[tests show windows then ignores to end of parameter]
689 */
699 }
701 /* Move to next thing to process */
702 thisparam++;
706 }
708 /* We have found something to process - build a COPY_FILE block to store it */
716 /* Time to work out the name. Allocate at least enough space (deliberately too much to
717 leave space to append \* to the end) , then copy in character by character. Strip off
718 quotes if we find them. */
729 pos1++;
731 }
735 /* This is either the first source, concatenated subsequent source or destination */
747 /* We have processed sources and destinations and still found more to do - invalid */
751 }
754 /* We either need to process the rest of the parameter or move to the next */
760 }
761 }
763 /* Ensure we have at least one source file */
768 }
770 /* Default whether automatic overwriting is on. If we are interactive then
771 we prompt by default, otherwise we overwrite by default
772 /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
776 /* By default, we will force the overwrite in batch mode and ask for
777 * confirmation in interactive mode. */
779 /* If COPYCMD is set, then we force the overwrite with /Y and ask for
780 * confirmation with /-Y. If COPYCMD is neither of those, then we use the
781 * default behavior. */
788 }
789 }
791 /* Calculate the destination now - if none supplied, it's current dir +
792 filename of first file in list*/
809 DWORD attributes;
813 /* Convert to fully qualified path/filename */
814 if (!WCMD_get_fullpath(destination->name, ARRAY_SIZE(destname), destname, &filenamepart)) return;
817 /* If parameter is a directory, ensure it ends in \ */
826 }
827 }
829 /* Normally, the destination is the current directory unless we are
830 concatenating, in which case it's current directory plus first filename.
831 Note that if the
832 In addition by default it is a binary copy unless concatenating, when
833 the copy defaults to an ascii copy (stop at EOF). We do not know the
834 first source part yet (until we search) so flag as needing filling in. */
837 /* We have found an a+b type syntax, so destination has to be a filename
838 and we need to default to ascii copying. If we have been supplied a
839 directory as the destination, we need to defer calculating the name */
844 /* We have been asked to copy to a filename. Default to ascii IF the
845 source contains wildcards (true even if only one match) */
850 }
854 }
855 }
856 }
858 /* Save away the destination name*/
864 /* Remember if the destination is a device */
868 }
870 /* Now we need to walk the set of sources, and process each name we come to.
871 If anyconcats is true, we are writing to one file, otherwise we are using
872 the source name each time.
873 If destination exists, prompt for overwrite the first time (if concatenating
874 we ask each time until yes is answered)
875 The first source file we come across must exist (when wildcards expanded)
876 and if concatenating with overwrite prompts, each source file must exist
877 until a yes is answered. */
887 DWORD attributes;
890 /* If it was not explicit, we now know whether we are concatenating or not and
891 hence whether to copy as binary or ascii */
894 /* Convert to fully qualified path/filename in srcpath, file filenamepart pointing
895 to where the filename portion begins (used for wildcard expansion). */
899 /* If parameter is a directory, ensure it ends in \* */
903 /* We need to know where the filename part starts, so append * and
904 recalculate the full resulting path */
913 /* We need to know where the filename part starts, so append \* and
914 recalculate the full resulting path */
918 }
923 /* If the source is a device, just use it, otherwise search */
930 /* Loop through all source files */
935 }
936 }
941 BOOL overwrite;
944 /* Skip . and .., and directories */
949 /* Build final destination name */
953 /* Build source name */
956 /* Do we just overwrite (we do if we are writing to a device) */
960 }
969 }
971 /* Prompt before overwriting */
981 }
983 }
985 /* If we needed to save away the first filename, do it */
992 }
994 /* Do the copy as appropriate */
997 /* Silently skip if the destination file is also a source file */
1004 }
1011 }
1019 /* Append EOF if ascii destination and we are not going to add more onto the end
1020 Note: Testing shows windows has an optimization whereas if you have a binary
1021 copy of a file to a single destination (ie concatenation) then it does not add
1022 the EOF, hence the check on the source copy type below. */
1027 }
1028 }
1029 }
1030 }
1031 }
1035 /* Error if the first file was not found */
1039 }
1040 }
1042 /* Step on to the next supplied source */
1044 }
1046 /* Append EOF if ascii destination and we were concatenating */
1051 }
1052 }
1054 /* Exit out of the routine, freeing any remaining allocated memory */
1055 exitreturn:
1060 /* Free up this block*/
1064 }
1066 /* Free up the destination memory */
1070 }
1073 }
1075 /****************************************************************************
1076 * WCMD_create_dir
1077 *
1078 * Create a directory (and, if needed, any intermediate directories).
1079 *
1080 * Modifies its argument by replacing slashes temporarily with nulls.
1081 */
1084 {
1087 /* don't mess with drive letter portion of path, if any */
1092 /* Strip trailing slashes. */
1096 /* Step through path, creating intermediate directories as needed. */
1097 /* First component includes drive letter, if any. */
1100 DWORD rv;
1101 /* Skip to end of component */
1105 /* path is now the original full path */
1107 }
1108 /* Truncate path, create intermediate directory, and restore path */
1114 }
1115 /* notreached */
1117 }
1126 }
1127 /* Loop through all args */
1134 }
1135 }
1136 }
1138 /* Parse the /A options given by the user on the commandline
1139 * into a bitmask of wanted attributes (*wantSet),
1140 * and a bitmask of unwanted attributes (*wantClear).
1141 */
1145 /* both are strictly 'out' parameters */
1149 /* For each /A argument */
1151 /* Skip /A itself */
1154 /* Skip optional : */
1157 /* For each of the attribute specifier chars to this /A option */
1164 p++;
1165 }
1167 /* Convert the attribute specifier to a bit in one of the masks */
1175 }
1178 else
1180 }
1181 }
1182 }
1184 /* If filename part of parameter is * or *.*,
1185 * and neither /Q nor /P options were given,
1186 * prompt the user whether to proceed.
1187 * Returns FALSE if user says no, TRUE otherwise.
1188 * *pPrompted is set to TRUE if the user is prompted.
1189 * (If /P supplied, del will prompt for individual files later.)
1190 */
1199 /* Convert path into actual directory spec */
1203 /* Only prompt for * and *.*, not *a, a*, *.a* etc */
1208 /* Caller uses this to suppress "file not found" warning later */
1211 /* Ask for confirmation */
1214 }
1215 }
1216 /* No scary wildcard, or question suppressed, so it's ok to delete the file(s) */
1218 }
1220 /* Helper function for WCMD_delete().
1221 * Deletes a single file, directory, or wildcard.
1222 * If /S was given, does it recursively.
1223 * Returns TRUE if a file was deleted.
1224 */
1226 DWORD wanted_attrs;
1227 DWORD unwanted_attrs;
1230 WIN32_FIND_DATAW fd;
1231 HANDLE hff;
1243 /* Skip this arg if user declines to delete *.* */
1245 }
1247 /* First, try to delete in the current directory */
1253 }
1255 /* Support del <dirname> by just deleting all files dirname\* */
1260 {
1271 /* Build the filename to delete as <supplied directory>\<findfirst filename> */
1278 }
1281 BOOL ok;
1283 /* Handle attribute matching (/A) */
1287 /* /P means prompt for each file */
1291 /* Ask for confirmation */
1295 }
1297 /* Only proceed if ok to */
1300 /* If file is read only, and /A:r or /F supplied, delete it */
1305 }
1307 /* Now do the delete */
1309 }
1311 }
1314 }
1316 /* Now recurse into all subdirectories handling the parameter in the same way */
1327 /* Convert path into actual directory spec */
1338 /* Append '*' to the directory */
1344 /* Remove residual '*' */
1359 {
1364 }
1365 /* Work out search parameter in sub dir */
1373 /* Allocate memory, add to list */
1380 }
1384 /* Go through each subdir doing the delete */
1394 }
1395 }
1396 }
1399 }
1401 /****************************************************************************
1402 * WCMD_delete
1403 *
1404 * Delete a file or wildcarded set.
1405 *
1406 * Note on /A:
1407 * - Testing shows /A is repeatable, eg. /a-r /ar matches all files
1408 * - Each set is a pattern, eg /ahr /as-r means
1409 * readonly+hidden OR nonreadonly system files
1410 * - The '-' applies to a single field, ie /a:-hr means read only
1411 * non-hidden files
1412 */
1423 BOOL found;
1438 }
1440 /* Handle no valid args */
1445 }
1447 /*
1448 * WCMD_strtrim
1449 *
1450 * Returns a trimmed version of s with all leading and trailing whitespace removed
1451 * Pre: s non NULL
1452 *
1453 */
1455 {
1470 }
1473 }
1475 /****************************************************************************
1476 * WCMD_echo
1477 *
1478 * Echo input to the screen (or not). We don't try to emulate the bugs
1479 * in DOS (try typing "ECHO ON AGAIN" for an example).
1480 */
1483 {
1490 args++;
1502 }
1511 }
1513 }
1515 /*****************************************************************************
1516 * WCMD_part_execute
1517 *
1518 * Execute a command, and any && or bracketed follow on to the command. The
1519 * first command to be executed may not be at the front of the
1520 * commands->thiscommand string (eg. it may point after a DO or ELSE)
1521 */
1524 {
1531 /* Skip leading whitespace between condition and the command */
1534 /* Process the first command, if there is one */
1539 }
1542 /* If it didn't move the position, step to next command */
1545 /* Process any other parts of the command */
1550 /* execute all appropriate commands */
1557 myDepth,
1558 processThese);
1560 /* Execute any statements appended to the line */
1561 /* FIXME: Only if previous call worked for && or failed for || */
1567 }
1570 /* Execute any appended to the statement with (...) */
1576 }
1579 /* End of the command - does 'ELSE ' follow as the next command? */
1582 /* Swap between if and else processing */
1585 /* Process the ELSE part */
1590 /* Skip leading whitespace between condition and the command */
1594 }
1596 /* Loop skipping all commands until we get back to the current
1597 depth, including skipping commands and their subsequent
1598 pipes (eg cmd | prog) */
1605 /* After the else is complete, we need to now process subsequent commands */
1607 }
1610 /* If we were in an IF statement and we didn't find an else and yet we get back to
1611 the same bracket depth as the IF, then the IF statement is over. This is required
1612 to handle nested ifs properly */
1620 }
1627 }
1628 }
1629 }
1630 }
1632 }
1634 /*****************************************************************************
1635 * WCMD_parse_forf_options
1636 *
1637 * Parses the for /f 'options', extracting the values and validating the
1638 * keywords. Note all keywords are optional.
1639 * Parameters:
1640 * options [I] The unparsed parameter string
1641 * eol [O] Set to the comment character (eol=x)
1642 * skip [O] Set to the number of lines to skip (skip=xx)
1643 * delims [O] Set to the token delimiters (delims=)
1644 * tokens [O] Set to the requested tokens, as provided (tokens=)
1645 * usebackq [O] Set to TRUE if usebackq found
1646 *
1647 * Returns TRUE on success, FALSE on syntax error
1648 *
1649 */
1652 {
1662 /* Initialize to defaults */
1669 /* Strip (optional) leading and trailing quotes */
1672 pos++;
1673 }
1675 /* Process each keyword */
1678 pos++;
1680 /* Save End of line character (Ignore line if first token (based on delims) starts with it) */
1687 /* Save number of lines to skip (Can be in base 10, hex (0x...) or octal (0xx) */
1696 /* Save if usebackq semantics are in effect */
1703 /* Save the supplied delims. Slightly odd as space can be a delimiter but only
1704 if you finish the optionsroot string with delims= otherwise the space is
1705 just a token delimiter! */
1713 pos++;
1714 }
1719 /* Save the tokens being requested */
1727 pos++;
1728 }
1735 }
1736 }
1738 }
1740 /*****************************************************************************
1741 * WCMD_add_dirstowalk
1742 *
1743 * When recursing through directories (for /r), we need to add to the list of
1744 * directories still to walk, any subdirectories of the one we are processing.
1745 *
1746 * Parameters
1747 * options [I] The remaining list of directories still to process
1748 *
1749 * Note this routine inserts the subdirectories found between the entry being
1750 * processed, and any other directory still to be processed, mimicking what
1751 * Windows does
1752 */
1756 WIN32_FIND_DATAW fd;
1757 HANDLE hff;
1759 /* Build a generic search and add all directories on the list of directories
1760 still to walk */
1769 {
1770 /* Allocate memory, add to list */
1773 {
1777 }
1783 toWalk->dirName = xalloc(sizeof(WCHAR) * (wcslen(dirsToWalk->dirName) + 2 + wcslen(fd.cFileName)));
1789 }
1793 }
1794 }
1796 /**************************************************************************
1797 * WCMD_for_nexttoken
1798 *
1799 * Parse the token= line, identifying the next highest number not processed
1800 * so far. Count how many tokens are referred (including duplicates) and
1801 * optionally return that, plus optionally indicate if the tokens= line
1802 * ends in a star.
1803 *
1804 * Parameters:
1805 * lasttoken [I] - Identifies the token index of the last one
1806 * returned so far (-1 used for first loop)
1807 * tokenstr [I] - The specified tokens= line
1808 * firstCmd [O] - Optionally indicate how many tokens are listed
1809 * doAll [O] - Optionally indicate if line ends with *
1810 * duplicates [O] - Optionally indicate if there is any evidence of
1811 * overlaying tokens in the string
1812 * Note the caller should keep a running track of duplicates as the tokens
1813 * are recursively passed. If any have duplicates, then the * token should
1814 * not be honoured.
1815 */
1819 {
1830 /* Loop through the token string, parsing it. Valid syntax is:
1831 token=m or x-y with comma delimiter and optionally * to finish*/
1836 /* Remember if the next character is a star, it indicates a need to
1837 show all remaining tokens and should be the last character */
1841 /* If we have not found a next token to return, then indicate
1842 time to process the star */
1845 /* Special case the syntax of tokens=* which just means get whole line */
1849 }
1850 }
1852 }
1854 /* Get the next number */
1857 /* If it is followed by a minus, it's a range, so get the next one as well */
1861 /* We want to return the lowest number that is higher than lasttoken
1862 but only if range is positive */
1871 }
1873 /* Flag if duplicates identified */
1877 }
1879 /* Update the running total for the whole range */
1882 }
1888 /* See if the number found is one we have already seen */
1891 /* We want to return the lowest number that is higher than lasttoken */
1895 }
1899 /* Step on to the next character, usually over comma */
1901 }
1903 }
1905 /* Return result */
1913 }
1917 }
1919 /**************************************************************************
1920 * WCMD_parse_line
1921 *
1922 * When parsing file or string contents (for /f), once the string to parse
1923 * has been identified, handle the various options and call the do part
1924 * if appropriate.
1925 *
1926 * Parameters:
1927 * cmdStart [I] - Identifies the list of commands making up the
1928 * for loop body (especially if brackets in use)
1929 * firstCmd [I] - The textual start of the command after the DO
1930 * which is within the first item of cmdStart
1931 * cmdEnd [O] - Identifies where to continue after the DO
1932 * variable [I] - The variable identified on the for line
1933 * buffer [I] - The string to parse
1934 * doExecuted [O] - Set to TRUE if the DO is ever executed once
1935 * forf_skip [I/O] - How many lines to skip first
1936 * forf_eol [I] - The 'end of line' (comment) character
1937 * forf_delims [I] - The delimiters to use when breaking the string apart
1938 * forf_tokens [I] - The tokens to use when breaking the string apart
1939 */
1947 WCHAR forf_eol,
1952 FOR_CONTEXT oldcontext;
1961 /* Skip lines if requested */
1965 }
1967 /* Save away any existing for variable context (e.g. nested for loops) */
1970 /* Extract the parameters based on the tokens= value (There will always
1971 be some value, as if it is not supplied, it defaults to tokens=1).
1972 Rough logic:
1973 Count how many tokens are named in the line, identify the lowest
1974 Empty (set to null terminated string) that number of named variables
1975 While lasttoken != nextlowest
1976 %letter = parameter number 'nextlowest'
1977 letter++ (if >26 or >52 abort)
1978 Go through token= string finding next lowest number
1979 If token ends in * set %letter = raw position of token(nextnumber+1)
1980 */
1986 /* Empty out variables */
1989 varoffset++) {
1991 }
1993 /* Loop extracting the tokens
1994 Note: nexttoken of 0 means there were no tokens requested, to handle
1995 the special case of tokens=* */
2001 /* Extract the token number requested and set into the next variable context */
2007 varoffset++;
2009 }
2011 /* Find the next token */
2015 }
2017 /* If all the rest of the tokens were requested, and there is still space in
2018 the variable range, write them now */
2020 nexttoken++;
2025 }
2027 /* Execute the body of the foor loop with these values */
2028 if (varidx >= 0 && forloopcontext.variable[varidx] && forloopcontext.variable[varidx][0] != forf_eol) {
2033 }
2035 /* Free the duplicated strings, and restore the context */
2042 }
2043 }
2044 }
2046 /* Restore the original for variable contextx */
2048 }
2050 /**************************************************************************
2051 * WCMD_forf_getinput
2052 *
2053 * Return a FILE* which can be used for reading the input lines,
2054 * either to a specific file (which may be quote delimited as we have to
2055 * read the parameters in raw mode) or to a command which we need to
2056 * execute. The command being executed runs in its own shell and stores
2057 * its data in a temporary file.
2058 *
2059 * Parameters:
2060 * usebackq [I] - Indicates whether usebackq is in effect or not
2061 * itemStr [I] - The item to be handled, either a filename or
2062 * whole command string to execute
2063 * iscmd [I] - Identifies whether this is a command or not
2064 *
2065 * Returns a file handle which can be used to read the input lines from.
2066 */
2074 /* Remove leading and trailing character (but there may be trailing whitespace too) */
2078 {
2082 }
2084 itemstr++;
2085 }
2088 /* Get temp filename */
2092 /* Redirect output to the temporary file */
2099 /* Open the file, read line by line and process */
2102 /* Open the file, read line by line and process */
2105 }
2108 }
2110 /**************************************************************************
2111 * WCMD_for
2112 *
2113 * Batch file loop processing.
2114 *
2115 * On entry: cmdList contains the syntax up to the set
2116 * next cmdList and all in that bracket contain the set data
2117 * next cmdlist contains the DO cmd
2118 * following that is either brackets or && entries (as per if)
2119 *
2120 */
2124 WIN32_FIND_DATAW fd;
2125 HANDLE hff;
2151 /* Handle optional qualifiers (multiple are allowed) */
2157 thisArg++;
2162 /* Recursive is special case - /R can have an optional path following it */
2163 /* filenamesets are another special case - /F can have an optional options following it */
2166 {
2167 /* When recursing directories, use current directory as the starting point unless
2168 subsequently overridden */
2174 /* Retrieve next parameter to see if is root/options (raw form required
2175 with for /f, or unquoted in for /r) */
2178 /* Next parm is either qualifier, path/options or variable -
2179 only care about it if it is the path/options */
2181 parameterNo++;
2183 }
2185 }
2188 }
2190 /* Step to next token */
2192 }
2194 /* Ensure line continues with variable */
2198 }
2200 /* With for /f parse the options if provided */
2204 {
2207 }
2209 /* Set up the list of directories to recurse if we are going to */
2211 /* Allocate memory, add to list */
2216 }
2218 /* Variable should follow */
2223 /* Ensure line continues with IN */
2230 }
2232 /* Save away where the set of data starts and the variable */
2237 /* Skip until the close bracket */
2244 }
2246 /* Skip the close bracket, if there is one */
2249 /* Syntax error if missing close bracket, or nothing following it
2250 and once we have the complete set, we expect a DO */
2255 }
2259 /* Loop repeatedly per-directory we are potentially walking, when in for /r
2260 mode, or once for the rest of the time. */
2263 /* Save away the starting position for the commands (and offset for the
2264 first one) */
2269 /* If we are recursing directories (ie /R), add all sub directories now, then
2270 prefix the root when searching for the item */
2274 /* Loop through all set entries */
2279 /* Loop through all entries on the same line */
2288 /*
2289 * If the parameter within the set has a wildcard then search for matching files
2290 * otherwise do a literal substitution.
2291 */
2293 /* Take a copy of the item returned from WCMD_parameter as it is held in a
2294 static buffer which can be overwritten during parsing of the for body */
2300 itemNum++;
2307 /* Now build the item to use / search for in the specified directory,
2308 as it is fully qualified in the /R case */
2317 }
2327 /* Handle as files or dirs appropriately, but ignore . and .. */
2330 {
2336 {
2340 }
2348 }
2351 /* Save away any existing for variable context (e.g. nested for loops)
2352 and restore it after executing the body of this for loop */
2356 }
2361 }
2364 }
2368 /* Save away any existing for variable context (e.g. nested for loops)
2369 and restore it after executing the body of this for loop */
2373 }
2378 }
2381 /* Convert the first 3 numbers to signed longs and save */
2383 /* else ignore them! */
2385 /* Filesets - either a list of files, or a command to run and parse the output */
2395 /* If backquote or single quote, we need to launch that command
2396 and parse the results - use a temporary file */
2400 /* Use itemstart because the command is the whole set, not just the first token */
2404 /* Use item because the file to process is just the first item in the set */
2406 }
2409 /* Process the input file */
2418 /* Read line by line until end of file */
2421 /* Either our buffer isn't large enough to fit a full line, or there's a stray
2422 * '\0' in the buffer.
2423 */
2431 }
2433 }
2435 /* When we have processed the item as a whole command, abort future set processing */
2439 }
2441 /* Filesets - A string literal */
2445 /* Remove leading and trailing character, ready to parse with delims= delimiters
2446 Note that the last quote is removed from the set and the string terminates
2447 there to mimic windows */
2451 itemStart++;
2452 }
2454 /* Copy the item away from the global buffer used by WCMD_parameter */
2459 /* Only one string can be supplied in the whole set, abort future set processing */
2462 }
2465 i++;
2466 }
2468 /* Move onto the next set line */
2470 }
2472 /* If /L is provided, now run the for loop */
2488 /* Save away any existing for variable context (e.g. nested for loops)
2489 and restore it after executing the body of this for loop */
2493 }
2496 }
2498 }
2500 /* If we are walking directories, move on to any which remain */
2509 }
2513 /* Now skip over the do part if we did not perform the for loop so far.
2514 We store in cmdEnd the next command after the do block, but we only
2515 know this if something was run. If it has not been, we need to calculate
2516 it. */
2522 }
2524 /* When the loop ends, either something like a GOTO or EXIT /b has terminated
2525 all processing, OR it should be pointing to the end of && processing OR
2526 it should be pointing at the NULL end of bracket for the DO. The return
2527 value needs to be the NEXT command to execute, which it either is, or
2528 we need to step over the closing bracket */
2531 }
2533 /**************************************************************************
2534 * WCMD_give_help
2535 *
2536 * Simple on-line help. Help text is stored in the resource file.
2537 */
2540 {
2546 }
2548 /* Display help message for builtin commands */
2554 }
2555 }
2556 /* Launch the command with the /? option for external commands shipped with cmd.exe */
2565 }
2566 }
2568 }
2570 }
2572 /****************************************************************************
2573 * WCMD_go_to
2574 *
2575 * Batch file jump instruction. Not the most efficient algorithm ;-)
2576 * Prints error message if the specified label cannot be found - the file pointer is
2577 * then at EOF, effectively stopping the batch file.
2578 * FIXME: DOS is supposed to allow labels with spaces - we don't.
2579 */
2587 /* Do not process any more parts of a processed multipart or multilines command */
2596 }
2598 /* Handle special :EOF label */
2602 }
2604 /* Support goto :label as well as goto label plus remove trailing chars */
2610 /* Loop through potentially twice - once from current file position
2611 through to the end, and second time from start to current file
2612 position */
2615 LARGE_INTEGER startli;
2618 /* On first loop, save the file size */
2623 /* On second loop, start at the beginning of the file */
2626 }
2631 /* Ignore leading whitespace or no-echo character */
2634 /* If the first real character is a : then this is a label */
2636 str++;
2638 /* Skip spaces between : and label */
2642 /* Label ends at whitespace or redirection characters */
2648 }
2650 /* See if we have gone beyond the end point if second time through */
2652 LARGE_INTEGER curli;
2659 }
2660 }
2661 }
2662 }
2663 }
2667 }
2669 }
2671 /*****************************************************************************
2672 * WCMD_pushd
2673 *
2674 * Push a directory onto the stack
2675 */
2678 {
2686 }
2695 }
2697 /* Change directory using CD code with /D parameter */
2713 }
2715 }
2716 }
2719 /*****************************************************************************
2720 * WCMD_popd
2721 *
2722 * Pop a directory from the stack
2723 */
2731 /* pop the old environment from the stack, and make it the current dir */
2736 }
2738 /*******************************************************************
2739 * evaluate_if_comparison
2740 *
2741 * Evaluates an "if" comparison operation
2742 *
2743 * PARAMS
2744 * leftOperand [I] left operand, non NULL
2745 * operator [I] "if" binary comparison operator, non NULL
2746 * rightOperand [I] right operand, non NULL
2747 * caseInsensitive [I] 0 for case sensitive comparison, anything else for insensitive
2748 *
2749 * RETURNS
2750 * Success: 1 if operator applied to the operands evaluates to TRUE
2751 * 0 if operator applied to the operands evaluates to FALSE
2752 * Failure: -1 if operator is not recognized
2753 */
2756 {
2759 BOOL int_operands;
2761 /* == is a special case, as it always compares strings */
2766 /* Check if we have plain integers (in decimal, octal or hexadecimal notation) */
2771 /* Perform actual (integer or string) comparison */
2775 else
2778 }
2783 else
2786 }
2791 else
2794 }
2799 else
2802 }
2807 else
2810 }
2815 else
2818 }
2821 }
2824 {
2839 }
2841 WIN32_FIND_DATAW fd;
2842 HANDLE hff;
2847 /* FindFirstFile does not like a directory path ending in '\', append a '.' */
2855 }
2860 }
2869 /* Note: '==' can't be returned by WCMD_parameter since '=' is a separator */
2872 p++;
2879 }
2892 }
2896 syntax_err:
2898 }
2900 /****************************************************************************
2901 * WCMD_if
2902 *
2903 * Batch file conditional.
2904 *
2905 * On entry, cmdlist will point to command containing the IF, and optionally
2906 * the first command to execute (if brackets not found)
2907 * If &&'s were found, this may be followed by a record flagged as isAmpersand
2908 * If ('s were found, execute all within that bracket
2909 * Command may optionally be followed by an ELSE - need to skip instructions
2910 * in the else using the same logic
2911 *
2912 * FIXME: Much more syntax checking needed!
2913 */
2915 {
2920 /* Function evaluate_if_condition relies on the global variables quals, param1 and param2
2921 set in a call to WCMD_parse before */
2929 /* Process rest of IF statement which is on the same line
2930 Note: This may process all or some of the cmdList (eg a GOTO) */
2934 syntax_err:
2936 }
2938 /****************************************************************************
2939 * WCMD_move
2940 *
2941 * Move a file, directory tree or wildcarded set of files.
2942 */
2945 {
2946 BOOL status;
2947 WIN32_FIND_DATAW fd;
2948 HANDLE hff;
2959 }
2961 /* If no destination supplied, assume current directory */
2964 }
2966 /* If 2nd parm is directory, then use original filename */
2967 /* Convert partial path to full path */
2973 /* Split into components */
2983 DWORD attribs;
2989 /* Build src & dest name */
2993 /* See if dest is an existing directory */
3002 }
3009 /* If destination exists, prompt unless /Y supplied */
3013 DWORD len;
3015 /* Default whether automatic overwriting is on. If we are interactive then
3016 we prompt by default, otherwise we overwrite by default
3017 /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
3023 /* By default, we will force the overwrite in batch mode and ask for
3024 * confirmation in interactive mode. */
3026 /* If COPYCMD is set, then we force the overwrite with /Y and ask for
3027 * confirmation with /-Y. If COPYCMD is neither of those, then we use the
3028 * default behavior. */
3035 }
3036 }
3038 /* Prompt if overwriting */
3042 /* Ask for confirmation */
3046 }
3050 }
3056 }
3061 }
3065 }
3067 /****************************************************************************
3068 * WCMD_pause
3069 *
3070 * Suspend execution of a batch script until a key is typed
3071 */
3074 {
3075 DWORD oldmode;
3076 BOOL have_console;
3077 DWORD count;
3078 WCHAR key;
3089 }
3091 /****************************************************************************
3092 * WCMD_remove_dir
3093 *
3094 * Delete a directory.
3095 */
3103 /* Loop through all args */
3109 argsProcessed++;
3111 /* If subdirectory search not supplied, just try to remove
3112 and report error if it fails (eg if it contains a file) */
3116 /* Otherwise use ShFileOp to recursively remove a directory */
3119 SHFILEOPSTRUCTW lpDir;
3121 /* Ask first */
3123 BOOL ok;
3126 /* Ask for confirmation */
3130 /* Abort if answer is 'N' */
3132 }
3134 /* Do the delete */
3141 /* SHFileOperationW needs file list with a double null termination */
3145 }
3146 }
3147 }
3149 /* Handle no valid args */
3153 }
3155 }
3157 /****************************************************************************
3158 * WCMD_rename
3159 *
3160 * Rename a file.
3161 */
3164 {
3165 BOOL status;
3166 HANDLE hff;
3167 WIN32_FIND_DATAW fd;
3177 /* Must be at least two args */
3182 }
3184 /* Destination cannot contain a drive letter or directory separator */
3190 }
3192 /* Convert partial path to full path */
3198 /* Split into components */
3213 /* FIXME: If dest name or extension is *, replace with filename/ext
3214 part otherwise use supplied name. This supports:
3215 ren *.fred *.jim
3216 ren jim.* fred.* etc
3217 However, windows has a more complex algorithm supporting eg
3218 ?'s and *'s mid name */
3221 /* Build src & dest name */
3228 /* Build name */
3235 }
3237 /* Build Extension */
3242 }
3252 }
3256 }
3258 /*****************************************************************************
3259 * WCMD_dupenv
3260 *
3261 * Make a copy of the environment.
3262 */
3264 {
3277 {
3280 }
3285 }
3287 /*****************************************************************************
3288 * WCMD_setlocal
3289 *
3290 * setlocal pushes the environment onto a stack
3291 * Save the environment as unicode so we don't screw anything up.
3292 */
3297 BOOL newdelay;
3299 /* setlocal does nothing outside of batch programs */
3302 /* DISABLEEXTENSIONS ignored */
3304 /* ENABLEDELAYEDEXPANSION / DISABLEDELAYEDEXPANSION could be parm1 or parm2
3305 (if both ENABLEEXTENSIONS and ENABLEDELAYEDEXPANSION supplied for example) */
3306 if (!wcsicmp(param1, L"ENABLEDELAYEDEXPANSION") || !wcsicmp(param2, L"ENABLEDELAYEDEXPANSION")) {
3308 } else if (!wcsicmp(param1, L"DISABLEDELAYEDEXPANSION") || !wcsicmp(param2, L"DISABLEDELAYEDEXPANSION")) {
3312 }
3317 {
3320 }
3325 {
3332 /* Save the current drive letter */
3335 }
3336 else
3341 }
3343 /*****************************************************************************
3344 * WCMD_endlocal
3345 *
3346 * endlocal pops the environment off a stack
3347 * Note: When searching for '=', search from WCHAR position 1, to handle
3348 * special internal environment variables =C:, =D: etc
3349 */
3355 /* setlocal does nothing outside of batch programs */
3358 /* setlocal needs a saved environment from within the same context (batch
3359 program) as it was saved in */
3363 /* pop the old environment from the stack */
3367 /* delete the current environment, totally */
3375 {
3378 }
3380 }
3384 /* restore old environment */
3393 {
3396 }
3398 }
3400 /* Restore current drive letter */
3409 }
3410 }
3414 }
3416 /*****************************************************************************
3417 * WCMD_setshow_default
3418 *
3419 * Set/Show the current default directory
3420 */
3424 BOOL status;
3428 WIN32_FIND_DATAW fd;
3429 HANDLE hff;
3433 /* Skip /D and trailing whitespace if on the front of the command line */
3440 args++;
3441 }
3448 }
3450 /* Remove any double quotes, which may be in the
3451 middle, eg. cd "C:\Program Files"\Microsoft is ok */
3455 args++;
3456 }
3458 pos--;
3461 /* Search for appropriate directory */
3473 /* Convert path into actual directory spec */
3477 /* Rebuild path */
3480 }
3483 }
3485 /* Change to that directory */
3495 /* Save away the actual new directory, to store as current location */
3498 /* Restore old directory if drive letter would change, and
3499 CD x:\directory /D (or pushd c:\directory) not supplied */
3503 }
3504 }
3506 /* Set special =C: type environment variable, for drive letter of
3507 change of directory, even if path was restored due to missing
3508 /D (allows changing drive letter when not resident on that
3509 drive */
3517 }
3519 }
3521 }
3523 /****************************************************************************
3524 * WCMD_setshow_date
3525 *
3526 * Set/Show the system date
3527 * FIXME: Can't change date yet
3528 */
3533 DWORD count;
3543 }
3544 }
3545 }
3547 }
3550 }
3551 }
3553 /****************************************************************************
3554 * WCMD_compare
3555 * Note: Native displays 'fred' before 'fred ', so need to only compare up to
3556 * the equals sign.
3557 */
3559 {
3567 }
3569 /****************************************************************************
3570 * WCMD_setshow_sortenv
3571 *
3572 * sort variables into order for display
3573 * Optionally only display those who start with a stub
3574 * returns the count displayed
3575 */
3577 {
3583 /* count the number of strings, and the total length */
3586 count++;
3587 }
3589 /* add the strings to an array */
3597 /* sort the array */
3600 /* print it */
3605 /* Don't display special internal variables */
3609 displayedcount++;
3610 }
3611 }
3612 }
3616 }
3618 /****************************************************************************
3619 * WCMD_getprecedence
3620 * Return the precedence of a particular operator
3621 */
3623 {
3660 }
3661 }
3663 /****************************************************************************
3664 * WCMD_pushnumber
3665 * Push either a number or name (environment variable) onto the supplied
3666 * stack
3667 */
3677 }
3680 }
3682 /****************************************************************************
3683 * WCMD_peeknumber
3684 * Returns the value of the top number or environment variable on the stack
3685 * and leaves the item on the stack.
3686 */
3697 }
3701 }
3702 }
3705 }
3707 /****************************************************************************
3708 * WCMD_popnumber
3709 * Returns the value of the top number or environment variable on the stack
3710 * and removes the item from the stack.
3711 */
3722 }
3725 }
3727 /****************************************************************************
3728 * WCMD_pushoperator
3729 * Push an operator onto the supplied stack
3730 */
3738 }
3740 /****************************************************************************
3741 * WCMD_popoperator
3742 * Returns the operator from the top of the stack and removes the item from
3743 * the stack.
3744 */
3754 }
3757 }
3759 /****************************************************************************
3760 * WCMD_reduce
3761 * Actions the top operator on the stack against the first and sometimes
3762 * second value on the variable stack, and pushes the result
3763 * Returns non-zero on error.
3764 */
3766 WCHAR thisop;
3773 }
3775 /* Remove the top operator */
3779 /* One variable operators */
3790 }
3792 /* Two variable operators */
3796 }
3827 /* Shift left has to be a positive number, 0-31 otherwise 0 is returned,
3828 which differs from the compiler (for example gcc) so being explicit. */
3833 }
3852 {
3855 /* The left of an equals must be one variable */
3858 }
3860 /* Make the number stack grow by inserting the value of the variable */
3865 /* Make the operand stack grow by pushing the assign operator plus the
3866 operator to perform */
3869 i++;
3870 }
3874 }
3879 }
3882 {
3885 /* Build the result, then push it onto the stack */
3893 }
3896 }
3899 }
3902 /****************************************************************************
3903 * WCMD_handleExpression
3904 * Handles an expression provided to set /a - If it finds brackets, it uses
3905 * recursion to process the parts in brackets.
3906 */
3908 {
3912 BOOL lastwasnumber = FALSE; /* FALSE makes a minus at the start of the expression easier to handle */
3917 /* Initialize */
3921 /* Iterate through until whole expression is processed */
3923 BOOL treatasnumber;
3925 /* Skip whitespace to get to the next character to process*/
3929 /* If we have found anything other than an operator then it's a number/variable */
3934 /* Cannot have an expression with var/number twice, without an operator
3935 in-between, nor or number following a half constructed << or >> operator */
3939 }
3943 /* For a number - just push it onto the stack */
3948 /* Verify the number was validly formed */
3952 }
3955 /* For a variable - just push it onto the stack */
3960 }
3962 }
3964 /* We have found an operator. Some operators are one character, some two, and the minus
3965 and plus signs need special processing as they can be either operators or just influence
3966 the parameter which follows them */
3968 /* Badly constructed operator pair */
3971 }
3976 /* > and < are special as they are double character operators (and spaces can be between them!)
3977 If we see these for the first time, set a flag, and second time around we continue.
3978 Note these double character operators are stored as just one of the characters on the stack */
3982 pos++;
3984 }
3985 /* We have found the rest, so clear up the knowledge of the half completed part and
3986 drop through to normal operator processing */
3988 /* drop through */
3991 /* = is special cased as if the last was an operator then we may have e.g. += or
3992 *= etc which we need to handle by replacing the operator that is on the stack
3993 with a calculated assignment equivalent */
3997 i++;
3998 }
4003 /* Remove the operator on the stack, it will be replaced with a ?= equivalent
4004 when the general operator handling happens further down. */
4007 }
4008 }
4009 }
4010 /* Drop though */
4012 /* + and - are slightly special as they can be a numeric prefix, if they follow an operator
4013 so if they do, convert the +/- (arithmetic) to +/- (numeric prefix for positive/negative) */
4015 /* drop through */
4017 /* drop through */
4019 /* Normal operators - push onto stack unless precedence means we have to calculate it now */
4028 /* General code for handling most of the operators - look at the
4029 precedence of the top item on the stack, and see if we need to
4030 action the stack before we push something else onto it. */
4031 {
4036 /* In general, for things with the same precedence, reduce immediately
4037 except for assignments and unary operators which do not */
4043 }
4046 pos++;
4048 }
4050 /* comma means start a new expression, ie calculate what we have */
4052 {
4057 }
4059 /* If we have anything other than one number left, error
4060 otherwise throw the number away */
4064 }
4069 pos++;
4071 }
4073 /* Open bracket - use iteration to parse the inner expression, then continue */
4076 pos++;
4081 }
4083 /* Close bracket - we have finished this depth, calculate and return */
4085 pos++;
4090 }
4092 }
4096 pos++;
4097 }
4099 }
4101 exprreturn:
4104 /* We need to reduce until we have a single number (or variable) on the
4105 stack and set the return value to that */
4108 }
4111 /* If we have anything other than one number left, error
4112 otherwise throw the number away */
4116 }
4118 /* Now get the number (and convert if it's just a variable name) */
4121 exprerrorreturn:
4122 /* Free all remaining memory */
4128 }
4130 /****************************************************************************
4131 * WCMD_setshow_env
4132 *
4133 * Set/Show the environment variables
4134 */
4138 LPVOID env;
4140 BOOL status;
4147 }
4149 /* See if /P supplied, and if so echo the prompt, and read in a reply */
4153 DWORD count;
4157 /* set /P "var=value"jim ignores anything after the last quote */
4163 }
4165 /* If no parameter, or no '=' sign, return an error */
4169 }
4171 /* Output the prompt */
4175 /* Read the reply */
4176 if (WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE), string, ARRAY_SIZE(string), &count) && count > 1) {
4182 }
4184 /* See if /A supplied, and if so calculate the results of all the expressions */
4188 /* /A supplied, so evaluate expressions and set variables appropriately */
4189 /* Syntax is set /a var=1,var2=var+4 etc, and it echos back the result */
4190 /* of the final computation */
4196 /* Remove all quotes before doing any calculations */
4202 src++;
4203 }
4206 /* Now calculate the results of the expression */
4211 /* If parsing failed, issue the error message */
4215 }
4217 /* If we have no context (interactive or cmd.exe /c) print the final result */
4221 }
4224 DWORD gle;
4226 /* set "var=value"jim ignores anything after the last quote */
4232 }
4240 }
4242 }
4254 }
4255 }
4257 /****************************************************************************
4258 * WCMD_setshow_path
4259 *
4260 * Set/Show the path environment variable
4261 */
4266 DWORD status;
4274 }
4277 }
4278 }
4283 }
4284 }
4286 /****************************************************************************
4287 * WCMD_setshow_prompt
4288 *
4289 * Set or show the command prompt.
4290 */
4298 }
4304 }
4306 }
4307 }
4309 /****************************************************************************
4310 * WCMD_setshow_time
4311 *
4312 * Set/Show the system time
4313 * FIXME: Can't change time yet
4314 */
4319 DWORD count;
4320 SYSTEMTIME st;
4331 }
4332 }
4333 }
4335 }
4338 }
4339 }
4341 /****************************************************************************
4342 * WCMD_shift
4343 *
4344 * Shift batch parameters.
4345 * Optional /n says where to start shifting (n=0-8)
4346 */
4363 }
4368 }
4370 }
4372 }
4374 /****************************************************************************
4375 * WCMD_start
4376 */
4378 {
4383 STARTUPINFOW st;
4384 PROCESS_INFORMATION pi;
4393 /* The start built-in has some special command-line parsing properties
4394 * which will be outlined here.
4395 *
4396 * both '\t' and ' ' are argument separators
4397 * '/' has a special double role as both separator and switch prefix, e.g.
4398 *
4399 * > start /low/i
4400 * or
4401 * > start "title"/i
4402 *
4403 * are valid ways to pass multiple options to start. In the latter case
4404 * '/i' is not a part of the title but parsed as a switch.
4405 *
4406 * However, '=', ';' and ',' are not separators:
4407 * > start "deus"=ex,machina
4408 *
4409 * will in fact open a console titled 'deus=ex,machina'
4410 *
4411 * The title argument parsing code is only interested in quotes themselves,
4412 * it does not respect escaping of any kind and all quotes are dropped
4413 * from the resulting title, therefore:
4414 *
4415 * > start "\"" hello"/low
4416 *
4417 * actually opens a console titled '\ hello' with low priorities.
4418 *
4419 * To not break compatibility with wine programs relying on
4420 * wine's separate 'start.exe', this program's peculiar console
4421 * title parsing is actually implemented in 'cmd.exe' which is the
4422 * application native Windows programs will use to invoke 'start'.
4423 *
4424 * WCMD_parameter_with_delims will take care of everything for us.
4425 */
4433 /* No more parameters */
4437 /* Found the title */
4442 /* Copy all of the cmdline processed */
4446 /* Add quoted title */
4451 /* Concatenate remaining command-line */
4456 }
4458 /* Skipping a regular argument? */
4462 /* Not an argument nor the title, start of program arguments,
4463 * stop looking for title.
4464 */
4467 }
4469 /* build command-line if not built yet */
4472 }
4478 {
4484 }
4485 else
4486 {
4490 }
4492 }
4494 /****************************************************************************
4495 * WCMD_title
4496 *
4497 * Set the console title
4498 */
4501 }
4503 /****************************************************************************
4504 * WCMD_type
4505 *
4506 * Copy a file to standard output.
4507 */
4518 }
4522 /* Loop through all args */
4527 HANDLE h;
4529 DWORD count;
4543 }
4548 }
4550 }
4551 }
4552 }
4554 /****************************************************************************
4555 * WCMD_more
4556 *
4557 * Output either a file or stdin to screen in pages
4558 */
4567 DWORD count;
4569 /* Prefix the NLS more with '-- ', then load the text */
4576 /* Wine implements pipes via temporary files, and hence stdin is
4577 effectively reading from the file. This means the prompts for
4578 more are satisfied by the next line from the input (file). To
4579 avoid this, ensure stdin is to the console */
4587 /* Warning: No easy way of ending the stream (ctrl+z on windows) so
4588 once you get in this bit unless due to a pipe, it's going to end badly... */
4596 }
4599 /* Restore stdin to what it was */
4607 /* Loop through all args */
4613 HANDLE h;
4619 /* Wait */
4625 }
4638 WIN32_FILE_ATTRIBUTE_DATA fileInfo;
4640 /* Get the file size */
4650 /* Update % count (would be used in WCMD_output_asis as prompt) */
4654 }
4656 }
4657 }
4660 }
4661 }
4663 /****************************************************************************
4664 * WCMD_verify
4665 *
4666 * Display verify flag.
4667 * FIXME: We don't actually do anything with the verify flag other than toggle
4668 * it...
4669 */
4680 }
4684 }
4688 }
4690 }
4692 /****************************************************************************
4693 * WCMD_version
4694 *
4695 * Display version info.
4696 */
4702 }
4704 /****************************************************************************
4705 * WCMD_volume
4706 *
4707 * Display volume information (set_label = FALSE)
4708 * Additionally set volume label (set_label = TRUE)
4709 * Returns 1 on success, 0 otherwise
4710 */
4713 {
4716 BOOL status;
4723 }
4725 }
4730 }
4732 status = GetVolumeInformationW(curdir, label, ARRAY_SIZE(label), &serial, NULL, NULL, NULL, 0);
4733 }
4737 }
4741 }
4745 }
4754 }
4757 }
4760 }
4761 }
4763 }
4765 /**************************************************************************
4766 * WCMD_exit
4767 *
4768 * Exit either the process, or just this batch program
4769 *
4770 */
4781 }
4782 }
4785 /*****************************************************************************
4786 * WCMD_assoc
4787 *
4788 * Lists or sets file associations (assoc = TRUE)
4789 * Lists or sets file types (assoc = FALSE)
4790 */
4793 HKEY key;
4798 DWORD valueLen;
4799 HKEY readKey;
4801 /* See if parameter includes '=' */
4806 /* Open a key to HKEY_CLASSES_ROOT for enumerating */
4810 }
4812 /* If no parameters then list all associations */
4816 /* Enumerate all the keys */
4819 DWORD nameLen;
4821 /* Find the next value */
4827 /* Only interested in extension ones if assoc, or others
4828 if not assoc */
4831 {
4842 /* If no default value found, leave line empty after '=' */
4845 }
4848 }
4849 }
4850 }
4851 }
4855 /* Parameter supplied - if no '=' on command line, it's a query */
4860 /* Query terminates the parameter at the first space */
4865 /* Set up key name */
4875 /* If no default value found, leave line empty after '=' */
4883 /* Load the translated 'File association not found' */
4888 }
4891 }
4893 /* Not a query - it's a set or clear of a value */
4898 /* Get pointer to new value */
4900 newValue++;
4902 /* Set up key name */
4906 /* If nothing after '=' then clear value - only valid for ASSOC */
4920 /* Load the translated 'File association not found' */
4925 }
4928 }
4930 /* It really is a set value = contents */
4939 }
4949 }
4950 }
4951 }
4952 }
4954 /* Clean up */
4956 }
4958 /****************************************************************************
4959 * WCMD_color
4960 *
4961 * Colors the terminal screen.
4962 */
4966 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
4972 }
4975 {
4976 COORD topLeft;
4977 DWORD screenSize;
4985 /* Convert the color hex digits */
4990 }
4992 /* Fail if fg == bg color */
4996 }
4998 /* Set the current screen contents and ensure all future writes
4999 remain this color */
5002 }
5003 }
5005 /****************************************************************************
5006 * WCMD_mklink
5007 */
5010 {
5023 }
5043 else
5045 }
5046 }
5052 else
5057 }