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