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