Choice Zusatztool, ENTER und ESC? (Batch)

if exist "%systemroot%\syswow64\cmd.exe" (set "editv=EditV64.exe") else set "editv=EditV32.exe"  
%editv% foo

int *valid = (int*)malloc((argc - 1) * sizeof(int));

// getkey.c

#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <errno.h>
#include <conio.h>

// Struktur mit dem ursprünglich übergebenen Wert und dem Suchwert (der dem ASCII Wert des Kleinbuchstaben entspricht, wenn Groß-/Kleinschreibung ignoriert werden soll)
typedef struct tag_KEYINFO { int origin; int search; } KEYINFO;

// Funktion um Tastatureingabe in einen numerischen Wert zu konvertieren
int key(const int ignorecase)
{
  int ret = _getch();
  if (ret == 0 || ret == 224)
    return 256 + _getch();

  return (ignorecase != 0) ? tolower(ret) : ret;
}

// Funktion um 2 Werte zu vergleichen (für qsort() und bsearch())
int compare(const KEYINFO *a, const KEYINFO *b)
{
  return a->search - b->search;
}

// Einsprungfunktion des Programms
int main(int argc, char *argv)
{
  // Wenn kein Argument übergeben wurde, auf Tasatureingabe warten, Wert zurückgeben und Programm beenden
  if (argc == 1)
    return key(0);

  // anderenfalls ... feststellen, ob Option /i übergeben werden
  int ignorecase = 0;
  if (_stricmp(argv[1], "/i") == 0)  
  {
    if (argc < 3)
      return -1;

    ignorecase = 1;
  }

  KEYINFO *valid = NULL, *found = NULL, current = {0};
  int offset = 1 + ignorecase;
  if ((valid = (KEYINFO*)malloc((argc - offset) * sizeof(KEYINFO))) == NULL) // Speicher für die konvertierten Argumente reservieren
    return -1;

  // übergebene Argumente in numerische Werte konvertieren
  for (int i = offset; i < argc; ++i)
  {
    char *endptr = NULL;
    long conv = strtol(argv[i], &endptr, 0);
    if (errno || *endptr || conv < 1L || conv > 511L)
    {
      free(valid);
      return -1;
    }

    valid[i - offset].origin = (int)conv;
    valid[i - offset].search = (ignorecase != 0 && conv < 256L) ? tolower((int)conv) : (int)conv;
  }

  // Werte für eine effiziente Suche sortieren
  qsort(valid, argc - offset, sizeof(KEYINFO), (int(*)(const void*,const void*))compare);

  // in einer Schleife Tastatureingaben mit den übergebenen Werten vergleich
  do
  {
    current.search = key(ignorecase);
  } while ((found = (KEYINFO*)bsearch(&current, valid, argc - offset, sizeof(KEYINFO), (int(*)(const void*,const void*))compare)) == NULL); // iterieren, solange keine Übereinstimmung gefunden wurde

  int ret = found->origin; // Rückgabewert kopieren (bevor er durch free() invalid wird)
  free(valid); // reservierten Speicher freigeben
  return ret; // Wert zurückgeben und Programm beenden
}

@echo off &setlocal
echo y/Y oder n/N
getkey /i 89 78
echo %errorlevel%
pause

// getkey.c

#ifdef _WIN32_WINNT
# undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#define WIN32_LEAN_AND_MEAN
#define NOUSER
#define NOSERVICE
#define NOMCX
#define NOIME
#define NOKERNEL

#include <windows.h>
#include <locale.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <errno.h>
#include <conio.h>

// Struktur mit dem ursprünglich übergebenen Wert und dem Suchwert (der dem ASCII Wert des Kleinbuchstaben entspricht, wenn Groß-/Kleinschreibung ignoriert werden soll)
typedef struct tag_KEYINFO
{
  int origin;
  int search;
} KEYINFO;

// Struktur zur Verwendung als Argument für die Threadfunktion
typedef struct tag_THREADARG
{
  int ret; // Rückgabewert
  int ignorecase; // 1 wenn Groß-/Kleinschreibung ignoriert werden soll
  KEYINFO *valid; // konvertierte Werte
  size_t vlength; // Anzahl konvertierter Werte
} THREADARG;

// Funktion um 2 Werte zu vergleichen (für qsort() und bsearch())
int compare(const KEYINFO *a, const KEYINFO *b);
// Funktion um Tastatureingabe in einen numerischen Wert zu konvertieren
void key(THREADARG *const p_arg);
// Threadfunktion (gibt nur dann zurück, wenn eine Übereinstimmung zwischen Eingabe und Vorgabewerten gefunden wird)
DWORD WINAPI check(THREADARG *const p_arg);


// Einsprungfunktion des Programms
int main(int argc, char *argv)
{
  // Lacale-Einstellungen der Umgebung übernehemen
  setlocale(LC_ALL, "");  

  THREADARG t_arg = {0};

  // Wenn kein Argument übergeben wurde, auf Tasatureingabe warten, Wert zurückgeben und Programm beenden
  if (argc == 1)
  {
    key(&t_arg);
    return t_arg.ret;
  }

  // anderenfalls ...
  DWORD timeout = INFINITE;
  int offset = 1;
  char *endptr = NULL;
  long conv = 0L;

  // feststellen, ob Option /i oder /t übergeben wurde
  for (int i = 1; i < 3 && *argv[i] == '/'; ++i)  
  {
    if (_stricmp(argv[i], "/i") == 0)  
    {
      t_arg.ignorecase = 1;
      ++offset;
    }
    else if (_strnicmp(argv[i], "/t:", 3U) == 0)  
    {
      if (argv[i][3U] == '\0')  
        return -1;

      conv = strtol(&argv[i][3U], &endptr, 0);
      if (errno || *endptr || conv < 0L || conv > 9999L)
        return -1;

      ++offset;
      timeout = conv * 1000U;
    }

    if (argc < offset + 1)
      return -1;
  }

  t_arg.vlength = argc - offset;
  if ((t_arg.valid = (KEYINFO*)malloc(t_arg.vlength * sizeof(KEYINFO))) == NULL) // Speicher für die konvertierten Argumente reservieren
    return -1;

  // übergebene Argumente in numerische Werte konvertieren
  for (int i = offset; i < argc; ++i)
  {
    conv = strtol(argv[i], &endptr, 0);
    if (errno || *endptr || conv < 1L || conv > 65791L)
    {
      free(t_arg.valid);
      return -1;
    }

    t_arg.valid[i - offset].origin = (int)conv;
    t_arg.valid[i - offset].search = (t_arg.ignorecase != 0 && conv < 65536L) ? towlower((wint_t)conv) : (int)conv;
  }

  // Default-Rückgabewert, wenn der Thread timeout ist
  int defaultret = t_arg.valid.origin;

  // Werte für eine effiziente Suche sortieren
  qsort(t_arg.valid, argc - offset, sizeof(KEYINFO), (int(*)(const void*,const void*))compare);

  HANDLE t_handle = CreateThread(NULL, 0U, (LPTHREAD_START_ROUTINE)check, &t_arg, 0U, NULL); // Thread starten
  DWORD waitret  = WaitForSingleObject(t_handle, timeout); // 'timeout' Millisekunden auf Beenden des Threads warten 
  CloseHandle(t_handle); // Threadhandle schließen
  free(t_arg.valid); // reservierten Speicher freigeben

  return (waitret == 0U) ? t_arg.ret : defaultret; // Wert zurückgeben und Programm beenden
}


int compare(const KEYINFO *a, const KEYINFO *b)
{
  return a->search - b->search;
}


void key(THREADARG *const p_arg)
{
  int ret = _getwch();

  if (ret == 0 || ret == 224)
    p_arg->ret = 65536 + _getwch();
  else
     p_arg->ret = (p_arg->ignorecase != 0) ? towlower(ret) : ret;
}


DWORD WINAPI check(THREADARG *const p_arg)
{
  KEYINFO *found = NULL, current = {0};

  // in einer Schleife Tastatureingaben mit den übergebenen Werten vergleich
  do
  {
    key(p_arg);
    current.search = p_arg->ret;
  } while ((found = (KEYINFO*)bsearch(&current, p_arg->valid, p_arg->vlength, sizeof(KEYINFO), (int(*)(const void*,const void*))compare)) == NULL); // iterieren, solange keine Übereinstimmung gefunden wurde

  p_arg->ret = found->origin;
  return 0U;
}

getkey [/i] [/t:s] [x1 [x2 [...xn]]]
  /i       Ignoriere Groß-/Kleinschreibung
  /t:s     Timeout nach s Sekunden, x1 wird als Default zurückgegeben
  x1...xn  Zugehörige Werte für die gültigen Tastatureingaben:
           Unicode Code Point des Zeichens oder
           (65536 + Scancode) für Tasten die kein Zeichen spezifizieren

Rückgabewert:
* bei Fehler -1
* wenn kein Wert spezifiziert wurde, der Wert einer beliebigen Tastatureingabe
* wenn Werte spezifiziert wurden, zugehöriger Wert zur Tastatureingabe
* bei Timeout, erster übergebener Wert

Pfeil rechts (65536 + Scancode 77) 65613
Pfeil links  (65536 + Scancode 75) 65611
Pfeil oben   (65536 + Scancode 72) 65608
Pfeil unten  (65536 + Scancode 80) 65616