/* * 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; }