dlls/msvcrt/console.c

   1 /*
   2  * msvcrt.dll console functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   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  * Note: init and free don't need MT locking since they are called at DLL
  21  * (de)attachment time, which is syncronised for us
  22  */
  23
  24 #include "msvcrt.h"
  25 #include "wincon.h"
  26 #include "mtdll.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  30
  31
  32
  33 /* MT */
  34 #define LOCK_CONSOLE   _mlock(_CONIO_LOCK)
  35 #define UNLOCK_CONSOLE _munlock(_CONIO_LOCK)
  36
  37 static HANDLE MSVCRT_console_in = INVALID_HANDLE_VALUE;
  38 static HANDLE MSVCRT_console_out= INVALID_HANDLE_VALUE;
  39 static int __MSVCRT_console_buffer = MSVCRT_EOF;
  40
  41 /* INTERNAL: Initialise console handles */
  42 void msvcrt_init_console(void)
  43 {
  44   TRACE(":Opening console handles\n");
  45
  46   DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
  47     GetCurrentProcess(), &MSVCRT_console_in, 0, FALSE, DUPLICATE_SAME_ACCESS);
  48
  49   /* FIXME: Should be initialised with:
  50    * CreateFileA("CONIN$", GENERIC_READ, FILE_SHARE_READ,
  51    * NULL, OPEN_EXISTING, 0, NULL);
  52    */
  53
  54   MSVCRT_console_out= CreateFileA("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE,
  55                                     NULL, OPEN_EXISTING, 0, NULL);
  56
  57   if ((MSVCRT_console_in == INVALID_HANDLE_VALUE) ||
  58       (MSVCRT_console_out== INVALID_HANDLE_VALUE))
  59     WARN(":Console handle Initialisation FAILED!\n");
  60 }
  61
  62 /* INTERNAL: Free console handles */
  63 void msvcrt_free_console(void)
  64 {
  65   TRACE(":Closing console handles\n");
  66   CloseHandle(MSVCRT_console_in);
  67   CloseHandle(MSVCRT_console_out);
  68 }
  69
  70 /*********************************************************************
  71  *              _cputs (MSVCRT.@)
  72  */
  73 int _cputs(const char* str)
  74 {
  75   DWORD count;
  76   int retval = MSVCRT_EOF;
  77
  78   LOCK_CONSOLE;
  79   if (WriteConsoleA(MSVCRT_console_out, str, strlen(str), &count, NULL)
  80       && count == 1)
  81     retval = 0;
  82   UNLOCK_CONSOLE;
  83   return retval;
  84 }
  85
  86 /*********************************************************************
  87  *              _getch (MSVCRT.@)
  88  */
  89 int _getch(void)
  90 {
  91   int retval = MSVCRT_EOF;
  92
  93   LOCK_CONSOLE;
  94   if (__MSVCRT_console_buffer != MSVCRT_EOF)
  95   {
  96     retval = __MSVCRT_console_buffer;
  97     __MSVCRT_console_buffer = MSVCRT_EOF;
  98   }
  99   else
 100   {
 101     INPUT_RECORD ir;
 102     DWORD count;
 103     DWORD mode = 0;
 104
 105     GetConsoleMode(MSVCRT_console_in, &mode);
 106     if(mode)
 107       SetConsoleMode(MSVCRT_console_in, 0);
 108
 109     do {
 110       if (ReadConsoleInputA(MSVCRT_console_in, &ir, 1, &count))
 111       {
 112         /* Only interested in ASCII chars */
 113         if (ir.EventType == KEY_EVENT &&
 114             ir.Event.KeyEvent.bKeyDown &&
 115             ir.Event.KeyEvent.uChar.AsciiChar)
 116         {
 117           retval = ir.Event.KeyEvent.uChar.AsciiChar;
 118           break;
 119         }
 120       }
 121       else
 122         break;
 123     } while(1);
 124     if (mode)
 125       SetConsoleMode(MSVCRT_console_in, mode);
 126   }
 127   UNLOCK_CONSOLE;
 128   return retval;
 129 }
 130
 131 /*********************************************************************
 132  *              _putch (MSVCRT.@)
 133  */
 134 int _putch(int c)
 135 {
 136   int retval = MSVCRT_EOF;
 137   DWORD count;
 138   LOCK_CONSOLE;
 139   if (WriteConsoleA(MSVCRT_console_out, &c, 1, &count, NULL) && count == 1)
 140     retval = c;
 141   UNLOCK_CONSOLE;
 142   return retval;
 143 }
 144
 145 /*********************************************************************
 146  *              _getche (MSVCRT.@)
 147  */
 148 int _getche(void)
 149 {
 150   int retval;
 151   LOCK_CONSOLE;
 152   retval = _getch();
 153   if (retval != MSVCRT_EOF)
 154     retval = _putch(retval);
 155   UNLOCK_CONSOLE;
 156   return retval;
 157 }
 158
 159 /*********************************************************************
 160  *              _cgets (MSVCRT.@)
 161  */
 162 char* _cgets(char* str)
 163 {
 164   char *buf = str + 2;
 165   int c;
 166   str[1] = 0; /* Length */
 167   /* FIXME: No editing of string supported */
 168   LOCK_CONSOLE;
 169   do
 170   {
 171     if (str[1] >= str[0] || (str[1]++, c = _getche()) == MSVCRT_EOF || c == '\n')
 172       break;
 173     *buf++ = c & 0xff;
 174   } while (1);
 175   UNLOCK_CONSOLE;
 176   *buf = '\0';
 177   return str + 2;
 178 }
 179
 180 /*********************************************************************
 181  *              _ungetch (MSVCRT.@)
 182  */
 183 int _ungetch(int c)
 184 {
 185   int retval = MSVCRT_EOF;
 186   LOCK_CONSOLE;
 187   if (c != MSVCRT_EOF && __MSVCRT_console_buffer == MSVCRT_EOF)
 188     retval = __MSVCRT_console_buffer = c;
 189   UNLOCK_CONSOLE;
 190   return retval;
 191 }
 192
 193 /*********************************************************************
 194  *              _kbhit (MSVCRT.@)
 195  */
 196 int _kbhit(void)
 197 {
 198   int retval = 0;
 199
 200   LOCK_CONSOLE;
 201   if (__MSVCRT_console_buffer != MSVCRT_EOF)
 202     retval = 1;
 203   else
 204   {
 205     /* FIXME: There has to be a faster way than this in Win32.. */
 206     INPUT_RECORD *ir = NULL;
 207     DWORD count = 0, i;
 208
 209     GetNumberOfConsoleInputEvents(MSVCRT_console_in, &count);
 210
 211     if (count && (ir = MSVCRT_malloc(count * sizeof(INPUT_RECORD))) &&
 212         PeekConsoleInputA(MSVCRT_console_in, ir, count, &count))
 213       for(i = 0; i < count - 1; i++)
 214       {
 215         if (ir[i].EventType == KEY_EVENT &&
 216             ir[i].Event.KeyEvent.bKeyDown &&
 217             ir[i].Event.KeyEvent.uChar.AsciiChar)
 218         {
 219           retval = 1;
 220           break;
 221         }
 222       }
 223     if (ir)
 224       MSVCRT_free(ir);
 225   }
 226   UNLOCK_CONSOLE;
 227   return retval;
 228 }
 229
 230
 231 /*********************************************************************
 232  *              _cprintf (MSVCRT.@)
 233  */
 234 int _cprintf(const char* format, ...)
 235 {
 236   char buf[2048], *mem = buf;
 237   int written, resize = sizeof(buf), retval;
 238   va_list valist;
 239
 240   va_start( valist, format );
 241   /* There are two conventions for snprintf failing:
 242    * Return -1 if we truncated, or
 243    * Return the number of bytes that would have been written
 244    * The code below handles both cases
 245    */
 246   while ((written = _snprintf( mem, resize, format, valist )) == -1 ||
 247           written > resize)
 248   {
 249     resize = (written == -1 ? resize * 2 : written + 1);
 250     if (mem != buf)
 251       MSVCRT_free (mem);
 252     if (!(mem = (char *)MSVCRT_malloc(resize)))
 253       return MSVCRT_EOF;
 254     va_start( valist, format );
 255   }
 256   va_end(valist);
 257   LOCK_CONSOLE;
 258   retval = _cputs( mem );
 259   UNLOCK_CONSOLE;
 260   if (mem != buf)
 261     MSVCRT_free (mem);
 262   return retval;
 263 }