git.oblomov.eu Git - wine/blob - programs/cmd/builtins.c

   1 /*
   2  * CMD - Wine-compatible command line interface - built-in functions.
   3  *
   4  * Copyright (C) 1999 D A Pickles
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22  * NOTES:
  23  * On entry to each function, global variables quals, param1, param2 contain
  24  * the qualifiers (uppercased and concatenated) and parameters entered, with
  25  * environment-variable and batch parameter substitution already done.
  26  */
  27
  28 /*
  29  * FIXME:
  30  * - No support for pipes, shell parameters
  31  * - Lots of functionality missing from builtins
  32  * - Messages etc need international support
  33  */
  34
  35 #define WIN32_LEAN_AND_MEAN
  36
  37 #include "wcmd.h"
  38
  39 void WCMD_execute (char *orig_command, char *parameter, char *substitution);
  40
  41 struct env_stack
  42 {
  43   struct env_stack *next;
  44   WCHAR *strings;
  45 };
  46
  47 struct env_stack *saved_environment;
  48
  49 extern HINSTANCE hinst;
  50 extern char *inbuilt[];
  51 extern int echo_mode, verify_mode;
  52 extern char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
  53 extern BATCH_CONTEXT *context;
  54 extern DWORD errorlevel;
  55
  56
  57
  58 /****************************************************************************
  59  * WCMD_clear_screen
  60  *
  61  * Clear the terminal screen.
  62  */
  63
  64 void WCMD_clear_screen (void) {
  65
  66   /* Emulate by filling the screen from the top left to bottom right with
  67         spaces, then moving the cursor to the top left afterwards */
  68   CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
  69   HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
  70
  71   if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
  72   {
  73       COORD topLeft;
  74       DWORD screenSize;
  75
  76       screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
  77
  78       topLeft.X = 0;
  79       topLeft.Y = 0;
  80       FillConsoleOutputCharacter(hStdOut, ' ', screenSize, topLeft, &screenSize);
  81       SetConsoleCursorPosition(hStdOut, topLeft);
  82   }
  83 }
  84
  85 /****************************************************************************
  86  * WCMD_change_tty
  87  *
  88  * Change the default i/o device (ie redirect STDin/STDout).
  89  */
  90
  91 void WCMD_change_tty (void) {
  92
  93   WCMD_output (nyi);
  94
  95 }
  96
  97 /****************************************************************************
  98  * WCMD_copy
  99  *
 100  * Copy a file or wildcarded set.
 101  * FIXME: No wildcard support
 102  */
 103
 104 void WCMD_copy (void) {
 105
 106 DWORD count;
 107 WIN32_FIND_DATA fd;
 108 HANDLE hff;
 109 BOOL force, status;
 110 static const char overwrite[] = "Overwrite file (Y/N)?";
 111 char string[8], outpath[MAX_PATH], inpath[MAX_PATH], *infile;
 112
 113   if (param1[0] == 0x00) {
 114     WCMD_output ("Argument missing\n");
 115     return;
 116   }
 117
 118   if ((strchr(param1,'*') != NULL) && (strchr(param1,'%') != NULL)) {
 119     WCMD_output ("Wildcards not yet supported\n");
 120     return;
 121   }
 122
 123   /* If no destination supplied, assume current directory */
 124   if (param2[0] == 0x00) {
 125       strcpy(param2, ".");
 126   }
 127
 128   GetFullPathName (param2, sizeof(outpath), outpath, NULL);
 129   if (outpath[strlen(outpath) - 1] == '\\')
 130       outpath[strlen(outpath) - 1] = '\0';
 131   hff = FindFirstFile (outpath, &fd);
 132   if (hff != INVALID_HANDLE_VALUE) {
 133     if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 134       GetFullPathName (param1, sizeof(inpath), inpath, &infile);
 135       strcat (outpath, "\\");
 136       strcat (outpath, infile);
 137     }
 138     FindClose (hff);
 139   }
 140
 141   force = (strstr (quals, "/Y") != NULL);
 142   if (!force) {
 143     hff = FindFirstFile (outpath, &fd);
 144     if (hff != INVALID_HANDLE_VALUE) {
 145       FindClose (hff);
 146       WCMD_output (overwrite);
 147       ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
 148       if (toupper(string[0]) == 'Y') force = TRUE;
 149     }
 150     else force = TRUE;
 151   }
 152   if (force) {
 153     status = CopyFile (param1, outpath, FALSE);
 154     if (!status) WCMD_print_error ();
 155   }
 156 }
 157
 158 /****************************************************************************
 159  * WCMD_create_dir
 160  *
 161  * Create a directory.
 162  *
 163  * this works recursivly. so mkdir dir1\dir2\dir3 will create dir1 and dir2 if
 164  * they do not already exist.
 165  */
 166
 167 BOOL create_full_path(CHAR* path)
 168 {
 169     int len;
 170     CHAR *new_path;
 171     BOOL ret = TRUE;
 172
 173     new_path = HeapAlloc(GetProcessHeap(),0,strlen(path)+1);
 174     strcpy(new_path,path);
 175
 176     while ((len = strlen(new_path)) && new_path[len - 1] == '\\')
 177         new_path[len - 1] = 0;
 178
 179     while (!CreateDirectory(new_path,NULL))
 180     {
 181         CHAR *slash;
 182         DWORD last_error = GetLastError();
 183         if (last_error == ERROR_ALREADY_EXISTS)
 184             break;
 185
 186         if (last_error != ERROR_PATH_NOT_FOUND)
 187         {
 188             ret = FALSE;
 189             break;
 190         }
 191
 192         if (!(slash = strrchr(new_path,'\\')) && ! (slash = strrchr(new_path,'/')))
 193         {
 194             ret = FALSE;
 195             break;
 196         }
 197
 198         len = slash - new_path;
 199         new_path[len] = 0;
 200         if (!create_full_path(new_path))
 201         {
 202             ret = FALSE;
 203             break;
 204         }
 205         new_path[len] = '\\';
 206     }
 207     HeapFree(GetProcessHeap(),0,new_path);
 208     return ret;
 209 }
 210
 211 void WCMD_create_dir (void) {
 212
 213     if (param1[0] == 0x00) {
 214         WCMD_output ("Argument missing\n");
 215         return;
 216     }
 217     if (!create_full_path(param1)) WCMD_print_error ();
 218 }
 219
 220 /****************************************************************************
 221  * WCMD_delete
 222  *
 223  * Delete a file or wildcarded set.
 224  *
 225  */
 226
 227 void WCMD_delete (int recurse) {
 228
 229 WIN32_FIND_DATA fd;
 230 HANDLE hff;
 231 char fpath[MAX_PATH];
 232 char *p;
 233
 234   if (param1[0] == 0x00) {
 235     WCMD_output ("Argument missing\n");
 236     return;
 237   }
 238   hff = FindFirstFile (param1, &fd);
 239   if (hff == INVALID_HANDLE_VALUE) {
 240     WCMD_output ("%s :File Not Found\n",param1);
 241     return;
 242   }
 243   if ((strchr(param1,'*') == NULL) && (strchr(param1,'?') == NULL)
 244         && (!recurse) && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 245     strcat (param1, "\\*");
 246     FindClose(hff);
 247     WCMD_delete (1);
 248     return;
 249   }
 250   if ((strchr(param1,'*') != NULL) || (strchr(param1,'?') != NULL)) {
 251     strcpy (fpath, param1);
 252     do {
 253       p = strrchr (fpath, '\\');
 254       if (p != NULL) {
 255         *++p = '\0';
 256         strcat (fpath, fd.cFileName);
 257       }
 258       else strcpy (fpath, fd.cFileName);
 259       if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 260         if (!DeleteFile (fpath)) WCMD_print_error ();
 261       }
 262     } while (FindNextFile(hff, &fd) != 0);
 263     FindClose (hff);
 264   }
 265   else {
 266     if (!DeleteFile (param1)) WCMD_print_error ();
 267     FindClose (hff);
 268   }
 269 }
 270
 271 /****************************************************************************
 272  * WCMD_echo
 273  *
 274  * Echo input to the screen (or not). We don't try to emulate the bugs
 275  * in DOS (try typing "ECHO ON AGAIN" for an example).
 276  */
 277
 278 void WCMD_echo (const char *command) {
 279
 280 static const char eon[] = "Echo is ON\n", eoff[] = "Echo is OFF\n";
 281 int count;
 282
 283   if ((command[0] == '.') && (command[1] == 0)) {
 284     WCMD_output (newline);
 285     return;
 286   }
 287   if (command[0]==' ')
 288     command++;
 289   count = strlen(command);
 290   if (count == 0) {
 291     if (echo_mode) WCMD_output (eon);
 292     else WCMD_output (eoff);
 293     return;
 294   }
 295   if (lstrcmpi(command, "ON") == 0) {
 296     echo_mode = 1;
 297     return;
 298   }
 299   if (lstrcmpi(command, "OFF") == 0) {
 300     echo_mode = 0;
 301     return;
 302   }
 303   WCMD_output_asis (command);
 304   WCMD_output (newline);
 305
 306 }
 307
 308 /**************************************************************************
 309  * WCMD_for
 310  *
 311  * Batch file loop processing.
 312  * FIXME: We don't exhaustively check syntax. Any command which works in MessDOS
 313  * will probably work here, but the reverse is not necessarily the case...
 314  */
 315
 316 void WCMD_for (char *p) {
 317
 318 WIN32_FIND_DATA fd;
 319 HANDLE hff;
 320 char *cmd, *item;
 321 char set[MAX_PATH], param[MAX_PATH];
 322 int i;
 323
 324   if (lstrcmpi (WCMD_parameter (p, 1, NULL), "in")
 325         || lstrcmpi (WCMD_parameter (p, 3, NULL), "do")
 326         || (param1[0] != '%')) {
 327     WCMD_output ("Syntax error\n");
 328     return;
 329   }
 330   lstrcpyn (set, WCMD_parameter (p, 2, NULL), sizeof(set));
 331   WCMD_parameter (p, 4, &cmd);
 332   lstrcpy (param, param1);
 333
 334 /*
 335  *      If the parameter within the set has a wildcard then search for matching files
 336  *      otherwise do a literal substitution.
 337  */
 338
 339   i = 0;
 340   while (*(item = WCMD_parameter (set, i, NULL))) {
 341     if (strpbrk (item, "*?")) {
 342       hff = FindFirstFile (item, &fd);
 343       if (hff == INVALID_HANDLE_VALUE) {
 344         return;
 345       }
 346       do {
 347         WCMD_execute (cmd, param, fd.cFileName);
 348       } while (FindNextFile(hff, &fd) != 0);
 349       FindClose (hff);
 350 }
 351     else {
 352       WCMD_execute (cmd, param, item);
 353     }
 354     i++;
 355   }
 356 }
 357
 358 /*****************************************************************************
 359  * WCMD_Execute
 360  *
 361  *      Execute a command after substituting variable text for the supplied parameter
 362  */
 363
 364 void WCMD_execute (char *orig_cmd, char *param, char *subst) {
 365
 366 char *new_cmd, *p, *s, *dup;
 367 int size;
 368
 369   size = lstrlen (orig_cmd);
 370   new_cmd = (char *) LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, size);
 371   dup = s = strdup (orig_cmd);
 372
 373   while ((p = strstr (s, param))) {
 374     *p = '\0';
 375     size += lstrlen (subst);
 376     new_cmd = (char *) LocalReAlloc ((HANDLE)new_cmd, size, 0);
 377     strcat (new_cmd, s);
 378     strcat (new_cmd, subst);
 379     s = p + lstrlen (param);
 380   }
 381   strcat (new_cmd, s);
 382   WCMD_process_command (new_cmd);
 383   free (dup);
 384   LocalFree ((HANDLE)new_cmd);
 385 }
 386
 387
 388 /**************************************************************************
 389  * WCMD_give_help
 390  *
 391  *      Simple on-line help. Help text is stored in the resource file.
 392  */
 393
 394 void WCMD_give_help (char *command) {
 395
 396 int i;
 397 char buffer[2048];
 398
 399   command = WCMD_strtrim_leading_spaces(command);
 400   if (lstrlen(command) == 0) {
 401     LoadString (hinst, 1000, buffer, sizeof(buffer));
 402     WCMD_output_asis (buffer);
 403   }
 404   else {
 405     for (i=0; i<=WCMD_EXIT; i++) {
 406       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
 407           param1, -1, inbuilt[i], -1) == 2) {
 408         LoadString (hinst, i, buffer, sizeof(buffer));
 409         WCMD_output_asis (buffer);
 410         return;
 411       }
 412     }
 413     WCMD_output ("No help available for %s\n", param1);
 414   }
 415   return;
 416 }
 417
 418 /****************************************************************************
 419  * WCMD_go_to
 420  *
 421  * Batch file jump instruction. Not the most efficient algorithm ;-)
 422  * Prints error message if the specified label cannot be found - the file pointer is
 423  * then at EOF, effectively stopping the batch file.
 424  * FIXME: DOS is supposed to allow labels with spaces - we don't.
 425  */
 426
 427 void WCMD_goto (void) {
 428
 429 char string[MAX_PATH];
 430
 431   if (param1[0] == 0x00) {
 432     WCMD_output ("Argument missing\n");
 433     return;
 434   }
 435   if (context != NULL) {
 436
 437     /* Handle special :EOF label */
 438     if (lstrcmpi (":eof", param1) == 0) {
 439       context -> skip_rest = TRUE;
 440       return;
 441     }
 442
 443     SetFilePointer (context -> h, 0, NULL, FILE_BEGIN);
 444     while (WCMD_fgets (string, sizeof(string), context -> h)) {
 445       if ((string[0] == ':') && (lstrcmpi (&string[1], param1) == 0)) return;
 446     }
 447     WCMD_output ("Target to GOTO not found\n");
 448   }
 449   return;
 450 }
 451
 452
 453 /****************************************************************************
 454  * WCMD_if
 455  *
 456  * Batch file conditional.
 457  * FIXME: Much more syntax checking needed!
 458  */
 459
 460 void WCMD_if (char *p) {
 461
 462 int negate = 0, test = 0;
 463 char condition[MAX_PATH], *command, *s;
 464
 465   if (!lstrcmpi (param1, "not")) {
 466     negate = 1;
 467     lstrcpy (condition, param2);
 468 }
 469   else {
 470     lstrcpy (condition, param1);
 471   }
 472   if (!lstrcmpi (condition, "errorlevel")) {
 473     if (errorlevel >= atoi(WCMD_parameter (p, 1+negate, NULL))) test = 1;
 474     WCMD_parameter (p, 2+negate, &command);
 475   }
 476   else if (!lstrcmpi (condition, "exist")) {
 477     if (GetFileAttributesA(WCMD_parameter (p, 1+negate, NULL)) != INVALID_FILE_ATTRIBUTES) {
 478         test = 1;
 479     }
 480     WCMD_parameter (p, 2+negate, &command);
 481   }
 482   else if (!lstrcmpi (condition, "defined")) {
 483     if (GetEnvironmentVariableA(WCMD_parameter (p, 1+negate, NULL), NULL, 0) > 0) {
 484         test = 1;
 485     }
 486     WCMD_parameter (p, 2+negate, &command);
 487   }
 488   else if ((s = strstr (p, "=="))) {
 489     s += 2;
 490     if (!lstrcmpi (condition, WCMD_parameter (s, 0, NULL))) test = 1;
 491     WCMD_parameter (s, 1, &command);
 492   }
 493   else {
 494     WCMD_output ("Syntax error\n");
 495     return;
 496   }
 497   if (test != negate) {
 498     command = strdup (command);
 499     WCMD_process_command (command);
 500     free (command);
 501   }
 502 }
 503
 504 /****************************************************************************
 505  * WCMD_move
 506  *
 507  * Move a file, directory tree or wildcarded set of files.
 508  * FIXME: Needs input and output files to be fully specified.
 509  */
 510
 511 void WCMD_move (void) {
 512
 513 int status;
 514 char outpath[MAX_PATH], inpath[MAX_PATH], *infile;
 515 WIN32_FIND_DATA fd;
 516 HANDLE hff;
 517
 518   if (param1[0] == 0x00) {
 519     WCMD_output ("Argument missing\n");
 520     return;
 521   }
 522
 523   if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
 524     WCMD_output ("Wildcards not yet supported\n");
 525     return;
 526   }
 527
 528   /* If no destination supplied, assume current directory */
 529   if (param2[0] == 0x00) {
 530       strcpy(param2, ".");
 531   }
 532
 533   /* If 2nd parm is directory, then use original filename */
 534   GetFullPathName (param2, sizeof(outpath), outpath, NULL);
 535   if (outpath[strlen(outpath) - 1] == '\\')
 536       outpath[strlen(outpath) - 1] = '\0';
 537   hff = FindFirstFile (outpath, &fd);
 538   if (hff != INVALID_HANDLE_VALUE) {
 539     if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 540       GetFullPathName (param1, sizeof(inpath), inpath, &infile);
 541       strcat (outpath, "\\");
 542       strcat (outpath, infile);
 543     }
 544     FindClose (hff);
 545   }
 546
 547   status = MoveFile (param1, outpath);
 548   if (!status) WCMD_print_error ();
 549 }
 550
 551 /****************************************************************************
 552  * WCMD_pause
 553  *
 554  * Wait for keyboard input.
 555  */
 556
 557 void WCMD_pause (void) {
 558
 559 DWORD count;
 560 char string[32];
 561
 562   WCMD_output (anykey);
 563   ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
 564 }
 565
 566 /****************************************************************************
 567  * WCMD_remove_dir
 568  *
 569  * Delete a directory.
 570  */
 571
 572 void WCMD_remove_dir (void) {
 573
 574   if (param1[0] == 0x00) {
 575     WCMD_output ("Argument missing\n");
 576     return;
 577   }
 578   if (!RemoveDirectory (param1)) WCMD_print_error ();
 579 }
 580
 581 /****************************************************************************
 582  * WCMD_rename
 583  *
 584  * Rename a file.
 585  * FIXME: Needs input and output files to be fully specified.
 586  */
 587
 588 void WCMD_rename (void) {
 589
 590 int status;
 591
 592   if (param1[0] == 0x00 || param2[0] == 0x00) {
 593     WCMD_output ("Argument missing\n");
 594     return;
 595   }
 596   if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
 597     WCMD_output ("Wildcards not yet supported\n");
 598     return;
 599   }
 600   status = MoveFile (param1, param2);
 601   if (!status) WCMD_print_error ();
 602 }
 603
 604 /*****************************************************************************
 605  * WCMD_dupenv
 606  *
 607  * Make a copy of the environment.
 608  */
 609 static WCHAR *WCMD_dupenv( const WCHAR *env )
 610 {
 611   WCHAR *env_copy;
 612   int len;
 613
 614   if( !env )
 615     return NULL;
 616
 617   len = 0;
 618   while ( env[len] )
 619     len += (lstrlenW(&env[len]) + 1);
 620
 621   env_copy = LocalAlloc (LMEM_FIXED, (len+1) * sizeof (WCHAR) );
 622   if (!env_copy)
 623   {
 624     WCMD_output ("out of memory\n");
 625     return env_copy;
 626   }
 627   memcpy (env_copy, env, len*sizeof (WCHAR));
 628   env_copy[len] = 0;
 629
 630   return env_copy;
 631 }
 632
 633 /*****************************************************************************
 634  * WCMD_setlocal
 635  *
 636  *  setlocal pushes the environment onto a stack
 637  *  Save the environment as unicode so we don't screw anything up.
 638  */
 639 void WCMD_setlocal (const char *s) {
 640   WCHAR *env;
 641   struct env_stack *env_copy;
 642
 643   /* DISABLEEXTENSIONS ignored */
 644
 645   env_copy = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
 646   if( !env_copy )
 647   {
 648     WCMD_output ("out of memory\n");
 649     return;
 650   }
 651
 652   env = GetEnvironmentStringsW ();
 653
 654   env_copy->strings = WCMD_dupenv (env);
 655   if (env_copy->strings)
 656   {
 657     env_copy->next = saved_environment;
 658     saved_environment = env_copy;
 659   }
 660   else
 661     LocalFree (env_copy);
 662
 663   FreeEnvironmentStringsW (env);
 664 }
 665
 666 /*****************************************************************************
 667  * WCMD_strchrW
 668  */
 669 static inline WCHAR *WCMD_strchrW(WCHAR *str, WCHAR ch)
 670 {
 671    while(*str)
 672    {
 673      if(*str == ch)
 674        return str;
 675      str++;
 676    }
 677    return NULL;
 678 }
 679
 680 /*****************************************************************************
 681  * WCMD_endlocal
 682  *
 683  *  endlocal pops the environment off a stack
 684  */
 685 void WCMD_endlocal (void) {
 686   WCHAR *env, *old, *p;
 687   struct env_stack *temp;
 688   int len, n;
 689
 690   if (!saved_environment)
 691     return;
 692
 693   /* pop the old environment from the stack */
 694   temp = saved_environment;
 695   saved_environment = temp->next;
 696
 697   /* delete the current environment, totally */
 698   env = GetEnvironmentStringsW ();
 699   old = WCMD_dupenv (GetEnvironmentStringsW ());
 700   len = 0;
 701   while (old[len]) {
 702     n = lstrlenW(&old[len]) + 1;
 703     p = WCMD_strchrW(&old[len], '=');
 704     if (p)
 705     {
 706       *p++ = 0;
 707       SetEnvironmentVariableW (&old[len], NULL);
 708     }
 709     len += n;
 710   }
 711   LocalFree (old);
 712   FreeEnvironmentStringsW (env);
 713
 714   /* restore old environment */
 715   env = temp->strings;
 716   len = 0;
 717   while (env[len]) {
 718     n = lstrlenW(&env[len]) + 1;
 719     p = WCMD_strchrW(&env[len], '=');
 720     if (p)
 721     {
 722       *p++ = 0;
 723       SetEnvironmentVariableW (&env[len], p);
 724     }
 725     len += n;
 726   }
 727   LocalFree (env);
 728   LocalFree (temp);
 729 }
 730
 731 /*****************************************************************************
 732  * WCMD_setshow_attrib
 733  *
 734  * Display and optionally sets DOS attributes on a file or directory
 735  *
 736  * FIXME: Wine currently uses the Unix stat() function to get file attributes.
 737  * As a result only the Readonly flag is correctly reported, the Archive bit
 738  * is always set and the rest are not implemented. We do the Right Thing anyway.
 739  *
 740  * FIXME: No SET functionality.
 741  *
 742  */
 743
 744 void WCMD_setshow_attrib (void) {
 745
 746 DWORD count;
 747 HANDLE hff;
 748 WIN32_FIND_DATA fd;
 749 char flags[9] = {"        "};
 750
 751   if (param1[0] == '-') {
 752     WCMD_output (nyi);
 753     return;
 754   }
 755
 756   if (lstrlen(param1) == 0) {
 757     GetCurrentDirectory (sizeof(param1), param1);
 758     strcat (param1, "\\*");
 759   }
 760
 761   hff = FindFirstFile (param1, &fd);
 762   if (hff == INVALID_HANDLE_VALUE) {
 763     WCMD_output ("%s: File Not Found\n",param1);
 764   }
 765   else {
 766     do {
 767       if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 768         if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
 769           flags[0] = 'H';
 770         }
 771         if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
 772           flags[1] = 'S';
 773         }
 774         if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
 775           flags[2] = 'A';
 776         }
 777         if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
 778           flags[3] = 'R';
 779         }
 780         if (fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
 781           flags[4] = 'T';
 782         }
 783         if (fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) {
 784           flags[5] = 'C';
 785         }
 786         WCMD_output ("%s   %s\n", flags, fd.cFileName);
 787         for (count=0; count < 8; count++) flags[count] = ' ';
 788       }
 789     } while (FindNextFile(hff, &fd) != 0);
 790   }
 791   FindClose (hff);
 792 }
 793
 794 /*****************************************************************************
 795  * WCMD_setshow_default
 796  *
 797  *      Set/Show the current default directory
 798  */
 799
 800 void WCMD_setshow_default (void) {
 801
 802 BOOL status;
 803 char string[1024];
 804
 805   if (strlen(param1) == 0) {
 806     GetCurrentDirectory (sizeof(string), string);
 807     strcat (string, "\n");
 808     WCMD_output (string);
 809   }
 810   else {
 811     status = SetCurrentDirectory (param1);
 812     if (!status) {
 813       WCMD_print_error ();
 814       return;
 815     }
 816    }
 817   return;
 818 }
 819
 820 /****************************************************************************
 821  * WCMD_setshow_date
 822  *
 823  * Set/Show the system date
 824  * FIXME: Can't change date yet
 825  */
 826
 827 void WCMD_setshow_date (void) {
 828
 829 char curdate[64], buffer[64];
 830 DWORD count;
 831
 832   if (lstrlen(param1) == 0) {
 833     if (GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL,
 834                 curdate, sizeof(curdate))) {
 835       WCMD_output ("Current Date is %s\nEnter new date: ", curdate);
 836       ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
 837       if (count > 2) {
 838         WCMD_output (nyi);
 839       }
 840     }
 841     else WCMD_print_error ();
 842   }
 843   else {
 844     WCMD_output (nyi);
 845   }
 846 }
 847
 848 /****************************************************************************
 849  * WCMD_compare
 850  */
 851 static int WCMD_compare( const void *a, const void *b )
 852 {
 853     int r;
 854     const char * const *str_a = a, * const *str_b = b;
 855     r = CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
 856           *str_a, -1, *str_b, -1 );
 857     if( r == CSTR_LESS_THAN ) return -1;
 858     if( r == CSTR_GREATER_THAN ) return 1;
 859     return 0;
 860 }
 861
 862 /****************************************************************************
 863  * WCMD_setshow_sortenv
 864  *
 865  * sort variables into order for display
 866  */
 867 static void WCMD_setshow_sortenv(const char *s)
 868 {
 869   UINT count=0, len=0, i;
 870   const char **str;
 871
 872   /* count the number of strings, and the total length */
 873   while ( s[len] ) {
 874     len += (lstrlen(&s[len]) + 1);
 875     count++;
 876   }
 877
 878   /* add the strings to an array */
 879   str = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, count * sizeof (char*) );
 880   if( !str )
 881     return;
 882   str[0] = s;
 883   for( i=1; i<count; i++ )
 884     str[i] = str[i-1] + lstrlen(str[i-1]) + 1;
 885
 886   /* sort the array */
 887   qsort( str, count, sizeof (char*), WCMD_compare );
 888
 889   /* print it */
 890   for( i=0; i<count; i++ ) {
 891       WCMD_output_asis(str[i]);
 892       WCMD_output_asis("\n");
 893   }
 894
 895   LocalFree( str );
 896 }
 897
 898 /****************************************************************************
 899  * WCMD_setshow_env
 900  *
 901  * Set/Show the environment variables
 902  */
 903
 904 void WCMD_setshow_env (char *s) {
 905
 906 LPVOID env;
 907 char *p;
 908 int status;
 909 char buffer[1048];
 910
 911   if (strlen(param1) == 0) {
 912     env = GetEnvironmentStrings ();
 913     WCMD_setshow_sortenv( env );
 914   }
 915   else {
 916     p = strchr (s, '=');
 917     if (p == NULL) {
 918
 919       /* FIXME: Emulate Win98 for now, ie "SET C" looks ONLY for an
 920          environment variable C, whereas on NT it shows ALL variables
 921          starting with C.
 922        */
 923       status = GetEnvironmentVariable(s, buffer, sizeof(buffer));
 924       if (status) {
 925         WCMD_output_asis( s);
 926         WCMD_output_asis( "=");
 927         WCMD_output_asis( buffer);
 928         WCMD_output_asis( "\n");
 929       } else {
 930         WCMD_output ("Environment variable %s not defined\n", s);
 931       }
 932       return;
 933     }
 934     *p++ = '\0';
 935
 936     if (strlen(p) == 0) p = NULL;
 937     status = SetEnvironmentVariable (s, p);
 938     if ((!status) & (GetLastError() != ERROR_ENVVAR_NOT_FOUND)) WCMD_print_error();
 939   }
 940   /* WCMD_output (newline);   @JED*/
 941 }
 942
 943 /****************************************************************************
 944  * WCMD_setshow_path
 945  *
 946  * Set/Show the path environment variable
 947  */
 948
 949 void WCMD_setshow_path (char *command) {
 950
 951 char string[1024];
 952 DWORD status;
 953
 954   if (strlen(param1) == 0) {
 955     status = GetEnvironmentVariable ("PATH", string, sizeof(string));
 956     if (status != 0) {
 957       WCMD_output_asis ( "PATH=");
 958       WCMD_output_asis ( string);
 959       WCMD_output_asis ( "\n");
 960     }
 961     else {
 962       WCMD_output ("PATH not found\n");
 963     }
 964   }
 965   else {
 966     if (*command == '=') command++; /* Skip leading '=' */
 967     status = SetEnvironmentVariable ("PATH", command);
 968     if (!status) WCMD_print_error();
 969   }
 970 }
 971
 972 /****************************************************************************
 973  * WCMD_setshow_prompt
 974  *
 975  * Set or show the command prompt.
 976  */
 977
 978 void WCMD_setshow_prompt (void) {
 979
 980 char *s;
 981
 982   if (strlen(param1) == 0) {
 983     SetEnvironmentVariable ("PROMPT", NULL);
 984   }
 985   else {
 986     s = param1;
 987     while ((*s == '=') || (*s == ' ')) s++;
 988     if (strlen(s) == 0) {
 989       SetEnvironmentVariable ("PROMPT", NULL);
 990     }
 991     else SetEnvironmentVariable ("PROMPT", s);
 992   }
 993 }
 994
 995 /****************************************************************************
 996  * WCMD_setshow_time
 997  *
 998  * Set/Show the system time
 999  * FIXME: Can't change time yet
1000  */
1001
1002 void WCMD_setshow_time (void) {
1003
1004 char curtime[64], buffer[64];
1005 DWORD count;
1006 SYSTEMTIME st;
1007
1008   if (strlen(param1) == 0) {
1009     GetLocalTime(&st);
1010     if (GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, NULL,
1011                 curtime, sizeof(curtime))) {
1012       WCMD_output ("Current Time is %s\nEnter new time: ", curtime);
1013       ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
1014       if (count > 2) {
1015         WCMD_output (nyi);
1016       }
1017     }
1018     else WCMD_print_error ();
1019   }
1020   else {
1021     WCMD_output (nyi);
1022   }
1023 }
1024
1025 /****************************************************************************
1026  * WCMD_shift
1027  *
1028  * Shift batch parameters.
1029  */
1030
1031 void WCMD_shift (void) {
1032
1033   if (context != NULL) context -> shift_count++;
1034
1035 }
1036
1037 /****************************************************************************
1038  * WCMD_title
1039  *
1040  * Set the console title
1041  */
1042 void WCMD_title (char *command) {
1043   SetConsoleTitle(command);
1044 }
1045
1046 /****************************************************************************
1047  * WCMD_type
1048  *
1049  * Copy a file to standard output.
1050  */
1051
1052 void WCMD_type (void) {
1053
1054 HANDLE h;
1055 char buffer[512];
1056 DWORD count;
1057
1058   if (param1[0] == 0x00) {
1059     WCMD_output ("Argument missing\n");
1060     return;
1061   }
1062   h = CreateFile (param1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
1063                 FILE_ATTRIBUTE_NORMAL, NULL);
1064   if (h == INVALID_HANDLE_VALUE) {
1065     WCMD_print_error ();
1066     return;
1067   }
1068   while (ReadFile (h, buffer, sizeof(buffer), &count, NULL)) {
1069     if (count == 0) break;      /* ReadFile reports success on EOF! */
1070     buffer[count] = 0;
1071     WCMD_output_asis (buffer);
1072   }
1073   CloseHandle (h);
1074 }
1075
1076 /****************************************************************************
1077  * WCMD_verify
1078  *
1079  * Display verify flag.
1080  * FIXME: We don't actually do anything with the verify flag other than toggle
1081  * it...
1082  */
1083
1084 void WCMD_verify (char *command) {
1085
1086 static const char von[] = "Verify is ON\n", voff[] = "Verify is OFF\n";
1087 int count;
1088
1089   count = strlen(command);
1090   if (count == 0) {
1091     if (verify_mode) WCMD_output (von);
1092     else WCMD_output (voff);
1093     return;
1094   }
1095   if (lstrcmpi(command, "ON") == 0) {
1096     verify_mode = 1;
1097     return;
1098   }
1099   else if (lstrcmpi(command, "OFF") == 0) {
1100     verify_mode = 0;
1101     return;
1102   }
1103   else WCMD_output ("Verify must be ON or OFF\n");
1104 }
1105
1106 /****************************************************************************
1107  * WCMD_version
1108  *
1109  * Display version info.
1110  */
1111
1112 void WCMD_version (void) {
1113
1114   WCMD_output (version_string);
1115
1116 }
1117
1118 /****************************************************************************
1119  * WCMD_volume
1120  *
1121  * Display volume info and/or set volume label. Returns 0 if error.
1122  */
1123
1124 int WCMD_volume (int mode, char *path) {
1125
1126 DWORD count, serial;
1127 char string[MAX_PATH], label[MAX_PATH], curdir[MAX_PATH];
1128 BOOL status;
1129
1130   if (lstrlen(path) == 0) {
1131     status = GetCurrentDirectory (sizeof(curdir), curdir);
1132     if (!status) {
1133       WCMD_print_error ();
1134       return 0;
1135     }
1136     status = GetVolumeInformation (NULL, label, sizeof(label), &serial, NULL,
1137         NULL, NULL, 0);
1138   }
1139   else {
1140     if ((path[1] != ':') || (lstrlen(path) != 2)) {
1141       WCMD_output_asis("Syntax Error\n\n");
1142       return 0;
1143     }
1144     wsprintf (curdir, "%s\\", path);
1145     status = GetVolumeInformation (curdir, label, sizeof(label), &serial, NULL,
1146         NULL, NULL, 0);
1147   }
1148   if (!status) {
1149     WCMD_print_error ();
1150     return 0;
1151   }
1152   WCMD_output ("Volume in drive %c is %s\nVolume Serial Number is %04x-%04x\n\n",
1153         curdir[0], label, HIWORD(serial), LOWORD(serial));
1154   if (mode) {
1155     WCMD_output ("Volume label (11 characters, ENTER for none)?");
1156     ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
1157     if (count > 1) {
1158       string[count-1] = '\0';           /* ReadFile output is not null-terminated! */
1159       if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
1160     }
1161     if (lstrlen(path) != 0) {
1162       if (!SetVolumeLabel (curdir, string)) WCMD_print_error ();
1163     }
1164     else {
1165       if (!SetVolumeLabel (NULL, string)) WCMD_print_error ();
1166     }
1167   }
1168   return 1;
1169 }
1170
1171 /**************************************************************************
1172  * WCMD_exit
1173  *
1174  * Exit either the process, or just this batch program
1175  *
1176  */
1177
1178 void WCMD_exit (void) {
1179
1180     int rc = atoi(param1); /* Note: atoi of empty parameter is 0 */
1181
1182     if (context && lstrcmpi(quals, "/B") == 0) {
1183         errorlevel = rc;
1184         context -> skip_rest = TRUE;
1185     } else {
1186         ExitProcess(rc);
1187     }
1188 }