Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575//// getch.cpp//// Copyright (c) Microsoft Corporation. All rights reserved.//// Defines _getch(), _getche(), and _ungetch(), which get and unget// characters directly from the console.//#include <conio.h>#include <corecrt_internal_lowio.h>#include <limits.h>#include <stdio.h>#include <stdlib.h>
namespace{ struct CharPair { unsigned char LeadChar; unsigned char SecondChar; };
struct EnhKeyVals { unsigned short ScanCode; CharPair RegChars; CharPair ShiftChars; CharPair CtrlChars; CharPair AltChars; };
struct NormKeyVals { CharPair RegChars; CharPair ShiftChars; CharPair CtrlChars; CharPair AltChars; };}
// Table of enhanced key values:static EnhKeyVals const EnhancedKeys[] ={ { 28, { 13, 0 }, { 13, 0 }, { 10, 0 }, { 0, 166 } }, { 53, { 47, 0 }, { 63, 0 }, { 0, 149 }, { 0, 164 } }, { 71, { 224, 71 }, { 224, 71 }, { 224, 119 }, { 0, 151 } }, { 72, { 224, 72 }, { 224, 72 }, { 224, 141 }, { 0, 152 } }, { 73, { 224, 73 }, { 224, 73 }, { 224, 134 }, { 0, 153 } }, { 75, { 224, 75 }, { 224, 75 }, { 224, 115 }, { 0, 155 } }, { 77, { 224, 77 }, { 224, 77 }, { 224, 116 }, { 0, 157 } }, { 79, { 224, 79 }, { 224, 79 }, { 224, 117 }, { 0, 159 } }, { 80, { 224, 80 }, { 224, 80 }, { 224, 145 }, { 0, 160 } }, { 81, { 224, 81 }, { 224, 81 }, { 224, 118 }, { 0, 161 } }, { 82, { 224, 82 }, { 224, 82 }, { 224, 146 }, { 0, 162 } }, { 83, { 224, 83 }, { 224, 83 }, { 224, 147 }, { 0, 163 } }};
// The number of elements in EnhancedKeys:#define NUM_EKA_ELTS (sizeof(EnhancedKeys) / sizeof(EnhKeyVals))
// Table of key values for normal keys. Note that the table is padded so that// the key scan code serves as an index into the table.static NormKeyVals const NormalKeys[] ={ /* padding */ { /* 0 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 1 */ { 27, 0 }, { 27, 0 }, { 27, 0 }, { 0, 1 } }, { /* 2 */ { 49, 0 }, { 33, 0 }, { 0, 0 }, { 0, 120 } }, { /* 3 */ { 50, 0 }, { 64, 0 }, { 0, 3 }, { 0, 121 } }, { /* 4 */ { 51, 0 }, { 35, 0 }, { 0, 0 }, { 0, 122 } }, { /* 5 */ { 52, 0 }, { 36, 0 }, { 0, 0 }, { 0, 123 } }, { /* 6 */ { 53, 0 }, { 37, 0 }, { 0, 0 }, { 0, 124 } }, { /* 7 */ { 54, 0 }, { 94, 0 }, { 30, 0 }, { 0, 125 } }, { /* 8 */ { 55, 0 }, { 38, 0 }, { 0, 0 }, { 0, 126 } }, { /* 9 */ { 56, 0 }, { 42, 0 }, { 0, 0 }, { 0, 127 } }, { /* 10 */ { 57, 0 }, { 40, 0 }, { 0, 0 }, { 0, 128 } }, { /* 11 */ { 48, 0 }, { 41, 0 }, { 0, 0 }, { 0, 129 } }, { /* 12 */ { 45, 0 }, { 95, 0 }, { 31, 0 }, { 0, 130 } }, { /* 13 */ { 61, 0 }, { 43, 0 }, { 0, 0 }, { 0, 131 } }, { /* 14 */ { 8, 0 }, { 8, 0 }, { 127, 0 }, { 0, 14 } }, { /* 15 */ { 9, 0 }, { 0, 15 }, { 0, 148 }, { 0, 15 } }, { /* 16 */ { 113, 0 }, { 81, 0 }, { 17, 0 }, { 0, 16 } }, { /* 17 */ { 119, 0 }, { 87, 0 }, { 23, 0 }, { 0, 17 } }, { /* 18 */ { 101, 0 }, { 69, 0 }, { 5, 0 }, { 0, 18 } }, { /* 19 */ { 114, 0 }, { 82, 0 }, { 18, 0 }, { 0, 19 } }, { /* 20 */ { 116, 0 }, { 84, 0 }, { 20, 0 }, { 0, 20 } }, { /* 21 */ { 121, 0 }, { 89, 0 }, { 25, 0 }, { 0, 21 } }, { /* 22 */ { 117, 0 }, { 85, 0 }, { 21, 0 }, { 0, 22 } }, { /* 23 */ { 105, 0 }, { 73, 0 }, { 9, 0 }, { 0, 23 } }, { /* 24 */ { 111, 0 }, { 79, 0 }, { 15, 0 }, { 0, 24 } }, { /* 25 */ { 112, 0 }, { 80, 0 }, { 16, 0 }, { 0, 25 } }, { /* 26 */ { 91, 0 }, { 123, 0 }, { 27, 0 }, { 0, 26 } }, { /* 27 */ { 93, 0 }, { 125, 0 }, { 29, 0 }, { 0, 27 } }, { /* 28 */ { 13, 0 }, { 13, 0 }, { 10, 0 }, { 0, 28 } },
/* padding */ { /* 29 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 30 */ { 97, 0 }, { 65, 0 }, { 1, 0 }, { 0, 30 } }, { /* 31 */ { 115, 0 }, { 83, 0 }, { 19, 0 }, { 0, 31 } }, { /* 32 */ { 100, 0 }, { 68, 0 }, { 4, 0 }, { 0, 32 } }, { /* 33 */ { 102, 0 }, { 70, 0 }, { 6, 0 }, { 0, 33 } }, { /* 34 */ { 103, 0 }, { 71, 0 }, { 7, 0 }, { 0, 34 } }, { /* 35 */ { 104, 0 }, { 72, 0 }, { 8, 0 }, { 0, 35 } }, { /* 36 */ { 106, 0 }, { 74, 0 }, { 10, 0 }, { 0, 36 } }, { /* 37 */ { 107, 0 }, { 75, 0 }, { 11, 0 }, { 0, 37 } }, { /* 38 */ { 108, 0 }, { 76, 0 }, { 12, 0 }, { 0, 38 } }, { /* 39 */ { 59, 0 }, { 58, 0 }, { 0, 0 }, { 0, 39 } }, { /* 40 */ { 39, 0 }, { 34, 0 }, { 0, 0 }, { 0, 40 } }, { /* 41 */ { 96, 0 }, { 126, 0 }, { 0, 0 }, { 0, 41 } },
/* padding */ { /* 42 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 43 */ { 92, 0 }, { 124, 0 }, { 28, 0 }, { 0, 0 } }, { /* 44 */ { 122, 0 }, { 90, 0 }, { 26, 0 }, { 0, 44 } }, { /* 45 */ { 120, 0 }, { 88, 0 }, { 24, 0 }, { 0, 45 } }, { /* 46 */ { 99, 0 }, { 67, 0 }, { 3, 0 }, { 0, 46 } }, { /* 47 */ { 118, 0 }, { 86, 0 }, { 22, 0 }, { 0, 47 } }, { /* 48 */ { 98, 0 }, { 66, 0 }, { 2, 0 }, { 0, 48 } }, { /* 49 */ { 110, 0 }, { 78, 0 }, { 14, 0 }, { 0, 49 } }, { /* 50 */ { 109, 0 }, { 77, 0 }, { 13, 0 }, { 0, 50 } }, { /* 51 */ { 44, 0 }, { 60, 0 }, { 0, 0 }, { 0, 51 } }, { /* 52 */ { 46, 0 }, { 62, 0 }, { 0, 0 }, { 0, 52 } }, { /* 53 */ { 47, 0 }, { 63, 0 }, { 0, 0 }, { 0, 53 } },
/* padding */ { /* 54 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 55 */ { 42, 0 }, { 0, 0 }, { 114, 0 }, { 0, 0 } },
/* padding */ { /* 56 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 57 */ { 32, 0 }, { 32, 0 }, { 32, 0 }, { 32, 0 } },
/* padding */ { /* 58 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 59 */ { 0, 59 }, { 0, 84 }, { 0, 94 }, { 0, 104 } }, { /* 60 */ { 0, 60 }, { 0, 85 }, { 0, 95 }, { 0, 105 } }, { /* 61 */ { 0, 61 }, { 0, 86 }, { 0, 96 }, { 0, 106 } }, { /* 62 */ { 0, 62 }, { 0, 87 }, { 0, 97 }, { 0, 107 } }, { /* 63 */ { 0, 63 }, { 0, 88 }, { 0, 98 }, { 0, 108 } }, { /* 64 */ { 0, 64 }, { 0, 89 }, { 0, 99 }, { 0, 109 } }, { /* 65 */ { 0, 65 }, { 0, 90 }, { 0, 100 }, { 0, 110 } }, { /* 66 */ { 0, 66 }, { 0, 91 }, { 0, 101 }, { 0, 111 } }, { /* 67 */ { 0, 67 }, { 0, 92 }, { 0, 102 }, { 0, 112 } }, { /* 68 */ { 0, 68 }, { 0, 93 }, { 0, 103 }, { 0, 113 } },
/* padding */ { /* 69 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }, { /* 70 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 71 */ { 0, 71 }, { 55, 0 }, { 0, 119 }, { 0, 0 } }, { /* 72 */ { 0, 72 }, { 56, 0 }, { 0, 141 }, { 0, 0 } }, { /* 73 */ { 0, 73 }, { 57, 0 }, { 0, 132 }, { 0, 0 } }, { /* 74 */ { 0, 0 }, { 45, 0 }, { 0, 0 }, { 0, 0 } }, { /* 75 */ { 0, 75 }, { 52, 0 }, { 0, 115 }, { 0, 0 } }, { /* 76 */ { 0, 0 }, { 53, 0 }, { 0, 0 }, { 0, 0 } }, { /* 77 */ { 0, 77 }, { 54, 0 }, { 0, 116 }, { 0, 0 } }, { /* 78 */ { 0, 0 }, { 43, 0 }, { 0, 0 }, { 0, 0 } }, { /* 79 */ { 0, 79 }, { 49, 0 }, { 0, 117 }, { 0, 0 } }, { /* 80 */ { 0, 80 }, { 50, 0 }, { 0, 145 }, { 0, 0 } }, { /* 81 */ { 0, 81 }, { 51, 0 }, { 0, 118 }, { 0, 0 } }, { /* 82 */ { 0, 82 }, { 48, 0 }, { 0, 146 }, { 0, 0 } }, { /* 83 */ { 0, 83 }, { 46, 0 }, { 0, 147 }, { 0, 0 } },
/* padding */ { /* 84 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }, { /* 85 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }, { /* 86 */ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
{ /* 87 */ { 224, 133 }, { 224, 135 }, { 224, 137 }, { 224, 139 } }, { /* 88 */ { 224, 134 }, { 224, 136 }, { 224, 138 }, { 224, 140 } }};
// The primary purpose of the pushback buffer is so that if a// multi-byte character or extended key code is read, we can return// the first byte and store the rest of the data in the buffer for// subsequent calls. UTF-8 characters can be up to 4 bytes long, so// the pushback buffer must be able to store the 3 remaining bytes.size_t const getch_pushback_buffer_capacity = 3;
static int getch_pushback_buffer[getch_pushback_buffer_capacity];static int getch_pushback_buffer_index = 0;static int getch_pushback_buffer_current_size = 0;
static bool is_getch_pushback_buffer_full(){ return getch_pushback_buffer_current_size >= getch_pushback_buffer_capacity;}
static void add_to_getch_pushback_buffer(int const c){ _ASSERTE(!is_getch_pushback_buffer_full()); getch_pushback_buffer[getch_pushback_buffer_current_size++] = c;}
static int peek_next_getch_pushback_buffer(){ if (getch_pushback_buffer_current_size == 0) { return EOF; }
return getch_pushback_buffer[getch_pushback_buffer_index];}
static int get_next_getch_pushback_buffer(){ if (getch_pushback_buffer_current_size == 0) { return EOF; }
int const ret_val = getch_pushback_buffer[getch_pushback_buffer_index++];
if (getch_pushback_buffer_index == getch_pushback_buffer_current_size) { getch_pushback_buffer_index = 0; getch_pushback_buffer_current_size = 0; }
return ret_val;}
extern "C" intptr_t __dcrt_lowio_console_input_handle;
extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD*);extern "C" int __cdecl _kbhit_nolock();
// These functions read a single character from the console. _getch() does not// echo the character; _getche() does echo the character. If the push-back// buffer is nonempty, the buffered character is returned immediately, without// being echoed.//// On success, the read character is returned; on failure, EOF is returned.extern "C" int __cdecl _getch(){ __acrt_lock(__acrt_conio_lock); int result = 0; __try { result = _getch_nolock(); } __finally { __acrt_unlock(__acrt_conio_lock); } __endtry return result;}
extern "C" int __cdecl _getche(){ __acrt_lock(__acrt_conio_lock); int result = 0; __try { result = _getche_nolock(); } __finally { __acrt_unlock(__acrt_conio_lock); } __endtry return result;}
extern "C" int __cdecl _getch_nolock(){ // Check the pushback buffer for a character. If one is present, return it: int const pushback = get_next_getch_pushback_buffer(); if (pushback != EOF) { return pushback; }
if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) { return EOF; }
// Switch console to raw mode: DWORD old_console_mode; __dcrt_get_input_console_mode(&old_console_mode); __dcrt_set_input_console_mode(0);
int result = 0;
__try { for ( ; ; ) { // Get a console input event: INPUT_RECORD input_record; DWORD num_read;
if (__dcrt_read_console_input(&input_record, 1, &num_read) == FALSE || num_read == 0) { result = EOF; __leave; }
// Look for, and decipher, key events. if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown) { // Simple case: if UnicodeChar is non-zero, we can convert it to char and return it. wchar_t const c = input_record.Event.KeyEvent.uChar.UnicodeChar; if (c != 0) { wchar_t const c_buffer[2] = {c, L'\0'}; char mb_chars[4];
size_t const amount_written = __acrt_wcs_to_mbs_cp_array( c_buffer, mb_chars, GetConsoleCP() );
// Mask with 0xFF to just get lowest byte if (amount_written >= 1) { result = mb_chars[0] & 0xFF; }
if (amount_written >= 2) { for (size_t i = 1; i < amount_written; ++i) { add_to_getch_pushback_buffer(mb_chars[i] & 0xFF); } } __leave; }
// Hard case: either it is an extended code or an event which // should not be recognized. Let _getextendedkeycode do the work: CharPair const* const cp = _getextendedkeycode(&input_record.Event.KeyEvent); if (cp != nullptr) { // Mask with 0xFF to just get lowest byte add_to_getch_pushback_buffer(cp->SecondChar & 0xFF); result = cp->LeadChar & 0xFF; __leave; } } } } __finally { // Restore the previous console mode: __dcrt_set_input_console_mode(old_console_mode); } __endtry return result;}
extern "C" int __cdecl _getche_nolock(){ // Check the pushback buffer for a character. If one is present, return // it without echoing: int const pushback = get_next_getch_pushback_buffer(); if (pushback != EOF) { return pushback; }
// Otherwise, read the next character from the console and echo it: int const c = _getch_nolock(); if (c == EOF) return EOF;
if (_putch_nolock(c) == EOF) return EOF;
return c;}
// Returns nonzero if a keystroke is waiting to be read; otherwise returns zero.extern "C" int __cdecl _kbhit(){ __acrt_lock(__acrt_conio_lock); int result = 0; __try { result = _kbhit_nolock(); } __finally { __acrt_unlock(__acrt_conio_lock); } __endtry return result;}
extern "C" int __cdecl _kbhit_nolock(){ // If a character has been pushed back, return TRUE: if (peek_next_getch_pushback_buffer() != EOF) { return TRUE; }
if (__dcrt_lowio_ensure_console_input_initialized() == FALSE) { return FALSE; }
// Peek at all pending console events: DWORD num_pending; if (__dcrt_get_number_of_console_input_events(&num_pending) == FALSE) { return FALSE; }
if (num_pending == 0) { return FALSE; }
__crt_scoped_stack_ptr<INPUT_RECORD> const input_buffer(_malloca_crt_t(INPUT_RECORD, num_pending)); if (input_buffer.get() == nullptr) { return FALSE; }
DWORD num_peeked; // AsciiChar is not read, so using the narrow Win32 API is permitted. if (__dcrt_peek_console_input_a(input_buffer.get(), num_pending, &num_peeked) == FALSE) { return FALSE; }
if (num_peeked == 0 || num_peeked > num_pending) { return FALSE; }
// Scan all of the peeked events to determine if any is a key event // that should be recognized: for (INPUT_RECORD* p = input_buffer.get(); num_peeked > 0; --num_peeked, ++p) { if (p->EventType != KEY_EVENT) continue;
if (!p->Event.KeyEvent.bKeyDown) continue;
if (p->Event.KeyEvent.uChar.AsciiChar == 0 && _getextendedkeycode(&p->Event.KeyEvent) == nullptr) continue;
return TRUE; }
return FALSE;}
// Pushes back ("ungets") one character to be read next by _getwch() or// _getwche(). On success, returns the character that was pushed back; on// failure, returns EOF.extern "C" int __cdecl _ungetch(int const c){ __acrt_lock(__acrt_conio_lock); int result = 0; __try { result = _ungetch_nolock(c); } __finally { __acrt_unlock(__acrt_conio_lock); } __endtry return result;}
extern "C" int __cdecl _ungetch_nolock(int const c){ // Fail if the character is EOF or the pusback buffer is nonempty: if (c == EOF || is_getch_pushback_buffer_full()) { return EOF; }
add_to_getch_pushback_buffer(c); return c;}
// Returns the extended code (if there is one) for a key event. This is the// core function for the _getch() and _getche() functions and their wide// character equivalents, and is essential to _kbhit(). This is the function// that determines whether or not a key event NOT accompanied by an ASCII// character has an extended code and returns that code.//// On success, a pointer to a CharPair value holding the lead and second// characters of the extended code is returned. On failure, nullptr is returned.extern "C" CharPair const* __cdecl _getextendedkeycode(KEY_EVENT_RECORD* const pKE){ DWORD const CKS = pKE->dwControlKeyState;
if (CKS & ENHANCED_KEY) { // Find the appropriate entry in EnhancedKeys[]: for (int i = 0 ; i < NUM_EKA_ELTS; ++i) { if (EnhancedKeys[i].ScanCode != pKE->wVirtualScanCode) { continue; }
// We found a match! Determine which pair to return: if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) { return &EnhancedKeys[i].AltChars; } else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) { return &EnhancedKeys[i].CtrlChars; } else if (CKS & SHIFT_PRESSED) { return &EnhancedKeys[i].ShiftChars; } else { return &EnhancedKeys[i].RegChars; } }
return nullptr; } else { // Regular key or keyboard event which shouldn't be recognized. // Determine which by getting the proper field of the proper entry in // NormalKeys[] and examining the extended code. CharPair const* pCP;
if (CKS & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) { pCP = &NormalKeys[pKE->wVirtualScanCode].AltChars; } else if (CKS & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) { pCP = &NormalKeys[pKE->wVirtualScanCode].CtrlChars; } else if (CKS & SHIFT_PRESSED) { pCP = &NormalKeys[pKE->wVirtualScanCode].ShiftChars; } else { pCP = &NormalKeys[pKE->wVirtualScanCode].RegChars; }
// Make sure it wasn't a keyboard event which should not be recognized // (e.g. the shift key was pressed): if ((pCP->LeadChar != 0 && pCP->LeadChar != 224) || pCP->SecondChar == 0) { return nullptr; }
return pCP; }}