| /* | |
| * msvcrt.dll console functions | |
| * | |
| * Copyright 2000 Jon Griffiths | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| * | |
| * Note: init and free don't need MT locking since they are called at DLL | |
| * (de)attachment time, which is syncronised for us | |
| */ | |
| #include "msvcrt.h" | |
| #include "wincon.h" | |
| #include "msvcrt/conio.h" | |
| #include "msvcrt/malloc.h" | |
| #include "msvcrt/stdio.h" | |
| #include "mtdll.h" | |
| #include "wine/debug.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(msvcrt); | |
| /* MT */ | |
| #define LOCK_CONSOLE _mlock(_CONIO_LOCK) | |
| #define UNLOCK_CONSOLE _munlock(_CONIO_LOCK) | |
| static HANDLE MSVCRT_console_in = INVALID_HANDLE_VALUE; | |
| static HANDLE MSVCRT_console_out= INVALID_HANDLE_VALUE; | |
| static int __MSVCRT_console_buffer = MSVCRT_EOF; | |
| /* INTERNAL: Initialise console handles */ | |
| void msvcrt_init_console(void) | |
| { | |
| TRACE(":Opening console handles\n"); | |
| MSVCRT_console_in = GetStdHandle(STD_INPUT_HANDLE); | |
| /* FIXME: Should be initialised with: | |
| * CreateFileA("CONIN$", GENERIC_READ, FILE_SHARE_READ, | |
| * NULL, OPEN_EXISTING, 0, (HANDLE)NULL); | |
| */ | |
| MSVCRT_console_out= CreateFileA("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, | |
| NULL, OPEN_EXISTING, 0, (HANDLE)NULL); | |
| if ((MSVCRT_console_in == INVALID_HANDLE_VALUE) || | |
| (MSVCRT_console_out== INVALID_HANDLE_VALUE)) | |
| WARN(":Console handle Initialisation FAILED!\n"); | |
| } | |
| /* INTERNAL: Free console handles */ | |
| void msvcrt_free_console(void) | |
| { | |
| TRACE(":Closing console handles\n"); | |
| CloseHandle(MSVCRT_console_in); | |
| CloseHandle(MSVCRT_console_out); | |
| } | |
| /********************************************************************* | |
| * _cputs (MSVCRT.@) | |
| */ | |
| int _cputs(const char* str) | |
| { | |
| DWORD count; | |
| int retval = MSVCRT_EOF; | |
| LOCK_CONSOLE; | |
| if (WriteConsoleA(MSVCRT_console_out, str, strlen(str), &count, NULL) | |
| && count == 1) | |
| retval = 0; | |
| UNLOCK_CONSOLE; | |
| return retval; | |
| } | |
| /********************************************************************* | |
| * _getch (MSVCRT.@) | |
| */ | |
| int _getch(void) | |
| { | |
| int retval = MSVCRT_EOF; | |
| LOCK_CONSOLE; | |
| if (__MSVCRT_console_buffer != MSVCRT_EOF) | |
| { | |
| retval = __MSVCRT_console_buffer; | |
| __MSVCRT_console_buffer = MSVCRT_EOF; | |
| } | |
| else | |
| { | |
| INPUT_RECORD ir; | |
| DWORD count; | |
| DWORD mode = 0; | |
| GetConsoleMode(MSVCRT_console_in, &mode); | |
| if(mode) | |
| SetConsoleMode(MSVCRT_console_in, 0); | |
| do { | |
| if (ReadConsoleInputA(MSVCRT_console_in, &ir, 1, &count)) | |
| { | |
| /* Only interested in ASCII chars */ | |
| if (ir.EventType == KEY_EVENT && | |
| ir.Event.KeyEvent.bKeyDown && | |
| ir.Event.KeyEvent.uChar.AsciiChar) | |
| { | |
| retval = ir.Event.KeyEvent.uChar.AsciiChar; | |
| break; | |
| } | |
| } | |
| else | |
| break; | |
| } while(1); | |
| if (mode) | |
| SetConsoleMode(MSVCRT_console_in, mode); | |
| } | |
| UNLOCK_CONSOLE; | |
| return retval; | |
| } | |
| /********************************************************************* | |
| * _putch (MSVCRT.@) | |
| */ | |
| int _putch(int c) | |
| { | |
| int retval = MSVCRT_EOF; | |
| DWORD count; | |
| LOCK_CONSOLE; | |
| if (WriteConsoleA(MSVCRT_console_out, &c, 1, &count, NULL) && count == 1) | |
| retval = c; | |
| UNLOCK_CONSOLE; | |
| return retval; | |
| } | |
| /********************************************************************* | |
| * _getche (MSVCRT.@) | |
| */ | |
| int _getche(void) | |
| { | |
| int retval; | |
| LOCK_CONSOLE; | |
| retval = _getch(); | |
| if (retval != MSVCRT_EOF) | |
| retval = _putch(retval); | |
| UNLOCK_CONSOLE; | |
| return retval; | |
| } | |
| /********************************************************************* | |
| * _cgets (MSVCRT.@) | |
| */ | |
| char* _cgets(char* str) | |
| { | |
| char *buf = str + 2; | |
| int c; | |
| str[1] = 0; /* Length */ | |
| /* FIXME: No editing of string supported */ | |
| LOCK_CONSOLE; | |
| do | |
| { | |
| if (str[1] >= str[0] || (str[1]++, c = _getche()) == MSVCRT_EOF || c == '\n') | |
| break; | |
| *buf++ = c & 0xff; | |
| } while (1); | |
| UNLOCK_CONSOLE; | |
| *buf = '\0'; | |
| return str + 2; | |
| } | |
| /********************************************************************* | |
| * _ungetch (MSVCRT.@) | |
| */ | |
| int _ungetch(int c) | |
| { | |
| int retval = MSVCRT_EOF; | |
| LOCK_CONSOLE; | |
| if (c != MSVCRT_EOF && __MSVCRT_console_buffer == MSVCRT_EOF) | |
| retval = __MSVCRT_console_buffer = c; | |
| UNLOCK_CONSOLE; | |
| return retval; | |
| } | |
| /* helper function for _cscanf. Returns the value of character c in the | |
| * given base, or -1 if the given character is not a digit of the base. | |
| */ | |
| static int char2digit(char c, int base) { | |
| if ((c>='0') && (c<='9') && (c<='0'+base-1)) return (c-'0'); | |
| if (base<=10) return -1; | |
| if ((c>='A') && (c<='Z') && (c<='A'+base-11)) return (c-'A'+10); | |
| if ((c>='a') && (c<='z') && (c<='a'+base-11)) return (c-'a'+10); | |
| return -1; | |
| } | |
| /********************************************************************* | |
| * _cscanf (MSVCRT.@) | |
| */ | |
| int _cscanf(const char* format, ...) | |
| { | |
| /* NOTE: If you extend this function, extend MSVCRT_fscanf in file.c too */ | |
| int rd = 0; | |
| int nch; | |
| va_list ap; | |
| if (!*format) return 0; | |
| WARN("\"%s\": semi-stub\n", format); | |
| va_start(ap, format); | |
| LOCK_CONSOLE; | |
| nch = _getch(); | |
| while (*format) { | |
| /* a whitespace character in the format string causes scanf to read, | |
| * but not store, all consecutive white-space characters in the input | |
| * up to the next non-white-space character. One white space character | |
| * in the input matches any number (including zero) and combination of | |
| * white-space characters in the input. */ | |
| if (isspace(*format)) { | |
| /* skip whitespace */ | |
| while ((nch!=MSVCRT_EOF) && isspace(nch)) | |
| nch = _getch(); | |
| } | |
| /* a format specification causes scanf to read and convert characters | |
| * in the input into values of a specified type. The value is assigned | |
| * to an argument in the argument list. Format specifications have | |
| * the form %[*][width][{h | l | I64 | L}]type */ | |
| /* FIXME: unimplemented: h/l/I64/L modifiers and some type specs. */ | |
| else if (*format == '%') { | |
| int st = 0; int suppress = 0; int width = 0; | |
| int base, number_signed; | |
| format++; | |
| /* look for leading asterisk, which means 'suppress assignment of | |
| * this field'. */ | |
| if (*format=='*') { | |
| format++; | |
| suppress=1; | |
| } | |
| /* look for width specification */ | |
| while (isdigit(*format)) { | |
| width*=10; | |
| width+=*format++ - '0'; | |
| } | |
| if (width==0) width=-1; /* no width spec seen */ | |
| switch(*format) { | |
| case '%': /* read a percent symbol */ | |
| if (nch!='%') break; | |
| nch = _getch(); | |
| break; | |
| case 'x': | |
| case 'X': /* hexadecimal integer. */ | |
| base = 16; number_signed = 0; | |
| goto number; | |
| case 'o': /* octal integer */ | |
| base = 8; number_signed = 0; | |
| goto number; | |
| case 'u': /* unsigned decimal integer */ | |
| base = 10; number_signed = 0; | |
| goto number; | |
| case 'd': /* signed decimal integer */ | |
| base = 10; number_signed = 1; | |
| goto number; | |
| case 'i': /* generic integer */ | |
| base = 0; number_signed = 1; | |
| number: { | |
| /* read an integer */ | |
| int*val = suppress ? NULL : va_arg(ap, int*); | |
| int cur = 0; int negative = 0; int seendigit=0; | |
| /* skip initial whitespace */ | |
| while ((nch!=MSVCRT_EOF) && isspace(nch)) | |
| nch = _getch(); | |
| /* get sign */ | |
| if (number_signed && (nch == '-' || nch == '+')) { | |
| negative = (nch=='-'); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| } | |
| /* look for leading indication of base */ | |
| if (width!=0 && nch == '0') { | |
| nch = _getch(); | |
| if (width>0) width--; | |
| seendigit=1; | |
| if (width!=0 && (nch=='x' || nch=='X')) { | |
| if (base==0) | |
| base=16; | |
| if (base==16) { | |
| nch = _getch(); | |
| if (width>0) width--; | |
| seendigit=0; | |
| } | |
| } else if (base==0) | |
| base = 8; | |
| } | |
| if (base==0) | |
| base=10; | |
| /* throw away leading zeros */ | |
| while (width!=0 && nch=='0') { | |
| nch = _getch(); | |
| if (width>0) width--; | |
| seendigit=1; | |
| } | |
| /* get first digit. Keep working copy negative, as the | |
| * range of negative numbers in two's complement notation | |
| * is one larger than the range of positive numbers. */ | |
| if (width!=0 && char2digit(nch, base)!=-1) { | |
| cur = -char2digit(nch, base); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| seendigit=1; | |
| } | |
| /* read until no more digits */ | |
| while (width!=0 && (nch!=MSVCRT_EOF) && isdigit(nch)) { | |
| cur = cur*base + char2digit(nch, base); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| seendigit=1; | |
| } | |
| /* negate parsed number if non-negative */ | |
| if (!negative) cur=-cur; | |
| /* okay, done! */ | |
| if (!seendigit) break; /* not a valid number */ | |
| st = 1; | |
| if (!suppress) *val = cur; | |
| } | |
| break; | |
| case 'e': | |
| case 'E': | |
| case 'f': | |
| case 'g': | |
| case 'G': { /* read a float */ | |
| float*val = suppress ? NULL : va_arg(ap, float*); | |
| float cur = 0; | |
| int negative = 0; | |
| /* skip initial whitespace */ | |
| while ((nch!=MSVCRT_EOF) && isspace(nch)) | |
| nch = _getch(); | |
| /* get sign. */ | |
| if (nch == '-' || nch == '+') { | |
| negative = (nch=='-'); | |
| if (width>0) width--; | |
| if (width==0) break; | |
| nch = _getch(); | |
| } | |
| /* get first digit. */ | |
| if (!isdigit(nch)) break; | |
| cur = (nch - '0') * (negative ? -1 : 1); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| /* read until no more digits */ | |
| while (width!=0 && (nch!=MSVCRT_EOF) && isdigit(nch)) { | |
| cur = cur*10 + (nch - '0'); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| } | |
| /* handle decimals */ | |
| if (width!=0 && nch == '.') { | |
| float dec = 1; | |
| nch = _getch(); | |
| if (width>0) width--; | |
| while (width!=0 && (nch!=MSVCRT_EOF) && isdigit(nch)) { | |
| dec /= 10; | |
| cur += dec * (nch - '0'); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| } | |
| } | |
| /* handle exponent */ | |
| if (width!=0 && (nch == 'e' || nch == 'E')) { | |
| int exponent = 0, negexp = 0; | |
| float expcnt; | |
| nch = _getch(); | |
| if (width>0) width--; | |
| /* possible sign on the exponent */ | |
| if (width!=0 && (nch=='+' || nch=='-')) { | |
| negexp = (nch=='-'); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| } | |
| /* exponent digits */ | |
| while (width!=0 && (nch!=MSVCRT_EOF) && isdigit(nch)) { | |
| exponent *= 10; | |
| exponent += (nch - '0'); | |
| nch = _getch(); | |
| if (width>0) width--; | |
| } | |
| /* update 'cur' with this exponent. */ | |
| expcnt = negexp ? .1 : 10; | |
| while (exponent!=0) { | |
| if (exponent&1) | |
| cur*=expcnt; | |
| exponent/=2; | |
| expcnt=expcnt*expcnt; | |
| } | |
| } | |
| st = 1; | |
| if (!suppress) *val = cur; | |
| } | |
| break; | |
| case 's': { /* read a word */ | |
| char*str = suppress ? NULL : va_arg(ap, char*); | |
| char*sptr = str; | |
| /* skip initial whitespace */ | |
| while ((nch!=MSVCRT_EOF) && isspace(nch)) | |
| nch = _getch(); | |
| /* read until whitespace */ | |
| while (width!=0 && (nch!=MSVCRT_EOF) && !isspace(nch)) { | |
| if (!suppress) *sptr++ = nch; | |
| st++; | |
| nch = _getch(); | |
| if (width>0) width--; | |
| } | |
| /* terminate */ | |
| if (!suppress) *sptr = 0; | |
| TRACE("read word: %s\n", str); | |
| } | |
| break; | |
| default: FIXME("unhandled: %%%c\n", *format); | |
| /* From spec: "if a percent sign is followed by a character | |
| * that has no meaning as a format-control character, that | |
| * character and the following characters are treated as | |
| * an ordinary sequence of characters, that is, a sequence | |
| * of characters that must match the input. For example, | |
| * to specify that a percent-sign character is to be input, | |
| * use %%." | |
| * LEAVING AS-IS because we catch bugs better that way. */ | |
| } | |
| if (st && !suppress) rd++; | |
| else break; | |
| } | |
| /* a non-white-space character causes scanf to read, but not store, | |
| * a matching non-white-space character. */ | |
| else { | |
| /* check for character match */ | |
| if (nch == *format) | |
| nch = _getch(); | |
| else break; | |
| } | |
| format++; | |
| } | |
| if (nch != MSVCRT_EOF) | |
| _ungetch(nch); | |
| UNLOCK_CONSOLE; | |
| va_end(ap); | |
| TRACE("returning %d\n", rd); | |
| return rd; | |
| } | |
| /********************************************************************* | |
| * _kbhit (MSVCRT.@) | |
| */ | |
| int _kbhit(void) | |
| { | |
| int retval = 0; | |
| LOCK_CONSOLE; | |
| if (__MSVCRT_console_buffer != MSVCRT_EOF) | |
| retval = 1; | |
| else | |
| { | |
| /* FIXME: There has to be a faster way than this in Win32.. */ | |
| INPUT_RECORD *ir = NULL; | |
| DWORD count = 0, i; | |
| GetNumberOfConsoleInputEvents(MSVCRT_console_in, &count); | |
| if (count && (ir = MSVCRT_malloc(count * sizeof(INPUT_RECORD))) && | |
| PeekConsoleInputA(MSVCRT_console_in, ir, count, &count)) | |
| for(i = 0; i < count - 1; i++) | |
| { | |
| if (ir[i].EventType == KEY_EVENT && | |
| ir[i].Event.KeyEvent.bKeyDown && | |
| ir[i].Event.KeyEvent.uChar.AsciiChar) | |
| { | |
| retval = 1; | |
| break; | |
| } | |
| } | |
| if (ir) | |
| MSVCRT_free(ir); | |
| } | |
| UNLOCK_CONSOLE; | |
| return retval; | |
| } | |
| /********************************************************************* | |
| * _cprintf (MSVCRT.@) | |
| */ | |
| int _cprintf(const char* format, ...) | |
| { | |
| char buf[2048], *mem = buf; | |
| int written, resize = sizeof(buf), retval; | |
| va_list valist; | |
| va_start( valist, format ); | |
| /* There are two conventions for snprintf failing: | |
| * Return -1 if we truncated, or | |
| * Return the number of bytes that would have been written | |
| * The code below handles both cases | |
| */ | |
| while ((written = _snprintf( mem, resize, format, valist )) == -1 || | |
| written > resize) | |
| { | |
| resize = (written == -1 ? resize * 2 : written + 1); | |
| if (mem != buf) | |
| MSVCRT_free (mem); | |
| if (!(mem = (char *)MSVCRT_malloc(resize))) | |
| return MSVCRT_EOF; | |
| va_start( valist, format ); | |
| } | |
| va_end(valist); | |
| LOCK_CONSOLE; | |
| retval = _cputs( mem ); | |
| UNLOCK_CONSOLE; | |
| if (mem != buf) | |
| MSVCRT_free (mem); | |
| return retval; | |
| } |