programs/cmd/wcmdmain.c

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