Don't use formatted output in WCMD_setshow_sortenv.
[wine] / programs / wcmd / wcmdmain.c
1 /*
2  * WCMD - Wine-compatible command line interface.
3  *
4  * Copyright (C) 1999 - 2001 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 /*
22  * FIXME:
23  * - Cannot handle parameters in quotes
24  * - Lots of functionality missing from builtins
25  */
26
27 #include "wcmd.h"
28
29 const char * const inbuilt[] = {"ATTRIB", "CALL", "CD", "CHDIR", "CLS", "COPY", "CTTY",
30                 "DATE", "DEL", "DIR", "ECHO", "ERASE", "FOR", "GOTO",
31                 "HELP", "IF", "LABEL", "MD", "MKDIR", "MOVE", "PATH", "PAUSE",
32                 "PROMPT", "REM", "REN", "RENAME", "RD", "RMDIR", "SET", "SHIFT",
33                 "TIME", "TITLE", "TYPE", "VERIFY", "VER", "VOL", 
34                 "ENDLOCAL", "SETLOCAL", "EXIT" };
35
36 HINSTANCE hinst;
37 DWORD errorlevel;
38 int echo_mode = 1, verify_mode = 0;
39 const char nyi[] = "Not Yet Implemented\n\n";
40 const char newline[] = "\n";
41 const char version_string[] = "WCMD Version 0.17\n\n";
42 const char anykey[] = "Press Return key to continue: ";
43 char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
44 BATCH_CONTEXT *context = NULL;
45 static HANDLE old_stdin = INVALID_HANDLE_VALUE, old_stdout = INVALID_HANDLE_VALUE;
46
47 /*****************************************************************************
48  * Main entry point. This is a console application so we have a main() not a
49  * winmain().
50  */
51
52 int main (int argc, char *argv[])
53 {
54   char string[1024];
55   char* cmd=NULL;
56   DWORD count;
57   HANDLE h;
58   int opt_c, opt_k, opt_q;
59
60   argv++;
61   opt_c=opt_k=opt_q=0;
62   while (*argv!=NULL)
63   {
64       if (lstrcmpi(*argv,"/c")==0) {
65           opt_c=1;
66           argv++;
67           break;
68       } else if (lstrcmpi(*argv,"/q")==0) {
69           opt_q=1;
70       } else if (lstrcmpi(*argv,"/k")==0) {
71           opt_k=1;
72           argv++;
73           break;
74       } else if (lstrcmpi(*argv,"/t")==0 || lstrcmpi(*argv,"/x")==0 ||
75                  lstrcmpi(*argv,"/y")==0) {
76           /* Ignored for compatibility with Windows */
77       } else {
78           break;
79       }
80       argv++;
81   }
82
83   if (opt_q) {
84     WCMD_echo("OFF");
85   }
86
87   if (opt_c || opt_k) {
88       int len;
89       char** arg;
90       char* p;
91
92       /* Build the command to execute */
93       len = 0;
94       for (arg = argv; *arg; arg++)
95       {
96           int has_space,bcount;
97           char* a;
98
99           has_space=0;
100           bcount=0;
101           a=*arg;
102           if( !*a ) has_space=1;
103           while (*a!='\0') {
104               if (*a=='\\') {
105                   bcount++;
106               } else {
107                   if (*a==' ' || *a=='\t') {
108                       has_space=1;
109                   } else if (*a=='"') {
110                       /* doubling of '\' preceding a '"',
111                        * plus escaping of said '"'
112                        */
113                       len+=2*bcount+1;
114                   }
115                   bcount=0;
116               }
117               a++;
118           }
119           len+=(a-*arg)+1 /* for the separating space */;
120           if (has_space)
121               len+=2; /* for the quotes */
122       }
123
124       cmd = HeapAlloc(GetProcessHeap(), 0, len);
125       if (!cmd)
126           exit(1);
127
128       p = cmd;
129       for (arg = argv; *arg; arg++)
130       {
131           int has_space,has_quote;
132           char* a;
133
134           /* Check for quotes and spaces in this argument */
135           has_space=has_quote=0;
136           a=*arg;
137           if( !*a ) has_space=1;
138           while (*a!='\0') {
139               if (*a==' ' || *a=='\t') {
140                   has_space=1;
141                   if (has_quote)
142                       break;
143               } else if (*a=='"') {
144                   has_quote=1;
145                   if (has_space)
146                       break;
147               }
148               a++;
149           }
150
151           /* Now transfer it to the command line */
152           if (has_space)
153               *p++='"';
154           if (has_quote) {
155               int bcount;
156               char* a;
157
158               bcount=0;
159               a=*arg;
160               while (*a!='\0') {
161                   if (*a=='\\') {
162                       *p++=*a;
163                       bcount++;
164                   } else {
165                       if (*a=='"') {
166                           int i;
167
168                           /* Double all the '\\' preceding this '"', plus one */
169                           for (i=0;i<=bcount;i++)
170                               *p++='\\';
171                           *p++='"';
172                       } else {
173                           *p++=*a;
174                       }
175                       bcount=0;
176                   }
177                   a++;
178               }
179           } else {
180               strcpy(p,*arg);
181               p+=strlen(*arg);
182           }
183           if (has_space)
184               *p++='"';
185           *p++=' ';
186       }
187       if (p > cmd)
188           p--;  /* remove last space */
189       *p = '\0';
190   }
191
192   if (opt_c) {
193       /* If we do a "wcmd /c command", we don't want to allocate a new
194        * console since the command returns immediately. Rather, we use
195        * the currently allocated input and output handles. This allows
196        * us to pipe to and read from the command interpreter.
197        */
198       if (strchr(cmd,'|') != NULL)
199           WCMD_pipe(cmd);
200       else
201           WCMD_process_command(cmd);
202       HeapFree(GetProcessHeap(), 0, cmd);
203       return 0;
204   }
205
206   SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_LINE_INPUT |
207                  ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
208   SetConsoleTitle("Wine Command Prompt");
209
210   if (opt_k) {
211       WCMD_process_command(cmd);
212       HeapFree(GetProcessHeap(), 0, cmd);
213   }
214
215 /*
216  *      If there is an AUTOEXEC.BAT file, try to execute it.
217  */
218
219   GetFullPathName ("\\autoexec.bat", sizeof(string), string, NULL);
220   h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
221   if (h != INVALID_HANDLE_VALUE) {
222     CloseHandle (h);
223 #if 0
224     WCMD_batch_command (string);
225 #endif
226   }
227
228 /*
229  *      Loop forever getting commands and executing them.
230  */
231
232   WCMD_version ();
233   while (TRUE) {
234     WCMD_show_prompt ();
235     ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
236     if (count > 1) {
237       string[count-1] = '\0'; /* ReadFile output is not null-terminated! */
238       if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
239       if (lstrlen (string) != 0) {
240         if (strchr(string,'|') != NULL) {
241           WCMD_pipe (string);
242         }
243         else {
244           WCMD_process_command (string);
245         }
246       }
247     }
248   }
249 }
250
251
252 /*****************************************************************************
253  * Process one command. If the command is EXIT this routine does not return.
254  * We will recurse through here executing batch files.
255  */
256
257
258 void WCMD_process_command (char *command)
259 {
260     char *cmd, *p;
261     int status, i, len;
262     DWORD count, creationDisposition;
263     HANDLE h;
264     char *whichcmd;
265     SECURITY_ATTRIBUTES sa;
266
267 /*
268  *      Expand up environment variables.
269  */
270     len = ExpandEnvironmentStrings (command, NULL, 0);
271     cmd = HeapAlloc( GetProcessHeap(), 0, len );
272     status = ExpandEnvironmentStrings (command, cmd, len);
273     if (!status) {
274       WCMD_print_error ();
275       HeapFree( GetProcessHeap(), 0, cmd );
276       return;
277     }
278
279 /*
280  *      Changing default drive has to be handled as a special case.
281  */
282
283     if ((cmd[1] == ':') && IsCharAlpha (cmd[0]) && (strlen(cmd) == 2)) {
284       status = SetCurrentDirectory (cmd);
285       if (!status) WCMD_print_error ();
286       HeapFree( GetProcessHeap(), 0, cmd );
287       return;
288     }
289
290     /* Don't issue newline WCMD_output (newline);           @JED*/
291
292     sa.nLength = sizeof(sa);
293     sa.lpSecurityDescriptor = NULL;
294     sa.bInheritHandle = TRUE;
295 /*
296  *      Redirect stdin and/or stdout if required.
297  */
298
299     if ((p = strchr(cmd,'<')) != NULL) {
300       h = CreateFile (WCMD_parameter (++p, 0, NULL), GENERIC_READ, FILE_SHARE_READ, &sa, OPEN_EXISTING,
301                 FILE_ATTRIBUTE_NORMAL, NULL);
302       if (h == INVALID_HANDLE_VALUE) {
303         WCMD_print_error ();
304         HeapFree( GetProcessHeap(), 0, cmd );
305         return;
306       }
307       old_stdin = GetStdHandle (STD_INPUT_HANDLE);
308       SetStdHandle (STD_INPUT_HANDLE, h);
309     }
310     if ((p = strchr(cmd,'>')) != NULL) {
311       *p++ = '\0';
312       if ('>' == *p) {
313         creationDisposition = OPEN_ALWAYS;
314         p++;
315       }
316       else {
317         creationDisposition = CREATE_ALWAYS;
318       }
319       h = CreateFile (WCMD_parameter (p, 0, NULL), GENERIC_WRITE, 0, &sa, creationDisposition,
320                 FILE_ATTRIBUTE_NORMAL, NULL);
321       if (h == INVALID_HANDLE_VALUE) {
322         WCMD_print_error ();
323         HeapFree( GetProcessHeap(), 0, cmd );
324         return;
325       }
326       if (SetFilePointer (h, 0, NULL, FILE_END) ==
327           INVALID_SET_FILE_POINTER) {
328         WCMD_print_error ();
329       }
330       old_stdout = GetStdHandle (STD_OUTPUT_HANDLE);
331       SetStdHandle (STD_OUTPUT_HANDLE, h);
332     }
333     if ((p = strchr(cmd,'<')) != NULL) *p = '\0';
334
335 /*
336  * Strip leading whitespaces, and a '@' if supplied
337  */
338     whichcmd = WCMD_strtrim_leading_spaces(cmd);
339     if (whichcmd[0] == '@') whichcmd++;
340
341 /*
342  *      Check if the command entered is internal. If it is, pass the rest of the
343  *      line down to the command. If not try to run a program.
344  */
345
346     count = 0;
347     while (IsCharAlphaNumeric(whichcmd[count])) {
348       count++;
349     }
350     for (i=0; i<=WCMD_EXIT; i++) {
351       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
352           whichcmd, count, inbuilt[i], -1) == 2) break;
353     }
354     p = WCMD_strtrim_leading_spaces (&whichcmd[count]);
355     WCMD_parse (p, quals, param1, param2);
356     switch (i) {
357
358       case WCMD_ATTRIB:
359         WCMD_setshow_attrib ();
360         break;
361       case WCMD_CALL:
362         WCMD_batch (param1, p, 1);
363         break;
364       case WCMD_CD:
365       case WCMD_CHDIR:
366         WCMD_setshow_default ();
367         break;
368       case WCMD_CLS:
369         WCMD_clear_screen ();
370         break;
371       case WCMD_COPY:
372         WCMD_copy ();
373         break;
374       case WCMD_CTTY:
375         WCMD_change_tty ();
376         break;
377       case WCMD_DATE:
378         WCMD_setshow_date ();
379         break;
380       case WCMD_DEL:
381       case WCMD_ERASE:
382         WCMD_delete (0);
383         break;
384       case WCMD_DIR:
385         WCMD_directory ();
386         break;
387       case WCMD_ECHO:
388         WCMD_echo(&whichcmd[count]);
389         break;
390       case WCMD_FOR:
391         WCMD_for (p);
392         break;
393       case WCMD_GOTO:
394         WCMD_goto ();
395         break;
396       case WCMD_HELP:
397         WCMD_give_help (p);
398         break;
399       case WCMD_IF:
400         WCMD_if (p);
401         break;
402       case WCMD_LABEL:
403         WCMD_volume (1, p);
404         break;
405       case WCMD_MD:
406       case WCMD_MKDIR:
407         WCMD_create_dir ();
408         break;
409       case WCMD_MOVE:
410         WCMD_move ();
411         break;
412       case WCMD_PATH:
413         WCMD_setshow_path (p);
414         break;
415       case WCMD_PAUSE:
416         WCMD_pause ();
417         break;
418       case WCMD_PROMPT:
419         WCMD_setshow_prompt ();
420         break;
421       case WCMD_REM:
422         break;
423       case WCMD_REN:
424       case WCMD_RENAME:
425         WCMD_rename ();
426         break;
427       case WCMD_RD:
428       case WCMD_RMDIR:
429         WCMD_remove_dir ();
430         break;
431       case WCMD_SETLOCAL:
432         WCMD_setlocal(p);
433         break;
434       case WCMD_ENDLOCAL:
435         WCMD_endlocal();
436         break;
437       case WCMD_SET:
438         WCMD_setshow_env (p);
439         break;
440       case WCMD_SHIFT:
441         WCMD_shift ();
442         break;
443       case WCMD_TIME:
444         WCMD_setshow_time ();
445         break;
446       case WCMD_TITLE:
447         if (strlen(&whichcmd[count]) > 0)
448           WCMD_title(&whichcmd[count+1]);
449         break;
450       case WCMD_TYPE:
451         WCMD_type ();
452         break;
453       case WCMD_VER:
454         WCMD_version ();
455         break;
456       case WCMD_VERIFY:
457         WCMD_verify (p);
458         break;
459       case WCMD_VOL:
460         WCMD_volume (0, p);
461         break;
462       case WCMD_EXIT:
463         ExitProcess (0);
464       default:
465         WCMD_run_program (whichcmd);
466     }
467     HeapFree( GetProcessHeap(), 0, cmd );
468     if (old_stdin != INVALID_HANDLE_VALUE) {
469       CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
470       SetStdHandle (STD_INPUT_HANDLE, old_stdin);
471       old_stdin = INVALID_HANDLE_VALUE;
472     }
473     if (old_stdout != INVALID_HANDLE_VALUE) {
474       CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
475       SetStdHandle (STD_OUTPUT_HANDLE, old_stdout);
476       old_stdout = INVALID_HANDLE_VALUE;
477     }
478 }
479
480 static void init_msvcrt_io_block(STARTUPINFO* st)
481 {
482     STARTUPINFO st_p;
483     /* fetch the parent MSVCRT info block if any, so that the child can use the
484      * same handles as its grand-father
485      */
486     st_p.cb = sizeof(STARTUPINFO);
487     GetStartupInfo(&st_p);
488     st->cbReserved2 = st_p.cbReserved2;
489     st->lpReserved2 = st_p.lpReserved2;
490     if (st_p.cbReserved2 && st_p.lpReserved2 &&
491         (old_stdin != INVALID_HANDLE_VALUE || old_stdout != INVALID_HANDLE_VALUE))
492     {
493         /* Override the entries for fd 0,1,2 if we happened
494          * to change those std handles (this depends on the way wcmd sets
495          * it's new input & output handles)
496          */
497         size_t sz = max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * 3, st_p.cbReserved2);
498         BYTE* ptr = HeapAlloc(GetProcessHeap(), 0, sz);
499         if (ptr)
500         {
501             unsigned num = *(unsigned*)st_p.lpReserved2;
502             char* flags = (char*)(ptr + sizeof(unsigned));
503             HANDLE* handles = (HANDLE*)(flags + num * sizeof(char));
504
505             memcpy(ptr, st_p.lpReserved2, st_p.cbReserved2);
506             st->cbReserved2 = sz;
507             st->lpReserved2 = ptr;
508
509 #define WX_OPEN 0x01    /* see dlls/msvcrt/file.c */
510             if (num <= 0 || (flags[0] & WX_OPEN))
511             {
512                 handles[0] = GetStdHandle(STD_INPUT_HANDLE);
513                 flags[0] |= WX_OPEN;
514             }
515             if (num <= 1 || (flags[1] & WX_OPEN))
516             {
517                 handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
518                 flags[1] |= WX_OPEN;
519             }
520             if (num <= 2 || (flags[2] & WX_OPEN))
521             {
522                 handles[2] = GetStdHandle(STD_ERROR_HANDLE);
523                 flags[2] |= WX_OPEN;
524             }
525 #undef WX_OPEN
526         }
527     }
528 }
529
530 /******************************************************************************
531  * WCMD_run_program
532  *
533  *      Execute a command line as an external program. If no extension given then
534  *      precedence is given to .BAT files. Must allow recursion.
535  *
536  *      FIXME: Case sensitivity in suffixes!
537  */
538
539 void WCMD_run_program (char *command) {
540
541 STARTUPINFO st;
542 PROCESS_INFORMATION pe;
543 SHFILEINFO psfi;
544 DWORD console;
545 BOOL status;
546 HANDLE h;
547 HINSTANCE hinst;
548 char filetorun[MAX_PATH];
549
550   WCMD_parse (command, quals, param1, param2);  /* Quick way to get the filename */
551   if (!(*param1) && !(*param2))
552     return;
553   if (strpbrk (param1, "/\\:") == NULL) {  /* No explicit path given */
554     char *ext = strrchr( param1, '.' );
555     if (!ext || !strcasecmp( ext, ".bat"))
556     {
557       if (SearchPath (NULL, param1, ".bat", sizeof(filetorun), filetorun, NULL)) {
558         WCMD_batch (filetorun, command, 0);
559         return;
560       }
561     }
562     if (!ext || !strcasecmp( ext, ".cmd"))
563     {
564       if (SearchPath (NULL, param1, ".cmd", sizeof(filetorun), filetorun, NULL)) {
565         WCMD_batch (filetorun, command, 0);
566         return;
567       }
568     }
569   }
570   else {                                        /* Explicit path given */
571     char *ext = strrchr( param1, '.' );
572     if (ext && (!strcasecmp( ext, ".bat" ) || !strcasecmp( ext, ".cmd" )))
573     {
574       WCMD_batch (param1, command, 0);
575       return;
576     }
577
578     if (ext && strpbrk( ext, "/\\:" )) ext = NULL;
579     if (!ext)
580     {
581       strcpy (filetorun, param1);
582       strcat (filetorun, ".bat");
583       h = CreateFile (filetorun, GENERIC_READ, FILE_SHARE_READ,
584                       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
585       if (h != INVALID_HANDLE_VALUE) {
586         CloseHandle (h);
587         WCMD_batch (param1, command, 0);
588         return;
589       }
590     }
591   }
592
593         /* No batch file found, assume executable */
594
595   hinst = FindExecutable (param1, NULL, filetorun);
596   if ((int)hinst < 32) {
597     WCMD_print_error ();
598     return;
599   }
600   console = SHGetFileInfo (filetorun, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
601   ZeroMemory (&st, sizeof(STARTUPINFO));
602   st.cb = sizeof(STARTUPINFO);
603   init_msvcrt_io_block(&st);
604
605   status = CreateProcess (NULL, command, NULL, NULL, TRUE, 
606                           0, NULL, NULL, &st, &pe);
607   if (!status) {
608     WCMD_print_error ();
609     return;
610   }
611   if (!console) errorlevel = 0;
612   else
613   {
614       if (!HIWORD(console)) WaitForSingleObject (pe.hProcess, INFINITE);
615       GetExitCodeProcess (pe.hProcess, &errorlevel);
616       if (errorlevel == STILL_ACTIVE) errorlevel = 0;
617   }
618   CloseHandle(pe.hProcess);
619   CloseHandle(pe.hThread);
620 }
621
622 /******************************************************************************
623  * WCMD_show_prompt
624  *
625  *      Display the prompt on STDout
626  *
627  */
628
629 void WCMD_show_prompt (void) {
630
631 int status;
632 char out_string[MAX_PATH], curdir[MAX_PATH], prompt_string[MAX_PATH];
633 char *p, *q;
634
635   status = GetEnvironmentVariable ("PROMPT", prompt_string, sizeof(prompt_string));
636   if ((status == 0) || (status > sizeof(prompt_string))) {
637     lstrcpy (prompt_string, "$P$G");
638   }
639   p = prompt_string;
640   q = out_string;
641   *q = '\0';
642   while (*p != '\0') {
643     if (*p != '$') {
644       *q++ = *p++;
645       *q = '\0';
646     }
647     else {
648       p++;
649       switch (toupper(*p)) {
650         case '$':
651           *q++ = '$';
652           break;
653         case 'B':
654           *q++ = '|';
655           break;
656         case 'D':
657           GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, q, MAX_PATH);
658           while (*q) q++;
659           break;
660         case 'E':
661           *q++ = '\E';
662           break;
663         case 'G':
664           *q++ = '>';
665           break;
666         case 'L':
667           *q++ = '<';
668           break;
669         case 'N':
670           status = GetCurrentDirectory (sizeof(curdir), curdir);
671           if (status) {
672             *q++ = curdir[0];
673           }
674           break;
675         case 'P':
676           status = GetCurrentDirectory (sizeof(curdir), curdir);
677           if (status) {
678             lstrcat (q, curdir);
679             while (*q) q++;
680           }
681           break;
682         case 'Q':
683           *q++ = '=';
684           break;
685         case 'T':
686           GetTimeFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL, q, MAX_PATH);
687           while (*q) q++;
688           break;
689        case 'V':
690            lstrcat (q, version_string);
691            while (*q) q++;
692          break;
693         case '_':
694           *q++ = '\n';
695           break;
696       }
697       p++;
698       *q = '\0';
699     }
700   }
701   WCMD_output (out_string);
702 }
703
704 /****************************************************************************
705  * WCMD_print_error
706  *
707  * Print the message for GetLastError
708  */
709
710 void WCMD_print_error (void) {
711 LPVOID lpMsgBuf;
712 DWORD error_code;
713 int status;
714
715   error_code = GetLastError ();
716   status = FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
717                         NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
718   if (!status) {
719     WCMD_output ("FIXME: Cannot display message for error %d, status %d\n",
720                         error_code, GetLastError());
721     return;
722   }
723   WCMD_output (lpMsgBuf);
724   LocalFree ((HLOCAL)lpMsgBuf);
725   WCMD_output (newline);
726   return;
727 }
728
729 /*******************************************************************
730  * WCMD_parse - parse a command into parameters and qualifiers.
731  *
732  *      On exit, all qualifiers are concatenated into q, the first string
733  *      not beginning with "/" is in p1 and the
734  *      second in p2. Any subsequent non-qualifier strings are lost.
735  *      Parameters in quotes are handled.
736  */
737
738 void WCMD_parse (char *s, char *q, char *p1, char *p2) {
739
740 int p = 0;
741
742   *q = *p1 = *p2 = '\0';
743   while (TRUE) {
744     switch (*s) {
745       case '/':
746         *q++ = *s++;
747         while ((*s != '\0') && (*s != ' ') && *s != '/') {
748           *q++ = toupper (*s++);
749         }
750         *q = '\0';
751         break;
752       case ' ':
753       case '\t':
754         s++;
755         break;
756       case '"':
757         s++;
758         while ((*s != '\0') && (*s != '"')) {
759           if (p == 0) *p1++ = *s++;
760           else if (p == 1) *p2++ = *s++;
761           else s++;
762         }
763         if (p == 0) *p1 = '\0';
764         if (p == 1) *p2 = '\0';
765         p++;
766         if (*s == '"') s++;
767         break;
768       case '\0':
769         return;
770       default:
771         while ((*s != '\0') && (*s != ' ') && (*s != '\t')) {
772           if (p == 0) *p1++ = *s++;
773           else if (p == 1) *p2++ = *s++;
774           else s++;
775         }
776         if (p == 0) *p1 = '\0';
777         if (p == 1) *p2 = '\0';
778         p++;
779     }
780   }
781 }
782
783 /*******************************************************************
784  * WCMD_output - send output to current standard output device.
785  *
786  */
787
788 void WCMD_output (const char *format, ...) {
789
790 va_list ap;
791 char string[1024];
792 int ret;
793
794   va_start(ap,format);
795   ret = vsnprintf (string, sizeof( string), format, ap);
796   va_end(ap);
797   if( ret >= sizeof( string)) {
798        WCMD_output_asis("ERR: output truncated in WCMD_output\n" );
799        string[sizeof( string) -1] = '\0';
800   }
801   WCMD_output_asis(string);
802 }
803
804
805 static int line_count;
806 static int max_height;
807 static BOOL paged_mode;
808
809 void WCMD_enter_paged_mode(void)
810 {
811 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
812
813   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo))
814     max_height = consoleInfo.dwSize.Y;
815   else
816     max_height = 25;
817   paged_mode = TRUE;
818   line_count = 5; /* keep 5 lines from previous output */
819 }
820
821 void WCMD_leave_paged_mode(void)
822 {
823   paged_mode = FALSE;
824 }
825
826 /*******************************************************************
827  * WCMD_output_asis - send output to current standard output device.
828  *        without formatting eg. when message contains '%'
829  */
830
831 void WCMD_output_asis (const char *message) {
832   DWORD count;
833   char* ptr;
834   char string[1024];
835
836   if (paged_mode) {
837     do {
838       if ((ptr = strchr(message, '\n')) != NULL) ptr++;
839       WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message, 
840                  (ptr) ? ptr - message : lstrlen(message), &count, NULL);
841       if (ptr) {
842         if (++line_count >= max_height - 1) {
843           line_count = 0;
844           WCMD_output_asis (anykey);
845           ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
846         }
847       }
848     } while ((message = ptr) != NULL);
849   } else {
850       WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message, lstrlen(message), &count, NULL);
851   }
852 }
853
854
855 /***************************************************************************
856  * WCMD_strtrim_leading_spaces
857  *
858  *      Remove leading spaces from a string. Return a pointer to the first
859  *      non-space character. Does not modify the input string
860  */
861
862 char *WCMD_strtrim_leading_spaces (char *string) {
863
864 char *ptr;
865
866   ptr = string;
867   while (*ptr == ' ') ptr++;
868   return ptr;
869 }
870
871 /*************************************************************************
872  * WCMD_strtrim_trailing_spaces
873  *
874  *      Remove trailing spaces from a string. This routine modifies the input
875  *      string by placing a null after the last non-space character
876  */
877
878 void WCMD_strtrim_trailing_spaces (char *string) {
879
880 char *ptr;
881
882   ptr = string + lstrlen (string) - 1;
883   while ((*ptr == ' ') && (ptr >= string)) {
884     *ptr = '\0';
885     ptr--;
886   }
887 }
888
889 /*************************************************************************
890  * WCMD_pipe
891  *
892  *      Handle pipes within a command - the DOS way using temporary files.
893  */
894
895 void WCMD_pipe (char *command) {
896
897 char *p;
898 char temp_path[MAX_PATH], temp_file[MAX_PATH], temp_file2[MAX_PATH], temp_cmd[1024];
899
900   GetTempPath (sizeof(temp_path), temp_path);
901   GetTempFileName (temp_path, "WCMD", 0, temp_file);
902   p = strchr(command, '|');
903   *p++ = '\0';
904   wsprintf (temp_cmd, "%s > %s", command, temp_file);
905   WCMD_process_command (temp_cmd);
906   command = p;
907   while ((p = strchr(command, '|'))) {
908     *p++ = '\0';
909     GetTempFileName (temp_path, "WCMD", 0, temp_file2);
910     wsprintf (temp_cmd, "%s < %s > %s", command, temp_file, temp_file2);
911     WCMD_process_command (temp_cmd);
912     DeleteFile (temp_file);
913     lstrcpy (temp_file, temp_file2);
914     command = p;
915   }
916   wsprintf (temp_cmd, "%s < %s", command, temp_file);
917   WCMD_process_command (temp_cmd);
918   DeleteFile (temp_file);
919 }