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