key module (Windows)

Author: marcgurevitx

MiniScript-cpp/README-key.md

@@ -8,28 +8,32 @@
 | `key.get` | compatible |
 | `key.put(keyChar)` | compatible |
 | `key.clear` | compatible |
-| `key.pressed(keyName="space")` | not ported |
-| `key.keyNames` | not ported |
-| `key.axis(axis="Horizontal")` | not ported |
-| `key._putInFront(keyChar)` | (non-standard) same as `key.put` but instead of adding its arg at the end of the input buffer, inserts it at the beginning |
-| `key._echo` | (non-standard, only unixes) property that controls whether typed characters are echoed in the terminal |
-| `key._scanMap` | (non-standard) property that controls how scan codes and escape sequences are mapped to the values that `key.get` is expected to return |
+| `key.pressed(keyName="space")` | (not ported) |
+| `key.keyNames` | (not ported) |
+| `key.axis(axis="Horizontal")` | (not ported) |
+| `key._putInFront(keyChar)` | (non-standard) same as `key.put` but inserts its arg at the beginning of the input buffer |
+| `key._echo` | (non-standard, only unixes) boolean property that controls whether typed characters are echoed in the terminal |
+| `key._scanMap` | (non-standard) property that controls how scan codes and escape sequences are mapped to the values that `key.get` is expected to return (`map` type) |
 
-There's a small demo that demonstrates the use of `key.available` and `key.get`: `demo/tetris.ms`.
+There's a small script that demonstrates the use of `key.available`, `key.get` and `key._echo`: `demo/tetris.ms`.
 
 
 ## Implementation of the input buffer
 
-The functions of this module maintain their shared internal buffer where key presses are stored.
+Functions of this module maintain a shared internal buffer where key presses are stored.
 
 It's implemented as a `SimpleVector` of entries where each entry is structure of two fields:
 
+| Field | Description |
+|---|---|
 | `c` | character code point of a regular (symbol) key |
 | `scanCode` | a code of a special key |
 
 Only one of these fields is non-zero at any times.
 
-This data type allows registering key presses on unixes where only code points are used, and Windows where key presses generate either a code point or a sequence of two integers: `0` and a scan code.
+This data type was chosen to register key presses on various systems:
+- On unixes only code points are used
+- On Windows key presses may generate either a code point or a sequence of two integers: `0` and a scan code.
 
 
 ## Scan map
@@ -38,9 +42,9 @@ Terminals vary in how they report special keys' presses.
 
 For example this is what \[Arrow up\] becomes in the Linux terminal: `char(27) + "[A"` (3 ASCII characters). The same key press on Windows produces `0` followed by scan code `72`. Finally, on Mini Micro it's `char(19)`.
 
-*Scan maps* is an internal mechanism of the `key` module that converts all various values into the same values that are returned by Mini Micro's `key.get` and hence should ensure portability of scripts.
+*Scan maps* is a mechanism of the `key` module that converts all various values into the same values that are returned by Mini Micro's `key.get` and hence facilitates portability of scripts.
 
-Scan maps are stored in a `key._scanMap` property and are MiniScript maps where the keys are either `number` type (in case you're mapping a scan code) or `string` type (in case of a sequence of characters), and the values are what you want to be returned by `key.get`.
+Scan maps are MiniScript `map`s (stored as a `key._scanMap` property) where the keys are either `number` type (in case you're mapping a scan code) or `string` type (in case of a sequence of characters), and the values are what you want to be returned by `key.get`.
 
 So, to overcome the above \[Arrow up\] problem one could define `key._scanMap` as
 
@@ -56,8 +60,8 @@ There is already a predefined scan map in the `key` module that covers certain s
 
 ## Scan map optimization
 
-In games, handling the user input is tipically a part of a game loop.
+In games, handling the user input is tipically a part of a game loop and thus needs to be fast.
 
-So, to make `key.get` a bit faster and avoid converting strings into code points on each frame, the scan map gets populated with optimized keys.
+To avoid converting strings into code points on each frame inside `key.get`, the scan map gets populated with optimized keys.
 
 This optimization happens on assignment to the `_scanMap` property via the `*AssignOverride` trick.

MiniScript-cpp/src/Key.cpp

@@ -3,9 +3,7 @@
 
 #if _WIN32 || _WIN64
 	#define WINDOWS 1
-	
-	// ...
-	
+	#include <conio.h>
 #else
 	#include <termios.h>
 	#include <unistd.h>
@@ -21,9 +19,13 @@ ValueDict& KeyDefaultScanMap() {
 	static ValueDict scanMap;
 	if (scanMap.Count() == 0) {
 		#if WINDOWS
-			
-			// ...
-			
+			scanMap.SetValue(83, "\x7F");   // delete
+			scanMap.SetValue(72, "\x13");   // up
+			scanMap.SetValue(80, "\x14");   // down
+			scanMap.SetValue(77, "\x12");   // right
+			scanMap.SetValue(75, "\x11");   // left
+			scanMap.SetValue(71, "\x01");   // home
+			scanMap.SetValue(79, "\x05");   // end
 		#else
 			scanMap.SetValue("\x7F", "\x08");     // backspace
 			scanMap.SetValue("\x1B[3~", "\x7F");  // delete
@@ -73,11 +75,17 @@ void KeyOptimizeScanMap(ValueDict& scanMap) {
 
 // Helper function to read all available characters from STDIN into the global input buffer.
 void slurpStdin() {
-	struct InputBufferEntry e = {0, 0};
-	
 	#if WINDOWS
 
-	// ...
+	while (_kbhit()) {
+		struct InputBufferEntry e = {0, 0};
+		e.c = _getwch();
+		if (e.c == 0 || e.c == 0xE0) {
+			e.c = 0;
+			e.scanCode = _getwch();
+		}
+		inputBuffer.push_back(e);
+	}
 
 	#else
 
@@ -106,6 +114,7 @@ void slurpStdin() {
 
 			// Nothing's left to slurp ; save to the input buffer a current unsaved character
 			if (p > buf) {
+				struct InputBufferEntry e = {0, 0};
 				e.c = UTF8Decode(buf);
 				inputBuffer.push_back(e);
 			}
@@ -117,6 +126,7 @@ void slurpStdin() {
 		if (p > buf && !IsUTF8IntraChar(*p)) {
 
 			// A new character has begun under `p`, save the previous one to the input buffer and continue slurping
+			struct InputBufferEntry e = {0, 0};
 			e.c = UTF8Decode(buf);
 			inputBuffer.push_back(e);
 			buf[0] = *p;
@@ -166,13 +176,14 @@ Value KeyGet(ValueDict& scanMap) {
 			break;	// malformed scan map
 		}
 	}
+	String s;
 	if (initialE.c == 0) {
-		Value v(initialE.scanCode);
-		return v;
+		s = "<" + String::Format(initialE.scanCode, "%d") + ">";
+	} else {
+		unsigned char buf[5] = {0, 0, 0, 0, 0};
+		long nBytes = UTF8Encode(initialE.c, buf);
+		s = String((char *)buf, nBytes);
 	}
-	unsigned char buf[5] = {0, 0, 0, 0, 0};
-	long nBytes = UTF8Encode(initialE.c, buf);
-	String s((char *)buf, nBytes);
 	Value v(s);
 	return v;
 }
@@ -213,7 +224,6 @@ void KeyClear() {
 bool KeyGetEcho() {
 	#if WINDOWS
 
-	// ...
 	return false;
 
 	#else
@@ -228,7 +238,7 @@ bool KeyGetEcho() {
 void KeySetEcho(bool on) {
 	#if WINDOWS
 
-	// ...
+	// no op
 
 	#else