programs/cmd/wcmdmain.c

   1 /*
   2  * CMD - Wine-compatible command line interface.
   3  *
   4  * Copyright (C) 1999 - 2001 D A Pickles
   5  * Copyright (C) 2007 J Edmeades
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /*
  23  * FIXME:
  24  * - Cannot handle parameters in quotes
  25  * - Lots of functionality missing from builtins
  26  */
  27
  28 #include "config.h"
  29 #include <time.h>
  30 #include "wcmd.h"
  31 #include "shellapi.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
  35
  36 extern const WCHAR inbuilt[][10];
  37 extern struct env_stack *pushd_directories;
  38
  39 BATCH_CONTEXT *context = NULL;
  40 DWORD errorlevel;
  41 WCHAR quals[MAX_PATH], param1[MAXSTRING], param2[MAXSTRING];
  42 BOOL  interactive;
  43 FOR_CONTEXT forloopcontext; /* The 'for' loop context */
  44 BOOL delayedsubst = FALSE; /* The current delayed substitution setting */
  45
  46 int defaultColor = 7;
  47 BOOL echo_mode = TRUE;
  48
  49 WCHAR anykey[100], version_string[100];
  50 const WCHAR newlineW[] = {'\r','\n','\0'};
  51 const WCHAR spaceW[]   = {' ','\0'};
  52 static const WCHAR envPathExt[] = {'P','A','T','H','E','X','T','\0'};
  53 static const WCHAR dfltPathExt[] = {'.','b','a','t',';',
  54                                     '.','c','o','m',';',
  55                                     '.','c','m','d',';',
  56                                     '.','e','x','e','\0'};
  57
  58 static BOOL opt_c, opt_k, opt_s, unicodeOutput = FALSE;
  59
  60 /* Variables pertaining to paging */
  61 static BOOL paged_mode;
  62 static const WCHAR *pagedMessage = NULL;
  63 static int line_count;
  64 static int max_height;
  65 static int max_width;
  66 static int numChars;
  67
  68 #define MAX_WRITECONSOLE_SIZE 65535
  69
  70 /*
  71  * Returns a buffer for reading from/writing to file
  72  * Never freed
  73  */
  74 static char *get_file_buffer(void)
  75 {
  76     static char *output_bufA = NULL;
  77     if (!output_bufA)
  78         output_bufA = heap_alloc(MAX_WRITECONSOLE_SIZE);
  79     return output_bufA;
  80 }
  81
  82 /*******************************************************************
  83  * WCMD_output_asis_len - send output to current standard output
  84  *
  85  * Output a formatted unicode string. Ideally this will go to the console
  86  *  and hence required WriteConsoleW to output it, however if file i/o is
  87  *  redirected, it needs to be WriteFile'd using OEM (not ANSI) format
  88  */
  89 static void WCMD_output_asis_len(const WCHAR *message, DWORD len, HANDLE device)
  90 {
  91     DWORD   nOut= 0;
  92     DWORD   res = 0;
  93
  94     /* If nothing to write, return (MORE does this sometimes) */
  95     if (!len) return;
  96
  97     /* Try to write as unicode assuming it is to a console */
  98     res = WriteConsoleW(device, message, len, &nOut, NULL);
  99
 100     /* If writing to console fails, assume it's file
 101        i/o so convert to OEM codepage and output                  */
 102     if (!res) {
 103       BOOL usedDefaultChar = FALSE;
 104       DWORD convertedChars;
 105       char *buffer;
 106
 107       if (!unicodeOutput) {
 108
 109         if (!(buffer = get_file_buffer()))
 110             return;
 111
 112         /* Convert to OEM, then output */
 113         convertedChars = WideCharToMultiByte(GetConsoleOutputCP(), 0, message,
 114                             len, buffer, MAX_WRITECONSOLE_SIZE,
 115                             "?", &usedDefaultChar);
 116         WriteFile(device, buffer, convertedChars,
 117                   &nOut, FALSE);
 118       } else {
 119         WriteFile(device, message, len*sizeof(WCHAR),
 120                   &nOut, FALSE);
 121       }
 122     }
 123     return;
 124 }
 125
 126 /*******************************************************************
 127  * WCMD_output - send output to current standard output device.
 128  *
 129  */
 130
 131 void CDECL WCMD_output (const WCHAR *format, ...) {
 132
 133   __ms_va_list ap;
 134   WCHAR* string;
 135   DWORD len;
 136
 137   __ms_va_start(ap,format);
 138   SetLastError(NO_ERROR);
 139   string = NULL;
 140   len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
 141                        format, 0, 0, (LPWSTR)&string, 0, &ap);
 142   __ms_va_end(ap);
 143   if (len == 0 && GetLastError() != NO_ERROR)
 144     WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format));
 145   else
 146   {
 147     WCMD_output_asis_len(string, len, GetStdHandle(STD_OUTPUT_HANDLE));
 148     LocalFree(string);
 149   }
 150 }
 151
 152 /*******************************************************************
 153  * WCMD_output_stderr - send output to current standard error device.
 154  *
 155  */
 156
 157 void CDECL WCMD_output_stderr (const WCHAR *format, ...) {
 158
 159   __ms_va_list ap;
 160   WCHAR* string;
 161   DWORD len;
 162
 163   __ms_va_start(ap,format);
 164   SetLastError(NO_ERROR);
 165   string = NULL;
 166   len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
 167                        format, 0, 0, (LPWSTR)&string, 0, &ap);
 168   __ms_va_end(ap);
 169   if (len == 0 && GetLastError() != NO_ERROR)
 170     WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format));
 171   else
 172   {
 173     WCMD_output_asis_len(string, len, GetStdHandle(STD_ERROR_HANDLE));
 174     LocalFree(string);
 175   }
 176 }
 177
 178 /*******************************************************************
 179  * WCMD_format_string - allocate a buffer and format a string
 180  *
 181  */
 182
 183 WCHAR* CDECL WCMD_format_string (const WCHAR *format, ...) {
 184
 185   __ms_va_list ap;
 186   WCHAR* string;
 187   DWORD len;
 188
 189   __ms_va_start(ap,format);
 190   SetLastError(NO_ERROR);
 191   len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
 192                        format, 0, 0, (LPWSTR)&string, 0, &ap);
 193   __ms_va_end(ap);
 194   if (len == 0 && GetLastError() != NO_ERROR) {
 195     WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format));
 196     string = (WCHAR*)LocalAlloc(LMEM_FIXED, 2);
 197     *string = 0;
 198   }
 199   return string;
 200 }
 201
 202 void WCMD_enter_paged_mode(const WCHAR *msg)
 203 {
 204   CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
 205
 206   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo)) {
 207     max_height = consoleInfo.dwSize.Y;
 208     max_width  = consoleInfo.dwSize.X;
 209   } else {
 210     max_height = 25;
 211     max_width  = 80;
 212   }
 213   paged_mode = TRUE;
 214   line_count = 0;
 215   numChars   = 0;
 216   pagedMessage = (msg==NULL)? anykey : msg;
 217 }
 218
 219 void WCMD_leave_paged_mode(void)
 220 {
 221   paged_mode = FALSE;
 222   pagedMessage = NULL;
 223 }
 224
 225 /***************************************************************************
 226  * WCMD_Readfile
 227  *
 228  *      Read characters in from a console/file, returning result in Unicode
 229  */
 230 BOOL WCMD_ReadFile(const HANDLE hIn, WCHAR *intoBuf, const DWORD maxChars, LPDWORD charsRead)
 231 {
 232     DWORD numRead;
 233     char *buffer;
 234
 235     if (WCMD_is_console_handle(hIn))
 236         /* Try to read from console as Unicode */
 237         return ReadConsoleW(hIn, intoBuf, maxChars, charsRead, NULL);
 238
 239     /* We assume it's a file handle and read then convert from assumed OEM codepage */
 240     if (!(buffer = get_file_buffer()))
 241         return FALSE;
 242
 243     if (!ReadFile(hIn, buffer, maxChars, &numRead, NULL))
 244         return FALSE;
 245
 246     *charsRead = MultiByteToWideChar(GetConsoleCP(), 0, buffer, numRead, intoBuf, maxChars);
 247
 248     return TRUE;
 249 }
 250
 251 /*******************************************************************
 252  * WCMD_output_asis_handle
 253  *
 254  * Send output to specified handle without formatting e.g. when message contains '%'
 255  */
 256 static void WCMD_output_asis_handle (DWORD std_handle, const WCHAR *message) {
 257   DWORD count;
 258   const WCHAR* ptr;
 259   WCHAR string[1024];
 260   HANDLE handle = GetStdHandle(std_handle);
 261
 262   if (paged_mode) {
 263     do {
 264       ptr = message;
 265       while (*ptr && *ptr!='\n' && (numChars < max_width)) {
 266         numChars++;
 267         ptr++;
 268       };
 269       if (*ptr == '\n') ptr++;
 270       WCMD_output_asis_len(message, ptr - message, handle);
 271       numChars = 0;
 272       if (++line_count >= max_height - 1) {
 273         line_count = 0;
 274         WCMD_output_asis_len(pagedMessage, strlenW(pagedMessage), handle);
 275         WCMD_ReadFile(GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string)/sizeof(WCHAR), &count);
 276       }
 277     } while (((message = ptr) != NULL) && (*ptr));
 278   } else {
 279     WCMD_output_asis_len(message, lstrlenW(message), handle);
 280   }
 281 }
 282
 283 /*******************************************************************
 284  * WCMD_output_asis
 285  *
 286  * Send output to current standard output device, without formatting
 287  * e.g. when message contains '%'
 288  */
 289 void WCMD_output_asis (const WCHAR *message) {
 290     WCMD_output_asis_handle(STD_OUTPUT_HANDLE, message);
 291 }
 292
 293 /*******************************************************************
 294  * WCMD_output_asis_stderr
 295  *
 296  * Send output to current standard error device, without formatting
 297  * e.g. when message contains '%'
 298  */
 299 void WCMD_output_asis_stderr (const WCHAR *message) {
 300     WCMD_output_asis_handle(STD_ERROR_HANDLE, message);
 301 }
 302
 303 /****************************************************************************
 304  * WCMD_print_error
 305  *
 306  * Print the message for GetLastError
 307  */
 308
 309 void WCMD_print_error (void) {
 310   LPVOID lpMsgBuf;
 311   DWORD error_code;
 312   int status;
 313
 314   error_code = GetLastError ();
 315   status = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 316                           NULL, error_code, 0, (LPWSTR) &lpMsgBuf, 0, NULL);
 317   if (!status) {
 318     WINE_FIXME ("Cannot display message for error %d, status %d\n",
 319                         error_code, GetLastError());
 320     return;
 321   }
 322
 323   WCMD_output_asis_len(lpMsgBuf, lstrlenW(lpMsgBuf),
 324                        GetStdHandle(STD_ERROR_HANDLE));
 325   LocalFree (lpMsgBuf);
 326   WCMD_output_asis_len (newlineW, lstrlenW(newlineW),
 327                         GetStdHandle(STD_ERROR_HANDLE));
 328   return;
 329 }
 330
 331 /******************************************************************************
 332  * WCMD_show_prompt
 333  *
 334  *      Display the prompt on STDout
 335  *
 336  */
 337
 338 static void WCMD_show_prompt (void) {
 339
 340   int status;
 341   WCHAR out_string[MAX_PATH], curdir[MAX_PATH], prompt_string[MAX_PATH];
 342   WCHAR *p, *q;
 343   DWORD len;
 344   static const WCHAR envPrompt[] = {'P','R','O','M','P','T','\0'};
 345
 346   len = GetEnvironmentVariableW(envPrompt, prompt_string,
 347                                 sizeof(prompt_string)/sizeof(WCHAR));
 348   if ((len == 0) || (len >= (sizeof(prompt_string)/sizeof(WCHAR)))) {
 349     static const WCHAR dfltPrompt[] = {'$','P','$','G','\0'};
 350     strcpyW (prompt_string, dfltPrompt);
 351   }
 352   p = prompt_string;
 353   q = out_string;
 354   *q++ = '\r';
 355   *q++ = '\n';
 356   *q = '\0';
 357   while (*p != '\0') {
 358     if (*p != '$') {
 359       *q++ = *p++;
 360       *q = '\0';
 361     }
 362     else {
 363       p++;
 364       switch (toupper(*p)) {
 365         case '$':
 366           *q++ = '$';
 367           break;
 368         case 'A':
 369           *q++ = '&';
 370           break;
 371         case 'B':
 372           *q++ = '|';
 373           break;
 374         case 'C':
 375           *q++ = '(';
 376           break;
 377         case 'D':
 378           GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, q, MAX_PATH);
 379           while (*q) q++;
 380           break;
 381         case 'E':
 382           *q++ = '\E';
 383           break;
 384         case 'F':
 385           *q++ = ')';
 386           break;
 387         case 'G':
 388           *q++ = '>';
 389           break;
 390         case 'H':
 391           *q++ = '\b';
 392           break;
 393         case 'L':
 394           *q++ = '<';
 395           break;
 396         case 'N':
 397           status = GetCurrentDirectoryW(sizeof(curdir)/sizeof(WCHAR), curdir);
 398           if (status) {
 399             *q++ = curdir[0];
 400           }
 401           break;
 402         case 'P':
 403           status = GetCurrentDirectoryW(sizeof(curdir)/sizeof(WCHAR), curdir);
 404           if (status) {
 405             strcatW (q, curdir);
 406             while (*q) q++;
 407           }
 408           break;
 409         case 'Q':
 410           *q++ = '=';
 411           break;
 412         case 'S':
 413           *q++ = ' ';
 414           break;
 415         case 'T':
 416           GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, NULL, q, MAX_PATH);
 417           while (*q) q++;
 418           break;
 419         case 'V':
 420           strcatW (q, version_string);
 421           while (*q) q++;
 422           break;
 423         case '_':
 424           *q++ = '\n';
 425           break;
 426         case '+':
 427           if (pushd_directories) {
 428             memset(q, '+', pushd_directories->u.stackdepth);
 429             q = q + pushd_directories->u.stackdepth;
 430           }
 431           break;
 432       }
 433       p++;
 434       *q = '\0';
 435     }
 436   }
 437   WCMD_output_asis (out_string);
 438 }
 439
 440 void *heap_alloc(size_t size)
 441 {
 442     void *ret;
 443
 444     ret = HeapAlloc(GetProcessHeap(), 0, size);
 445     if(!ret) {
 446         ERR("Out of memory\n");
 447         ExitProcess(1);
 448     }
 449
 450     return ret;
 451 }
 452
 453 /*************************************************************************
 454  * WCMD_strsubstW
 455  *    Replaces a portion of a Unicode string with the specified string.
 456  *    It's up to the caller to ensure there is enough space in the
 457  *    destination buffer.
 458  */
 459 void WCMD_strsubstW(WCHAR *start, const WCHAR *next, const WCHAR *insert, int len) {
 460
 461    if (len < 0)
 462       len=insert ? lstrlenW(insert) : 0;
 463    if (start+len != next)
 464        memmove(start+len, next, (strlenW(next) + 1) * sizeof(*next));
 465    if (insert)
 466        memcpy(start, insert, len * sizeof(*insert));
 467 }
 468
 469 /***************************************************************************
 470  * WCMD_skip_leading_spaces
 471  *
 472  *  Return a pointer to the first non-whitespace character of string.
 473  *  Does not modify the input string.
 474  */
 475 WCHAR *WCMD_skip_leading_spaces (WCHAR *string) {
 476
 477   WCHAR *ptr;
 478
 479   ptr = string;
 480   while (*ptr == ' ' || *ptr == '\t') ptr++;
 481   return ptr;
 482 }
 483
 484 /***************************************************************************
 485  * WCMD_keyword_ws_found
 486  *
 487  *  Checks if the string located at ptr matches a keyword (of length len)
 488  *  followed by a whitespace character (space or tab)
 489  */
 490 BOOL WCMD_keyword_ws_found(const WCHAR *keyword, int len, const WCHAR *ptr) {
 491     return (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
 492                            ptr, len, keyword, len) == CSTR_EQUAL)
 493             && ((*(ptr + len) == ' ') || (*(ptr + len) == '\t'));
 494 }
 495
 496 /*************************************************************************
 497  * WCMD_strip_quotes
 498  *
 499  *  Remove first and last quote WCHARacters, preserving all other text
 500  *  Returns the location of the final quote
 501  */
 502 WCHAR *WCMD_strip_quotes(WCHAR *cmd) {
 503   WCHAR *src = cmd + 1, *dest = cmd, *lastq = NULL, *lastquote;
 504   while((*dest=*src) != '\0') {
 505       if (*src=='\"')
 506           lastq=dest;
 507       dest++, src++;
 508   }
 509   lastquote = lastq;
 510   if (lastq) {
 511       dest=lastq++;
 512       while ((*dest++=*lastq++) != 0)
 513           ;
 514   }
 515   return lastquote;
 516 }
 517
 518
 519 /*************************************************************************
 520  * WCMD_is_magic_envvar
 521  * Return TRUE if s is '%'magicvar'%'
 522  * and is not masked by a real environment variable.
 523  */
 524
 525 static inline BOOL WCMD_is_magic_envvar(const WCHAR *s, const WCHAR *magicvar)
 526 {
 527     int len;
 528
 529     if (s[0] != '%')
 530         return FALSE;         /* Didn't begin with % */
 531     len = strlenW(s);
 532     if (len < 2 || s[len-1] != '%')
 533         return FALSE;         /* Didn't end with another % */
 534
 535     if (CompareStringW(LOCALE_USER_DEFAULT,
 536                        NORM_IGNORECASE | SORT_STRINGSORT,
 537                        s+1, len-2, magicvar, -1) != CSTR_EQUAL) {
 538         /* Name doesn't match. */
 539         return FALSE;
 540     }
 541
 542     if (GetEnvironmentVariableW(magicvar, NULL, 0) > 0) {
 543         /* Masked by real environment variable. */
 544         return FALSE;
 545     }
 546
 547     return TRUE;
 548 }
 549
 550 /*************************************************************************
 551  * WCMD_expand_envvar
 552  *
 553  *      Expands environment variables, allowing for WCHARacter substitution
 554  */
 555 static WCHAR *WCMD_expand_envvar(WCHAR *start, WCHAR startchar)
 556 {
 557     WCHAR *endOfVar = NULL, *s;
 558     WCHAR *colonpos = NULL;
 559     WCHAR thisVar[MAXSTRING];
 560     WCHAR thisVarContents[MAXSTRING];
 561     WCHAR savedchar = 0x00;
 562     int len;
 563
 564     static const WCHAR ErrorLvl[]  = {'E','R','R','O','R','L','E','V','E','L','\0'};
 565     static const WCHAR Date[]      = {'D','A','T','E','\0'};
 566     static const WCHAR Time[]      = {'T','I','M','E','\0'};
 567     static const WCHAR Cd[]        = {'C','D','\0'};
 568     static const WCHAR Random[]    = {'R','A','N','D','O','M','\0'};
 569     WCHAR Delims[]    = {'%',':','\0'}; /* First char gets replaced appropriately */
 570
 571     WINE_TRACE("Expanding: %s (%c)\n", wine_dbgstr_w(start), startchar);
 572
 573     /* Find the end of the environment variable, and extract name */
 574     Delims[0] = startchar;
 575     endOfVar = strpbrkW(start+1, Delims);
 576
 577     if (endOfVar == NULL || *endOfVar==' ') {
 578
 579       /* In batch program, missing terminator for % and no following
 580          ':' just removes the '%'                                   */
 581       if (context) {
 582         WCMD_strsubstW(start, start + 1, NULL, 0);
 583         return start;
 584       } else {
 585
 586         /* In command processing, just ignore it - allows command line
 587            syntax like: for %i in (a.a) do echo %i                     */
 588         return start+1;
 589       }
 590     }
 591
 592     /* If ':' found, process remaining up until '%' (or stop at ':' if
 593        a missing '%' */
 594     if (*endOfVar==':') {
 595         WCHAR *endOfVar2 = strchrW(endOfVar+1, startchar);
 596         if (endOfVar2 != NULL) endOfVar = endOfVar2;
 597     }
 598
 599     memcpy(thisVar, start, ((endOfVar - start) + 1) * sizeof(WCHAR));
 600     thisVar[(endOfVar - start)+1] = 0x00;
 601     colonpos = strchrW(thisVar+1, ':');
 602
 603     /* If there's complex substitution, just need %var% for now
 604        to get the expanded data to play with                    */
 605     if (colonpos) {
 606         *colonpos = startchar;
 607         savedchar = *(colonpos+1);
 608         *(colonpos+1) = 0x00;
 609     }
 610
 611     /* By now, we know the variable we want to expand but it may be
 612        surrounded by '!' if we are in delayed expansion - if so convert
 613        to % signs.                                                      */
 614     if (startchar=='!') {
 615       thisVar[0]                  = '%';
 616       thisVar[(endOfVar - start)] = '%';
 617     }
 618     WINE_TRACE("Retrieving contents of %s\n", wine_dbgstr_w(thisVar));
 619
 620     /* Expand to contents, if unchanged, return */
 621     /* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
 622     /* override if existing env var called that name              */
 623     if (WCMD_is_magic_envvar(thisVar, ErrorLvl)) {
 624       static const WCHAR fmt[] = {'%','d','\0'};
 625       wsprintfW(thisVarContents, fmt, errorlevel);
 626       len = strlenW(thisVarContents);
 627     } else if (WCMD_is_magic_envvar(thisVar, Date)) {
 628       GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL,
 629                     NULL, thisVarContents, MAXSTRING);
 630       len = strlenW(thisVarContents);
 631     } else if (WCMD_is_magic_envvar(thisVar, Time)) {
 632       GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL,
 633                         NULL, thisVarContents, MAXSTRING);
 634       len = strlenW(thisVarContents);
 635     } else if (WCMD_is_magic_envvar(thisVar, Cd)) {
 636       GetCurrentDirectoryW(MAXSTRING, thisVarContents);
 637       len = strlenW(thisVarContents);
 638     } else if (WCMD_is_magic_envvar(thisVar, Random)) {
 639       static const WCHAR fmt[] = {'%','d','\0'};
 640       wsprintfW(thisVarContents, fmt, rand() % 32768);
 641       len = strlenW(thisVarContents);
 642     } else {
 643
 644       len = ExpandEnvironmentStringsW(thisVar, thisVarContents,
 645                                sizeof(thisVarContents)/sizeof(WCHAR));
 646     }
 647
 648     if (len == 0)
 649       return endOfVar+1;
 650
 651     /* In a batch program, unknown env vars are replaced with nothing,
 652          note syntax %garbage:1,3% results in anything after the ':'
 653          except the %
 654        From the command line, you just get back what you entered      */
 655     if (lstrcmpiW(thisVar, thisVarContents) == 0) {
 656
 657       /* Restore the complex part after the compare */
 658       if (colonpos) {
 659         *colonpos = ':';
 660         *(colonpos+1) = savedchar;
 661       }
 662
 663       /* Command line - just ignore this */
 664       if (context == NULL) return endOfVar+1;
 665
 666
 667       /* Batch - replace unknown env var with nothing */
 668       if (colonpos == NULL) {
 669         WCMD_strsubstW(start, endOfVar + 1, NULL, 0);
 670       } else {
 671         len = strlenW(thisVar);
 672         thisVar[len-1] = 0x00;
 673         /* If %:...% supplied, : is retained */
 674         if (colonpos == thisVar+1) {
 675           WCMD_strsubstW(start, endOfVar + 1, colonpos, -1);
 676         } else {
 677           WCMD_strsubstW(start, endOfVar + 1, colonpos + 1, -1);
 678         }
 679       }
 680       return start;
 681
 682     }
 683
 684     /* See if we need to do complex substitution (any ':'s), if not
 685        then our work here is done                                  */
 686     if (colonpos == NULL) {
 687       WCMD_strsubstW(start, endOfVar + 1, thisVarContents, -1);
 688       return start;
 689     }
 690
 691     /* Restore complex bit */
 692     *colonpos = ':';
 693     *(colonpos+1) = savedchar;
 694
 695     /*
 696         Handle complex substitutions:
 697            xxx=yyy    (replace xxx with yyy)
 698            *xxx=yyy   (replace up to and including xxx with yyy)
 699            ~x         (from x WCHARs in)
 700            ~-x        (from x WCHARs from the end)
 701            ~x,y       (from x WCHARs in for y WCHARacters)
 702            ~x,-y      (from x WCHARs in until y WCHARacters from the end)
 703      */
 704
 705     /* ~ is substring manipulation */
 706     if (savedchar == '~') {
 707
 708       int   substrposition, substrlength = 0;
 709       WCHAR *commapos = strchrW(colonpos+2, ',');
 710       WCHAR *startCopy;
 711
 712       substrposition = atolW(colonpos+2);
 713       if (commapos) substrlength = atolW(commapos+1);
 714
 715       /* Check bounds */
 716       if (substrposition >= 0) {
 717         startCopy = &thisVarContents[min(substrposition, len)];
 718       } else {
 719         startCopy = &thisVarContents[max(0, len+substrposition-1)];
 720       }
 721
 722       if (commapos == NULL) {
 723         /* Copy the lot */
 724         WCMD_strsubstW(start, endOfVar + 1, startCopy, -1);
 725       } else if (substrlength < 0) {
 726
 727         int copybytes = (len+substrlength-1)-(startCopy-thisVarContents);
 728         if (copybytes > len) copybytes = len;
 729         else if (copybytes < 0) copybytes = 0;
 730         WCMD_strsubstW(start, endOfVar + 1, startCopy, copybytes);
 731       } else {
 732         substrlength = min(substrlength, len - (startCopy- thisVarContents + 1));
 733         WCMD_strsubstW(start, endOfVar + 1, startCopy, substrlength);
 734       }
 735
 736     /* search and replace manipulation */
 737     } else {
 738       WCHAR *equalspos = strstrW(colonpos, equalW);
 739       WCHAR *replacewith = equalspos+1;
 740       WCHAR *found       = NULL;
 741       WCHAR *searchIn;
 742       WCHAR *searchFor;
 743
 744       if (equalspos == NULL) return start+1;
 745       s = heap_strdupW(endOfVar + 1);
 746
 747       /* Null terminate both strings */
 748       thisVar[strlenW(thisVar)-1] = 0x00;
 749       *equalspos = 0x00;
 750
 751       /* Since we need to be case insensitive, copy the 2 buffers */
 752       searchIn  = heap_strdupW(thisVarContents);
 753       CharUpperBuffW(searchIn, strlenW(thisVarContents));
 754       searchFor = heap_strdupW(colonpos+1);
 755       CharUpperBuffW(searchFor, strlenW(colonpos+1));
 756
 757       /* Handle wildcard case */
 758       if (*(colonpos+1) == '*') {
 759         /* Search for string to replace */
 760         found = strstrW(searchIn, searchFor+1);
 761
 762         if (found) {
 763           /* Do replacement */
 764           strcpyW(start, replacewith);
 765           strcatW(start, thisVarContents + (found-searchIn) + strlenW(searchFor+1));
 766           strcatW(start, s);
 767         } else {
 768           /* Copy as is */
 769           strcpyW(start, thisVarContents);
 770           strcatW(start, s);
 771         }
 772
 773       } else {
 774         /* Loop replacing all instances */
 775         WCHAR *lastFound = searchIn;
 776         WCHAR *outputposn = start;
 777
 778         *start = 0x00;
 779         while ((found = strstrW(lastFound, searchFor))) {
 780             lstrcpynW(outputposn,
 781                     thisVarContents + (lastFound-searchIn),
 782                     (found - lastFound)+1);
 783             outputposn  = outputposn + (found - lastFound);
 784             strcatW(outputposn, replacewith);
 785             outputposn = outputposn + strlenW(replacewith);
 786             lastFound = found + strlenW(searchFor);
 787         }
 788         strcatW(outputposn,
 789                 thisVarContents + (lastFound-searchIn));
 790         strcatW(outputposn, s);
 791       }
 792       heap_free(s);
 793       heap_free(searchIn);
 794       heap_free(searchFor);
 795     }
 796     return start;
 797 }
 798
 799 /*****************************************************************************
 800  * Expand the command. Native expands lines from batch programs as they are
 801  * read in and not again, except for 'for' variable substitution.
 802  * eg. As evidence, "echo %1 && shift && echo %1" or "echo %%path%%"
 803  * atExecute is TRUE when the expansion is occurring as the command is executed
 804  * rather than at parse time, i.e. delayed expansion and for loops need to be
 805  * processed
 806  */
 807 static void handleExpansion(WCHAR *cmd, BOOL atExecute, BOOL delayed) {
 808
 809   /* For commands in a context (batch program):                  */
 810   /*   Expand environment variables in a batch file %{0-9} first */
 811   /*     including support for any ~ modifiers                   */
 812   /* Additionally:                                               */
 813   /*   Expand the DATE, TIME, CD, RANDOM and ERRORLEVEL special  */
 814   /*     names allowing environment variable overrides           */
 815   /* NOTE: To support the %PATH:xxx% syntax, also perform        */
 816   /*   manual expansion of environment variables here            */
 817
 818   WCHAR *p = cmd;
 819   WCHAR *t;
 820   int   i;
 821   WCHAR *delayedp = NULL;
 822   WCHAR  startchar = '%';
 823   WCHAR *normalp;
 824
 825   /* Display the FOR variables in effect */
 826   for (i=0;i<52;i++) {
 827     if (forloopcontext.variable[i]) {
 828       WINE_TRACE("FOR variable context: %c = '%s'\n",
 829                  i<26?i+'a':(i-26)+'A',
 830                  wine_dbgstr_w(forloopcontext.variable[i]));
 831     }
 832   }
 833
 834   /* Find the next environment variable delimiter */
 835   normalp = strchrW(p, '%');
 836   if (delayed) delayedp = strchrW(p, '!');
 837   if (!normalp) p = delayedp;
 838   else if (!delayedp) p = normalp;
 839   else p = min(p,delayedp);
 840   if (p) startchar = *p;
 841
 842   while (p) {
 843
 844     WINE_TRACE("Translate command:%s %d (at: %s)\n",
 845                    wine_dbgstr_w(cmd), atExecute, wine_dbgstr_w(p));
 846     i = *(p+1) - '0';
 847
 848     /* Don't touch %% unless it's in Batch */
 849     if (!atExecute && *(p+1) == startchar) {
 850       if (context) {
 851         WCMD_strsubstW(p, p+1, NULL, 0);
 852       }
 853       p+=1;
 854
 855     /* Replace %~ modifications if in batch program */
 856     } else if (*(p+1) == '~') {
 857       WCMD_HandleTildaModifiers(&p, atExecute);
 858       p++;
 859
 860     /* Replace use of %0...%9 if in batch program*/
 861     } else if (!atExecute && context && (i >= 0) && (i <= 9) && startchar == '%') {
 862       t = WCMD_parameter(context -> command, i + context -> shift_count[i],
 863                          NULL, TRUE, TRUE);
 864       WCMD_strsubstW(p, p+2, t, -1);
 865
 866     /* Replace use of %* if in batch program*/
 867     } else if (!atExecute && context && *(p+1)=='*' && startchar == '%') {
 868       WCHAR *startOfParms = NULL;
 869       WCHAR *thisParm = WCMD_parameter(context -> command, 0, &startOfParms, TRUE, TRUE);
 870       if (startOfParms != NULL) {
 871         startOfParms += strlenW(thisParm);
 872         while (*startOfParms==' ' || *startOfParms == '\t') startOfParms++;
 873         WCMD_strsubstW(p, p+2, startOfParms, -1);
 874       } else
 875         WCMD_strsubstW(p, p+2, NULL, 0);
 876
 877     } else {
 878       int forvaridx = FOR_VAR_IDX(*(p+1));
 879       if (startchar == '%' && forvaridx != -1 && forloopcontext.variable[forvaridx]) {
 880         /* Replace the 2 characters, % and for variable character */
 881         WCMD_strsubstW(p, p + 2, forloopcontext.variable[forvaridx], -1);
 882       } else if (!atExecute || startchar == '!') {
 883         p = WCMD_expand_envvar(p, startchar);
 884
 885       /* In a FOR loop, see if this is the variable to replace */
 886       } else { /* Ignore %'s on second pass of batch program */
 887         p++;
 888       }
 889     }
 890
 891     /* Find the next environment variable delimiter */
 892     normalp = strchrW(p, '%');
 893     if (delayed) delayedp = strchrW(p, '!');
 894     if (!normalp) p = delayedp;
 895     else if (!delayedp) p = normalp;
 896     else p = min(p,delayedp);
 897     if (p) startchar = *p;
 898   }
 899
 900   return;
 901 }
 902
 903
 904 /*******************************************************************
 905  * WCMD_parse - parse a command into parameters and qualifiers.
 906  *
 907  *      On exit, all qualifiers are concatenated into q, the first string
 908  *      not beginning with "/" is in p1 and the
 909  *      second in p2. Any subsequent non-qualifier strings are lost.
 910  *      Parameters in quotes are handled.
 911  */
 912 static void WCMD_parse (const WCHAR *s, WCHAR *q, WCHAR *p1, WCHAR *p2)
 913 {
 914   int p = 0;
 915
 916   *q = *p1 = *p2 = '\0';
 917   while (TRUE) {
 918     switch (*s) {
 919       case '/':
 920         *q++ = *s++;
 921         while ((*s != '\0') && (*s != ' ') && *s != '/') {
 922           *q++ = toupperW (*s++);
 923         }
 924         *q = '\0';
 925         break;
 926       case ' ':
 927       case '\t':
 928         s++;
 929         break;
 930       case '"':
 931         s++;
 932         while ((*s != '\0') && (*s != '"')) {
 933           if (p == 0) *p1++ = *s++;
 934           else if (p == 1) *p2++ = *s++;
 935           else s++;
 936         }
 937         if (p == 0) *p1 = '\0';
 938         if (p == 1) *p2 = '\0';
 939         p++;
 940         if (*s == '"') s++;
 941         break;
 942       case '\0':
 943         return;
 944       default:
 945         while ((*s != '\0') && (*s != ' ') && (*s != '\t')
 946                && (*s != '=')  && (*s != ',') ) {
 947           if (p == 0) *p1++ = *s++;
 948           else if (p == 1) *p2++ = *s++;
 949           else s++;
 950         }
 951         /* Skip concurrent parms */
 952         while ((*s == ' ') || (*s == '\t') || (*s == '=')  || (*s == ',') ) s++;
 953
 954         if (p == 0) *p1 = '\0';
 955         if (p == 1) *p2 = '\0';
 956         p++;
 957     }
 958   }
 959 }
 960
 961 static void init_msvcrt_io_block(STARTUPINFOW* st)
 962 {
 963     STARTUPINFOW st_p;
 964     /* fetch the parent MSVCRT info block if any, so that the child can use the
 965      * same handles as its grand-father
 966      */
 967     st_p.cb = sizeof(STARTUPINFOW);
 968     GetStartupInfoW(&st_p);
 969     st->cbReserved2 = st_p.cbReserved2;
 970     st->lpReserved2 = st_p.lpReserved2;
 971     if (st_p.cbReserved2 && st_p.lpReserved2)
 972     {
 973         unsigned num = *(unsigned*)st_p.lpReserved2;
 974         char* flags;
 975         HANDLE* handles;
 976         BYTE *ptr;
 977         size_t sz;
 978
 979         /* Override the entries for fd 0,1,2 if we happened
 980          * to change those std handles (this depends on the way cmd sets
 981          * its new input & output handles)
 982          */
 983         sz = max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * 3, st_p.cbReserved2);
 984         ptr = heap_alloc(sz);
 985         flags = (char*)(ptr + sizeof(unsigned));
 986         handles = (HANDLE*)(flags + num * sizeof(char));
 987
 988         memcpy(ptr, st_p.lpReserved2, st_p.cbReserved2);
 989         st->cbReserved2 = sz;
 990         st->lpReserved2 = ptr;
 991
 992 #define WX_OPEN 0x01    /* see dlls/msvcrt/file.c */
 993         if (num <= 0 || (flags[0] & WX_OPEN))
 994         {
 995             handles[0] = GetStdHandle(STD_INPUT_HANDLE);
 996             flags[0] |= WX_OPEN;
 997         }
 998         if (num <= 1 || (flags[1] & WX_OPEN))
 999         {
1000             handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
1001             flags[1] |= WX_OPEN;
1002         }
1003         if (num <= 2 || (flags[2] & WX_OPEN))
1004         {
1005             handles[2] = GetStdHandle(STD_ERROR_HANDLE);
1006             flags[2] |= WX_OPEN;
1007         }
1008 #undef WX_OPEN
1009     }
1010 }
1011
1012 /******************************************************************************
1013  * WCMD_run_program
1014  *
1015  *      Execute a command line as an external program. Must allow recursion.
1016  *
1017  *      Precedence:
1018  *        Manual testing under windows shows PATHEXT plays a key part in this,
1019  *      and the search algorithm and precedence appears to be as follows.
1020  *
1021  *      Search locations:
1022  *        If directory supplied on command, just use that directory
1023  *        If extension supplied on command, look for that explicit name first
1024  *        Otherwise, search in each directory on the path
1025  *      Precedence:
1026  *        If extension supplied on command, look for that explicit name first
1027  *        Then look for supplied name .* (even if extension supplied, so
1028  *          'garbage.exe' will match 'garbage.exe.cmd')
1029  *        If any found, cycle through PATHEXT looking for name.exe one by one
1030  *      Launching
1031  *        Once a match has been found, it is launched - Code currently uses
1032  *          findexecutable to achieve this which is left untouched.
1033  *        If an executable has not been found, and we were launched through
1034  *          a call, we need to check if the command is an internal command,
1035  *          so go back through wcmd_execute.
1036  */
1037
1038 void WCMD_run_program (WCHAR *command, BOOL called)
1039 {
1040   WCHAR  temp[MAX_PATH];
1041   WCHAR  pathtosearch[MAXSTRING];
1042   WCHAR *pathposn;
1043   WCHAR  stemofsearch[MAX_PATH];    /* maximum allowed executable name is
1044                                        MAX_PATH, including null character */
1045   WCHAR *lastSlash;
1046   WCHAR  pathext[MAXSTRING];
1047   WCHAR *firstParam;
1048   BOOL  extensionsupplied = FALSE;
1049   BOOL  status;
1050   DWORD len;
1051   static const WCHAR envPath[] = {'P','A','T','H','\0'};
1052   static const WCHAR delims[] = {'/','\\',':','\0'};
1053
1054   /* Quick way to get the filename is to extract the first argument. */
1055   WINE_TRACE("Running '%s' (%d)\n", wine_dbgstr_w(command), called);
1056   firstParam = WCMD_parameter(command, 0, NULL, FALSE, TRUE);
1057   if (!firstParam) return;
1058
1059   /* Calculate the search path and stem to search for */
1060   if (strpbrkW (firstParam, delims) == NULL) {  /* No explicit path given, search path */
1061     static const WCHAR curDir[] = {'.',';','\0'};
1062     strcpyW(pathtosearch, curDir);
1063     len = GetEnvironmentVariableW(envPath, &pathtosearch[2], (sizeof(pathtosearch)/sizeof(WCHAR))-2);
1064     if ((len == 0) || (len >= (sizeof(pathtosearch)/sizeof(WCHAR)) - 2)) {
1065       static const WCHAR curDir[] = {'.','\0'};
1066       strcpyW (pathtosearch, curDir);
1067     }
1068     if (strchrW(firstParam, '.') != NULL) extensionsupplied = TRUE;
1069     if (strlenW(firstParam) >= MAX_PATH)
1070     {
1071         WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_LINETOOLONG));
1072         return;
1073     }
1074
1075     strcpyW(stemofsearch, firstParam);
1076
1077   } else {
1078
1079     /* Convert eg. ..\fred to include a directory by removing file part */
1080     GetFullPathNameW(firstParam, sizeof(pathtosearch)/sizeof(WCHAR), pathtosearch, NULL);
1081     lastSlash = strrchrW(pathtosearch, '\\');
1082     if (lastSlash && strchrW(lastSlash, '.') != NULL) extensionsupplied = TRUE;
1083     strcpyW(stemofsearch, lastSlash+1);
1084
1085     /* Reduce pathtosearch to a path with trailing '\' to support c:\a.bat and
1086        c:\windows\a.bat syntax                                                 */
1087     if (lastSlash) *(lastSlash + 1) = 0x00;
1088   }
1089
1090   /* Now extract PATHEXT */
1091   len = GetEnvironmentVariableW(envPathExt, pathext, sizeof(pathext)/sizeof(WCHAR));
1092   if ((len == 0) || (len >= (sizeof(pathext)/sizeof(WCHAR)))) {
1093     strcpyW (pathext, dfltPathExt);
1094   }
1095
1096   /* Loop through the search path, dir by dir */
1097   pathposn = pathtosearch;
1098   WINE_TRACE("Searching in '%s' for '%s'\n", wine_dbgstr_w(pathtosearch),
1099              wine_dbgstr_w(stemofsearch));
1100   while (pathposn) {
1101     WCHAR  thisDir[MAX_PATH] = {'\0'};
1102     WCHAR *pos               = NULL;
1103     BOOL  found             = FALSE;
1104
1105     /* Work on the first directory on the search path */
1106     pos = strchrW(pathposn, ';');
1107     if (pos) {
1108       memcpy(thisDir, pathposn, (pos-pathposn) * sizeof(WCHAR));
1109       thisDir[(pos-pathposn)] = 0x00;
1110       pathposn = pos+1;
1111
1112     } else {
1113       strcpyW(thisDir, pathposn);
1114       pathposn = NULL;
1115     }
1116
1117     /* Since you can have eg. ..\.. on the path, need to expand
1118        to full information                                      */
1119     strcpyW(temp, thisDir);
1120     GetFullPathNameW(temp, MAX_PATH, thisDir, NULL);
1121
1122     /* 1. If extension supplied, see if that file exists */
1123     strcatW(thisDir, slashW);
1124     strcatW(thisDir, stemofsearch);
1125     pos = &thisDir[strlenW(thisDir)]; /* Pos = end of name */
1126
1127     /* 1. If extension supplied, see if that file exists */
1128     if (extensionsupplied) {
1129       if (GetFileAttributesW(thisDir) != INVALID_FILE_ATTRIBUTES) {
1130         found = TRUE;
1131       }
1132     }
1133
1134     /* 2. Any .* matches? */
1135     if (!found) {
1136       HANDLE          h;
1137       WIN32_FIND_DATAW finddata;
1138       static const WCHAR allFiles[] = {'.','*','\0'};
1139
1140       strcatW(thisDir,allFiles);
1141       h = FindFirstFileW(thisDir, &finddata);
1142       FindClose(h);
1143       if (h != INVALID_HANDLE_VALUE) {
1144
1145         WCHAR *thisExt = pathext;
1146
1147         /* 3. Yes - Try each path ext */
1148         while (thisExt) {
1149           WCHAR *nextExt = strchrW(thisExt, ';');
1150
1151           if (nextExt) {
1152             memcpy(pos, thisExt, (nextExt-thisExt) * sizeof(WCHAR));
1153             pos[(nextExt-thisExt)] = 0x00;
1154             thisExt = nextExt+1;
1155           } else {
1156             strcpyW(pos, thisExt);
1157             thisExt = NULL;
1158           }
1159
1160           if (GetFileAttributesW(thisDir) != INVALID_FILE_ATTRIBUTES) {
1161             found = TRUE;
1162             thisExt = NULL;
1163           }
1164         }
1165       }
1166     }
1167
1168     /* Once found, launch it */
1169     if (found) {
1170       STARTUPINFOW st;
1171       PROCESS_INFORMATION pe;
1172       SHFILEINFOW psfi;
1173       DWORD console;
1174       HINSTANCE hinst;
1175       WCHAR *ext = strrchrW( thisDir, '.' );
1176       static const WCHAR batExt[] = {'.','b','a','t','\0'};
1177       static const WCHAR cmdExt[] = {'.','c','m','d','\0'};
1178
1179       WINE_TRACE("Found as %s\n", wine_dbgstr_w(thisDir));
1180
1181       /* Special case BAT and CMD */
1182       if (ext && (!strcmpiW(ext, batExt) || !strcmpiW(ext, cmdExt))) {
1183         BOOL oldinteractive = interactive;
1184         interactive = FALSE;
1185         WCMD_batch (thisDir, command, called, NULL, INVALID_HANDLE_VALUE);
1186         interactive = oldinteractive;
1187         return;
1188       } else {
1189
1190         /* thisDir contains the file to be launched, but with what?
1191            eg. a.exe will require a.exe to be launched, a.html may be iexplore */
1192         hinst = FindExecutableW (thisDir, NULL, temp);
1193         if ((INT_PTR)hinst < 32)
1194           console = 0;
1195         else
1196           console = SHGetFileInfoW(temp, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
1197
1198         ZeroMemory (&st, sizeof(STARTUPINFOW));
1199         st.cb = sizeof(STARTUPINFOW);
1200         init_msvcrt_io_block(&st);
1201
1202         /* Launch the process and if a CUI wait on it to complete
1203            Note: Launching internal wine processes cannot specify a full path to exe */
1204         status = CreateProcessW(thisDir,
1205                                 command, NULL, NULL, TRUE, 0, NULL, NULL, &st, &pe);
1206         heap_free(st.lpReserved2);
1207         if ((opt_c || opt_k) && !opt_s && !status
1208             && GetLastError()==ERROR_FILE_NOT_FOUND && command[0]=='\"') {
1209           /* strip first and last quote WCHARacters and try again */
1210           WCMD_strip_quotes(command);
1211           opt_s = TRUE;
1212           WCMD_run_program(command, called);
1213           return;
1214         }
1215
1216         if (!status)
1217           break;
1218
1219         /* Always wait when non-interactive (cmd /c or in batch program),
1220            or for console applications                                    */
1221         if (!interactive || (console && !HIWORD(console)))
1222             WaitForSingleObject (pe.hProcess, INFINITE);
1223         GetExitCodeProcess (pe.hProcess, &errorlevel);
1224         if (errorlevel == STILL_ACTIVE) errorlevel = 0;
1225
1226         CloseHandle(pe.hProcess);
1227         CloseHandle(pe.hThread);
1228         return;
1229       }
1230     }
1231   }
1232
1233   /* Not found anywhere - were we called? */
1234   if (called) {
1235     CMD_LIST *toExecute = NULL;         /* Commands left to be executed */
1236
1237     /* Parse the command string, without reading any more input */
1238     WCMD_ReadAndParseLine(command, &toExecute, INVALID_HANDLE_VALUE);
1239     WCMD_process_commands(toExecute, FALSE, called);
1240     WCMD_free_commands(toExecute);
1241     toExecute = NULL;
1242     return;
1243   }
1244
1245   /* Not found anywhere - give up */
1246   WCMD_output_stderr(WCMD_LoadMessage(WCMD_NO_COMMAND_FOUND), command);
1247
1248   /* If a command fails to launch, it sets errorlevel 9009 - which
1249      does not seem to have any associated constant definition     */
1250   errorlevel = 9009;
1251   return;
1252
1253 }
1254
1255 /*****************************************************************************
1256  * Process one command. If the command is EXIT this routine does not return.
1257  * We will recurse through here executing batch files.
1258  * Note: If call is used to a non-existing program, we reparse the line and
1259  *       try to run it as an internal command. 'retrycall' represents whether
1260  *       we are attempting this retry.
1261  */
1262 void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
1263                    CMD_LIST **cmdList, BOOL retrycall)
1264 {
1265     WCHAR *cmd, *p, *redir;
1266     int status, i;
1267     DWORD count, creationDisposition;
1268     HANDLE h;
1269     WCHAR *whichcmd;
1270     SECURITY_ATTRIBUTES sa;
1271     WCHAR *new_cmd = NULL;
1272     WCHAR *new_redir = NULL;
1273     HANDLE old_stdhandles[3] = {GetStdHandle (STD_INPUT_HANDLE),
1274                                 GetStdHandle (STD_OUTPUT_HANDLE),
1275                                 GetStdHandle (STD_ERROR_HANDLE)};
1276     DWORD  idx_stdhandles[3] = {STD_INPUT_HANDLE,
1277                                 STD_OUTPUT_HANDLE,
1278                                 STD_ERROR_HANDLE};
1279     BOOL prev_echo_mode, piped = FALSE;
1280
1281     WINE_TRACE("command on entry:%s (%p)\n",
1282                wine_dbgstr_w(command), cmdList);
1283
1284     /* If the next command is a pipe then we implement pipes by redirecting
1285        the output from this command to a temp file and input into the
1286        next command from that temp file.
1287        FIXME: Use of named pipes would make more sense here as currently this
1288        process has to finish before the next one can start but this requires
1289        a change to not wait for the first app to finish but rather the pipe  */
1290     if (cmdList && (*cmdList)->nextcommand &&
1291         (*cmdList)->nextcommand->prevDelim == CMD_PIPE) {
1292
1293         WCHAR temp_path[MAX_PATH];
1294         static const WCHAR cmdW[]     = {'C','M','D','\0'};
1295
1296         /* Remember piping is in action */
1297         WINE_TRACE("Output needs to be piped\n");
1298         piped = TRUE;
1299
1300         /* Generate a unique temporary filename */
1301         GetTempPathW(sizeof(temp_path)/sizeof(WCHAR), temp_path);
1302         GetTempFileNameW(temp_path, cmdW, 0, (*cmdList)->nextcommand->pipeFile);
1303         WINE_TRACE("Using temporary file of %s\n",
1304                    wine_dbgstr_w((*cmdList)->nextcommand->pipeFile));
1305     }
1306
1307     /* Move copy of the command onto the heap so it can be expanded */
1308     new_cmd = heap_alloc(MAXSTRING * sizeof(WCHAR));
1309     strcpyW(new_cmd, command);
1310
1311     /* Move copy of the redirects onto the heap so it can be expanded */
1312     new_redir = heap_alloc(MAXSTRING * sizeof(WCHAR));
1313
1314     /* If piped output, send stdout to the pipe by appending >filename to redirects */
1315     if (piped) {
1316         static const WCHAR redirOut[] = {'%','s',' ','>',' ','%','s','\0'};
1317         wsprintfW (new_redir, redirOut, redirects, (*cmdList)->nextcommand->pipeFile);
1318         WINE_TRACE("Redirects now %s\n", wine_dbgstr_w(new_redir));
1319     } else {
1320         strcpyW(new_redir, redirects);
1321     }
1322
1323     /* Expand variables in command line mode only (batch mode will
1324        be expanded as the line is read in, except for 'for' loops) */
1325     handleExpansion(new_cmd, (context != NULL), delayedsubst);
1326     handleExpansion(new_redir, (context != NULL), delayedsubst);
1327     cmd = new_cmd;
1328
1329 /*
1330  *      Changing default drive has to be handled as a special case.
1331  */
1332
1333     if ((strlenW(cmd) == 2) && (cmd[1] == ':') && IsCharAlphaW(cmd[0])) {
1334       WCHAR envvar[5];
1335       WCHAR dir[MAX_PATH];
1336
1337       /* According to MSDN CreateProcess docs, special env vars record
1338          the current directory on each drive, in the form =C:
1339          so see if one specified, and if so go back to it             */
1340       strcpyW(envvar, equalW);
1341       strcatW(envvar, cmd);
1342       if (GetEnvironmentVariableW(envvar, dir, MAX_PATH) == 0) {
1343         static const WCHAR fmt[] = {'%','s','\\','\0'};
1344         wsprintfW(cmd, fmt, cmd);
1345         WINE_TRACE("No special directory settings, using dir of %s\n", wine_dbgstr_w(cmd));
1346       }
1347       WINE_TRACE("Got directory %s as %s\n", wine_dbgstr_w(envvar), wine_dbgstr_w(cmd));
1348       status = SetCurrentDirectoryW(cmd);
1349       if (!status) WCMD_print_error ();
1350       heap_free(cmd );
1351       heap_free(new_redir);
1352       return;
1353     }
1354
1355     sa.nLength = sizeof(sa);
1356     sa.lpSecurityDescriptor = NULL;
1357     sa.bInheritHandle = TRUE;
1358
1359 /*
1360  *      Redirect stdin, stdout and/or stderr if required.
1361  */
1362
1363     /* STDIN could come from a preceding pipe, so delete on close if it does */
1364     if (cmdList && (*cmdList)->pipeFile[0] != 0x00) {
1365         WINE_TRACE("Input coming from %s\n", wine_dbgstr_w((*cmdList)->pipeFile));
1366         h = CreateFileW((*cmdList)->pipeFile, GENERIC_READ,
1367                   FILE_SHARE_READ, &sa, OPEN_EXISTING,
1368                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL);
1369         if (h == INVALID_HANDLE_VALUE) {
1370           WCMD_print_error ();
1371           heap_free(cmd);
1372           heap_free(new_redir);
1373           return;
1374         }
1375         SetStdHandle (STD_INPUT_HANDLE, h);
1376
1377         /* No need to remember the temporary name any longer once opened */
1378         (*cmdList)->pipeFile[0] = 0x00;
1379
1380     /* Otherwise STDIN could come from a '<' redirect */
1381     } else if ((p = strchrW(new_redir,'<')) != NULL) {
1382       h = CreateFileW(WCMD_parameter(++p, 0, NULL, FALSE, FALSE), GENERIC_READ, FILE_SHARE_READ,
1383                       &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1384       if (h == INVALID_HANDLE_VALUE) {
1385         WCMD_print_error ();
1386         heap_free(cmd);
1387         heap_free(new_redir);
1388         return;
1389       }
1390       SetStdHandle (STD_INPUT_HANDLE, h);
1391     }
1392
1393     /* Scan the whole command looking for > and 2> */
1394     redir = new_redir;
1395     while (redir != NULL && ((p = strchrW(redir,'>')) != NULL)) {
1396       int handle = 0;
1397
1398       if (p > redir && (*(p-1)=='2'))
1399         handle = 2;
1400       else
1401         handle = 1;
1402
1403       p++;
1404       if ('>' == *p) {
1405         creationDisposition = OPEN_ALWAYS;
1406         p++;
1407       }
1408       else {
1409         creationDisposition = CREATE_ALWAYS;
1410       }
1411
1412       /* Add support for 2>&1 */
1413       redir = p;
1414       if (*p == '&') {
1415         int idx = *(p+1) - '0';
1416
1417         if (DuplicateHandle(GetCurrentProcess(),
1418                         GetStdHandle(idx_stdhandles[idx]),
1419                         GetCurrentProcess(),
1420                         &h,
1421                         0, TRUE, DUPLICATE_SAME_ACCESS) == 0) {
1422           WINE_FIXME("Duplicating handle failed with gle %d\n", GetLastError());
1423         }
1424         WINE_TRACE("Redirect %d (%p) to %d (%p)\n", handle, GetStdHandle(idx_stdhandles[idx]), idx, h);
1425
1426       } else {
1427         WCHAR *param = WCMD_parameter(p, 0, NULL, FALSE, FALSE);
1428         h = CreateFileW(param, GENERIC_WRITE, 0, &sa, creationDisposition,
1429                         FILE_ATTRIBUTE_NORMAL, NULL);
1430         if (h == INVALID_HANDLE_VALUE) {
1431           WCMD_print_error ();
1432           heap_free(cmd);
1433           heap_free(new_redir);
1434           return;
1435         }
1436         if (SetFilePointer (h, 0, NULL, FILE_END) ==
1437               INVALID_SET_FILE_POINTER) {
1438           WCMD_print_error ();
1439         }
1440         WINE_TRACE("Redirect %d to '%s' (%p)\n", handle, wine_dbgstr_w(param), h);
1441       }
1442
1443       SetStdHandle (idx_stdhandles[handle], h);
1444     }
1445
1446 /*
1447  * Strip leading whitespaces, and a '@' if supplied
1448  */
1449     whichcmd = WCMD_skip_leading_spaces(cmd);
1450     WINE_TRACE("Command: '%s'\n", wine_dbgstr_w(cmd));
1451     if (whichcmd[0] == '@') whichcmd++;
1452
1453 /*
1454  *      Check if the command entered is internal. If it is, pass the rest of the
1455  *      line down to the command. If not try to run a program.
1456  */
1457
1458     count = 0;
1459     while (IsCharAlphaNumericW(whichcmd[count])) {
1460       count++;
1461     }
1462     for (i=0; i<=WCMD_EXIT; i++) {
1463       if (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1464         whichcmd, count, inbuilt[i], -1) == CSTR_EQUAL) break;
1465     }
1466     p = WCMD_skip_leading_spaces (&whichcmd[count]);
1467     WCMD_parse (p, quals, param1, param2);
1468     WINE_TRACE("param1: %s, param2: %s\n", wine_dbgstr_w(param1), wine_dbgstr_w(param2));
1469
1470     if (i <= WCMD_EXIT && (p[0] == '/') && (p[1] == '?')) {
1471       /* this is a help request for a builtin program */
1472       i = WCMD_HELP;
1473       memcpy(p, whichcmd, count * sizeof(WCHAR));
1474       p[count] = '\0';
1475
1476     }
1477
1478     switch (i) {
1479
1480       case WCMD_CALL:
1481         WCMD_call (p);
1482         break;
1483       case WCMD_CD:
1484       case WCMD_CHDIR:
1485         WCMD_setshow_default (p);
1486         break;
1487       case WCMD_CLS:
1488         WCMD_clear_screen ();
1489         break;
1490       case WCMD_COPY:
1491         WCMD_copy (p);
1492         break;
1493       case WCMD_CTTY:
1494         WCMD_change_tty ();
1495         break;
1496       case WCMD_DATE:
1497         WCMD_setshow_date ();
1498         break;
1499       case WCMD_DEL:
1500       case WCMD_ERASE:
1501         WCMD_delete (p);
1502         break;
1503       case WCMD_DIR:
1504         WCMD_directory (p);
1505         break;
1506       case WCMD_ECHO:
1507         WCMD_echo(&whichcmd[count]);
1508         break;
1509       case WCMD_GOTO:
1510         WCMD_goto (cmdList);
1511         break;
1512       case WCMD_HELP:
1513         WCMD_give_help (p);
1514         break;
1515       case WCMD_LABEL:
1516         WCMD_volume (TRUE, p);
1517         break;
1518       case WCMD_MD:
1519       case WCMD_MKDIR:
1520         WCMD_create_dir (p);
1521         break;
1522       case WCMD_MOVE:
1523         WCMD_move ();
1524         break;
1525       case WCMD_PATH:
1526         WCMD_setshow_path (p);
1527         break;
1528       case WCMD_PAUSE:
1529         WCMD_pause ();
1530         break;
1531       case WCMD_PROMPT:
1532         WCMD_setshow_prompt ();
1533         break;
1534       case WCMD_REM:
1535         break;
1536       case WCMD_REN:
1537       case WCMD_RENAME:
1538         WCMD_rename ();
1539         break;
1540       case WCMD_RD:
1541       case WCMD_RMDIR:
1542         WCMD_remove_dir (p);
1543         break;
1544       case WCMD_SETLOCAL:
1545         WCMD_setlocal(p);
1546         break;
1547       case WCMD_ENDLOCAL:
1548         WCMD_endlocal();
1549         break;
1550       case WCMD_SET:
1551         WCMD_setshow_env (p);
1552         break;
1553       case WCMD_SHIFT:
1554         WCMD_shift (p);
1555         break;
1556       case WCMD_START:
1557         WCMD_start (p);
1558         break;
1559       case WCMD_TIME:
1560         WCMD_setshow_time ();
1561         break;
1562       case WCMD_TITLE:
1563         if (strlenW(&whichcmd[count]) > 0)
1564           WCMD_title(&whichcmd[count+1]);
1565         break;
1566       case WCMD_TYPE:
1567         WCMD_type (p);
1568         break;
1569       case WCMD_VER:
1570         WCMD_output_asis(newlineW);
1571         WCMD_version ();
1572         break;
1573       case WCMD_VERIFY:
1574         WCMD_verify (p);
1575         break;
1576       case WCMD_VOL:
1577         WCMD_volume (FALSE, p);
1578         break;
1579       case WCMD_PUSHD:
1580         WCMD_pushd(p);
1581         break;
1582       case WCMD_POPD:
1583         WCMD_popd();
1584         break;
1585       case WCMD_ASSOC:
1586         WCMD_assoc(p, TRUE);
1587         break;
1588       case WCMD_COLOR:
1589         WCMD_color();
1590         break;
1591       case WCMD_FTYPE:
1592         WCMD_assoc(p, FALSE);
1593         break;
1594       case WCMD_MORE:
1595         WCMD_more(p);
1596         break;
1597       case WCMD_CHOICE:
1598         WCMD_choice(p);
1599         break;
1600       case WCMD_EXIT:
1601         WCMD_exit (cmdList);
1602         break;
1603       case WCMD_FOR:
1604       case WCMD_IF:
1605         /* Very oddly, probably because of all the special parsing required for
1606            these two commands, neither 'for' nor 'if' is supported when called,
1607            i.e. 'call if 1==1...' will fail.                                    */
1608         if (!retrycall) {
1609           if (i==WCMD_FOR) WCMD_for (p, cmdList);
1610           else if (i==WCMD_IF) WCMD_if (p, cmdList);
1611           break;
1612         }
1613         /* else: drop through */
1614       default:
1615         prev_echo_mode = echo_mode;
1616         WCMD_run_program (whichcmd, FALSE);
1617         echo_mode = prev_echo_mode;
1618     }
1619     heap_free(cmd);
1620     heap_free(new_redir);
1621
1622     /* Restore old handles */
1623     for (i=0; i<3; i++) {
1624       if (old_stdhandles[i] != GetStdHandle(idx_stdhandles[i])) {
1625         CloseHandle (GetStdHandle (idx_stdhandles[i]));
1626         SetStdHandle (idx_stdhandles[i], old_stdhandles[i]);
1627       }
1628     }
1629 }
1630
1631 /*************************************************************************
1632  * WCMD_LoadMessage
1633  *    Load a string from the resource file, handling any error
1634  *    Returns string retrieved from resource file
1635  */
1636 WCHAR *WCMD_LoadMessage(UINT id) {
1637     static WCHAR msg[2048];
1638     static const WCHAR failedMsg[]  = {'F','a','i','l','e','d','!','\0'};
1639
1640     if (!LoadStringW(GetModuleHandleW(NULL), id, msg, sizeof(msg)/sizeof(WCHAR))) {
1641        WINE_FIXME("LoadString failed with %d\n", GetLastError());
1642        strcpyW(msg, failedMsg);
1643     }
1644     return msg;
1645 }
1646
1647 /***************************************************************************
1648  * WCMD_DumpCommands
1649  *
1650  *      Dumps out the parsed command line to ensure syntax is correct
1651  */
1652 static void WCMD_DumpCommands(CMD_LIST *commands) {
1653     CMD_LIST *thisCmd = commands;
1654
1655     WINE_TRACE("Parsed line:\n");
1656     while (thisCmd != NULL) {
1657       WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
1658                thisCmd,
1659                thisCmd->prevDelim,
1660                thisCmd->bracketDepth,
1661                thisCmd->nextcommand,
1662                wine_dbgstr_w(thisCmd->command),
1663                wine_dbgstr_w(thisCmd->redirects));
1664       thisCmd = thisCmd->nextcommand;
1665     }
1666 }
1667
1668 /***************************************************************************
1669  * WCMD_addCommand
1670  *
1671  *   Adds a command to the current command list
1672  */
1673 static void WCMD_addCommand(WCHAR *command, int *commandLen,
1674                      WCHAR *redirs,  int *redirLen,
1675                      WCHAR **copyTo, int **copyToLen,
1676                      CMD_DELIMITERS prevDelim, int curDepth,
1677                      CMD_LIST **lastEntry, CMD_LIST **output) {
1678
1679     CMD_LIST *thisEntry = NULL;
1680
1681     /* Allocate storage for command */
1682     thisEntry = heap_alloc(sizeof(CMD_LIST));
1683
1684     /* Copy in the command */
1685     if (command) {
1686         thisEntry->command = heap_alloc((*commandLen+1) * sizeof(WCHAR));
1687         memcpy(thisEntry->command, command, *commandLen * sizeof(WCHAR));
1688         thisEntry->command[*commandLen] = 0x00;
1689
1690         /* Copy in the redirects */
1691         thisEntry->redirects = heap_alloc((*redirLen+1) * sizeof(WCHAR));
1692         memcpy(thisEntry->redirects, redirs, *redirLen * sizeof(WCHAR));
1693         thisEntry->redirects[*redirLen] = 0x00;
1694         thisEntry->pipeFile[0] = 0x00;
1695
1696         /* Reset the lengths */
1697         *commandLen   = 0;
1698         *redirLen     = 0;
1699         *copyToLen    = commandLen;
1700         *copyTo       = command;
1701
1702     } else {
1703         thisEntry->command = NULL;
1704         thisEntry->redirects = NULL;
1705         thisEntry->pipeFile[0] = 0x00;
1706     }
1707
1708     /* Fill in other fields */
1709     thisEntry->nextcommand = NULL;
1710     thisEntry->prevDelim = prevDelim;
1711     thisEntry->bracketDepth = curDepth;
1712     if (*lastEntry) {
1713         (*lastEntry)->nextcommand = thisEntry;
1714     } else {
1715         *output = thisEntry;
1716     }
1717     *lastEntry = thisEntry;
1718 }
1719
1720
1721 /***************************************************************************
1722  * WCMD_IsEndQuote
1723  *
1724  *   Checks if the quote pointed to is the end-quote.
1725  *
1726  *   Quotes end if:
1727  *
1728  *   1) The current parameter ends at EOL or at the beginning
1729  *      of a redirection or pipe and not in a quote section.
1730  *
1731  *   2) If the next character is a space and not in a quote section.
1732  *
1733  *   Returns TRUE if this is an end quote, and FALSE if it is not.
1734  *
1735  */
1736 static BOOL WCMD_IsEndQuote(const WCHAR *quote, int quoteIndex)
1737 {
1738     int quoteCount = quoteIndex;
1739     int i;
1740
1741     /* If we are not in a quoted section, then we are not an end-quote */
1742     if(quoteIndex == 0)
1743     {
1744         return FALSE;
1745     }
1746
1747     /* Check how many quotes are left for this parameter */
1748     for(i=0;quote[i];i++)
1749     {
1750         if(quote[i] == '"')
1751         {
1752             quoteCount++;
1753         }
1754
1755         /* Quote counting ends at EOL, redirection, space or pipe if current quote is complete */
1756         else if(((quoteCount % 2) == 0)
1757             && ((quote[i] == '<') || (quote[i] == '>') || (quote[i] == '|') || (quote[i] == ' ')))
1758         {
1759             break;
1760         }
1761     }
1762
1763     /* If the quote is part of the last part of a series of quotes-on-quotes, then it must
1764        be an end-quote */
1765     if(quoteIndex >= (quoteCount / 2))
1766     {
1767         return TRUE;
1768     }
1769
1770     /* No cigar */
1771     return FALSE;
1772 }
1773
1774 /***************************************************************************
1775  * WCMD_ReadAndParseLine
1776  *
1777  *   Either uses supplied input or
1778  *     Reads a file from the handle, and then...
1779  *   Parse the text buffer, splitting into separate commands
1780  *     - unquoted && strings split 2 commands but the 2nd is flagged as
1781  *            following an &&
1782  *     - ( as the first character just ups the bracket depth
1783  *     - unquoted ) when bracket depth > 0 terminates a bracket and
1784  *            adds a CMD_LIST structure with null command
1785  *     - Anything else gets put into the command string (including
1786  *            redirects)
1787  */
1788 WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE readFrom)
1789 {
1790     WCHAR    *curPos;
1791     int       inQuotes = 0;
1792     WCHAR     curString[MAXSTRING];
1793     int       curStringLen = 0;
1794     WCHAR     curRedirs[MAXSTRING];
1795     int       curRedirsLen = 0;
1796     WCHAR    *curCopyTo;
1797     int      *curLen;
1798     int       curDepth = 0;
1799     CMD_LIST *lastEntry = NULL;
1800     CMD_DELIMITERS prevDelim = CMD_NONE;
1801     static WCHAR    *extraSpace = NULL;  /* Deliberately never freed */
1802     static const WCHAR remCmd[] = {'r','e','m'};
1803     static const WCHAR forCmd[] = {'f','o','r'};
1804     static const WCHAR ifCmd[]  = {'i','f'};
1805     static const WCHAR ifElse[] = {'e','l','s','e'};
1806     BOOL      inOneLine = FALSE;
1807     BOOL      inFor = FALSE;
1808     BOOL      inIn  = FALSE;
1809     BOOL      inIf  = FALSE;
1810     BOOL      inElse= FALSE;
1811     BOOL      onlyWhiteSpace = FALSE;
1812     BOOL      lastWasWhiteSpace = FALSE;
1813     BOOL      lastWasDo   = FALSE;
1814     BOOL      lastWasIn   = FALSE;
1815     BOOL      lastWasElse = FALSE;
1816     BOOL      lastWasRedirect = TRUE;
1817     BOOL      lastWasCaret = FALSE;
1818
1819     /* Allocate working space for a command read from keyboard, file etc */
1820     if (!extraSpace)
1821         extraSpace = heap_alloc((MAXSTRING+1) * sizeof(WCHAR));
1822     if (!extraSpace)
1823     {
1824         WINE_ERR("Could not allocate memory for extraSpace\n");
1825         return NULL;
1826     }
1827
1828     /* If initial command read in, use that, otherwise get input from handle */
1829     if (optionalcmd != NULL) {
1830         strcpyW(extraSpace, optionalcmd);
1831     } else if (readFrom == INVALID_HANDLE_VALUE) {
1832         WINE_FIXME("No command nor handle supplied\n");
1833     } else {
1834         if (!WCMD_fgets(extraSpace, MAXSTRING, readFrom))
1835           return NULL;
1836     }
1837     curPos = extraSpace;
1838
1839     /* Handle truncated input - issue warning */
1840     if (strlenW(extraSpace) == MAXSTRING -1) {
1841         WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_TRUNCATEDLINE));
1842         WCMD_output_asis_stderr(extraSpace);
1843         WCMD_output_asis_stderr(newlineW);
1844     }
1845
1846     /* Replace env vars if in a batch context */
1847     if (context) handleExpansion(extraSpace, FALSE, FALSE);
1848
1849     /* Skip preceding whitespace */
1850     while (*curPos == ' ' || *curPos == '\t') curPos++;
1851
1852     /* Show prompt before batch line IF echo is on and in batch program */
1853     if (context && echo_mode && *curPos && (*curPos != '@')) {
1854       static const WCHAR echoDot[] = {'e','c','h','o','.'};
1855       static const WCHAR echoCol[] = {'e','c','h','o',':'};
1856       static const WCHAR echoSlash[] = {'e','c','h','o','/'};
1857       const DWORD len = sizeof(echoDot)/sizeof(echoDot[0]);
1858       DWORD curr_size = strlenW(curPos);
1859       DWORD min_len = (curr_size < len ? curr_size : len);
1860       WCMD_show_prompt();
1861       WCMD_output_asis(curPos);
1862       /* I don't know why Windows puts a space here but it does */
1863       /* Except for lines starting with 'echo.', 'echo:' or 'echo/'. Ask MS why */
1864       if (CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1865                          curPos, min_len, echoDot, len) != CSTR_EQUAL
1866           && CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1867                          curPos, min_len, echoCol, len) != CSTR_EQUAL
1868           && CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1869                          curPos, min_len, echoSlash, len) != CSTR_EQUAL)
1870       {
1871           WCMD_output_asis(spaceW);
1872       }
1873       WCMD_output_asis(newlineW);
1874     }
1875
1876     /* Skip repeated 'no echo' characters */
1877     while (*curPos == '@') curPos++;
1878
1879     /* Start with an empty string, copying to the command string */
1880     curStringLen = 0;
1881     curRedirsLen = 0;
1882     curCopyTo    = curString;
1883     curLen       = &curStringLen;
1884     lastWasRedirect = FALSE;  /* Required e.g. for spaces between > and filename */
1885
1886     /* Parse every character on the line being processed */
1887     while (*curPos != 0x00) {
1888
1889       WCHAR thisChar;
1890
1891       /* Debugging AID:
1892       WINE_TRACE("Looking at '%c' (len:%d, lws:%d, ows:%d)\n", *curPos, *curLen,
1893                  lastWasWhiteSpace, onlyWhiteSpace);
1894       */
1895
1896       /* Prevent overflow caused by the caret escape char */
1897       if (*curLen >= MAXSTRING) {
1898         WINE_ERR("Overflow detected in command\n");
1899         return NULL;
1900       }
1901
1902       /* Certain commands need special handling */
1903       if (curStringLen == 0 && curCopyTo == curString) {
1904         static const WCHAR forDO[] = {'d','o'};
1905
1906         /* If command starts with 'rem ' or identifies a label, ignore any &&, ( etc. */
1907         if (WCMD_keyword_ws_found(remCmd, sizeof(remCmd)/sizeof(remCmd[0]), curPos) ||
1908             *curPos == ':') {
1909           inOneLine = TRUE;
1910
1911         } else if (WCMD_keyword_ws_found(forCmd, sizeof(forCmd)/sizeof(forCmd[0]), curPos)) {
1912           inFor = TRUE;
1913
1914         /* If command starts with 'if ' or 'else ', handle ('s mid line. We should ensure this
1915            is only true in the command portion of the IF statement, but this
1916            should suffice for now
1917             FIXME: Silly syntax like "if 1(==1( (
1918                                         echo they equal
1919                                       )" will be parsed wrong */
1920         } else if (WCMD_keyword_ws_found(ifCmd, sizeof(ifCmd)/sizeof(ifCmd[0]), curPos)) {
1921           inIf = TRUE;
1922
1923         } else if (WCMD_keyword_ws_found(ifElse, sizeof(ifElse)/sizeof(ifElse[0]), curPos)) {
1924           const int keyw_len = sizeof(ifElse)/sizeof(ifElse[0]) + 1;
1925           inElse = TRUE;
1926           lastWasElse = TRUE;
1927           onlyWhiteSpace = TRUE;
1928           memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1929           (*curLen)+=keyw_len;
1930           curPos+=keyw_len;
1931           continue;
1932
1933         /* In a for loop, the DO command will follow a close bracket followed by
1934            whitespace, followed by DO, ie closeBracket inserts a NULL entry, curLen
1935            is then 0, and all whitespace is skipped                                */
1936         } else if (inFor &&
1937                    WCMD_keyword_ws_found(forDO, sizeof(forDO)/sizeof(forDO[0]), curPos)) {
1938           const int keyw_len = sizeof(forDO)/sizeof(forDO[0]) + 1;
1939           WINE_TRACE("Found 'DO '\n");
1940           lastWasDo = TRUE;
1941           onlyWhiteSpace = TRUE;
1942           memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1943           (*curLen)+=keyw_len;
1944           curPos+=keyw_len;
1945           continue;
1946         }
1947       } else if (curCopyTo == curString) {
1948
1949         /* Special handling for the 'FOR' command */
1950         if (inFor && lastWasWhiteSpace) {
1951           static const WCHAR forIN[] = {'i','n'};
1952
1953           WINE_TRACE("Found 'FOR ', comparing next parm: '%s'\n", wine_dbgstr_w(curPos));
1954
1955           if (WCMD_keyword_ws_found(forIN, sizeof(forIN)/sizeof(forIN[0]), curPos)) {
1956             const int keyw_len = sizeof(forIN)/sizeof(forIN[0]) + 1;
1957             WINE_TRACE("Found 'IN '\n");
1958             lastWasIn = TRUE;
1959             onlyWhiteSpace = TRUE;
1960             memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1961             (*curLen)+=keyw_len;
1962             curPos+=keyw_len;
1963             continue;
1964           }
1965         }
1966       }
1967
1968       /* Nothing 'ends' a one line statement (e.g. REM or :labels mean
1969          the &&, quotes and redirection etc are ineffective, so just force
1970          the use of the default processing by skipping character specific
1971          matching below)                                                   */
1972       if (!inOneLine) thisChar = *curPos;
1973       else            thisChar = 'X';  /* Character with no special processing */
1974
1975       lastWasWhiteSpace = FALSE; /* Will be reset below */
1976       lastWasCaret = FALSE;
1977
1978       switch (thisChar) {
1979
1980       case '=': /* drop through - ignore token delimiters at the start of a command */
1981       case ',': /* drop through - ignore token delimiters at the start of a command */
1982       case '\t':/* drop through - ignore token delimiters at the start of a command */
1983       case ' ':
1984                 /* If a redirect in place, it ends here */
1985                 if (!inQuotes && !lastWasRedirect) {
1986
1987                   /* If finishing off a redirect, add a whitespace delimiter */
1988                   if (curCopyTo == curRedirs) {
1989                       curCopyTo[(*curLen)++] = ' ';
1990                   }
1991                   curCopyTo = curString;
1992                   curLen = &curStringLen;
1993                 }
1994                 if (*curLen > 0) {
1995                   curCopyTo[(*curLen)++] = *curPos;
1996                 }
1997
1998                 /* Remember just processed whitespace */
1999                 lastWasWhiteSpace = TRUE;
2000
2001                 break;
2002
2003       case '>': /* drop through - handle redirect chars the same */
2004       case '<':
2005                 /* Make a redirect start here */
2006                 if (!inQuotes) {
2007                   curCopyTo = curRedirs;
2008                   curLen = &curRedirsLen;
2009                   lastWasRedirect = TRUE;
2010                 }
2011
2012                 /* See if 1>, 2> etc, in which case we have some patching up
2013                    to do (provided there's a preceding whitespace, and enough
2014                    chars read so far) */
2015                 if (curStringLen > 2
2016                         && (*(curPos-1)>='1') && (*(curPos-1)<='9')
2017                         && ((*(curPos-2)==' ') || (*(curPos-2)=='\t'))) {
2018                     curStringLen--;
2019                     curString[curStringLen] = 0x00;
2020                     curCopyTo[(*curLen)++] = *(curPos-1);
2021                 }
2022
2023                 curCopyTo[(*curLen)++] = *curPos;
2024
2025                 /* If a redirect is immediately followed by '&' (ie. 2>&1) then
2026                     do not process that ampersand as an AND operator */
2027                 if (thisChar == '>' && *(curPos+1) == '&') {
2028                     curCopyTo[(*curLen)++] = *(curPos+1);
2029                     curPos++;
2030                 }
2031                 break;
2032
2033       case '|': /* Pipe character only if not || */
2034                 if (!inQuotes) {
2035                   lastWasRedirect = FALSE;
2036
2037                   /* Add an entry to the command list */
2038                   if (curStringLen > 0) {
2039
2040                     /* Add the current command */
2041                     WCMD_addCommand(curString, &curStringLen,
2042                           curRedirs, &curRedirsLen,
2043                           &curCopyTo, &curLen,
2044                           prevDelim, curDepth,
2045                           &lastEntry, output);
2046
2047                   }
2048
2049                   if (*(curPos+1) == '|') {
2050                     curPos++; /* Skip other | */
2051                     prevDelim = CMD_ONFAILURE;
2052                   } else {
2053                     prevDelim = CMD_PIPE;
2054                   }
2055                 } else {
2056                   curCopyTo[(*curLen)++] = *curPos;
2057                 }
2058                 break;
2059
2060       case '"': if (WCMD_IsEndQuote(curPos, inQuotes)) {
2061                     inQuotes--;
2062                 } else {
2063                     inQuotes++; /* Quotes within quotes are fun! */
2064                 }
2065                 curCopyTo[(*curLen)++] = *curPos;
2066                 lastWasRedirect = FALSE;
2067                 break;
2068
2069       case '(': /* If a '(' is the first non whitespace in a command portion
2070                    ie start of line or just after &&, then we read until an
2071                    unquoted ) is found                                       */
2072                 WINE_TRACE("Found '(' conditions: curLen(%d), inQ(%d), onlyWS(%d)"
2073                            ", for(%d, In:%d, Do:%d)"
2074                            ", if(%d, else:%d, lwe:%d)\n",
2075                            *curLen, inQuotes,
2076                            onlyWhiteSpace,
2077                            inFor, lastWasIn, lastWasDo,
2078                            inIf, inElse, lastWasElse);
2079                 lastWasRedirect = FALSE;
2080
2081                 /* Ignore open brackets inside the for set */
2082                 if (*curLen == 0 && !inIn) {
2083                   curDepth++;
2084
2085                 /* If in quotes, ignore brackets */
2086                 } else if (inQuotes) {
2087                   curCopyTo[(*curLen)++] = *curPos;
2088
2089                 /* In a FOR loop, an unquoted '(' may occur straight after
2090                       IN or DO
2091                    In an IF statement just handle it regardless as we don't
2092                       parse the operands
2093                    In an ELSE statement, only allow it straight away after
2094                       the ELSE and whitespace
2095                  */
2096                 } else if (inIf ||
2097                            (inElse && lastWasElse && onlyWhiteSpace) ||
2098                            (inFor && (lastWasIn || lastWasDo) && onlyWhiteSpace)) {
2099
2100                    /* If entering into an 'IN', set inIn */
2101                   if (inFor && lastWasIn && onlyWhiteSpace) {
2102                     WINE_TRACE("Inside an IN\n");
2103                     inIn = TRUE;
2104                   }
2105
2106                   /* Add the current command */
2107                   WCMD_addCommand(curString, &curStringLen,
2108                                   curRedirs, &curRedirsLen,
2109                                   &curCopyTo, &curLen,
2110                                   prevDelim, curDepth,
2111                                   &lastEntry, output);
2112
2113                   curDepth++;
2114                 } else {
2115                   curCopyTo[(*curLen)++] = *curPos;
2116                 }
2117                 break;
2118
2119       case '^': if (!inQuotes) {
2120                   /* If we reach the end of the input, we need to wait for more */
2121                   if (*(curPos+1) == 0x00) {
2122                     lastWasCaret = TRUE;
2123                     WINE_TRACE("Caret found at end of line\n");
2124                     break;
2125                   }
2126                   curPos++;
2127                 }
2128                 curCopyTo[(*curLen)++] = *curPos;
2129                 break;
2130
2131       case '&': if (!inQuotes) {
2132                   lastWasRedirect = FALSE;
2133
2134                   /* Add an entry to the command list */
2135                   if (curStringLen > 0) {
2136
2137                     /* Add the current command */
2138                     WCMD_addCommand(curString, &curStringLen,
2139                           curRedirs, &curRedirsLen,
2140                           &curCopyTo, &curLen,
2141                           prevDelim, curDepth,
2142                           &lastEntry, output);
2143
2144                   }
2145
2146                   if (*(curPos+1) == '&') {
2147                     curPos++; /* Skip other & */
2148                     prevDelim = CMD_ONSUCCESS;
2149                   } else {
2150                     prevDelim = CMD_NONE;
2151                   }
2152                 } else {
2153                   curCopyTo[(*curLen)++] = *curPos;
2154                 }
2155                 break;
2156
2157       case ')': if (!inQuotes && curDepth > 0) {
2158                   lastWasRedirect = FALSE;
2159
2160                   /* Add the current command if there is one */
2161                   if (curStringLen) {
2162
2163                       /* Add the current command */
2164                       WCMD_addCommand(curString, &curStringLen,
2165                             curRedirs, &curRedirsLen,
2166                             &curCopyTo, &curLen,
2167                             prevDelim, curDepth,
2168                             &lastEntry, output);
2169                   }
2170
2171                   /* Add an empty entry to the command list */
2172                   prevDelim = CMD_NONE;
2173                   WCMD_addCommand(NULL, &curStringLen,
2174                         curRedirs, &curRedirsLen,
2175                         &curCopyTo, &curLen,
2176                         prevDelim, curDepth,
2177                         &lastEntry, output);
2178                   curDepth--;
2179
2180                   /* Leave inIn if necessary */
2181                   if (inIn) inIn =  FALSE;
2182                 } else {
2183                   curCopyTo[(*curLen)++] = *curPos;
2184                 }
2185                 break;
2186       default:
2187                 lastWasRedirect = FALSE;
2188                 curCopyTo[(*curLen)++] = *curPos;
2189       }
2190
2191       curPos++;
2192
2193       /* At various times we need to know if we have only skipped whitespace,
2194          so reset this variable and then it will remain true until a non
2195          whitespace is found                                               */
2196       if ((thisChar != ' ') && (thisChar != '\t') && (thisChar != '\n'))
2197         onlyWhiteSpace = FALSE;
2198
2199       /* Flag end of interest in FOR DO and IN parms once something has been processed */
2200       if (!lastWasWhiteSpace) {
2201         lastWasIn = lastWasDo = FALSE;
2202       }
2203
2204       /* If we have reached the end, add this command into the list
2205          Do not add command to list if escape char ^ was last */
2206       if (*curPos == 0x00 && !lastWasCaret && *curLen > 0) {
2207
2208           /* Add an entry to the command list */
2209           WCMD_addCommand(curString, &curStringLen,
2210                 curRedirs, &curRedirsLen,
2211                 &curCopyTo, &curLen,
2212                 prevDelim, curDepth,
2213                 &lastEntry, output);
2214       }
2215
2216       /* If we have reached the end of the string, see if bracketing or
2217          final caret is outstanding */
2218       if (*curPos == 0x00 && (curDepth > 0 || lastWasCaret) &&
2219           readFrom != INVALID_HANDLE_VALUE) {
2220         WCHAR *extraData;
2221
2222         WINE_TRACE("Need to read more data as outstanding brackets or carets\n");
2223         inOneLine = FALSE;
2224         prevDelim = CMD_NONE;
2225         inQuotes = 0;
2226         memset(extraSpace, 0x00, (MAXSTRING+1) * sizeof(WCHAR));
2227         extraData = extraSpace;
2228
2229         /* Read more, skipping any blank lines */
2230         do {
2231           WINE_TRACE("Read more input\n");
2232           if (!context) WCMD_output_asis( WCMD_LoadMessage(WCMD_MOREPROMPT));
2233           if (!WCMD_fgets(extraData, MAXSTRING, readFrom))
2234             break;
2235
2236           /* Edge case for carets - a completely blank line (i.e. was just
2237              CRLF) is oddly added as an LF but then more data is received (but
2238              only once more!) */
2239           if (lastWasCaret) {
2240             if (*extraSpace == 0x00) {
2241               WINE_TRACE("Read nothing, so appending LF char and will try again\n");
2242               *extraData++ = '\r';
2243               *extraData = 0x00;
2244             } else break;
2245           }
2246
2247         } while (*extraData == 0x00);
2248         curPos = extraSpace;
2249         if (context) handleExpansion(extraSpace, FALSE, FALSE);
2250         /* Continue to echo commands IF echo is on and in batch program */
2251         if (context && echo_mode && extraSpace[0] && (extraSpace[0] != '@')) {
2252           WCMD_output_asis(extraSpace);
2253           WCMD_output_asis(newlineW);
2254         }
2255       }
2256     }
2257
2258     /* Dump out the parsed output */
2259     WCMD_DumpCommands(*output);
2260
2261     return extraSpace;
2262 }
2263
2264 /***************************************************************************
2265  * WCMD_process_commands
2266  *
2267  * Process all the commands read in so far
2268  */
2269 CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL oneBracket,
2270                                 BOOL retrycall) {
2271
2272     int bdepth = -1;
2273
2274     if (thisCmd && oneBracket) bdepth = thisCmd->bracketDepth;
2275
2276     /* Loop through the commands, processing them one by one */
2277     while (thisCmd) {
2278
2279       CMD_LIST *origCmd = thisCmd;
2280
2281       /* If processing one bracket only, and we find the end bracket
2282          entry (or less), return                                    */
2283       if (oneBracket && !thisCmd->command &&
2284           bdepth <= thisCmd->bracketDepth) {
2285         WINE_TRACE("Finished bracket @ %p, next command is %p\n",
2286                    thisCmd, thisCmd->nextcommand);
2287         return thisCmd->nextcommand;
2288       }
2289
2290       /* Ignore the NULL entries a ')' inserts (Only 'if' cares
2291          about them and it will be handled in there)
2292          Also, skip over any batch labels (eg. :fred)          */
2293       if (thisCmd->command && thisCmd->command[0] != ':') {
2294         WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd->command));
2295         WCMD_execute (thisCmd->command, thisCmd->redirects, &thisCmd, retrycall);
2296       }
2297
2298       /* Step on unless the command itself already stepped on */
2299       if (thisCmd == origCmd) thisCmd = thisCmd->nextcommand;
2300     }
2301     return NULL;
2302 }
2303
2304 /***************************************************************************
2305  * WCMD_free_commands
2306  *
2307  * Frees the storage held for a parsed command line
2308  * - This is not done in the process_commands, as eventually the current
2309  *   pointer will be modified within the commands, and hence a single free
2310  *   routine is simpler
2311  */
2312 void WCMD_free_commands(CMD_LIST *cmds) {
2313
2314     /* Loop through the commands, freeing them one by one */
2315     while (cmds) {
2316       CMD_LIST *thisCmd = cmds;
2317       cmds = cmds->nextcommand;
2318       heap_free(thisCmd->command);
2319       heap_free(thisCmd->redirects);
2320       heap_free(thisCmd);
2321     }
2322 }
2323
2324
2325 /*****************************************************************************
2326  * Main entry point. This is a console application so we have a main() not a
2327  * winmain().
2328  */
2329
2330 int wmain (int argc, WCHAR *argvW[])
2331 {
2332   int     args;
2333   WCHAR  *cmdLine = NULL;
2334   WCHAR  *cmd     = NULL;
2335   WCHAR  *argPos  = NULL;
2336   WCHAR string[1024];
2337   WCHAR envvar[4];
2338   BOOL opt_q;
2339   int opt_t = 0;
2340   static const WCHAR offW[] = {'O','F','F','\0'};
2341   static const WCHAR promptW[] = {'P','R','O','M','P','T','\0'};
2342   static const WCHAR defaultpromptW[] = {'$','P','$','G','\0'};
2343   CMD_LIST *toExecute = NULL;         /* Commands left to be executed */
2344   OSVERSIONINFOW osv;
2345   char osver[50];
2346
2347   srand(time(NULL));
2348
2349   /* Get the windows version being emulated */
2350   osv.dwOSVersionInfoSize = sizeof(osv);
2351   GetVersionExW(&osv);
2352
2353   /* Pre initialize some messages */
2354   strcpyW(anykey, WCMD_LoadMessage(WCMD_ANYKEY));
2355   sprintf(osver, "%d.%d.%d (%s)", osv.dwMajorVersion, osv.dwMinorVersion,
2356           osv.dwBuildNumber, PACKAGE_VERSION);
2357   cmd = WCMD_format_string(WCMD_LoadMessage(WCMD_VERSION), osver);
2358   strcpyW(version_string, cmd);
2359   LocalFree(cmd);
2360   cmd = NULL;
2361
2362   /* Can't use argc/argv as it will have stripped quotes from parameters
2363    * meaning cmd.exe /C echo "quoted string" is impossible
2364    */
2365   cmdLine = GetCommandLineW();
2366   WINE_TRACE("Full commandline '%s'\n", wine_dbgstr_w(cmdLine));
2367   args = 0;
2368
2369   opt_c = opt_k = opt_q = opt_s = FALSE;
2370   WCMD_parameter(cmdLine, args, &argPos, TRUE, TRUE);
2371   while (argPos && argPos[0] != 0x00)
2372   {
2373       WCHAR c;
2374       WINE_TRACE("Command line parm: '%s'\n", wine_dbgstr_w(argPos));
2375       if (argPos[0]!='/' || argPos[1]=='\0') {
2376           args++;
2377           WCMD_parameter(cmdLine, args, &argPos, TRUE, TRUE);
2378           continue;
2379       }
2380
2381       c=argPos[1];
2382       if (tolowerW(c)=='c') {
2383           opt_c = TRUE;
2384       } else if (tolowerW(c)=='q') {
2385           opt_q = TRUE;
2386       } else if (tolowerW(c)=='k') {
2387           opt_k = TRUE;
2388       } else if (tolowerW(c)=='s') {
2389           opt_s = TRUE;
2390       } else if (tolowerW(c)=='a') {
2391           unicodeOutput = FALSE;
2392       } else if (tolowerW(c)=='u') {
2393           unicodeOutput = TRUE;
2394       } else if (tolowerW(c)=='v' && argPos[2]==':') {
2395           delayedsubst = strncmpiW(&argPos[3], offW, 3);
2396           if (delayedsubst) WINE_TRACE("Delayed substitution is on\n");
2397       } else if (tolowerW(c)=='t' && argPos[2]==':') {
2398           opt_t=strtoulW(&argPos[3], NULL, 16);
2399       } else if (tolowerW(c)=='x' || tolowerW(c)=='y') {
2400           /* Ignored for compatibility with Windows */
2401       }
2402
2403       if (argPos[2]==0 || argPos[2]==' ' || argPos[2]=='\t' ||
2404           tolowerW(c)=='v') {
2405           args++;
2406           WCMD_parameter(cmdLine, args, &argPos, TRUE, TRUE);
2407       }
2408       else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
2409       {
2410           /* Do not step to next parameter, instead carry on parsing this one */
2411           argPos+=2;
2412       }
2413
2414       if (opt_c || opt_k) /* break out of parsing immediately after c or k */
2415           break;
2416   }
2417
2418   if (opt_q) {
2419     WCMD_echo(offW);
2420   }
2421
2422   /* Until we start to read from the keyboard, stay as non-interactive */
2423   interactive = FALSE;
2424
2425   SetEnvironmentVariableW(promptW, defaultpromptW);
2426
2427   if (opt_c || opt_k) {
2428       int     len;
2429       WCHAR   *q1 = NULL,*q2 = NULL,*p;
2430
2431       /* Handle very edge case error scenario, "cmd.exe /c" ie when there are no
2432        * parameters after the /C or /K by pretending there was a single space     */
2433       if (argPos == NULL) argPos = (WCHAR *)spaceW;
2434
2435       /* Take a copy */
2436       cmd = heap_strdupW(argPos);
2437
2438       /* opt_s left unflagged if the command starts with and contains exactly
2439        * one quoted string (exactly two quote characters). The quoted string
2440        * must be an executable name that has whitespace and must not have the
2441        * following characters: &<>()@^| */
2442
2443       if (!opt_s) {
2444         /* 1. Confirm there is at least one quote */
2445         q1 = strchrW(argPos, '"');
2446         if (!q1) opt_s=1;
2447       }
2448
2449       if (!opt_s) {
2450           /* 2. Confirm there is a second quote */
2451           q2 = strchrW(q1+1, '"');
2452           if (!q2) opt_s=1;
2453       }
2454
2455       if (!opt_s) {
2456           /* 3. Ensure there are no more quotes */
2457           if (strchrW(q2+1, '"')) opt_s=1;
2458       }
2459
2460       /* check first parameter for a space and invalid characters. There must not be any
2461        * invalid characters, but there must be one or more whitespace                    */
2462       if (!opt_s) {
2463           opt_s = TRUE;
2464           p=q1;
2465           while (p!=q2) {
2466               if (*p=='&' || *p=='<' || *p=='>' || *p=='(' || *p==')'
2467                   || *p=='@' || *p=='^' || *p=='|') {
2468                   opt_s = TRUE;
2469                   break;
2470               }
2471               if (*p==' ' || *p=='\t')
2472                   opt_s = FALSE;
2473               p++;
2474           }
2475       }
2476
2477       WINE_TRACE("/c command line: '%s'\n", wine_dbgstr_w(cmd));
2478
2479       /* Finally, we only stay in new mode IF the first parameter is quoted and
2480          is a valid executable, i.e. must exist, otherwise drop back to old mode  */
2481       if (!opt_s) {
2482         WCHAR *thisArg = WCMD_parameter(cmd, 0, NULL, FALSE, TRUE);
2483         WCHAR  pathext[MAXSTRING];
2484         BOOL found = FALSE;
2485
2486         /* Now extract PATHEXT */
2487         len = GetEnvironmentVariableW(envPathExt, pathext, sizeof(pathext)/sizeof(WCHAR));
2488         if ((len == 0) || (len >= (sizeof(pathext)/sizeof(WCHAR)))) {
2489           strcpyW (pathext, dfltPathExt);
2490         }
2491
2492         /* If the supplied parameter has any directory information, look there */
2493         WINE_TRACE("First parameter is '%s'\n", wine_dbgstr_w(thisArg));
2494         if (strchrW(thisArg, '\\') != NULL) {
2495
2496           GetFullPathNameW(thisArg, sizeof(string)/sizeof(WCHAR), string, NULL);
2497           WINE_TRACE("Full path name '%s'\n", wine_dbgstr_w(string));
2498           p = string + strlenW(string);
2499
2500           /* Does file exist with this name? */
2501           if (GetFileAttributesW(string) != INVALID_FILE_ATTRIBUTES) {
2502             WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string));
2503             found = TRUE;
2504           } else {
2505             WCHAR *thisExt = pathext;
2506
2507             /* No - try with each of the PATHEXT extensions */
2508             while (!found && thisExt) {
2509               WCHAR *nextExt = strchrW(thisExt, ';');
2510
2511               if (nextExt) {
2512                 memcpy(p, thisExt, (nextExt-thisExt) * sizeof(WCHAR));
2513                 p[(nextExt-thisExt)] = 0x00;
2514                 thisExt = nextExt+1;
2515               } else {
2516                 strcpyW(p, thisExt);
2517                 thisExt = NULL;
2518               }
2519
2520               /* Does file exist with this extension appended? */
2521               if (GetFileAttributesW(string) != INVALID_FILE_ATTRIBUTES) {
2522                 WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string));
2523                 found = TRUE;
2524               }
2525             }
2526           }
2527
2528         /* Otherwise we now need to look in the path to see if we can find it */
2529         } else {
2530           p = thisArg + strlenW(thisArg);
2531
2532           /* Does file exist with this name? */
2533           if (SearchPathW(NULL, thisArg, NULL, sizeof(string)/sizeof(WCHAR), string, NULL) != 0)  {
2534             WINE_TRACE("Found on path as '%s'\n", wine_dbgstr_w(string));
2535             found = TRUE;
2536           } else {
2537             WCHAR *thisExt = pathext;
2538
2539             /* No - try with each of the PATHEXT extensions */
2540             while (!found && thisExt) {
2541               WCHAR *nextExt = strchrW(thisExt, ';');
2542
2543               if (nextExt) {
2544                 *nextExt = 0;
2545                 nextExt = nextExt+1;
2546               } else {
2547                 nextExt = NULL;
2548               }
2549
2550               /* Does file exist with this extension? */
2551               if (SearchPathW(NULL, thisArg, thisExt, sizeof(string)/sizeof(WCHAR), string, NULL) != 0)  {
2552                 WINE_TRACE("Found on path as '%s' with extension '%s'\n", wine_dbgstr_w(string),
2553                            wine_dbgstr_w(thisExt));
2554                 found = TRUE;
2555               }
2556               thisExt = nextExt;
2557             }
2558           }
2559         }
2560
2561         /* If not found, drop back to old behaviour */
2562         if (!found) {
2563           WINE_TRACE("Binary not found, dropping back to old behaviour\n");
2564           opt_s = TRUE;
2565         }
2566
2567       }
2568
2569       /* strip first and last quote characters if opt_s; check for invalid
2570        * executable is done later */
2571       if (opt_s && *cmd=='\"')
2572           WCMD_strip_quotes(cmd);
2573   }
2574
2575   /* Save cwd into appropriate env var (Must be before the /c processing */
2576   GetCurrentDirectoryW(sizeof(string)/sizeof(WCHAR), string);
2577   if (IsCharAlphaW(string[0]) && string[1] == ':') {
2578     static const WCHAR fmt[] = {'=','%','c',':','\0'};
2579     wsprintfW(envvar, fmt, string[0]);
2580     SetEnvironmentVariableW(envvar, string);
2581     WINE_TRACE("Set %s to %s\n", wine_dbgstr_w(envvar), wine_dbgstr_w(string));
2582   }
2583
2584   if (opt_c) {
2585       /* If we do a "cmd /c command", we don't want to allocate a new
2586        * console since the command returns immediately. Rather, we use
2587        * the currently allocated input and output handles. This allows
2588        * us to pipe to and read from the command interpreter.
2589        */
2590
2591       /* Parse the command string, without reading any more input */
2592       WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
2593       WCMD_process_commands(toExecute, FALSE, FALSE);
2594       WCMD_free_commands(toExecute);
2595       toExecute = NULL;
2596
2597       heap_free(cmd);
2598       return errorlevel;
2599   }
2600
2601   SetConsoleTitleW(WCMD_LoadMessage(WCMD_CONSTITLE));
2602
2603   /* Note: cmd.exe /c dir does not get a new color, /k dir does */
2604   if (opt_t) {
2605       if (!(((opt_t & 0xF0) >> 4) == (opt_t & 0x0F))) {
2606           defaultColor = opt_t & 0xFF;
2607           param1[0] = 0x00;
2608           WCMD_color();
2609       }
2610   } else {
2611       /* Check HKCU\Software\Microsoft\Command Processor
2612          Then  HKLM\Software\Microsoft\Command Processor
2613            for defaultcolour value
2614            Note  Can be supplied as DWORD or REG_SZ
2615            Note2 When supplied as REG_SZ it's in decimal!!! */
2616       HKEY key;
2617       DWORD type;
2618       DWORD value=0, size=4;
2619       static const WCHAR regKeyW[] = {'S','o','f','t','w','a','r','e','\\',
2620                                       'M','i','c','r','o','s','o','f','t','\\',
2621                                       'C','o','m','m','a','n','d',' ','P','r','o','c','e','s','s','o','r','\0'};
2622       static const WCHAR dfltColorW[] = {'D','e','f','a','u','l','t','C','o','l','o','r','\0'};
2623
2624       if (RegOpenKeyExW(HKEY_CURRENT_USER, regKeyW,
2625                        0, KEY_READ, &key) == ERROR_SUCCESS) {
2626           WCHAR  strvalue[4];
2627
2628           /* See if DWORD or REG_SZ */
2629           if (RegQueryValueExW(key, dfltColorW, NULL, &type,
2630                      NULL, NULL) == ERROR_SUCCESS) {
2631               if (type == REG_DWORD) {
2632                   size = sizeof(DWORD);
2633                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2634                                   (LPBYTE)&value, &size);
2635               } else if (type == REG_SZ) {
2636                   size = sizeof(strvalue)/sizeof(WCHAR);
2637                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2638                                   (LPBYTE)strvalue, &size);
2639                   value = strtoulW(strvalue, NULL, 10);
2640               }
2641           }
2642           RegCloseKey(key);
2643       }
2644
2645       if (value == 0 && RegOpenKeyExW(HKEY_LOCAL_MACHINE, regKeyW,
2646                        0, KEY_READ, &key) == ERROR_SUCCESS) {
2647           WCHAR  strvalue[4];
2648
2649           /* See if DWORD or REG_SZ */
2650           if (RegQueryValueExW(key, dfltColorW, NULL, &type,
2651                      NULL, NULL) == ERROR_SUCCESS) {
2652               if (type == REG_DWORD) {
2653                   size = sizeof(DWORD);
2654                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2655                                   (LPBYTE)&value, &size);
2656               } else if (type == REG_SZ) {
2657                   size = sizeof(strvalue)/sizeof(WCHAR);
2658                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2659                                   (LPBYTE)strvalue, &size);
2660                   value = strtoulW(strvalue, NULL, 10);
2661               }
2662           }
2663           RegCloseKey(key);
2664       }
2665
2666       /* If one found, set the screen to that colour */
2667       if (!(((value & 0xF0) >> 4) == (value & 0x0F))) {
2668           defaultColor = value & 0xFF;
2669           param1[0] = 0x00;
2670           WCMD_color();
2671       }
2672
2673   }
2674
2675   if (opt_k) {
2676       /* Parse the command string, without reading any more input */
2677       WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
2678       WCMD_process_commands(toExecute, FALSE, FALSE);
2679       WCMD_free_commands(toExecute);
2680       toExecute = NULL;
2681       heap_free(cmd);
2682   }
2683
2684 /*
2685  *      Loop forever getting commands and executing them.
2686  */
2687
2688   interactive = TRUE;
2689   if (!opt_k) WCMD_version ();
2690   while (TRUE) {
2691
2692     /* Read until EOF (which for std input is never, but if redirect
2693        in place, may occur                                          */
2694     if (echo_mode) WCMD_show_prompt();
2695     if (!WCMD_ReadAndParseLine(NULL, &toExecute, GetStdHandle(STD_INPUT_HANDLE)))
2696       break;
2697     WCMD_process_commands(toExecute, FALSE, FALSE);
2698     WCMD_free_commands(toExecute);
2699     toExecute = NULL;
2700   }
2701   return 0;
2702 }