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 its 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 its 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 || (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  launched = FALSE;
1050   BOOL  status;
1051   DWORD len;
1052   static const WCHAR envPath[] = {'P','A','T','H','\0'};
1053   static const WCHAR delims[] = {'/','\\',':','\0'};
1054
1055   /* Quick way to get the filename is to extract the first argument. */
1056   WINE_TRACE("Running '%s' (%d)\n", wine_dbgstr_w(command), called);
1057   firstParam = WCMD_parameter(command, 0, NULL, FALSE, TRUE);
1058   if (!firstParam) return;
1059
1060   /* Calculate the search path and stem to search for */
1061   if (strpbrkW (firstParam, delims) == NULL) {  /* No explicit path given, search path */
1062     static const WCHAR curDir[] = {'.',';','\0'};
1063     strcpyW(pathtosearch, curDir);
1064     len = GetEnvironmentVariableW(envPath, &pathtosearch[2], (sizeof(pathtosearch)/sizeof(WCHAR))-2);
1065     if ((len == 0) || (len >= (sizeof(pathtosearch)/sizeof(WCHAR)) - 2)) {
1066       static const WCHAR curDir[] = {'.','\0'};
1067       strcpyW (pathtosearch, curDir);
1068     }
1069     if (strchrW(firstParam, '.') != NULL) extensionsupplied = TRUE;
1070     if (strlenW(firstParam) >= MAX_PATH)
1071     {
1072         WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_LINETOOLONG));
1073         return;
1074     }
1075
1076     strcpyW(stemofsearch, firstParam);
1077
1078   } else {
1079
1080     /* Convert eg. ..\fred to include a directory by removing file part */
1081     GetFullPathNameW(firstParam, sizeof(pathtosearch)/sizeof(WCHAR), pathtosearch, NULL);
1082     lastSlash = strrchrW(pathtosearch, '\\');
1083     if (lastSlash && strchrW(lastSlash, '.') != NULL) extensionsupplied = TRUE;
1084     strcpyW(stemofsearch, lastSlash+1);
1085
1086     /* Reduce pathtosearch to a path with trailing '\' to support c:\a.bat and
1087        c:\windows\a.bat syntax                                                 */
1088     if (lastSlash) *(lastSlash + 1) = 0x00;
1089   }
1090
1091   /* Now extract PATHEXT */
1092   len = GetEnvironmentVariableW(envPathExt, pathext, sizeof(pathext)/sizeof(WCHAR));
1093   if ((len == 0) || (len >= (sizeof(pathext)/sizeof(WCHAR)))) {
1094     strcpyW (pathext, dfltPathExt);
1095   }
1096
1097   /* Loop through the search path, dir by dir */
1098   pathposn = pathtosearch;
1099   WINE_TRACE("Searching in '%s' for '%s'\n", wine_dbgstr_w(pathtosearch),
1100              wine_dbgstr_w(stemofsearch));
1101   while (!launched && pathposn) {
1102
1103     WCHAR  thisDir[MAX_PATH] = {'\0'};
1104     WCHAR *pos               = NULL;
1105     BOOL  found             = FALSE;
1106
1107     /* Work on the first directory on the search path */
1108     pos = strchrW(pathposn, ';');
1109     if (pos) {
1110       memcpy(thisDir, pathposn, (pos-pathposn) * sizeof(WCHAR));
1111       thisDir[(pos-pathposn)] = 0x00;
1112       pathposn = pos+1;
1113
1114     } else {
1115       strcpyW(thisDir, pathposn);
1116       pathposn = NULL;
1117     }
1118
1119     /* Since you can have eg. ..\.. on the path, need to expand
1120        to full information                                      */
1121     strcpyW(temp, thisDir);
1122     GetFullPathNameW(temp, MAX_PATH, thisDir, NULL);
1123
1124     /* 1. If extension supplied, see if that file exists */
1125     strcatW(thisDir, slashW);
1126     strcatW(thisDir, stemofsearch);
1127     pos = &thisDir[strlenW(thisDir)]; /* Pos = end of name */
1128
1129     /* 1. If extension supplied, see if that file exists */
1130     if (extensionsupplied) {
1131       if (GetFileAttributesW(thisDir) != INVALID_FILE_ATTRIBUTES) {
1132         found = TRUE;
1133       }
1134     }
1135
1136     /* 2. Any .* matches? */
1137     if (!found) {
1138       HANDLE          h;
1139       WIN32_FIND_DATAW finddata;
1140       static const WCHAR allFiles[] = {'.','*','\0'};
1141
1142       strcatW(thisDir,allFiles);
1143       h = FindFirstFileW(thisDir, &finddata);
1144       FindClose(h);
1145       if (h != INVALID_HANDLE_VALUE) {
1146
1147         WCHAR *thisExt = pathext;
1148
1149         /* 3. Yes - Try each path ext */
1150         while (thisExt) {
1151           WCHAR *nextExt = strchrW(thisExt, ';');
1152
1153           if (nextExt) {
1154             memcpy(pos, thisExt, (nextExt-thisExt) * sizeof(WCHAR));
1155             pos[(nextExt-thisExt)] = 0x00;
1156             thisExt = nextExt+1;
1157           } else {
1158             strcpyW(pos, thisExt);
1159             thisExt = NULL;
1160           }
1161
1162           if (GetFileAttributesW(thisDir) != INVALID_FILE_ATTRIBUTES) {
1163             found = TRUE;
1164             thisExt = NULL;
1165           }
1166         }
1167       }
1168     }
1169
1170     /* Once found, launch it */
1171     if (found) {
1172       STARTUPINFOW st;
1173       PROCESS_INFORMATION pe;
1174       SHFILEINFOW psfi;
1175       DWORD console;
1176       HINSTANCE hinst;
1177       WCHAR *ext = strrchrW( thisDir, '.' );
1178       static const WCHAR batExt[] = {'.','b','a','t','\0'};
1179       static const WCHAR cmdExt[] = {'.','c','m','d','\0'};
1180
1181       WINE_TRACE("Found as %s\n", wine_dbgstr_w(thisDir));
1182
1183       /* Special case BAT and CMD */
1184       if (ext && (!strcmpiW(ext, batExt) || !strcmpiW(ext, cmdExt))) {
1185         BOOL oldinteractive = interactive;
1186         interactive = FALSE;
1187         WCMD_batch (thisDir, command, called, NULL, INVALID_HANDLE_VALUE);
1188         interactive = oldinteractive;
1189         return;
1190       } else {
1191
1192         /* thisDir contains the file to be launched, but with what?
1193            eg. a.exe will require a.exe to be launched, a.html may be iexplore */
1194         hinst = FindExecutableW (thisDir, NULL, temp);
1195         if ((INT_PTR)hinst < 32)
1196           console = 0;
1197         else
1198           console = SHGetFileInfoW(temp, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
1199
1200         ZeroMemory (&st, sizeof(STARTUPINFOW));
1201         st.cb = sizeof(STARTUPINFOW);
1202         init_msvcrt_io_block(&st);
1203
1204         /* Launch the process and if a CUI wait on it to complete
1205            Note: Launching internal wine processes cannot specify a full path to exe */
1206         status = CreateProcessW(thisDir,
1207                                 command, NULL, NULL, TRUE, 0, NULL, NULL, &st, &pe);
1208         heap_free(st.lpReserved2);
1209         if ((opt_c || opt_k) && !opt_s && !status
1210             && GetLastError()==ERROR_FILE_NOT_FOUND && command[0]=='\"') {
1211           /* strip first and last quote WCHARacters and try again */
1212           WCMD_strip_quotes(command);
1213           opt_s = TRUE;
1214           WCMD_run_program(command, called);
1215           return;
1216         }
1217
1218         if (!status)
1219           break;
1220
1221         /* Always wait when non-interactive (cmd /c or in batch program),
1222            or for console applications                                    */
1223         if (!interactive || (console && !HIWORD(console)))
1224             WaitForSingleObject (pe.hProcess, INFINITE);
1225         GetExitCodeProcess (pe.hProcess, &errorlevel);
1226         if (errorlevel == STILL_ACTIVE) errorlevel = 0;
1227
1228         CloseHandle(pe.hProcess);
1229         CloseHandle(pe.hThread);
1230         return;
1231       }
1232     }
1233   }
1234
1235   /* Not found anywhere - were we called? */
1236   if (called) {
1237     CMD_LIST *toExecute = NULL;         /* Commands left to be executed */
1238
1239     /* Parse the command string, without reading any more input */
1240     WCMD_ReadAndParseLine(command, &toExecute, INVALID_HANDLE_VALUE);
1241     WCMD_process_commands(toExecute, FALSE, called);
1242     WCMD_free_commands(toExecute);
1243     toExecute = NULL;
1244     return;
1245   }
1246
1247   /* Not found anywhere - give up */
1248   WCMD_output_stderr(WCMD_LoadMessage(WCMD_NO_COMMAND_FOUND), command);
1249
1250   /* If a command fails to launch, it sets errorlevel 9009 - which
1251      does not seem to have any associated constant definition     */
1252   errorlevel = 9009;
1253   return;
1254
1255 }
1256
1257 /*****************************************************************************
1258  * Process one command. If the command is EXIT this routine does not return.
1259  * We will recurse through here executing batch files.
1260  * Note: If call is used to a non-existing program, we reparse the line and
1261  *       try to run it as an internal command. 'retrycall' represents whether
1262  *       we are attempting this retry.
1263  */
1264 void WCMD_execute (const WCHAR *command, const WCHAR *redirects,
1265                    CMD_LIST **cmdList, BOOL retrycall)
1266 {
1267     WCHAR *cmd, *p, *redir;
1268     int status, i;
1269     DWORD count, creationDisposition;
1270     HANDLE h;
1271     WCHAR *whichcmd;
1272     SECURITY_ATTRIBUTES sa;
1273     WCHAR *new_cmd = NULL;
1274     WCHAR *new_redir = NULL;
1275     HANDLE old_stdhandles[3] = {GetStdHandle (STD_INPUT_HANDLE),
1276                                 GetStdHandle (STD_OUTPUT_HANDLE),
1277                                 GetStdHandle (STD_ERROR_HANDLE)};
1278     DWORD  idx_stdhandles[3] = {STD_INPUT_HANDLE,
1279                                 STD_OUTPUT_HANDLE,
1280                                 STD_ERROR_HANDLE};
1281     BOOL prev_echo_mode, piped = FALSE;
1282
1283     WINE_TRACE("command on entry:%s (%p)\n",
1284                wine_dbgstr_w(command), cmdList);
1285
1286     /* If the next command is a pipe then we implement pipes by redirecting
1287        the output from this command to a temp file and input into the
1288        next command from that temp file.
1289        FIXME: Use of named pipes would make more sense here as currently this
1290        process has to finish before the next one can start but this requires
1291        a change to not wait for the first app to finish but rather the pipe  */
1292     if (cmdList && (*cmdList)->nextcommand &&
1293         (*cmdList)->nextcommand->prevDelim == CMD_PIPE) {
1294
1295         WCHAR temp_path[MAX_PATH];
1296         static const WCHAR cmdW[]     = {'C','M','D','\0'};
1297
1298         /* Remember piping is in action */
1299         WINE_TRACE("Output needs to be piped\n");
1300         piped = TRUE;
1301
1302         /* Generate a unique temporary filename */
1303         GetTempPathW(sizeof(temp_path)/sizeof(WCHAR), temp_path);
1304         GetTempFileNameW(temp_path, cmdW, 0, (*cmdList)->nextcommand->pipeFile);
1305         WINE_TRACE("Using temporary file of %s\n",
1306                    wine_dbgstr_w((*cmdList)->nextcommand->pipeFile));
1307     }
1308
1309     /* Move copy of the command onto the heap so it can be expanded */
1310     new_cmd = heap_alloc(MAXSTRING * sizeof(WCHAR));
1311     strcpyW(new_cmd, command);
1312
1313     /* Move copy of the redirects onto the heap so it can be expanded */
1314     new_redir = heap_alloc(MAXSTRING * sizeof(WCHAR));
1315
1316     /* If piped output, send stdout to the pipe by appending >filename to redirects */
1317     if (piped) {
1318         static const WCHAR redirOut[] = {'%','s',' ','>',' ','%','s','\0'};
1319         wsprintfW (new_redir, redirOut, redirects, (*cmdList)->nextcommand->pipeFile);
1320         WINE_TRACE("Redirects now %s\n", wine_dbgstr_w(new_redir));
1321     } else {
1322         strcpyW(new_redir, redirects);
1323     }
1324
1325     /* Expand variables in command line mode only (batch mode will
1326        be expanded as the line is read in, except for 'for' loops) */
1327     handleExpansion(new_cmd, (context != NULL), delayedsubst);
1328     handleExpansion(new_redir, (context != NULL), delayedsubst);
1329     cmd = new_cmd;
1330
1331 /*
1332  *      Changing default drive has to be handled as a special case.
1333  */
1334
1335     if ((cmd[1] == ':') && IsCharAlphaW(cmd[0]) && (strlenW(cmd) == 2)) {
1336       WCHAR envvar[5];
1337       WCHAR dir[MAX_PATH];
1338
1339       /* According to MSDN CreateProcess docs, special env vars record
1340          the current directory on each drive, in the form =C:
1341          so see if one specified, and if so go back to it             */
1342       strcpyW(envvar, equalW);
1343       strcatW(envvar, cmd);
1344       if (GetEnvironmentVariableW(envvar, dir, MAX_PATH) == 0) {
1345         static const WCHAR fmt[] = {'%','s','\\','\0'};
1346         wsprintfW(cmd, fmt, cmd);
1347         WINE_TRACE("No special directory settings, using dir of %s\n", wine_dbgstr_w(cmd));
1348       }
1349       WINE_TRACE("Got directory %s as %s\n", wine_dbgstr_w(envvar), wine_dbgstr_w(cmd));
1350       status = SetCurrentDirectoryW(cmd);
1351       if (!status) WCMD_print_error ();
1352       heap_free(cmd );
1353       heap_free(new_redir);
1354       return;
1355     }
1356
1357     sa.nLength = sizeof(sa);
1358     sa.lpSecurityDescriptor = NULL;
1359     sa.bInheritHandle = TRUE;
1360
1361 /*
1362  *      Redirect stdin, stdout and/or stderr if required.
1363  */
1364
1365     /* STDIN could come from a preceding pipe, so delete on close if it does */
1366     if (cmdList && (*cmdList)->pipeFile[0] != 0x00) {
1367         WINE_TRACE("Input coming from %s\n", wine_dbgstr_w((*cmdList)->pipeFile));
1368         h = CreateFileW((*cmdList)->pipeFile, GENERIC_READ,
1369                   FILE_SHARE_READ, &sa, OPEN_EXISTING,
1370                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL);
1371         if (h == INVALID_HANDLE_VALUE) {
1372           WCMD_print_error ();
1373           heap_free(cmd);
1374           heap_free(new_redir);
1375           return;
1376         }
1377         SetStdHandle (STD_INPUT_HANDLE, h);
1378
1379         /* No need to remember the temporary name any longer once opened */
1380         (*cmdList)->pipeFile[0] = 0x00;
1381
1382     /* Otherwise STDIN could come from a '<' redirect */
1383     } else if ((p = strchrW(new_redir,'<')) != NULL) {
1384       h = CreateFileW(WCMD_parameter(++p, 0, NULL, FALSE, FALSE), GENERIC_READ, FILE_SHARE_READ,
1385                       &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1386       if (h == INVALID_HANDLE_VALUE) {
1387         WCMD_print_error ();
1388         heap_free(cmd);
1389         heap_free(new_redir);
1390         return;
1391       }
1392       SetStdHandle (STD_INPUT_HANDLE, h);
1393     }
1394
1395     /* Scan the whole command looking for > and 2> */
1396     redir = new_redir;
1397     while (redir != NULL && ((p = strchrW(redir,'>')) != NULL)) {
1398       int handle = 0;
1399
1400       if (p > redir && (*(p-1)=='2'))
1401         handle = 2;
1402       else
1403         handle = 1;
1404
1405       p++;
1406       if ('>' == *p) {
1407         creationDisposition = OPEN_ALWAYS;
1408         p++;
1409       }
1410       else {
1411         creationDisposition = CREATE_ALWAYS;
1412       }
1413
1414       /* Add support for 2>&1 */
1415       redir = p;
1416       if (*p == '&') {
1417         int idx = *(p+1) - '0';
1418
1419         if (DuplicateHandle(GetCurrentProcess(),
1420                         GetStdHandle(idx_stdhandles[idx]),
1421                         GetCurrentProcess(),
1422                         &h,
1423                         0, TRUE, DUPLICATE_SAME_ACCESS) == 0) {
1424           WINE_FIXME("Duplicating handle failed with gle %d\n", GetLastError());
1425         }
1426         WINE_TRACE("Redirect %d (%p) to %d (%p)\n", handle, GetStdHandle(idx_stdhandles[idx]), idx, h);
1427
1428       } else {
1429         WCHAR *param = WCMD_parameter(p, 0, NULL, FALSE, FALSE);
1430         h = CreateFileW(param, GENERIC_WRITE, 0, &sa, creationDisposition,
1431                         FILE_ATTRIBUTE_NORMAL, NULL);
1432         if (h == INVALID_HANDLE_VALUE) {
1433           WCMD_print_error ();
1434           heap_free(cmd);
1435           heap_free(new_redir);
1436           return;
1437         }
1438         if (SetFilePointer (h, 0, NULL, FILE_END) ==
1439               INVALID_SET_FILE_POINTER) {
1440           WCMD_print_error ();
1441         }
1442         WINE_TRACE("Redirect %d to '%s' (%p)\n", handle, wine_dbgstr_w(param), h);
1443       }
1444
1445       SetStdHandle (idx_stdhandles[handle], h);
1446     }
1447
1448 /*
1449  * Strip leading whitespaces, and a '@' if supplied
1450  */
1451     whichcmd = WCMD_skip_leading_spaces(cmd);
1452     WINE_TRACE("Command: '%s'\n", wine_dbgstr_w(cmd));
1453     if (whichcmd[0] == '@') whichcmd++;
1454
1455 /*
1456  *      Check if the command entered is internal. If it is, pass the rest of the
1457  *      line down to the command. If not try to run a program.
1458  */
1459
1460     count = 0;
1461     while (IsCharAlphaNumericW(whichcmd[count])) {
1462       count++;
1463     }
1464     for (i=0; i<=WCMD_EXIT; i++) {
1465       if (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1466         whichcmd, count, inbuilt[i], -1) == CSTR_EQUAL) break;
1467     }
1468     p = WCMD_skip_leading_spaces (&whichcmd[count]);
1469     WCMD_parse (p, quals, param1, param2);
1470     WINE_TRACE("param1: %s, param2: %s\n", wine_dbgstr_w(param1), wine_dbgstr_w(param2));
1471
1472     if (i <= WCMD_EXIT && (p[0] == '/') && (p[1] == '?')) {
1473       /* this is a help request for a builtin program */
1474       i = WCMD_HELP;
1475       memcpy(p, whichcmd, count * sizeof(WCHAR));
1476       p[count] = '\0';
1477
1478     }
1479
1480     switch (i) {
1481
1482       case WCMD_CALL:
1483         WCMD_call (p);
1484         break;
1485       case WCMD_CD:
1486       case WCMD_CHDIR:
1487         WCMD_setshow_default (p);
1488         break;
1489       case WCMD_CLS:
1490         WCMD_clear_screen ();
1491         break;
1492       case WCMD_COPY:
1493         WCMD_copy (p);
1494         break;
1495       case WCMD_CTTY:
1496         WCMD_change_tty ();
1497         break;
1498       case WCMD_DATE:
1499         WCMD_setshow_date ();
1500         break;
1501       case WCMD_DEL:
1502       case WCMD_ERASE:
1503         WCMD_delete (p);
1504         break;
1505       case WCMD_DIR:
1506         WCMD_directory (p);
1507         break;
1508       case WCMD_ECHO:
1509         WCMD_echo(&whichcmd[count]);
1510         break;
1511       case WCMD_GOTO:
1512         WCMD_goto (cmdList);
1513         break;
1514       case WCMD_HELP:
1515         WCMD_give_help (p);
1516         break;
1517       case WCMD_LABEL:
1518         WCMD_volume (TRUE, p);
1519         break;
1520       case WCMD_MD:
1521       case WCMD_MKDIR:
1522         WCMD_create_dir (p);
1523         break;
1524       case WCMD_MOVE:
1525         WCMD_move ();
1526         break;
1527       case WCMD_PATH:
1528         WCMD_setshow_path (p);
1529         break;
1530       case WCMD_PAUSE:
1531         WCMD_pause ();
1532         break;
1533       case WCMD_PROMPT:
1534         WCMD_setshow_prompt ();
1535         break;
1536       case WCMD_REM:
1537         break;
1538       case WCMD_REN:
1539       case WCMD_RENAME:
1540         WCMD_rename ();
1541         break;
1542       case WCMD_RD:
1543       case WCMD_RMDIR:
1544         WCMD_remove_dir (p);
1545         break;
1546       case WCMD_SETLOCAL:
1547         WCMD_setlocal(p);
1548         break;
1549       case WCMD_ENDLOCAL:
1550         WCMD_endlocal();
1551         break;
1552       case WCMD_SET:
1553         WCMD_setshow_env (p);
1554         break;
1555       case WCMD_SHIFT:
1556         WCMD_shift (p);
1557         break;
1558       case WCMD_START:
1559         WCMD_start (p);
1560         break;
1561       case WCMD_TIME:
1562         WCMD_setshow_time ();
1563         break;
1564       case WCMD_TITLE:
1565         if (strlenW(&whichcmd[count]) > 0)
1566           WCMD_title(&whichcmd[count+1]);
1567         break;
1568       case WCMD_TYPE:
1569         WCMD_type (p);
1570         break;
1571       case WCMD_VER:
1572         WCMD_output_asis(newlineW);
1573         WCMD_version ();
1574         break;
1575       case WCMD_VERIFY:
1576         WCMD_verify (p);
1577         break;
1578       case WCMD_VOL:
1579         WCMD_volume (FALSE, p);
1580         break;
1581       case WCMD_PUSHD:
1582         WCMD_pushd(p);
1583         break;
1584       case WCMD_POPD:
1585         WCMD_popd();
1586         break;
1587       case WCMD_ASSOC:
1588         WCMD_assoc(p, TRUE);
1589         break;
1590       case WCMD_COLOR:
1591         WCMD_color();
1592         break;
1593       case WCMD_FTYPE:
1594         WCMD_assoc(p, FALSE);
1595         break;
1596       case WCMD_MORE:
1597         WCMD_more(p);
1598         break;
1599       case WCMD_CHOICE:
1600         WCMD_choice(p);
1601         break;
1602       case WCMD_EXIT:
1603         WCMD_exit (cmdList);
1604         break;
1605       case WCMD_FOR:
1606       case WCMD_IF:
1607         /* Very oddly, probably because of all the special parsing required for
1608            these two commands, neither for nor if are supported when called,
1609            ie call if 1==1... will fail.                                        */
1610         if (!retrycall) {
1611           if (i==WCMD_FOR) WCMD_for (p, cmdList);
1612           else if (i==WCMD_IF) WCMD_if (p, cmdList);
1613           break;
1614         }
1615         /* else: drop through */
1616       default:
1617         prev_echo_mode = echo_mode;
1618         WCMD_run_program (whichcmd, FALSE);
1619         echo_mode = prev_echo_mode;
1620     }
1621     heap_free(cmd);
1622     heap_free(new_redir);
1623
1624     /* Restore old handles */
1625     for (i=0; i<3; i++) {
1626       if (old_stdhandles[i] != GetStdHandle(idx_stdhandles[i])) {
1627         CloseHandle (GetStdHandle (idx_stdhandles[i]));
1628         SetStdHandle (idx_stdhandles[i], old_stdhandles[i]);
1629       }
1630     }
1631 }
1632
1633 /*************************************************************************
1634  * WCMD_LoadMessage
1635  *    Load a string from the resource file, handling any error
1636  *    Returns string retrieved from resource file
1637  */
1638 WCHAR *WCMD_LoadMessage(UINT id) {
1639     static WCHAR msg[2048];
1640     static const WCHAR failedMsg[]  = {'F','a','i','l','e','d','!','\0'};
1641
1642     if (!LoadStringW(GetModuleHandleW(NULL), id, msg, sizeof(msg)/sizeof(WCHAR))) {
1643        WINE_FIXME("LoadString failed with %d\n", GetLastError());
1644        strcpyW(msg, failedMsg);
1645     }
1646     return msg;
1647 }
1648
1649 /***************************************************************************
1650  * WCMD_DumpCommands
1651  *
1652  *      Dumps out the parsed command line to ensure syntax is correct
1653  */
1654 static void WCMD_DumpCommands(CMD_LIST *commands) {
1655     CMD_LIST *thisCmd = commands;
1656
1657     WINE_TRACE("Parsed line:\n");
1658     while (thisCmd != NULL) {
1659       WINE_TRACE("%p %d %2.2d %p %s Redir:%s\n",
1660                thisCmd,
1661                thisCmd->prevDelim,
1662                thisCmd->bracketDepth,
1663                thisCmd->nextcommand,
1664                wine_dbgstr_w(thisCmd->command),
1665                wine_dbgstr_w(thisCmd->redirects));
1666       thisCmd = thisCmd->nextcommand;
1667     }
1668 }
1669
1670 /***************************************************************************
1671  * WCMD_addCommand
1672  *
1673  *   Adds a command to the current command list
1674  */
1675 static void WCMD_addCommand(WCHAR *command, int *commandLen,
1676                      WCHAR *redirs,  int *redirLen,
1677                      WCHAR **copyTo, int **copyToLen,
1678                      CMD_DELIMITERS prevDelim, int curDepth,
1679                      CMD_LIST **lastEntry, CMD_LIST **output) {
1680
1681     CMD_LIST *thisEntry = NULL;
1682
1683     /* Allocate storage for command */
1684     thisEntry = heap_alloc(sizeof(CMD_LIST));
1685
1686     /* Copy in the command */
1687     if (command) {
1688         thisEntry->command = heap_alloc((*commandLen+1) * sizeof(WCHAR));
1689         memcpy(thisEntry->command, command, *commandLen * sizeof(WCHAR));
1690         thisEntry->command[*commandLen] = 0x00;
1691
1692         /* Copy in the redirects */
1693         thisEntry->redirects = heap_alloc((*redirLen+1) * sizeof(WCHAR));
1694         memcpy(thisEntry->redirects, redirs, *redirLen * sizeof(WCHAR));
1695         thisEntry->redirects[*redirLen] = 0x00;
1696         thisEntry->pipeFile[0] = 0x00;
1697
1698         /* Reset the lengths */
1699         *commandLen   = 0;
1700         *redirLen     = 0;
1701         *copyToLen    = commandLen;
1702         *copyTo       = command;
1703
1704     } else {
1705         thisEntry->command = NULL;
1706         thisEntry->redirects = NULL;
1707         thisEntry->pipeFile[0] = 0x00;
1708     }
1709
1710     /* Fill in other fields */
1711     thisEntry->nextcommand = NULL;
1712     thisEntry->prevDelim = prevDelim;
1713     thisEntry->bracketDepth = curDepth;
1714     if (*lastEntry) {
1715         (*lastEntry)->nextcommand = thisEntry;
1716     } else {
1717         *output = thisEntry;
1718     }
1719     *lastEntry = thisEntry;
1720 }
1721
1722
1723 /***************************************************************************
1724  * WCMD_IsEndQuote
1725  *
1726  *   Checks if the quote pointed to is the end-quote.
1727  *
1728  *   Quotes end if:
1729  *
1730  *   1) The current parameter ends at EOL or at the beginning
1731  *      of a redirection or pipe and not in a quote section.
1732  *
1733  *   2) If the next character is a space and not in a quote section.
1734  *
1735  *   Returns TRUE if this is an end quote, and FALSE if it is not.
1736  *
1737  */
1738 static BOOL WCMD_IsEndQuote(const WCHAR *quote, int quoteIndex)
1739 {
1740     int quoteCount = quoteIndex;
1741     int i;
1742
1743     /* If we are not in a quoted section, then we are not an end-quote */
1744     if(quoteIndex == 0)
1745     {
1746         return FALSE;
1747     }
1748
1749     /* Check how many quotes are left for this parameter */
1750     for(i=0;quote[i];i++)
1751     {
1752         if(quote[i] == '"')
1753         {
1754             quoteCount++;
1755         }
1756
1757         /* Quote counting ends at EOL, redirection, space or pipe if current quote is complete */
1758         else if(((quoteCount % 2) == 0)
1759             && ((quote[i] == '<') || (quote[i] == '>') || (quote[i] == '|') || (quote[i] == ' ')))
1760         {
1761             break;
1762         }
1763     }
1764
1765     /* If the quote is part of the last part of a series of quotes-on-quotes, then it must
1766        be an end-quote */
1767     if(quoteIndex >= (quoteCount / 2))
1768     {
1769         return TRUE;
1770     }
1771
1772     /* No cigar */
1773     return FALSE;
1774 }
1775
1776 /***************************************************************************
1777  * WCMD_ReadAndParseLine
1778  *
1779  *   Either uses supplied input or
1780  *     Reads a file from the handle, and then...
1781  *   Parse the text buffer, splitting into separate commands
1782  *     - unquoted && strings split 2 commands but the 2nd is flagged as
1783  *            following an &&
1784  *     - ( as the first character just ups the bracket depth
1785  *     - unquoted ) when bracket depth > 0 terminates a bracket and
1786  *            adds a CMD_LIST structure with null command
1787  *     - Anything else gets put into the command string (including
1788  *            redirects)
1789  */
1790 WCHAR *WCMD_ReadAndParseLine(const WCHAR *optionalcmd, CMD_LIST **output, HANDLE readFrom)
1791 {
1792     WCHAR    *curPos;
1793     int       inQuotes = 0;
1794     WCHAR     curString[MAXSTRING];
1795     int       curStringLen = 0;
1796     WCHAR     curRedirs[MAXSTRING];
1797     int       curRedirsLen = 0;
1798     WCHAR    *curCopyTo;
1799     int      *curLen;
1800     int       curDepth = 0;
1801     CMD_LIST *lastEntry = NULL;
1802     CMD_DELIMITERS prevDelim = CMD_NONE;
1803     static WCHAR    *extraSpace = NULL;  /* Deliberately never freed */
1804     static const WCHAR remCmd[] = {'r','e','m'};
1805     static const WCHAR forCmd[] = {'f','o','r'};
1806     static const WCHAR ifCmd[]  = {'i','f'};
1807     static const WCHAR ifElse[] = {'e','l','s','e'};
1808     BOOL      inOneLine = FALSE;
1809     BOOL      inFor = FALSE;
1810     BOOL      inIn  = FALSE;
1811     BOOL      inIf  = FALSE;
1812     BOOL      inElse= FALSE;
1813     BOOL      onlyWhiteSpace = FALSE;
1814     BOOL      lastWasWhiteSpace = FALSE;
1815     BOOL      lastWasDo   = FALSE;
1816     BOOL      lastWasIn   = FALSE;
1817     BOOL      lastWasElse = FALSE;
1818     BOOL      lastWasRedirect = TRUE;
1819     BOOL      lastWasCaret = FALSE;
1820
1821     /* Allocate working space for a command read from keyboard, file etc */
1822     if (!extraSpace)
1823         extraSpace = heap_alloc((MAXSTRING+1) * sizeof(WCHAR));
1824     if (!extraSpace)
1825     {
1826         WINE_ERR("Could not allocate memory for extraSpace\n");
1827         return NULL;
1828     }
1829
1830     /* If initial command read in, use that, otherwise get input from handle */
1831     if (optionalcmd != NULL) {
1832         strcpyW(extraSpace, optionalcmd);
1833     } else if (readFrom == INVALID_HANDLE_VALUE) {
1834         WINE_FIXME("No command nor handle supplied\n");
1835     } else {
1836         if (!WCMD_fgets(extraSpace, MAXSTRING, readFrom))
1837           return NULL;
1838     }
1839     curPos = extraSpace;
1840
1841     /* Handle truncated input - issue warning */
1842     if (strlenW(extraSpace) == MAXSTRING -1) {
1843         WCMD_output_asis_stderr(WCMD_LoadMessage(WCMD_TRUNCATEDLINE));
1844         WCMD_output_asis_stderr(extraSpace);
1845         WCMD_output_asis_stderr(newlineW);
1846     }
1847
1848     /* Replace env vars if in a batch context */
1849     if (context) handleExpansion(extraSpace, FALSE, FALSE);
1850
1851     /* Skip preceding whitespace */
1852     while (*curPos == ' ' || *curPos == '\t') curPos++;
1853
1854     /* Show prompt before batch line IF echo is on and in batch program */
1855     if (context && echo_mode && *curPos && (*curPos != '@')) {
1856       static const WCHAR echoDot[] = {'e','c','h','o','.'};
1857       static const WCHAR echoCol[] = {'e','c','h','o',':'};
1858       const DWORD len = sizeof(echoDot)/sizeof(echoDot[0]);
1859       DWORD curr_size = strlenW(curPos);
1860       DWORD min_len = (curr_size < len ? curr_size : len);
1861       WCMD_show_prompt();
1862       WCMD_output_asis(curPos);
1863       /* I don't know why Windows puts a space here but it does */
1864       /* Except for lines starting with 'echo.' or 'echo:'. Ask MS why */
1865       if (CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1866                          curPos, min_len, echoDot, len) != CSTR_EQUAL
1867           && CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1868                          curPos, min_len, echoCol, len) != CSTR_EQUAL)
1869       {
1870           WCMD_output_asis(spaceW);
1871       }
1872       WCMD_output_asis(newlineW);
1873     }
1874
1875     /* Skip repeated 'no echo' characters */
1876     while (*curPos == '@') curPos++;
1877
1878     /* Start with an empty string, copying to the command string */
1879     curStringLen = 0;
1880     curRedirsLen = 0;
1881     curCopyTo    = curString;
1882     curLen       = &curStringLen;
1883     lastWasRedirect = FALSE;  /* Required e.g. for spaces between > and filename */
1884
1885     /* Parse every character on the line being processed */
1886     while (*curPos != 0x00) {
1887
1888       WCHAR thisChar;
1889
1890       /* Debugging AID:
1891       WINE_TRACE("Looking at '%c' (len:%d, lws:%d, ows:%d)\n", *curPos, *curLen,
1892                  lastWasWhiteSpace, onlyWhiteSpace);
1893       */
1894
1895       /* Prevent overflow caused by the caret escape char */
1896       if (*curLen >= MAXSTRING) {
1897         WINE_ERR("Overflow detected in command\n");
1898         return NULL;
1899       }
1900
1901       /* Certain commands need special handling */
1902       if (curStringLen == 0 && curCopyTo == curString) {
1903         static const WCHAR forDO[] = {'d','o'};
1904
1905         /* If command starts with 'rem ' or identifies a label, ignore any &&, ( etc. */
1906         if (WCMD_keyword_ws_found(remCmd, sizeof(remCmd)/sizeof(remCmd[0]), curPos) ||
1907             *curPos == ':') {
1908           inOneLine = TRUE;
1909
1910         } else if (WCMD_keyword_ws_found(forCmd, sizeof(forCmd)/sizeof(forCmd[0]), curPos)) {
1911           inFor = TRUE;
1912
1913         /* If command starts with 'if ' or 'else ', handle ('s mid line. We should ensure this
1914            is only true in the command portion of the IF statement, but this
1915            should suffice for now
1916             FIXME: Silly syntax like "if 1(==1( (
1917                                         echo they equal
1918                                       )" will be parsed wrong */
1919         } else if (WCMD_keyword_ws_found(ifCmd, sizeof(ifCmd)/sizeof(ifCmd[0]), curPos)) {
1920           inIf = TRUE;
1921
1922         } else if (WCMD_keyword_ws_found(ifElse, sizeof(ifElse)/sizeof(ifElse[0]), curPos)) {
1923           const int keyw_len = sizeof(ifElse)/sizeof(ifElse[0]) + 1;
1924           inElse = TRUE;
1925           lastWasElse = TRUE;
1926           onlyWhiteSpace = TRUE;
1927           memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1928           (*curLen)+=keyw_len;
1929           curPos+=keyw_len;
1930           continue;
1931
1932         /* In a for loop, the DO command will follow a close bracket followed by
1933            whitespace, followed by DO, ie closeBracket inserts a NULL entry, curLen
1934            is then 0, and all whitespace is skipped                                */
1935         } else if (inFor &&
1936                    WCMD_keyword_ws_found(forDO, sizeof(forDO)/sizeof(forDO[0]), curPos)) {
1937           const int keyw_len = sizeof(forDO)/sizeof(forDO[0]) + 1;
1938           WINE_TRACE("Found 'DO '\n");
1939           lastWasDo = TRUE;
1940           onlyWhiteSpace = TRUE;
1941           memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1942           (*curLen)+=keyw_len;
1943           curPos+=keyw_len;
1944           continue;
1945         }
1946       } else if (curCopyTo == curString) {
1947
1948         /* Special handling for the 'FOR' command */
1949         if (inFor && lastWasWhiteSpace) {
1950           static const WCHAR forIN[] = {'i','n'};
1951
1952           WINE_TRACE("Found 'FOR ', comparing next parm: '%s'\n", wine_dbgstr_w(curPos));
1953
1954           if (WCMD_keyword_ws_found(forIN, sizeof(forIN)/sizeof(forIN[0]), curPos)) {
1955             const int keyw_len = sizeof(forIN)/sizeof(forIN[0]) + 1;
1956             WINE_TRACE("Found 'IN '\n");
1957             lastWasIn = TRUE;
1958             onlyWhiteSpace = TRUE;
1959             memcpy(&curCopyTo[*curLen], curPos, keyw_len*sizeof(WCHAR));
1960             (*curLen)+=keyw_len;
1961             curPos+=keyw_len;
1962             continue;
1963           }
1964         }
1965       }
1966
1967       /* Nothing 'ends' a one line statement (e.g. REM or :labels mean
1968          the &&, quotes and redirection etc are ineffective, so just force
1969          the use of the default processing by skipping character specific
1970          matching below)                                                   */
1971       if (!inOneLine) thisChar = *curPos;
1972       else            thisChar = 'X';  /* Character with no special processing */
1973
1974       lastWasWhiteSpace = FALSE; /* Will be reset below */
1975       lastWasCaret = FALSE;
1976
1977       switch (thisChar) {
1978
1979       case '=': /* drop through - ignore token delimiters at the start of a command */
1980       case ',': /* drop through - ignore token delimiters at the start of a command */
1981       case '\t':/* drop through - ignore token delimiters at the start of a command */
1982       case ' ':
1983                 /* If a redirect in place, it ends here */
1984                 if (!inQuotes && !lastWasRedirect) {
1985
1986                   /* If finishing off a redirect, add a whitespace delimiter */
1987                   if (curCopyTo == curRedirs) {
1988                       curCopyTo[(*curLen)++] = ' ';
1989                   }
1990                   curCopyTo = curString;
1991                   curLen = &curStringLen;
1992                 }
1993                 if (*curLen > 0) {
1994                   curCopyTo[(*curLen)++] = *curPos;
1995                 }
1996
1997                 /* Remember just processed whitespace */
1998                 lastWasWhiteSpace = TRUE;
1999
2000                 break;
2001
2002       case '>': /* drop through - handle redirect chars the same */
2003       case '<':
2004                 /* Make a redirect start here */
2005                 if (!inQuotes) {
2006                   curCopyTo = curRedirs;
2007                   curLen = &curRedirsLen;
2008                   lastWasRedirect = TRUE;
2009                 }
2010
2011                 /* See if 1>, 2> etc, in which case we have some patching up
2012                    to do (provided there's a preceding whitespace, and enough
2013                    chars read so far) */
2014                 if (curStringLen > 2
2015                         && (*(curPos-1)>='1') && (*(curPos-1)<='9')
2016                         && ((*(curPos-2)==' ') || (*(curPos-2)=='\t'))) {
2017                     curStringLen--;
2018                     curString[curStringLen] = 0x00;
2019                     curCopyTo[(*curLen)++] = *(curPos-1);
2020                 }
2021
2022                 curCopyTo[(*curLen)++] = *curPos;
2023
2024                 /* If a redirect is immediately followed by '&' (ie. 2>&1) then
2025                     do not process that ampersand as an AND operator */
2026                 if (thisChar == '>' && *(curPos+1) == '&') {
2027                     curCopyTo[(*curLen)++] = *(curPos+1);
2028                     curPos++;
2029                 }
2030                 break;
2031
2032       case '|': /* Pipe character only if not || */
2033                 if (!inQuotes) {
2034                   lastWasRedirect = FALSE;
2035
2036                   /* Add an entry to the command list */
2037                   if (curStringLen > 0) {
2038
2039                     /* Add the current command */
2040                     WCMD_addCommand(curString, &curStringLen,
2041                           curRedirs, &curRedirsLen,
2042                           &curCopyTo, &curLen,
2043                           prevDelim, curDepth,
2044                           &lastEntry, output);
2045
2046                   }
2047
2048                   if (*(curPos+1) == '|') {
2049                     curPos++; /* Skip other | */
2050                     prevDelim = CMD_ONFAILURE;
2051                   } else {
2052                     prevDelim = CMD_PIPE;
2053                   }
2054                 } else {
2055                   curCopyTo[(*curLen)++] = *curPos;
2056                 }
2057                 break;
2058
2059       case '"': if (WCMD_IsEndQuote(curPos, inQuotes)) {
2060                     inQuotes--;
2061                 } else {
2062                     inQuotes++; /* Quotes within quotes are fun! */
2063                 }
2064                 curCopyTo[(*curLen)++] = *curPos;
2065                 lastWasRedirect = FALSE;
2066                 break;
2067
2068       case '(': /* If a '(' is the first non whitespace in a command portion
2069                    ie start of line or just after &&, then we read until an
2070                    unquoted ) is found                                       */
2071                 WINE_TRACE("Found '(' conditions: curLen(%d), inQ(%d), onlyWS(%d)"
2072                            ", for(%d, In:%d, Do:%d)"
2073                            ", if(%d, else:%d, lwe:%d)\n",
2074                            *curLen, inQuotes,
2075                            onlyWhiteSpace,
2076                            inFor, lastWasIn, lastWasDo,
2077                            inIf, inElse, lastWasElse);
2078                 lastWasRedirect = FALSE;
2079
2080                 /* Ignore open brackets inside the for set */
2081                 if (*curLen == 0 && !inIn) {
2082                   curDepth++;
2083
2084                 /* If in quotes, ignore brackets */
2085                 } else if (inQuotes) {
2086                   curCopyTo[(*curLen)++] = *curPos;
2087
2088                 /* In a FOR loop, an unquoted '(' may occur straight after
2089                       IN or DO
2090                    In an IF statement just handle it regardless as we don't
2091                       parse the operands
2092                    In an ELSE statement, only allow it straight away after
2093                       the ELSE and whitespace
2094                  */
2095                 } else if (inIf ||
2096                            (inElse && lastWasElse && onlyWhiteSpace) ||
2097                            (inFor && (lastWasIn || lastWasDo) && onlyWhiteSpace)) {
2098
2099                    /* If entering into an 'IN', set inIn */
2100                   if (inFor && lastWasIn && onlyWhiteSpace) {
2101                     WINE_TRACE("Inside an IN\n");
2102                     inIn = TRUE;
2103                   }
2104
2105                   /* Add the current command */
2106                   WCMD_addCommand(curString, &curStringLen,
2107                                   curRedirs, &curRedirsLen,
2108                                   &curCopyTo, &curLen,
2109                                   prevDelim, curDepth,
2110                                   &lastEntry, output);
2111
2112                   curDepth++;
2113                 } else {
2114                   curCopyTo[(*curLen)++] = *curPos;
2115                 }
2116                 break;
2117
2118       case '^': if (!inQuotes) {
2119                   /* If we reach the end of the input, we need to wait for more */
2120                   if (*(curPos+1) == 0x00) {
2121                     lastWasCaret = TRUE;
2122                     WINE_TRACE("Caret found at end of line\n");
2123                     break;
2124                   }
2125                   curPos++;
2126                 }
2127                 curCopyTo[(*curLen)++] = *curPos;
2128                 break;
2129
2130       case '&': if (!inQuotes) {
2131                   lastWasRedirect = FALSE;
2132
2133                   /* Add an entry to the command list */
2134                   if (curStringLen > 0) {
2135
2136                     /* Add the current command */
2137                     WCMD_addCommand(curString, &curStringLen,
2138                           curRedirs, &curRedirsLen,
2139                           &curCopyTo, &curLen,
2140                           prevDelim, curDepth,
2141                           &lastEntry, output);
2142
2143                   }
2144
2145                   if (*(curPos+1) == '&') {
2146                     curPos++; /* Skip other & */
2147                     prevDelim = CMD_ONSUCCESS;
2148                   } else {
2149                     prevDelim = CMD_NONE;
2150                   }
2151                 } else {
2152                   curCopyTo[(*curLen)++] = *curPos;
2153                 }
2154                 break;
2155
2156       case ')': if (!inQuotes && curDepth > 0) {
2157                   lastWasRedirect = FALSE;
2158
2159                   /* Add the current command if there is one */
2160                   if (curStringLen) {
2161
2162                       /* Add the current command */
2163                       WCMD_addCommand(curString, &curStringLen,
2164                             curRedirs, &curRedirsLen,
2165                             &curCopyTo, &curLen,
2166                             prevDelim, curDepth,
2167                             &lastEntry, output);
2168                   }
2169
2170                   /* Add an empty entry to the command list */
2171                   prevDelim = CMD_NONE;
2172                   WCMD_addCommand(NULL, &curStringLen,
2173                         curRedirs, &curRedirsLen,
2174                         &curCopyTo, &curLen,
2175                         prevDelim, curDepth,
2176                         &lastEntry, output);
2177                   curDepth--;
2178
2179                   /* Leave inIn if necessary */
2180                   if (inIn) inIn =  FALSE;
2181                 } else {
2182                   curCopyTo[(*curLen)++] = *curPos;
2183                 }
2184                 break;
2185       default:
2186                 lastWasRedirect = FALSE;
2187                 curCopyTo[(*curLen)++] = *curPos;
2188       }
2189
2190       curPos++;
2191
2192       /* At various times we need to know if we have only skipped whitespace,
2193          so reset this variable and then it will remain true until a non
2194          whitespace is found                                               */
2195       if ((thisChar != ' ') && (thisChar != '\t') && (thisChar != '\n'))
2196         onlyWhiteSpace = FALSE;
2197
2198       /* Flag end of interest in FOR DO and IN parms once something has been processed */
2199       if (!lastWasWhiteSpace) {
2200         lastWasIn = lastWasDo = FALSE;
2201       }
2202
2203       /* If we have reached the end, add this command into the list
2204          Do not add command to list if escape char ^ was last */
2205       if (*curPos == 0x00 && !lastWasCaret && *curLen > 0) {
2206
2207           /* Add an entry to the command list */
2208           WCMD_addCommand(curString, &curStringLen,
2209                 curRedirs, &curRedirsLen,
2210                 &curCopyTo, &curLen,
2211                 prevDelim, curDepth,
2212                 &lastEntry, output);
2213       }
2214
2215       /* If we have reached the end of the string, see if bracketing or
2216          final caret is outstanding */
2217       if (*curPos == 0x00 && (curDepth > 0 || lastWasCaret) &&
2218           readFrom != INVALID_HANDLE_VALUE) {
2219         WCHAR *extraData;
2220
2221         WINE_TRACE("Need to read more data as outstanding brackets or carets\n");
2222         inOneLine = FALSE;
2223         prevDelim = CMD_NONE;
2224         inQuotes = 0;
2225         memset(extraSpace, 0x00, (MAXSTRING+1) * sizeof(WCHAR));
2226         extraData = extraSpace;
2227
2228         /* Read more, skipping any blank lines */
2229         do {
2230           WINE_TRACE("Read more input\n");
2231           if (!context) WCMD_output_asis( WCMD_LoadMessage(WCMD_MOREPROMPT));
2232           if (!WCMD_fgets(extraData, MAXSTRING, readFrom))
2233             break;
2234
2235           /* Edge case for carets - a completely blank line (i.e. was just
2236              CRLF) is oddly added as an LF but then more data is received (but
2237              only once more!) */
2238           if (lastWasCaret) {
2239             if (*extraSpace == 0x00) {
2240               WINE_TRACE("Read nothing, so appending LF char and will try again\n");
2241               *extraData++ = '\r';
2242               *extraData = 0x00;
2243             } else break;
2244           }
2245
2246         } while (*extraData == 0x00);
2247         curPos = extraSpace;
2248         if (context) handleExpansion(extraSpace, FALSE, FALSE);
2249         /* Continue to echo commands IF echo is on and in batch program */
2250         if (context && echo_mode && extraSpace[0] && (extraSpace[0] != '@')) {
2251           WCMD_output_asis(extraSpace);
2252           WCMD_output_asis(newlineW);
2253         }
2254       }
2255     }
2256
2257     /* Dump out the parsed output */
2258     WCMD_DumpCommands(*output);
2259
2260     return extraSpace;
2261 }
2262
2263 /***************************************************************************
2264  * WCMD_process_commands
2265  *
2266  * Process all the commands read in so far
2267  */
2268 CMD_LIST *WCMD_process_commands(CMD_LIST *thisCmd, BOOL oneBracket,
2269                                 BOOL retrycall) {
2270
2271     int bdepth = -1;
2272
2273     if (thisCmd && oneBracket) bdepth = thisCmd->bracketDepth;
2274
2275     /* Loop through the commands, processing them one by one */
2276     while (thisCmd) {
2277
2278       CMD_LIST *origCmd = thisCmd;
2279
2280       /* If processing one bracket only, and we find the end bracket
2281          entry (or less), return                                    */
2282       if (oneBracket && !thisCmd->command &&
2283           bdepth <= thisCmd->bracketDepth) {
2284         WINE_TRACE("Finished bracket @ %p, next command is %p\n",
2285                    thisCmd, thisCmd->nextcommand);
2286         return thisCmd->nextcommand;
2287       }
2288
2289       /* Ignore the NULL entries a ')' inserts (Only 'if' cares
2290          about them and it will be handled in there)
2291          Also, skip over any batch labels (eg. :fred)          */
2292       if (thisCmd->command && thisCmd->command[0] != ':') {
2293         WINE_TRACE("Executing command: '%s'\n", wine_dbgstr_w(thisCmd->command));
2294         WCMD_execute (thisCmd->command, thisCmd->redirects, &thisCmd, retrycall);
2295       }
2296
2297       /* Step on unless the command itself already stepped on */
2298       if (thisCmd == origCmd) thisCmd = thisCmd->nextcommand;
2299     }
2300     return NULL;
2301 }
2302
2303 /***************************************************************************
2304  * WCMD_free_commands
2305  *
2306  * Frees the storage held for a parsed command line
2307  * - This is not done in the process_commands, as eventually the current
2308  *   pointer will be modified within the commands, and hence a single free
2309  *   routine is simpler
2310  */
2311 void WCMD_free_commands(CMD_LIST *cmds) {
2312
2313     /* Loop through the commands, freeing them one by one */
2314     while (cmds) {
2315       CMD_LIST *thisCmd = cmds;
2316       cmds = cmds->nextcommand;
2317       heap_free(thisCmd->command);
2318       heap_free(thisCmd->redirects);
2319       heap_free(thisCmd);
2320     }
2321 }
2322
2323
2324 /*****************************************************************************
2325  * Main entry point. This is a console application so we have a main() not a
2326  * winmain().
2327  */
2328
2329 int wmain (int argc, WCHAR *argvW[])
2330 {
2331   int     args;
2332   WCHAR  *cmdLine = NULL;
2333   WCHAR  *cmd     = NULL;
2334   WCHAR  *argPos  = NULL;
2335   WCHAR string[1024];
2336   WCHAR envvar[4];
2337   BOOL opt_q;
2338   int opt_t = 0;
2339   static const WCHAR offW[] = {'O','F','F','\0'};
2340   static const WCHAR promptW[] = {'P','R','O','M','P','T','\0'};
2341   static const WCHAR defaultpromptW[] = {'$','P','$','G','\0'};
2342   CMD_LIST *toExecute = NULL;         /* Commands left to be executed */
2343   OSVERSIONINFOW osv;
2344   char osver[50];
2345
2346   srand(time(NULL));
2347
2348   /* Get the windows version being emulated */
2349   osv.dwOSVersionInfoSize = sizeof(osv);
2350   GetVersionExW(&osv);
2351
2352   /* Pre initialize some messages */
2353   strcpyW(anykey, WCMD_LoadMessage(WCMD_ANYKEY));
2354   sprintf(osver, "%d.%d.%d (%s)", osv.dwMajorVersion, osv.dwMinorVersion,
2355           osv.dwBuildNumber, PACKAGE_VERSION);
2356   cmd = WCMD_format_string(WCMD_LoadMessage(WCMD_VERSION), osver);
2357   strcpyW(version_string, cmd);
2358   LocalFree(cmd);
2359   cmd = NULL;
2360
2361   /* Can't use argc/argv as it will have stripped quotes from parameters
2362    * meaning cmd.exe /C echo "quoted string" is impossible
2363    */
2364   cmdLine = GetCommandLineW();
2365   WINE_TRACE("Full commandline '%s'\n", wine_dbgstr_w(cmdLine));
2366   args = 1;                /* start at first arg, skipping cmd.exe itself */
2367
2368   opt_c = opt_k = opt_q = opt_s = FALSE;
2369   WCMD_parameter(cmdLine, args, &argPos, TRUE, TRUE);
2370   while (argPos && argPos[0] != 0x00)
2371   {
2372       WCHAR c;
2373       WINE_TRACE("Command line parm: '%s'\n", wine_dbgstr_w(argPos));
2374       if (argPos[0]!='/' || argPos[1]=='\0') {
2375           args++;
2376           WCMD_parameter(cmdLine, args, &argPos, TRUE, TRUE);
2377           continue;
2378       }
2379
2380       c=argPos[1];
2381       if (tolowerW(c)=='c') {
2382           opt_c = TRUE;
2383       } else if (tolowerW(c)=='q') {
2384           opt_q = TRUE;
2385       } else if (tolowerW(c)=='k') {
2386           opt_k = TRUE;
2387       } else if (tolowerW(c)=='s') {
2388           opt_s = TRUE;
2389       } else if (tolowerW(c)=='a') {
2390           unicodeOutput = FALSE;
2391       } else if (tolowerW(c)=='u') {
2392           unicodeOutput = TRUE;
2393       } else if (tolowerW(c)=='v' && argPos[2]==':') {
2394           delayedsubst = strncmpiW(&argPos[3], offW, 3);
2395           if (delayedsubst) WINE_TRACE("Delayed substitution is on\n");
2396       } else if (tolowerW(c)=='t' && argPos[2]==':') {
2397           opt_t=strtoulW(&argPos[3], NULL, 16);
2398       } else if (tolowerW(c)=='x' || tolowerW(c)=='y') {
2399           /* Ignored for compatibility with Windows */
2400       }
2401
2402       if (argPos[2]==0 || argPos[2]==' ' || argPos[2]=='\t' ||
2403           tolowerW(c)=='v') {
2404           args++;
2405           WCMD_parameter(cmdLine, args, &argPos, TRUE, TRUE);
2406       }
2407       else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
2408       {
2409           /* Do not step to next parameter, instead carry on parsing this one */
2410           argPos+=2;
2411       }
2412
2413       if (opt_c || opt_k) /* break out of parsing immediately after c or k */
2414           break;
2415   }
2416
2417   if (opt_q) {
2418     WCMD_echo(offW);
2419   }
2420
2421   /* Until we start to read from the keyboard, stay as non-interactive */
2422   interactive = FALSE;
2423
2424   if (opt_c || opt_k) {
2425       int     len;
2426       WCHAR   *q1 = NULL,*q2 = NULL,*p;
2427
2428       /* Handle very edge case error scenario, "cmd.exe /c" ie when there are no
2429        * parameters after the /C or /K by pretending there was a single space     */
2430       if (argPos == NULL) argPos = (WCHAR *)spaceW;
2431
2432       /* Take a copy */
2433       cmd = heap_strdupW(argPos);
2434
2435       /* opt_s left unflagged if the command starts with and contains exactly
2436        * one quoted string (exactly two quote characters). The quoted string
2437        * must be an executable name that has whitespace and must not have the
2438        * following characters: &<>()@^| */
2439
2440       if (!opt_s) {
2441         /* 1. Confirm there is at least one quote */
2442         q1 = strchrW(argPos, '"');
2443         if (!q1) opt_s=1;
2444       }
2445
2446       if (!opt_s) {
2447           /* 2. Confirm there is a second quote */
2448           q2 = strchrW(q1+1, '"');
2449           if (!q2) opt_s=1;
2450       }
2451
2452       if (!opt_s) {
2453           /* 3. Ensure there are no more quotes */
2454           if (strchrW(q2+1, '"')) opt_s=1;
2455       }
2456
2457       /* check first parameter for a space and invalid characters. There must not be any
2458        * invalid characters, but there must be one or more whitespace                    */
2459       if (!opt_s) {
2460           opt_s = TRUE;
2461           p=q1;
2462           while (p!=q2) {
2463               if (*p=='&' || *p=='<' || *p=='>' || *p=='(' || *p==')'
2464                   || *p=='@' || *p=='^' || *p=='|') {
2465                   opt_s = TRUE;
2466                   break;
2467               }
2468               if (*p==' ' || *p=='\t')
2469                   opt_s = FALSE;
2470               p++;
2471           }
2472       }
2473
2474       WINE_TRACE("/c command line: '%s'\n", wine_dbgstr_w(cmd));
2475
2476       /* Finally, we only stay in new mode IF the first parameter is quoted and
2477          is a valid executable, i.e. must exist, otherwise drop back to old mode  */
2478       if (!opt_s) {
2479         WCHAR *thisArg = WCMD_parameter(cmd, 0, NULL, FALSE, TRUE);
2480         WCHAR  pathext[MAXSTRING];
2481         BOOL found = FALSE;
2482
2483         /* Now extract PATHEXT */
2484         len = GetEnvironmentVariableW(envPathExt, pathext, sizeof(pathext)/sizeof(WCHAR));
2485         if ((len == 0) || (len >= (sizeof(pathext)/sizeof(WCHAR)))) {
2486           strcpyW (pathext, dfltPathExt);
2487         }
2488
2489         /* If the supplied parameter has any directory information, look there */
2490         WINE_TRACE("First parameter is '%s'\n", wine_dbgstr_w(thisArg));
2491         if (strchrW(thisArg, '\\') != NULL) {
2492
2493           GetFullPathNameW(thisArg, sizeof(string)/sizeof(WCHAR), string, NULL);
2494           WINE_TRACE("Full path name '%s'\n", wine_dbgstr_w(string));
2495           p = string + strlenW(string);
2496
2497           /* Does file exist with this name? */
2498           if (GetFileAttributesW(string) != INVALID_FILE_ATTRIBUTES) {
2499             WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string));
2500             found = TRUE;
2501           } else {
2502             WCHAR *thisExt = pathext;
2503
2504             /* No - try with each of the PATHEXT extensions */
2505             while (!found && thisExt) {
2506               WCHAR *nextExt = strchrW(thisExt, ';');
2507
2508               if (nextExt) {
2509                 memcpy(p, thisExt, (nextExt-thisExt) * sizeof(WCHAR));
2510                 p[(nextExt-thisExt)] = 0x00;
2511                 thisExt = nextExt+1;
2512               } else {
2513                 strcpyW(p, thisExt);
2514                 thisExt = NULL;
2515               }
2516
2517               /* Does file exist with this extension appended? */
2518               if (GetFileAttributesW(string) != INVALID_FILE_ATTRIBUTES) {
2519                 WINE_TRACE("Found file as '%s'\n", wine_dbgstr_w(string));
2520                 found = TRUE;
2521               }
2522             }
2523           }
2524
2525         /* Otherwise we now need to look in the path to see if we can find it */
2526         } else {
2527           p = thisArg + strlenW(thisArg);
2528
2529           /* Does file exist with this name? */
2530           if (SearchPathW(NULL, thisArg, NULL, sizeof(string)/sizeof(WCHAR), string, NULL) != 0)  {
2531             WINE_TRACE("Found on path as '%s'\n", wine_dbgstr_w(string));
2532             found = TRUE;
2533           } else {
2534             WCHAR *thisExt = pathext;
2535
2536             /* No - try with each of the PATHEXT extensions */
2537             while (!found && thisExt) {
2538               WCHAR *nextExt = strchrW(thisExt, ';');
2539
2540               if (nextExt) {
2541                 *nextExt = 0;
2542                 nextExt = nextExt+1;
2543               } else {
2544                 nextExt = NULL;
2545               }
2546
2547               /* Does file exist with this extension? */
2548               if (SearchPathW(NULL, thisArg, thisExt, sizeof(string)/sizeof(WCHAR), string, NULL) != 0)  {
2549                 WINE_TRACE("Found on path as '%s' with extension '%s'\n", wine_dbgstr_w(string),
2550                            wine_dbgstr_w(thisExt));
2551                 found = TRUE;
2552               }
2553               thisExt = nextExt;
2554             }
2555           }
2556         }
2557
2558         /* If not found, drop back to old behaviour */
2559         if (!found) {
2560           WINE_TRACE("Binary not found, dropping back to old behaviour\n");
2561           opt_s = TRUE;
2562         }
2563
2564       }
2565
2566       /* strip first and last quote characters if opt_s; check for invalid
2567        * executable is done later */
2568       if (opt_s && *cmd=='\"')
2569           WCMD_strip_quotes(cmd);
2570   }
2571
2572   /* Save cwd into appropriate env var (Must be before the /c processing */
2573   GetCurrentDirectoryW(sizeof(string)/sizeof(WCHAR), string);
2574   if (IsCharAlphaW(string[0]) && string[1] == ':') {
2575     static const WCHAR fmt[] = {'=','%','c',':','\0'};
2576     wsprintfW(envvar, fmt, string[0]);
2577     SetEnvironmentVariableW(envvar, string);
2578     WINE_TRACE("Set %s to %s\n", wine_dbgstr_w(envvar), wine_dbgstr_w(string));
2579   }
2580
2581   if (opt_c) {
2582       /* If we do a "cmd /c command", we don't want to allocate a new
2583        * console since the command returns immediately. Rather, we use
2584        * the currently allocated input and output handles. This allows
2585        * us to pipe to and read from the command interpreter.
2586        */
2587
2588       /* Parse the command string, without reading any more input */
2589       WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
2590       WCMD_process_commands(toExecute, FALSE, FALSE);
2591       WCMD_free_commands(toExecute);
2592       toExecute = NULL;
2593
2594       heap_free(cmd);
2595       return errorlevel;
2596   }
2597
2598   SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_LINE_INPUT |
2599                  ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
2600   SetConsoleTitleW(WCMD_LoadMessage(WCMD_CONSTITLE));
2601
2602   /* Note: cmd.exe /c dir does not get a new color, /k dir does */
2603   if (opt_t) {
2604       if (!(((opt_t & 0xF0) >> 4) == (opt_t & 0x0F))) {
2605           defaultColor = opt_t & 0xFF;
2606           param1[0] = 0x00;
2607           WCMD_color();
2608       }
2609   } else {
2610       /* Check HKCU\Software\Microsoft\Command Processor
2611          Then  HKLM\Software\Microsoft\Command Processor
2612            for defaultcolour value
2613            Note  Can be supplied as DWORD or REG_SZ
2614            Note2 When supplied as REG_SZ it's in decimal!!! */
2615       HKEY key;
2616       DWORD type;
2617       DWORD value=0, size=4;
2618       static const WCHAR regKeyW[] = {'S','o','f','t','w','a','r','e','\\',
2619                                       'M','i','c','r','o','s','o','f','t','\\',
2620                                       'C','o','m','m','a','n','d',' ','P','r','o','c','e','s','s','o','r','\0'};
2621       static const WCHAR dfltColorW[] = {'D','e','f','a','u','l','t','C','o','l','o','r','\0'};
2622
2623       if (RegOpenKeyExW(HKEY_CURRENT_USER, regKeyW,
2624                        0, KEY_READ, &key) == ERROR_SUCCESS) {
2625           WCHAR  strvalue[4];
2626
2627           /* See if DWORD or REG_SZ */
2628           if (RegQueryValueExW(key, dfltColorW, NULL, &type,
2629                      NULL, NULL) == ERROR_SUCCESS) {
2630               if (type == REG_DWORD) {
2631                   size = sizeof(DWORD);
2632                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2633                                   (LPBYTE)&value, &size);
2634               } else if (type == REG_SZ) {
2635                   size = sizeof(strvalue)/sizeof(WCHAR);
2636                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2637                                   (LPBYTE)strvalue, &size);
2638                   value = strtoulW(strvalue, NULL, 10);
2639               }
2640           }
2641           RegCloseKey(key);
2642       }
2643
2644       if (value == 0 && RegOpenKeyExW(HKEY_LOCAL_MACHINE, regKeyW,
2645                        0, KEY_READ, &key) == ERROR_SUCCESS) {
2646           WCHAR  strvalue[4];
2647
2648           /* See if DWORD or REG_SZ */
2649           if (RegQueryValueExW(key, dfltColorW, NULL, &type,
2650                      NULL, NULL) == ERROR_SUCCESS) {
2651               if (type == REG_DWORD) {
2652                   size = sizeof(DWORD);
2653                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2654                                   (LPBYTE)&value, &size);
2655               } else if (type == REG_SZ) {
2656                   size = sizeof(strvalue)/sizeof(WCHAR);
2657                   RegQueryValueExW(key, dfltColorW, NULL, NULL,
2658                                   (LPBYTE)strvalue, &size);
2659                   value = strtoulW(strvalue, NULL, 10);
2660               }
2661           }
2662           RegCloseKey(key);
2663       }
2664
2665       /* If one found, set the screen to that colour */
2666       if (!(((value & 0xF0) >> 4) == (value & 0x0F))) {
2667           defaultColor = value & 0xFF;
2668           param1[0] = 0x00;
2669           WCMD_color();
2670       }
2671
2672   }
2673
2674   if (opt_k) {
2675       /* Parse the command string, without reading any more input */
2676       WCMD_ReadAndParseLine(cmd, &toExecute, INVALID_HANDLE_VALUE);
2677       WCMD_process_commands(toExecute, FALSE, FALSE);
2678       WCMD_free_commands(toExecute);
2679       toExecute = NULL;
2680       heap_free(cmd);
2681   }
2682
2683 /*
2684  *      Loop forever getting commands and executing them.
2685  */
2686
2687   SetEnvironmentVariableW(promptW, defaultpromptW);
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 }