lib/linenoise-ng/linenoise.cpp

/* linenoise.c -- guerrilla line editing library against the idea that a
 * line editing lib needs to be 20,000 lines of C code.
 *
 * Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
 * Copyright (c) 2010, Pieter Noordhuis <pcnoordhuis at gmail dot com>
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the name of Redis nor the names of its contributors may be used
 *     to endorse or promote products derived from this software without
 *     specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * line editing lib needs to be 20,000 lines of C code.
 *
 * You can find the latest source code at:
 *
 *   http://github.com/antirez/linenoise
 *
 * Does a number of crazy assumptions that happen to be true in 99.9999% of
 * the 2010 UNIX computers around.
 *
 * References:
 * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
 * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
 *
 * Todo list:
 * - Switch to gets() if $TERM is something we can't support.
 * - Filter bogus Ctrl+<char> combinations.
 * - Win32 support
 *
 * Bloat:
 * - Completion?
 * - History search like Ctrl+r in readline?
 *
 * List of escape sequences used by this program, we do everything just
 * with three sequences. In order to be so cheap we may have some
 * flickering effect with some slow terminal, but the lesser sequences
 * the more compatible.
 *
 * CHA (Cursor Horizontal Absolute)
 *    Sequence: ESC [ n G
 *    Effect: moves cursor to column n (1 based)
 *
 * EL (Erase Line)
 *    Sequence: ESC [ n K
 *    Effect: if n is 0 or missing, clear from cursor to end of line
 *    Effect: if n is 1, clear from beginning of line to cursor
 *    Effect: if n is 2, clear entire line
 *
 * CUF (Cursor Forward)
 *    Sequence: ESC [ n C
 *    Effect: moves cursor forward of n chars
 *
 * The following are used to clear the screen: ESC [ H ESC [ 2 J
 * This is actually composed of two sequences:
 *
 * cursorhome
 *    Sequence: ESC [ H
 *    Effect: moves the cursor to upper left corner
 *
 * ED2 (Clear entire screen)
 *    Sequence: ESC [ 2 J
 *    Effect: clear the whole screen
 *
 */

#ifdef _WIN32

#include <conio.h>
#include <windows.h>
#include <io.h>

#if defined(_MSC_VER) && _MSC_VER < 1900
#define snprintf _snprintf  // Microsoft headers use underscores in some names
#endif

typedef unsigned char uc;

static const unsigned char charmap[] = {
	(uc)'\000',(uc)'\001',(uc)'\002',(uc)'\003',(uc)'\004',(uc)'\005',(uc)'\006',(uc)'\007',
	(uc)'\010',(uc)'\011',(uc)'\012',(uc)'\013',(uc)'\014',(uc)'\015',(uc)'\016',(uc)'\017',
	(uc)'\020',(uc)'\021',(uc)'\022',(uc)'\023',(uc)'\024',(uc)'\025',(uc)'\026',(uc)'\027',
	(uc)'\030',(uc)'\031',(uc)'\032',(uc)'\033',(uc)'\034',(uc)'\035',(uc)'\036',(uc)'\037',
	(uc)'\040',(uc)'\041',(uc)'\042',(uc)'\043',(uc)'\044',(uc)'\045',(uc)'\046',(uc)'\047',
	(uc)'\050',(uc)'\051',(uc)'\052',(uc)'\053',(uc)'\054',(uc)'\055',(uc)'\056',(uc)'\057',
	(uc)'\060',(uc)'\061',(uc)'\062',(uc)'\063',(uc)'\064',(uc)'\065',(uc)'\066',(uc)'\067',
	(uc)'\070',(uc)'\071',(uc)'\072',(uc)'\073',(uc)'\074',(uc)'\075',(uc)'\076',(uc)'\077',
	(uc)'\100',(uc)'\141',(uc)'\142',(uc)'\143',(uc)'\144',(uc)'\145',(uc)'\146',(uc)'\147',
	(uc)'\150',(uc)'\151',(uc)'\152',(uc)'\153',(uc)'\154',(uc)'\155',(uc)'\156',(uc)'\157',
	(uc)'\160',(uc)'\161',(uc)'\162',(uc)'\163',(uc)'\164',(uc)'\165',(uc)'\166',(uc)'\167',
	(uc)'\170',(uc)'\171',(uc)'\172',(uc)'\133',(uc)'\134',(uc)'\135',(uc)'\136',(uc)'\137',
	(uc)'\140',(uc)'\141',(uc)'\142',(uc)'\143',(uc)'\144',(uc)'\145',(uc)'\146',(uc)'\147',
	(uc)'\150',(uc)'\151',(uc)'\152',(uc)'\153',(uc)'\154',(uc)'\155',(uc)'\156',(uc)'\157',
	(uc)'\160',(uc)'\161',(uc)'\162',(uc)'\163',(uc)'\164',(uc)'\165',(uc)'\166',(uc)'\167',
	(uc)'\170',(uc)'\171',(uc)'\172',(uc)'\173',(uc)'\174',(uc)'\175',(uc)'\176',(uc)'\177',
	(uc)'\200',(uc)'\201',(uc)'\202',(uc)'\203',(uc)'\204',(uc)'\205',(uc)'\206',(uc)'\207',
	(uc)'\210',(uc)'\211',(uc)'\212',(uc)'\213',(uc)'\214',(uc)'\215',(uc)'\216',(uc)'\217',
	(uc)'\220',(uc)'\221',(uc)'\222',(uc)'\223',(uc)'\224',(uc)'\225',(uc)'\226',(uc)'\227',
	(uc)'\230',(uc)'\231',(uc)'\232',(uc)'\233',(uc)'\234',(uc)'\235',(uc)'\236',(uc)'\237',
	(uc)'\240',(uc)'\241',(uc)'\242',(uc)'\243',(uc)'\244',(uc)'\245',(uc)'\246',(uc)'\247',
	(uc)'\250',(uc)'\251',(uc)'\252',(uc)'\253',(uc)'\254',(uc)'\255',(uc)'\256',(uc)'\257',
	(uc)'\260',(uc)'\261',(uc)'\262',(uc)'\263',(uc)'\264',(uc)'\265',(uc)'\266',(uc)'\267',
	(uc)'\270',(uc)'\271',(uc)'\272',(uc)'\273',(uc)'\274',(uc)'\275',(uc)'\276',(uc)'\277',
	(uc)'\300',(uc)'\341',(uc)'\342',(uc)'\343',(uc)'\344',(uc)'\345',(uc)'\346',(uc)'\347',
	(uc)'\350',(uc)'\351',(uc)'\352',(uc)'\353',(uc)'\354',(uc)'\355',(uc)'\356',(uc)'\357',
	(uc)'\360',(uc)'\361',(uc)'\362',(uc)'\363',(uc)'\364',(uc)'\365',(uc)'\366',(uc)'\367',
	(uc)'\370',(uc)'\371',(uc)'\372',(uc)'\333',(uc)'\334',(uc)'\335',(uc)'\336',(uc)'\337',
	(uc)'\340',(uc)'\341',(uc)'\342',(uc)'\343',(uc)'\344',(uc)'\345',(uc)'\346',(uc)'\347',
	(uc)'\350',(uc)'\351',(uc)'\352',(uc)'\353',(uc)'\354',(uc)'\355',(uc)'\356',(uc)'\357',
	(uc)'\360',(uc)'\361',(uc)'\362',(uc)'\363',(uc)'\364',(uc)'\365',(uc)'\366',(uc)'\367',
	(uc)'\370',(uc)'\371',(uc)'\372',(uc)'\373',(uc)'\374',(uc)'\375',(uc)'\376',(uc)'\377',
};

static int ln_strcasecmp(const char *s1, const char *s2)
{
    unsigned char u1, u2;

    for (;;) {
        u1 = (unsigned char)*s1++;
        u2 = (unsigned char) *s2++;
        if (charmap[u1] != charmap[u2]) {
            return charmap[u1] - charmap[u2];
        }
        if (u1 == '\0') {
            return 0;
        }
    }
}

static char *ln_strdup(const char *s)
{
    size_t len = strlen(s) + 1;
    char *result = (char*)malloc(len);
    if (result == (char*)0) {
        return (char*)0;
    }
    return (char*)memcpy (result, s, len);
}

#define strcasecmp ln_strcasecmp
#define strdup ln_strdup
#define isatty _isatty
#define write _write
#define STDIN_FILENO 0

#else /* _WIN32 */

#include <signal.h>
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <cctype>
#include <wctype.h>

#endif /* _WIN32 */

#include <stdio.h>
#include <errno.h>
#include <fcntl.h>

#include "linenoise.h"
#include "ConvertUTF.h"

#include <string>
#include <vector>
#include <memory>

using std::string;
using std::vector;
using std::unique_ptr;
using namespace linenoise_ng;

typedef unsigned char char8_t;

static ConversionResult copyString8to32(char32_t* dst, size_t dstSize,
                                        size_t& dstCount, const char* src) {
  const UTF8* sourceStart = reinterpret_cast<const UTF8*>(src);
  const UTF8* sourceEnd = sourceStart + strlen(src);
  UTF32* targetStart = reinterpret_cast<UTF32*>(dst);
  UTF32* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF8toUTF32(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    dstCount = targetStart - reinterpret_cast<UTF32*>(dst);

    if (dstCount < dstSize) {
      *targetStart = 0;
    }
  }

  return res;
}

static ConversionResult copyString8to32(char32_t* dst, size_t dstSize,
                                        size_t& dstCount, const char8_t* src) {
  return copyString8to32(dst, dstSize, dstCount,
                         reinterpret_cast<const char*>(src));
}

static size_t strlen32(const char32_t* str) {
  const char32_t* ptr = str;

  while (*ptr) {
    ++ptr;
  }

  return ptr - str;
}

static size_t strlen8(const char8_t* str) {
  return strlen(reinterpret_cast<const char*>(str));
}

static char8_t* strdup8(const char* src) {
  return reinterpret_cast<char8_t*>(strdup(src));
}

#ifdef _WIN32
static const int FOREGROUND_WHITE =
    FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
static const int BACKGROUND_WHITE =
    BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
static const int INTENSITY = FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;

class WinAttributes {
 public:
  WinAttributes() {
    CONSOLE_SCREEN_BUFFER_INFO info;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
    _defaultAttribute = info.wAttributes & INTENSITY;
    _defaultColor = info.wAttributes & FOREGROUND_WHITE;
    _defaultBackground = info.wAttributes & BACKGROUND_WHITE;

    _consoleAttribute = _defaultAttribute;
    _consoleColor = _defaultColor | _defaultBackground;
  }

 public:
  int _defaultAttribute;
  int _defaultColor;
  int _defaultBackground;

  int _consoleAttribute;
  int _consoleColor;
};

static WinAttributes WIN_ATTR;

static void copyString32to16(char16_t* dst, size_t dstSize, size_t* dstCount,
                             const char32_t* src, size_t srcSize) {
  const UTF32* sourceStart = reinterpret_cast<const UTF32*>(src);
  const UTF32* sourceEnd = sourceStart + srcSize;
  char16_t* targetStart = reinterpret_cast<char16_t*>(dst);
  char16_t* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF32toUTF16(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    *dstCount = targetStart - reinterpret_cast<char16_t*>(dst);

    if (*dstCount < dstSize) {
      *targetStart = 0;
    }
  }
}
#endif

static void copyString32to8(char* dst, size_t dstSize, size_t* dstCount,
                            const char32_t* src, size_t srcSize) {
  const UTF32* sourceStart = reinterpret_cast<const UTF32*>(src);
  const UTF32* sourceEnd = sourceStart + srcSize;
  UTF8* targetStart = reinterpret_cast<UTF8*>(dst);
  UTF8* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF32toUTF8(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    *dstCount = targetStart - reinterpret_cast<UTF8*>(dst);

    if (*dstCount < dstSize) {
      *targetStart = 0;
    }
  }
}

static void copyString32to8(char* dst, size_t dstLen, const char32_t* src) {
  size_t dstCount = 0;
  copyString32to8(dst, dstLen, &dstCount, src, strlen32(src));
}

static void copyString32(char32_t* dst, const char32_t* src, size_t len) {
  while (0 < len && *src) {
    *dst++ = *src++;
    --len;
  }

  *dst = 0;
}

static int strncmp32(const char32_t* left, const char32_t* right, size_t len) {
  while (0 < len && *left) {
    if (*left != *right) {
      return *left - *right;
    }

    ++left;
    ++right;
    --len;
  }

  return 0;
}

#ifdef _WIN32
#include <iostream>

static size_t OutputWin(char16_t* text16, char32_t* text32, size_t len32) {
  size_t count16 = 0;

  copyString32to16(text16, len32, &count16, text32, len32);
  WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), text16,
                static_cast<DWORD>(count16), nullptr, nullptr);

  return count16;
}

static char32_t* HandleEsc(char32_t* p, char32_t* end) {
  if (*p == '[') {
    int code = 0;

    for (++p; p < end; ++p) {
      char32_t c = *p;

      if ('0' <= c && c <= '9') {
        code = code * 10 + (c - '0');
      } else if (c == 'm' || c == ';') {
        switch (code) {
          case 0:
            WIN_ATTR._consoleAttribute = WIN_ATTR._defaultAttribute;
            WIN_ATTR._consoleColor =
                WIN_ATTR._defaultColor | WIN_ATTR._defaultBackground;
            break;

          case 1:  // BOLD
          case 5:  // BLINK
            WIN_ATTR._consoleAttribute =
                (WIN_ATTR._defaultAttribute ^ FOREGROUND_INTENSITY) & INTENSITY;
            break;

          case 30:
            WIN_ATTR._consoleColor = BACKGROUND_WHITE;
            break;

          case 31:
            WIN_ATTR._consoleColor =
                FOREGROUND_RED | WIN_ATTR._defaultBackground;
            break;

          case 32:
            WIN_ATTR._consoleColor =
                FOREGROUND_GREEN | WIN_ATTR._defaultBackground;
            break;

          case 33:
            WIN_ATTR._consoleColor =
                FOREGROUND_RED | FOREGROUND_GREEN | WIN_ATTR._defaultBackground;
            break;

          case 34:
            WIN_ATTR._consoleColor =
                FOREGROUND_BLUE | WIN_ATTR._defaultBackground;
            break;

          case 35:
            WIN_ATTR._consoleColor =
                FOREGROUND_BLUE | FOREGROUND_RED | WIN_ATTR._defaultBackground;
            break;

          case 36:
            WIN_ATTR._consoleColor = FOREGROUND_BLUE | FOREGROUND_GREEN |
                                     WIN_ATTR._defaultBackground;
            break;

          case 37:
            WIN_ATTR._consoleColor = FOREGROUND_GREEN | FOREGROUND_RED |
                                     FOREGROUND_BLUE |
                                     WIN_ATTR._defaultBackground;
            break;
        }

        code = 0;
      }

      if (*p == 'm') {
        ++p;
        break;
      }
    }
  } else {
    ++p;
  }

  auto handle = GetStdHandle(STD_OUTPUT_HANDLE);
  SetConsoleTextAttribute(handle,
                          WIN_ATTR._consoleAttribute | WIN_ATTR._consoleColor);

  return p;
}

static size_t WinWrite32(char16_t* text16, char32_t* text32, size_t len32) {
  char32_t* p = text32;
  char32_t* q = p;
  char32_t* e = text32 + len32;
  size_t count16 = 0;

  while (p < e) {
    if (*p == 27) {
      if (q < p) {
        count16 += OutputWin(text16, q, p - q);
      }

      q = p = HandleEsc(p + 1, e);
    } else {
      ++p;
    }
  }

  if (q < p) {
    count16 += OutputWin(text16, q, p - q);
  }

  return count16;
}
#endif

static int write32(int fd, char32_t* text32, int len32) {
#ifdef _WIN32
  if (isatty(fd)) {
    size_t len16 = 2 * len32 + 1;
    unique_ptr<char16_t[]> text16(new char16_t[len16]);
    size_t count16 = WinWrite32(text16.get(), text32, len32);

    return static_cast<int>(count16);
  } else {
    size_t len8 = 4 * len32 + 1;
    unique_ptr<char[]> text8(new char[len8]);
    size_t count8 = 0;

    copyString32to8(text8.get(), len8, &count8, text32, len32);

    return write(fd, text8.get(), static_cast<unsigned int>(count8));
  }
#else
  size_t len8 = 4 * len32 + 1;
  unique_ptr<char[]> text8(new char[len8]);
  size_t count8 = 0;

  copyString32to8(text8.get(), len8, &count8, text32, len32);

  /* Compyx, 2020-07-24: fix -Wshorten-64-to-32 warning
   *
   * Do not ask me if this clean C++ or whatever, just shutting up the compiler
   * at this point.
   */
  return (int)write(fd, text8.get(), count8);
#endif
}

class Utf32String {
 public:
  Utf32String() : _length(0), _data(nullptr) {
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[1]();
  }

  explicit Utf32String(const char* src) : _length(0), _data(nullptr) {
    size_t len = strlen(src);
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[len + 1]();
    copyString8to32(_data, len + 1, _length, src);
  }

  explicit Utf32String(const char8_t* src) : _length(0), _data(nullptr) {
    size_t len = strlen(reinterpret_cast<const char*>(src));
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[len + 1]();
    copyString8to32(_data, len + 1, _length, src);
  }

  explicit Utf32String(const char32_t* src) : _length(0), _data(nullptr) {
    for (_length = 0; src[_length] != 0; ++_length) {
    }

    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[_length + 1]();
    memcpy(_data, src, _length * sizeof(char32_t));
  }

  explicit Utf32String(const char32_t* src, int len) : _length(len), _data(nullptr) {
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[len + 1]();
    memcpy(_data, src, len * sizeof(char32_t));
  }

  explicit Utf32String(int len) : _length(0), _data(nullptr) {
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[len]();
  }

  explicit Utf32String(const Utf32String& that) : _length(that._length), _data(nullptr) {
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[_length + 1]();
    memcpy(_data, that._data, sizeof(char32_t) * _length);
  }

  Utf32String& operator=(const Utf32String& that) {
    if (this != &that) {
      delete[] _data;
      _data = new char32_t[that._length]();
      _length = that._length;
      memcpy(_data, that._data, sizeof(char32_t) * _length);
    }

    return *this;
  }

  ~Utf32String() { delete[] _data; }

 public:
  char32_t* get() const { return _data; }

  size_t length() const { return _length; }

  size_t chars() const { return _length; }

  void initFromBuffer() {
    for (_length = 0; _data[_length] != 0; ++_length) {
    }
  }

  const char32_t& operator[](size_t pos) const { return _data[pos]; }

  char32_t& operator[](size_t pos) { return _data[pos]; }

 private:
  size_t _length;
  char32_t* _data;
};

class Utf8String {
  Utf8String(const Utf8String&) = delete;
  Utf8String& operator=(const Utf8String&) = delete;

 public:
  explicit Utf8String(const Utf32String& src) {
    size_t len = src.length() * 4 + 1;
    _data = new char[len];
    copyString32to8(_data, len, src.get());
  }

  ~Utf8String() { delete[] _data; }

 public:
  char* get() const { return _data; }

 private:
  char* _data;
};

struct linenoiseCompletions {
  vector<Utf32String> completionStrings;
};

#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
#define LINENOISE_MAX_LINE 4096

// make control-characters more readable
#define ctrlChar(upperCaseASCII) (upperCaseASCII - 0x40)

/**
 * Recompute widths of all characters in a char32_t buffer
 * @param text          input buffer of Unicode characters
 * @param widths        output buffer of character widths
 * @param charCount     number of characters in buffer
 */
namespace linenoise_ng {
int mk_wcwidth(char32_t ucs);
}

static void recomputeCharacterWidths(const char32_t* text, char* widths,
                                     int charCount) {
  for (int i = 0; i < charCount; ++i) {
    widths[i] = mk_wcwidth(text[i]);
  }
}

/**
 * Calculate a new screen position given a starting position, screen width and
 * character count
 * @param x             initial x position (zero-based)
 * @param y             initial y position (zero-based)
 * @param screenColumns screen column count
 * @param charCount     character positions to advance
 * @param xOut          returned x position (zero-based)
 * @param yOut          returned y position (zero-based)
 */
static void calculateScreenPosition(int x, int y, int screenColumns,
                                    int charCount, int& xOut, int& yOut) {
  xOut = x;
  yOut = y;
  int charsRemaining = charCount;
  while (charsRemaining > 0) {
    int charsThisRow = (x + charsRemaining < screenColumns) ? charsRemaining
                                                            : screenColumns - x;
    xOut = x + charsThisRow;
    yOut = y;
    charsRemaining -= charsThisRow;
    x = 0;
    ++y;
  }
  if (xOut == screenColumns) {  // we have to special-case line wrap
    xOut = 0;
    ++yOut;
  }
}

/**
 * Calculate a column width using mk_wcswidth()
 * @param buf32  text to calculate
 * @param len    length of text to calculate
 */
namespace linenoise_ng {
int mk_wcswidth(const char32_t* pwcs, size_t n);
}

static int calculateColumnPosition(char32_t* buf32, int len) {
  int width = mk_wcswidth(reinterpret_cast<const char32_t*>(buf32), len);
  if (width == -1)
    return len;
  else
    return width;
}

static bool isControlChar(char32_t testChar) {
  return (testChar < ' ') ||                      // C0 controls
         (testChar >= 0x7F && testChar <= 0x9F);  // DEL and C1 controls
}

struct PromptBase {            // a convenience struct for grouping prompt info
  Utf32String promptText;      // our copy of the prompt text, edited
  char* promptCharWidths;      // character widths from mk_wcwidth()
  int promptChars;             // chars in promptText
  int promptBytes;             // bytes in promptText
  int promptExtraLines;        // extra lines (beyond 1) occupied by prompt
  int promptIndentation;       // column offset to end of prompt
  int promptLastLinePosition;  // index into promptText where last line begins
  int promptPreviousInputLen;  // promptChars of previous input line, for
                               // clearing
  int promptCursorRowOffset;   // where the cursor is relative to the start of
                               // the prompt
  int promptScreenColumns;     // width of screen in columns
  int promptPreviousLen;       // help erasing
  int promptErrorCode;         // error code (invalid UTF-8) or zero

  PromptBase() : promptPreviousInputLen(0) {}

  bool write() {
    if (write32(1, promptText.get(), promptBytes) == -1) return false;

    return true;
  }
};

struct PromptInfo : public PromptBase {
  PromptInfo(const char* textPtr, int columns) {
    promptExtraLines = 0;
    promptLastLinePosition = 0;
    promptPreviousLen = 0;
    promptScreenColumns = columns;
    Utf32String tempUnicode(textPtr);

    // strip control characters from the prompt -- we do allow newline
    char32_t* pIn = tempUnicode.get();
    char32_t* pOut = pIn;

    int len = 0;
    int x = 0;

    bool const strip = (isatty(1) == 0);

    while (*pIn) {
      char32_t c = *pIn;
      if ('\n' == c || !isControlChar(c)) {
        *pOut = c;
        ++pOut;
        ++pIn;
        ++len;
        if ('\n' == c || ++x >= promptScreenColumns) {
          x = 0;
          ++promptExtraLines;
          promptLastLinePosition = len;
        }
      } else if (c == '\x1b') {
        if (strip) {
          // jump over control chars
          ++pIn;
          if (*pIn == '[') {
            ++pIn;
            while (*pIn && ((*pIn == ';') || ((*pIn >= '0' && *pIn <= '9')))) {
              ++pIn;
            }
            if (*pIn == 'm') {
              ++pIn;
            }
          }
        } else {
          // copy control chars
          *pOut = *pIn;
          ++pOut;
          ++pIn;
          if (*pIn == '[') {
            *pOut = *pIn;
            ++pOut;
            ++pIn;
            while (*pIn && ((*pIn == ';') || ((*pIn >= '0' && *pIn <= '9')))) {
              *pOut = *pIn;
              ++pOut;
              ++pIn;
            }
            if (*pIn == 'm') {
              *pOut = *pIn;
              ++pOut;
              ++pIn;
            }
          }
        }
      } else {
        ++pIn;
      }
    }
    *pOut = 0;
    promptChars = len;
    promptBytes = static_cast<int>(pOut - tempUnicode.get());
    promptText = tempUnicode;

    promptIndentation = len - promptLastLinePosition;
    promptCursorRowOffset = promptExtraLines;
  }
};

// Used with DynamicPrompt (history search)
//
static const Utf32String forwardSearchBasePrompt("(i-search)`");
static const Utf32String reverseSearchBasePrompt("(reverse-i-search)`");
static const Utf32String endSearchBasePrompt("': ");
static Utf32String
    previousSearchText;  // remembered across invocations of linenoise()

// changing prompt for "(reverse-i-search)`text':" etc.
//
struct DynamicPrompt : public PromptBase {
  Utf32String searchText;  // text we are searching for
  char* searchCharWidths;  // character widths from mk_wcwidth()
  int searchTextLen;       // chars in searchText
  int direction;           // current search direction, 1=forward, -1=reverse

  DynamicPrompt(PromptBase& pi, int initialDirection)
      : searchTextLen(0), direction(initialDirection) {
    promptScreenColumns = pi.promptScreenColumns;
    promptCursorRowOffset = 0;
    Utf32String emptyString(1);
    searchText = emptyString;
    const Utf32String* basePrompt =
        (direction > 0) ? &forwardSearchBasePrompt : &reverseSearchBasePrompt;
    size_t promptStartLength = basePrompt->length();
    promptChars =
        static_cast<int>(promptStartLength + endSearchBasePrompt.length());
    promptBytes = promptChars;
    promptLastLinePosition = promptChars;  // TODO fix this, we are asssuming
                                           // that the history prompt won't wrap
                                           // (!)
    promptPreviousLen = promptChars;
    Utf32String tempUnicode(promptChars + 1);
    memcpy(tempUnicode.get(), basePrompt->get(),
           sizeof(char32_t) * promptStartLength);
    memcpy(&tempUnicode[promptStartLength], endSearchBasePrompt.get(),
           sizeof(char32_t) * (endSearchBasePrompt.length() + 1));
    tempUnicode.initFromBuffer();
    promptText = tempUnicode;
    calculateScreenPosition(0, 0, pi.promptScreenColumns, promptChars,
                            promptIndentation, promptExtraLines);
  }

  void updateSearchPrompt(void) {
    const Utf32String* basePrompt =
        (direction > 0) ? &forwardSearchBasePrompt : &reverseSearchBasePrompt;
    size_t promptStartLength = basePrompt->length();
    promptChars = static_cast<int>(promptStartLength + searchTextLen +
                                   endSearchBasePrompt.length());
    promptBytes = promptChars;
    Utf32String tempUnicode(promptChars + 1);
    memcpy(tempUnicode.get(), basePrompt->get(),
           sizeof(char32_t) * promptStartLength);
    memcpy(&tempUnicode[promptStartLength], searchText.get(),
           sizeof(char32_t) * searchTextLen);
    size_t endIndex = promptStartLength + searchTextLen;
    memcpy(&tempUnicode[endIndex], endSearchBasePrompt.get(),
           sizeof(char32_t) * (endSearchBasePrompt.length() + 1));
    tempUnicode.initFromBuffer();
    promptText = tempUnicode;
  }

  void updateSearchText(const char32_t* textPtr) {
    Utf32String tempUnicode(textPtr);
    searchTextLen = static_cast<int>(tempUnicode.chars());
    searchText = tempUnicode;
    updateSearchPrompt();
  }
};

class KillRing {
  static const int capacity = 10;
  int size;
  int index;
  char indexToSlot[10];
  vector<Utf32String> theRing;

 public:
  enum action { actionOther, actionKill, actionYank };
  action lastAction;
  size_t lastYankSize;

  KillRing() : size(0), index(0), lastAction(actionOther) {
    theRing.reserve(capacity);
  }

  void kill(const char32_t* text, int textLen, bool forward) {
    if (textLen == 0) {
      return;
    }
    Utf32String killedText(text, textLen);
    if (lastAction == actionKill && size > 0) {
      int slot = indexToSlot[0];
      int currentLen = static_cast<int>(theRing[slot].length());
      int resultLen = currentLen + textLen;
      Utf32String temp(resultLen + 1);
      if (forward) {
        memcpy(temp.get(), theRing[slot].get(), currentLen * sizeof(char32_t));
        memcpy(&temp[currentLen], killedText.get(), textLen * sizeof(char32_t));
      } else {
        memcpy(temp.get(), killedText.get(), textLen * sizeof(char32_t));
        memcpy(&temp[textLen], theRing[slot].get(),
               currentLen * sizeof(char32_t));
      }
      temp[resultLen] = 0;
      temp.initFromBuffer();
      theRing[slot] = temp;
    } else {
      if (size < capacity) {
        if (size > 0) {
          memmove(&indexToSlot[1], &indexToSlot[0], size);
        }
        indexToSlot[0] = size;
        size++;
        theRing.push_back(killedText);
      } else {
        int slot = indexToSlot[capacity - 1];
        theRing[slot] = killedText;
        memmove(&indexToSlot[1], &indexToSlot[0], capacity - 1);
        indexToSlot[0] = slot;
      }
      index = 0;
    }
  }

  Utf32String* yank() { return (size > 0) ? &theRing[indexToSlot[index]] : 0; }

  Utf32String* yankPop() {
    if (size == 0) {
      return 0;
    }
    ++index;
    if (index == size) {
      index = 0;
    }
    return &theRing[indexToSlot[index]];
  }
};

class InputBuffer {
  char32_t* buf32;   // input buffer
  char* charWidths;  // character widths from mk_wcwidth()
  int buflen;        // buffer size in characters
  int len;           // length of text in input buffer
  int pos;           // character position in buffer ( 0 <= pos <= len )

  void clearScreen(PromptBase& pi);
  int incrementalHistorySearch(PromptBase& pi, int startChar);
  int completeLine(PromptBase& pi);
  void refreshLine(PromptBase& pi);

 public:
  InputBuffer(char32_t* buffer, char* widthArray, int bufferLen)
      : buf32(buffer),
        charWidths(widthArray),
        buflen(bufferLen - 1),
        len(0),
        pos(0) {
    buf32[0] = 0;
  }
  void preloadBuffer(const char* preloadText) {
    size_t ucharCount = 0;
    copyString8to32(buf32, buflen + 1, ucharCount, preloadText);
    recomputeCharacterWidths(buf32, charWidths, static_cast<int>(ucharCount));
    len = static_cast<int>(ucharCount);
    pos = static_cast<int>(ucharCount);
  }
  int getInputLine(PromptBase& pi);
  int length(void) const { return len; }
};

// Special codes for keyboard input:
//
// Between Windows and the various Linux "terminal" programs, there is some
// pretty diverse behavior in the "scan codes" and escape sequences we are
// presented with.  So ... we'll translate them all into our own pidgin
// pseudocode, trying to stay out of the way of UTF-8 and international
// characters.  Here's the general plan.
//
// "User input keystrokes" (key chords, whatever) will be encoded as a single
// value.
// The low 21 bits are reserved for Unicode characters.  Popular function-type
// keys
// get their own codes in the range 0x10200000 to (if needed) 0x1FE00000,
// currently
// just arrow keys, Home, End and Delete.  Keypresses with Ctrl get ORed with
// 0x20000000, with Alt get ORed with 0x40000000.  So, Ctrl+Alt+Home is encoded
// as 0x20000000 + 0x40000000 + 0x10A00000 == 0x70A00000.  To keep things
// complicated,
// the Alt key is equivalent to prefixing the keystroke with ESC, so ESC
// followed by
// D is treated the same as Alt + D ... we'll just use Emacs terminology and
// call
// this "Meta".  So, we will encode both ESC followed by D and Alt held down
// while D
// is pressed the same, as Meta-D, encoded as 0x40000064.
//
// Here are the definitions of our component constants:
//
// Maximum unsigned 32-bit value    = 0xFFFFFFFF;   // For reference, max 32-bit
// value
// Highest allocated Unicode char   = 0x001FFFFF;   // For reference, max
// Unicode value
static const int META = 0x40000000;  // Meta key combination
static const int CTRL = 0x20000000;  // Ctrl key combination
// static const int SPECIAL_KEY = 0x10000000;   // Common bit for all special
// keys
static const int UP_ARROW_KEY = 0x10200000;  // Special keys
static const int DOWN_ARROW_KEY = 0x10400000;
static const int RIGHT_ARROW_KEY = 0x10600000;
static const int LEFT_ARROW_KEY = 0x10800000;
static const int HOME_KEY = 0x10A00000;
static const int END_KEY = 0x10C00000;
static const int DELETE_KEY = 0x10E00000;
static const int PAGE_UP_KEY = 0x11000000;
static const int PAGE_DOWN_KEY = 0x11200000;

static const char* unsupported_term[] = {"dumb", "cons25", "emacs", NULL};
static linenoiseCompletionCallback* completionCallback = NULL;

#ifdef _WIN32
static HANDLE console_in, console_out;
static DWORD oldMode;
static WORD oldDisplayAttribute;
#else
static struct termios orig_termios; /* in order to restore at exit */
#endif

static KillRing killRing;

static int rawmode = 0; /* for atexit() function to check if restore is needed*/
static int atexit_registered = 0; /* register atexit just 1 time */
static int historyMaxLen = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
static int historyLen = 0;
static int historyIndex = 0;
static char8_t** history = NULL;

// used to emulate Windows command prompt on down-arrow after a recall
// we use -2 as our "not set" value because we add 1 to the previous index on
// down-arrow,
// and zero is a valid index (so -1 is a valid "previous index")
static int historyPreviousIndex = -2;
static bool historyRecallMostRecent = false;

#ifndef _WIN32
static void linenoiseAtExit(void);
#endif

static bool isUnsupportedTerm(void) {
  char* term = getenv("TERM");
  if (term == NULL) return false;
  for (int j = 0; unsupported_term[j]; ++j)
    if (!strcasecmp(term, unsupported_term[j])) {
      return true;
    }
  return false;
}

static void beep() {
  fprintf(stderr, "\x7");  // ctrl-G == bell/beep
  fflush(stderr);
}

void linenoiseHistoryFree(void) {
  if (history) {
    for (int j = 0; j < historyLen; ++j) free(history[j]);
    historyLen = 0;
    free(history);
    history = 0;
  }
}

static int enableRawMode(void) {
#ifdef _WIN32
  if (!console_in) {
    console_in = GetStdHandle(STD_INPUT_HANDLE);
    console_out = GetStdHandle(STD_OUTPUT_HANDLE);

    GetConsoleMode(console_in, &oldMode);
    SetConsoleMode(console_in, oldMode &
                                   ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT |
                                     ENABLE_PROCESSED_INPUT));
  }
  return 0;
#else
  struct termios raw;

  if (!isatty(STDIN_FILENO)) goto fatal;
  if (!atexit_registered) {
    atexit(linenoiseAtExit);
    atexit_registered = 1;
  }
  if (tcgetattr(0, &orig_termios) == -1) goto fatal;

  raw = orig_termios; /* modify the original mode */
  /* input modes: no break, no CR to NL, no parity check, no strip char,
   * no start/stop output control. */
  raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
  /* output modes - disable post processing */
  // this is wrong, we don't want raw output, it turns newlines into straight
  // linefeeds
  // raw.c_oflag &= ~(OPOST);
  /* control modes - set 8 bit chars */
  raw.c_cflag |= (CS8);
  /* local modes - echoing off, canonical off, no extended functions,
   * no signal chars (^Z,^C) */
  raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
  /* control chars - set return condition: min number of bytes and timer.
   * We want read to return every single byte, without timeout. */
  raw.c_cc[VMIN] = 1;
  raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

  /* put terminal in raw mode after flushing */
  if (tcsetattr(0, TCSADRAIN, &raw) < 0) goto fatal;
  rawmode = 1;
  return 0;

fatal:
  errno = ENOTTY;
  return -1;
#endif
}

static void disableRawMode(void) {
#ifdef _WIN32
  SetConsoleMode(console_in, oldMode);
  console_in = 0;
  console_out = 0;
#else
  if (rawmode && tcsetattr(0, TCSADRAIN, &orig_termios) != -1) rawmode = 0;
#endif
}


/* Fix compiler warning: non-Windows seems to need this.
 */
#ifndef _WIN32
// At exit we'll try to fix the terminal to the initial conditions
static void linenoiseAtExit(void) { disableRawMode(); }
#endif


static int getScreenColumns(void) {
  int cols;
#ifdef _WIN32
  CONSOLE_SCREEN_BUFFER_INFO inf;
  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &inf);
  cols = inf.dwSize.X;
#else
  struct winsize ws;
  cols = (ioctl(1, TIOCGWINSZ, &ws) == -1) ? 80 : ws.ws_col;
#endif
  // cols is 0 in certain circumstances like inside debugger, which creates
  // further issues
  return (cols > 0) ? cols : 80;
}

static int getScreenRows(void) {
  int rows;
#ifdef _WIN32
  CONSOLE_SCREEN_BUFFER_INFO inf;
  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &inf);
  rows = 1 + inf.srWindow.Bottom - inf.srWindow.Top;
#else
  struct winsize ws;
  rows = (ioctl(1, TIOCGWINSZ, &ws) == -1) ? 24 : ws.ws_row;
#endif
  return (rows > 0) ? rows : 24;
}

static void setDisplayAttribute(bool enhancedDisplay, bool error) {
#ifdef _WIN32
  if (enhancedDisplay) {
    CONSOLE_SCREEN_BUFFER_INFO inf;
    GetConsoleScreenBufferInfo(console_out, &inf);
    oldDisplayAttribute = inf.wAttributes;
    BYTE oldLowByte = oldDisplayAttribute & 0xFF;
    BYTE newLowByte;
    switch (oldLowByte) {
      case 0x07:
        // newLowByte = FOREGROUND_BLUE | FOREGROUND_INTENSITY;  // too dim
        // newLowByte = FOREGROUND_BLUE;                         // even dimmer
        newLowByte = FOREGROUND_BLUE |
                     FOREGROUND_GREEN;  // most similar to xterm appearance
        break;
      case 0x70:
        newLowByte = BACKGROUND_BLUE | BACKGROUND_INTENSITY;
        break;
      default:
        newLowByte = oldLowByte ^ 0xFF;  // default to inverse video
        break;
    }
    inf.wAttributes = (inf.wAttributes & 0xFF00) | newLowByte;
    SetConsoleTextAttribute(console_out, inf.wAttributes);
  } else {
    SetConsoleTextAttribute(console_out, oldDisplayAttribute);
  }
#else
  if (enhancedDisplay) {
    char const* p = (error ? "\x1b[1;31m" : "\x1b[1;34m");
    if (write(1, p, 7) == -1)
      return; /* bright blue (visible with both B&W bg) */
  } else {
    if (write(1, "\x1b[0m", 4) == -1) return; /* reset */
  }
#endif
}

/**
 * Display the dynamic incremental search prompt and the current user input
 * line.
 * @param pi   PromptBase struct holding information about the prompt and our
 * screen position
 * @param buf32  input buffer to be displayed
 * @param len  count of characters in the buffer
 * @param pos  current cursor position within the buffer (0 <= pos <= len)
 */
static void dynamicRefresh(PromptBase& pi, char32_t* buf32, int len, int pos) {
  // calculate the position of the end of the prompt
  int xEndOfPrompt, yEndOfPrompt;
  calculateScreenPosition(0, 0, pi.promptScreenColumns, pi.promptChars,
                          xEndOfPrompt, yEndOfPrompt);
  pi.promptIndentation = xEndOfPrompt;

  // calculate the position of the end of the input line
  int xEndOfInput, yEndOfInput;
  calculateScreenPosition(xEndOfPrompt, yEndOfPrompt, pi.promptScreenColumns,
                          calculateColumnPosition(buf32, len), xEndOfInput,
                          yEndOfInput);

  // calculate the desired position of the cursor
  int xCursorPos, yCursorPos;
  calculateScreenPosition(xEndOfPrompt, yEndOfPrompt, pi.promptScreenColumns,
                          calculateColumnPosition(buf32, pos), xCursorPos,
                          yCursorPos);

#ifdef _WIN32
  // position at the start of the prompt, clear to end of previous input
  CONSOLE_SCREEN_BUFFER_INFO inf;
  GetConsoleScreenBufferInfo(console_out, &inf);
  inf.dwCursorPosition.X = 0;
  inf.dwCursorPosition.Y -= pi.promptCursorRowOffset /*- pi.promptExtraLines*/;
  SetConsoleCursorPosition(console_out, inf.dwCursorPosition);
  DWORD count;
  FillConsoleOutputCharacterA(console_out, ' ',
                              pi.promptPreviousLen + pi.promptPreviousInputLen,
                              inf.dwCursorPosition, &count);
  pi.promptPreviousLen = pi.promptIndentation;
  pi.promptPreviousInputLen = len;

  // display the prompt
  if (!pi.write()) return;

  // display the input line
  if (write32(1, buf32, len) == -1) return;

  // position the cursor
  GetConsoleScreenBufferInfo(console_out, &inf);
  inf.dwCursorPosition.X = xCursorPos;  // 0-based on Win32
  inf.dwCursorPosition.Y -= yEndOfInput - yCursorPos;
  SetConsoleCursorPosition(console_out, inf.dwCursorPosition);
#else  // _WIN32
  char seq[64];
  int cursorRowMovement = pi.promptCursorRowOffset - pi.promptExtraLines;
  if (cursorRowMovement > 0) {  // move the cursor up as required
    snprintf(seq, sizeof seq, "\x1b[%dA", cursorRowMovement);
    if (write(1, seq, strlen(seq)) == -1) return;
  }
  // position at the start of the prompt, clear to end of screen
  snprintf(seq, sizeof seq, "\x1b[1G\x1b[J");  // 1-based on VT100
  if (write(1, seq, strlen(seq)) == -1) return;

  // display the prompt
  if (!pi.write()) return;

  // display the input line
  if (write32(1, buf32, len) == -1) return;

  // we have to generate our own newline on line wrap
  if (xEndOfInput == 0 && yEndOfInput > 0)
    if (write(1, "\n", 1) == -1) return;

  // position the cursor
  cursorRowMovement = yEndOfInput - yCursorPos;
  if (cursorRowMovement > 0) {  // move the cursor up as required
    snprintf(seq, sizeof seq, "\x1b[%dA", cursorRowMovement);
    if (write(1, seq, strlen(seq)) == -1) return;
  }
  // position the cursor within the line
  snprintf(seq, sizeof seq, "\x1b[%dG", xCursorPos + 1);  // 1-based on VT100
  if (write(1, seq, strlen(seq)) == -1) return;
#endif

  pi.promptCursorRowOffset =
      pi.promptExtraLines + yCursorPos;  // remember row for next pass
}

/**
 * Refresh the user's input line: the prompt is already onscreen and is not
 * redrawn here
 * @param pi   PromptBase struct holding information about the prompt and our
 * screen position
 */
void InputBuffer::refreshLine(PromptBase& pi) {
  // check for a matching brace/bracket/paren, remember its position if found
  int highlight = -1;
  bool indicateError = false;
  if (pos < len) {
    /* this scans for a brace matching buf32[pos] to highlight */
    unsigned char part1, part2;
    int scanDirection = 0;
    if (strchr("}])", buf32[pos])) {
      scanDirection = -1; /* backwards */
      if (buf32[pos] == '}') {
        part1 = '}'; part2 = '{';
      } else if (buf32[pos] == ']') {
        part1 = ']'; part2 = '[';
      } else {
        part1 = ')'; part2 = '(';
      }
    }
    else if (strchr("{[(", buf32[pos])) {
      scanDirection = 1; /* forwards */
      if (buf32[pos] == '{') {
        //part1 = '{'; part2 = '}';
        part1 = '}'; part2 = '{';
      } else if (buf32[pos] == '[') {
        //part1 = '['; part2 = ']';
        part1 = ']'; part2 = '[';
      } else {
        //part1 = '('; part2 = ')';
        part1 = ')'; part2 = '(';
      }
    }

    if (scanDirection) {
      int unmatched = scanDirection;
      int unmatchedOther = 0;
      for (int i = pos + scanDirection; i >= 0 && i < len; i += scanDirection) {
        /* TODO: the right thing when inside a string */
        if (strchr("}])", buf32[i])) {
          if (buf32[i] == part1) {
            --unmatched;
          } else {
            --unmatchedOther;
          }
        } else if (strchr("{[(", buf32[i])) {
          if (buf32[i] == part2) {
            ++unmatched;
          } else {
            ++unmatchedOther;
          }
        }
/*
        if (strchr("}])", buf32[i]))
          --unmatched;
        else if (strchr("{[(", buf32[i]))
          ++unmatched;
*/
        if (unmatched == 0) {
          highlight = i;
          indicateError = (unmatchedOther != 0);
          break;
        }
      }
    }
  }

  // calculate the position of the end of the input line
  int xEndOfInput, yEndOfInput;
  calculateScreenPosition(pi.promptIndentation, 0, pi.promptScreenColumns,
                          calculateColumnPosition(buf32, len), xEndOfInput,
                          yEndOfInput);

  // calculate the desired position of the cursor
  int xCursorPos, yCursorPos;
  calculateScreenPosition(pi.promptIndentation, 0, pi.promptScreenColumns,
                          calculateColumnPosition(buf32, pos), xCursorPos,
                          yCursorPos);

#ifdef _WIN32
  // position at the end of the prompt, clear to end of previous input
  CONSOLE_SCREEN_BUFFER_INFO inf;
  GetConsoleScreenBufferInfo(console_out, &inf);
  inf.dwCursorPosition.X = pi.promptIndentation;  // 0-based on Win32
  inf.dwCursorPosition.Y -= pi.promptCursorRowOffset - pi.promptExtraLines;
  SetConsoleCursorPosition(console_out, inf.dwCursorPosition);
  DWORD count;
  if (len < pi.promptPreviousInputLen)
    FillConsoleOutputCharacterA(console_out, ' ', pi.promptPreviousInputLen,
                                inf.dwCursorPosition, &count);
  pi.promptPreviousInputLen = len;

  // display the input line
  if (highlight == -1) {
    if (write32(1, buf32, len) == -1) return;
  } else {
    if (write32(1, buf32, highlight) == -1) return;
    setDisplayAttribute(true, indicateError); /* bright blue (visible with both B&W bg) */
    if (write32(1, &buf32[highlight], 1) == -1) return;
    setDisplayAttribute(false, indicateError);
    if (write32(1, buf32 + highlight + 1, len - highlight - 1) == -1) return;
  }

  // position the cursor
  GetConsoleScreenBufferInfo(console_out, &inf);
  inf.dwCursorPosition.X = xCursorPos;  // 0-based on Win32
  inf.dwCursorPosition.Y -= yEndOfInput - yCursorPos;
  SetConsoleCursorPosition(console_out, inf.dwCursorPosition);
#else  // _WIN32
  char seq[64];
  int cursorRowMovement = pi.promptCursorRowOffset - pi.promptExtraLines;
  if (cursorRowMovement > 0) {  // move the cursor up as required
    snprintf(seq, sizeof seq, "\x1b[%dA", cursorRowMovement);
    if (write(1, seq, strlen(seq)) == -1) return;
  }
  // position at the end of the prompt, clear to end of screen
  snprintf(seq, sizeof seq, "\x1b[%dG\x1b[J",
           pi.promptIndentation + 1);  // 1-based on VT100
  if (write(1, seq, strlen(seq)) == -1) return;

  if (highlight == -1) {  // write unhighlighted text
    if (write32(1, buf32, len) == -1) return;
  } else {  // highlight the matching brace/bracket/parenthesis
    if (write32(1, buf32, highlight) == -1) return;
    setDisplayAttribute(true, indicateError);
    if (write32(1, &buf32[highlight], 1) == -1) return;
    setDisplayAttribute(false, indicateError);
    if (write32(1, buf32 + highlight + 1, len - highlight - 1) == -1) return;
  }

  // we have to generate our own newline on line wrap
  if (xEndOfInput == 0 && yEndOfInput > 0)
    if (write(1, "\n", 1) == -1) return;

  // position the cursor
  cursorRowMovement = yEndOfInput - yCursorPos;
  if (cursorRowMovement > 0) {  // move the cursor up as required
    snprintf(seq, sizeof seq, "\x1b[%dA", cursorRowMovement);
    if (write(1, seq, strlen(seq)) == -1) return;
  }
  // position the cursor within the line
  snprintf(seq, sizeof seq, "\x1b[%dG", xCursorPos + 1);  // 1-based on VT100
  if (write(1, seq, strlen(seq)) == -1) return;
#endif

  pi.promptCursorRowOffset =
      pi.promptExtraLines + yCursorPos;  // remember row for next pass
}

#ifndef _WIN32

/**
 * Read a UTF-8 sequence from the non-Windows keyboard and return the Unicode
 * (char32_t) character it
 * encodes
 *
 * @return  char32_t Unicode character
 */
static char32_t readUnicodeCharacter(void) {
  static char8_t utf8String[5];
  static size_t utf8Count = 0;
  while (true) {
    char8_t c;

    /* Continue reading if interrupted by signal. */
    ssize_t nread;
    do {
      nread = read(0, &c, 1);
    } while ((nread == -1) && (errno == EINTR));

    if (nread <= 0) return 0;
    if (c <= 0x7F) {  // short circuit ASCII
      utf8Count = 0;
      return c;
    } else if (utf8Count < sizeof(utf8String) - 1) {
      utf8String[utf8Count++] = c;
      utf8String[utf8Count] = 0;
      char32_t unicodeChar[2];
      size_t ucharCount;
      ConversionResult res =
          copyString8to32(unicodeChar, 2, ucharCount, utf8String);
      if (res == conversionOK && ucharCount) {
        utf8Count = 0;
        return unicodeChar[0];
      }
    } else {
      utf8Count =
          0;  // this shouldn't happen: got four bytes but no UTF-8 character
    }
  }
}

namespace EscapeSequenceProcessing {  // move these out of global namespace

// This chunk of code does parsing of the escape sequences sent by various Linux
// terminals.
//
// It handles arrow keys, Home, End and Delete keys by interpreting the
// sequences sent by
// gnome terminal, xterm, rxvt, konsole, aterm and yakuake including the Alt and
// Ctrl key
// combinations that are understood by linenoise.
//
// The parsing uses tables, a bunch of intermediate dispatch routines and a
// doDispatch
// loop that reads the tables and sends control to "deeper" routines to continue
// the
// parsing.  The starting call to doDispatch( c, initialDispatch ) will
// eventually return
// either a character (with optional CTRL and META bits set), or -1 if parsing
// fails, or
// zero if an attempt to read from the keyboard fails.
//
// This is rather sloppy escape sequence processing, since we're not paying
// attention to what the
// actual TERM is set to and are processing all key sequences for all terminals,
// but it works with
// the most common keystrokes on the most common terminals.  It's intricate, but
// the nested 'if'
// statements required to do it directly would be worse.  This way has the
// advantage of allowing
// changes and extensions without having to touch a lot of code.

// This is a typedef for the routine called by doDispatch().  It takes the
// current character
// as input, does any required processing including reading more characters and
// calling other
// dispatch routines, then eventually returns the final (possibly extended or
// special) character.
//
typedef char32_t (*CharacterDispatchRoutine)(char32_t);

// This structure is used by doDispatch() to hold a list of characters to test
// for and
// a list of routines to call if the character matches.  The dispatch routine
// list is one
// longer than the character list; the final entry is used if no character
// matches.
//
struct CharacterDispatch {
  unsigned int len;                    // length of the chars list
  const char* chars;                   // chars to test
  CharacterDispatchRoutine* dispatch;  // array of routines to call
};

// This dispatch routine is given a dispatch table and then farms work out to
// routines
// listed in the table based on the character it is called with.  The dispatch
// routines can
// read more input characters to decide what should eventually be returned.
// Eventually,
// a called routine returns either a character or -1 to indicate parsing
// failure.
//
static char32_t doDispatch(char32_t c, CharacterDispatch& dispatchTable) {
  for (unsigned int i = 0; i < dispatchTable.len; ++i) {
    if (static_cast<unsigned char>(dispatchTable.chars[i]) == c) {
      return dispatchTable.dispatch[i](c);
    }
  }
  return dispatchTable.dispatch[dispatchTable.len](c);
}

static char32_t thisKeyMetaCtrl =
    0;  // holds pre-set Meta and/or Ctrl modifiers

// Final dispatch routines -- return something
//
static char32_t normalKeyRoutine(char32_t c) { return thisKeyMetaCtrl | c; }
static char32_t upArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | UP_ARROW_KEY;
}
static char32_t downArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | DOWN_ARROW_KEY;
}
static char32_t rightArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | RIGHT_ARROW_KEY;
}
static char32_t leftArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | LEFT_ARROW_KEY;
}
static char32_t homeKeyRoutine(char32_t) { return thisKeyMetaCtrl | HOME_KEY; }
static char32_t endKeyRoutine(char32_t) { return thisKeyMetaCtrl | END_KEY; }
static char32_t pageUpKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | PAGE_UP_KEY;
}
static char32_t pageDownKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | PAGE_DOWN_KEY;
}
static char32_t deleteCharRoutine(char32_t) {
  return thisKeyMetaCtrl | ctrlChar('H');
}  // key labeled Backspace
static char32_t deleteKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | DELETE_KEY;
}  // key labeled Delete
static char32_t ctrlUpArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | CTRL | UP_ARROW_KEY;
}
static char32_t ctrlDownArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | CTRL | DOWN_ARROW_KEY;
}
static char32_t ctrlRightArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | CTRL | RIGHT_ARROW_KEY;
}
static char32_t ctrlLeftArrowKeyRoutine(char32_t) {
  return thisKeyMetaCtrl | CTRL | LEFT_ARROW_KEY;
}
static char32_t escFailureRoutine(char32_t) {
  beep();
  return -1;
}

// Handle ESC [ 1 ; 3 (or 5) <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket1Semicolon3or5Routines[] = {
    upArrowKeyRoutine, downArrowKeyRoutine, rightArrowKeyRoutine,
    leftArrowKeyRoutine, escFailureRoutine};
static CharacterDispatch escLeftBracket1Semicolon3or5Dispatch = {
    4, "ABCD", escLeftBracket1Semicolon3or5Routines};

// Handle ESC [ 1 ; <more stuff> escape sequences
//
static char32_t escLeftBracket1Semicolon3Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  thisKeyMetaCtrl |= META;
  return doDispatch(c, escLeftBracket1Semicolon3or5Dispatch);
}
static char32_t escLeftBracket1Semicolon5Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  thisKeyMetaCtrl |= CTRL;
  return doDispatch(c, escLeftBracket1Semicolon3or5Dispatch);
}
static CharacterDispatchRoutine escLeftBracket1SemicolonRoutines[] = {
    escLeftBracket1Semicolon3Routine, escLeftBracket1Semicolon5Routine,
    escFailureRoutine};
static CharacterDispatch escLeftBracket1SemicolonDispatch = {
    2, "35", escLeftBracket1SemicolonRoutines};

// Handle ESC [ 1 <more stuff> escape sequences
//
static char32_t escLeftBracket1SemicolonRoutine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket1SemicolonDispatch);
}
static CharacterDispatchRoutine escLeftBracket1Routines[] = {
    homeKeyRoutine, escLeftBracket1SemicolonRoutine, escFailureRoutine};
static CharacterDispatch escLeftBracket1Dispatch = {2, "~;",
                                                    escLeftBracket1Routines};

// Handle ESC [ 3 <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket3Routines[] = {deleteKeyRoutine,
                                                             escFailureRoutine};
static CharacterDispatch escLeftBracket3Dispatch = {1, "~",
                                                    escLeftBracket3Routines};

// Handle ESC [ 4 <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket4Routines[] = {endKeyRoutine,
                                                             escFailureRoutine};
static CharacterDispatch escLeftBracket4Dispatch = {1, "~",
                                                    escLeftBracket4Routines};

// Handle ESC [ 5 <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket5Routines[] = {pageUpKeyRoutine,
                                                             escFailureRoutine};
static CharacterDispatch escLeftBracket5Dispatch = {1, "~",
                                                    escLeftBracket5Routines};

// Handle ESC [ 6 <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket6Routines[] = {pageDownKeyRoutine,
                                                             escFailureRoutine};
static CharacterDispatch escLeftBracket6Dispatch = {1, "~",
                                                    escLeftBracket6Routines};

// Handle ESC [ 7 <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket7Routines[] = {homeKeyRoutine,
                                                             escFailureRoutine};
static CharacterDispatch escLeftBracket7Dispatch = {1, "~",
                                                    escLeftBracket7Routines};

// Handle ESC [ 8 <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracket8Routines[] = {endKeyRoutine,
                                                             escFailureRoutine};
static CharacterDispatch escLeftBracket8Dispatch = {1, "~",
                                                    escLeftBracket8Routines};

// Handle ESC [ <digit> escape sequences
//
static char32_t escLeftBracket0Routine(char32_t c) {
  return escFailureRoutine(c);
}
static char32_t escLeftBracket1Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket1Dispatch);
}
static char32_t escLeftBracket2Routine(char32_t c) {
  return escFailureRoutine(c);  // Insert key, unused
}
static char32_t escLeftBracket3Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket3Dispatch);
}
static char32_t escLeftBracket4Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket4Dispatch);
}
static char32_t escLeftBracket5Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket5Dispatch);
}
static char32_t escLeftBracket6Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket6Dispatch);
}
static char32_t escLeftBracket7Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket7Dispatch);
}
static char32_t escLeftBracket8Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracket8Dispatch);
}
static char32_t escLeftBracket9Routine(char32_t c) {
  return escFailureRoutine(c);
}

// Handle ESC [ <more stuff> escape sequences
//
static CharacterDispatchRoutine escLeftBracketRoutines[] = {
    upArrowKeyRoutine,      downArrowKeyRoutine,    rightArrowKeyRoutine,
    leftArrowKeyRoutine,    homeKeyRoutine,         endKeyRoutine,
    escLeftBracket0Routine, escLeftBracket1Routine, escLeftBracket2Routine,
    escLeftBracket3Routine, escLeftBracket4Routine, escLeftBracket5Routine,
    escLeftBracket6Routine, escLeftBracket7Routine, escLeftBracket8Routine,
    escLeftBracket9Routine, escFailureRoutine};
static CharacterDispatch escLeftBracketDispatch = {16, "ABCDHF0123456789",
                                                   escLeftBracketRoutines};

// Handle ESC O <char> escape sequences
//
static CharacterDispatchRoutine escORoutines[] = {
    upArrowKeyRoutine,       downArrowKeyRoutine,     rightArrowKeyRoutine,
    leftArrowKeyRoutine,     homeKeyRoutine,          endKeyRoutine,
    ctrlUpArrowKeyRoutine,   ctrlDownArrowKeyRoutine, ctrlRightArrowKeyRoutine,
    ctrlLeftArrowKeyRoutine, escFailureRoutine};
static CharacterDispatch escODispatch = {10, "ABCDHFabcd", escORoutines};

// Initial ESC dispatch -- could be a Meta prefix or the start of an escape
// sequence
//
static char32_t escLeftBracketRoutine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escLeftBracketDispatch);
}
static char32_t escORoutine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escODispatch);
}
static char32_t setMetaRoutine(char32_t c);  // need forward reference
static CharacterDispatchRoutine escRoutines[] = {escLeftBracketRoutine,
                                                 escORoutine, setMetaRoutine};
static CharacterDispatch escDispatch = {2, "[O", escRoutines};

// Initial dispatch -- we are not in the middle of anything yet
//
static char32_t escRoutine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  return doDispatch(c, escDispatch);
}
static CharacterDispatchRoutine initialRoutines[] = {
    escRoutine, deleteCharRoutine, normalKeyRoutine};
static CharacterDispatch initialDispatch = {2, "\x1B\x7F", initialRoutines};

// Special handling for the ESC key because it does double duty
//
static char32_t setMetaRoutine(char32_t c) {
  thisKeyMetaCtrl = META;
  if (c == 0x1B) {  // another ESC, stay in ESC processing mode
    c = readUnicodeCharacter();
    if (c == 0) return 0;
    return doDispatch(c, escDispatch);
  }
  return doDispatch(c, initialDispatch);
}

}  // namespace EscapeSequenceProcessing // move these out of global namespace

#endif  // #ifndef _WIN32

// linenoiseReadChar -- read a keystroke or keychord from the keyboard, and
// translate it
// into an encoded "keystroke".  When convenient, extended keys are translated
// into their
// simpler Emacs keystrokes, so an unmodified "left arrow" becomes Ctrl-B.
//
// A return value of zero means "no input available", and a return value of -1
// means "invalid key".
//
static char32_t linenoiseReadChar(void) {
#ifdef _WIN32

  INPUT_RECORD rec;
  DWORD count;
  int modifierKeys = 0;
  bool escSeen = false;
  while (true) {
    ReadConsoleInputW(console_in, &rec, 1, &count);
#if 0  // helper for debugging keystrokes, display info in the debug "Output"
       // window in the debugger
        {
            if ( rec.EventType == KEY_EVENT ) {
                //if ( rec.Event.KeyEvent.uChar.UnicodeChar ) {
                    char buf[1024];
                    sprintf(
                            buf,
                            "Unicode character 0x%04X, repeat count %d, virtual keycode 0x%04X, "
                            "virtual scancode 0x%04X, key %s%s%s%s%s\n",
                            rec.Event.KeyEvent.uChar.UnicodeChar,
                            rec.Event.KeyEvent.wRepeatCount,
                            rec.Event.KeyEvent.wVirtualKeyCode,
                            rec.Event.KeyEvent.wVirtualScanCode,
                            rec.Event.KeyEvent.bKeyDown ? "down" : "up",
                                (rec.Event.KeyEvent.dwControlKeyState & LEFT_CTRL_PRESSED)  ?
                                    " L-Ctrl" : "",
                                (rec.Event.KeyEvent.dwControlKeyState & RIGHT_CTRL_PRESSED) ?
                                    " R-Ctrl" : "",
                                (rec.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED)   ?
                                    " L-Alt"  : "",
                                (rec.Event.KeyEvent.dwControlKeyState & RIGHT_ALT_PRESSED)  ?
                                    " R-Alt"  : ""
                           );
                    OutputDebugStringA( buf );
                //}
            }
        }
#endif
    if (rec.EventType != KEY_EVENT) {
      continue;
    }
    // Windows provides for entry of characters that are not on your keyboard by
    // sending the
    // Unicode characters as a "key up" with virtual keycode 0x12 (VK_MENU ==
    // Alt key) ...
    // accept these characters, otherwise only process characters on "key down"
    if (!rec.Event.KeyEvent.bKeyDown &&
        rec.Event.KeyEvent.wVirtualKeyCode != VK_MENU) {
      continue;
    }
    modifierKeys = 0;
    // AltGr is encoded as ( LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED ), so don't
    // treat this
    // combination as either CTRL or META we just turn off those two bits, so it
    // is still
    // possible to combine CTRL and/or META with an AltGr key by using
    // right-Ctrl and/or
    // left-Alt
    if ((rec.Event.KeyEvent.dwControlKeyState &
         (LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED)) ==
        (LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED)) {
      rec.Event.KeyEvent.dwControlKeyState &=
          ~(LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED);
    }
    if (rec.Event.KeyEvent.dwControlKeyState &
        (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) {
      modifierKeys |= CTRL;
    }
    if (rec.Event.KeyEvent.dwControlKeyState &
        (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)) {
      modifierKeys |= META;
    }
    if (escSeen) {
      modifierKeys |= META;
    }
    if (rec.Event.KeyEvent.uChar.UnicodeChar == 0) {
      switch (rec.Event.KeyEvent.wVirtualKeyCode) {
        case VK_LEFT:
          return modifierKeys | LEFT_ARROW_KEY;
        case VK_RIGHT:
          return modifierKeys | RIGHT_ARROW_KEY;
        case VK_UP:
          return modifierKeys | UP_ARROW_KEY;
        case VK_DOWN:
          return modifierKeys | DOWN_ARROW_KEY;
        case VK_DELETE:
          return modifierKeys | DELETE_KEY;
        case VK_HOME:
          return modifierKeys | HOME_KEY;
        case VK_END:
          return modifierKeys | END_KEY;
        case VK_PRIOR:
          return modifierKeys | PAGE_UP_KEY;
        case VK_NEXT:
          return modifierKeys | PAGE_DOWN_KEY;
        default:
          continue;  // in raw mode, ReadConsoleInput shows shift, ctrl ...
      }              //  ... ignore them
    } else if (rec.Event.KeyEvent.uChar.UnicodeChar ==
               ctrlChar('[')) {  // ESC, set flag for later
      escSeen = true;
      continue;
    } else {
      // we got a real character, return it
      return modifierKeys | rec.Event.KeyEvent.uChar.UnicodeChar;
    }
  }

#else
  char32_t c;
  c = readUnicodeCharacter();
  if (c == 0) return 0;

// If _DEBUG_LINUX_KEYBOARD is set, then ctrl-^ puts us into a keyboard
// debugging mode
// where we print out decimal and decoded values for whatever the "terminal"
// program
// gives us on different keystrokes.  Hit ctrl-C to exit this mode.
//
#define _DEBUG_LINUX_KEYBOARD
#if defined(_DEBUG_LINUX_KEYBOARD)
  if (c == ctrlChar('^')) {  // ctrl-^, special debug mode, prints all keys hit,
                             // ctrl-C to get out
    printf(
        "\nEntering keyboard debugging mode (on ctrl-^), press ctrl-C to exit "
        "this mode\n");
    while (true) {
      unsigned char keys[10];
      long ret = read(0, keys, 10);

      if (ret <= 0) {
        printf("\nret: %ld\n", ret);
      }
      for (int i = 0; i < ret; ++i) {
        char32_t key = static_cast<char32_t>(keys[i]);
        char* friendlyTextPtr;
        char friendlyTextBuf[10];
        const char* prefixText = (key < 0x80) ? "" : "0x80+";
        char32_t keyCopy = (key < 0x80) ? key : key - 0x80;
        if (keyCopy >= '!' && keyCopy <= '~') {  // printable
          friendlyTextBuf[0] = '\'';
          friendlyTextBuf[1] = keyCopy;
          friendlyTextBuf[2] = '\'';
          friendlyTextBuf[3] = 0;
          friendlyTextPtr = friendlyTextBuf;
        } else if (keyCopy == ' ') {
          friendlyTextPtr = const_cast<char*>("space");
        } else if (keyCopy == 27) {
          friendlyTextPtr = const_cast<char*>("ESC");
        } else if (keyCopy == 0) {
          friendlyTextPtr = const_cast<char*>("NUL");
        } else if (keyCopy == 127) {
          friendlyTextPtr = const_cast<char*>("DEL");
        } else {
          friendlyTextBuf[0] = '^';
          friendlyTextBuf[1] = keyCopy + 0x40;
          friendlyTextBuf[2] = 0;
          friendlyTextPtr = friendlyTextBuf;
        }
        printf("%u x%02X (%s%s)  ", key, key, prefixText, friendlyTextPtr);
      }
      printf("\x1b[1G\n");  // go to first column of new line

      // drop out of this loop on ctrl-C
      if (keys[0] == ctrlChar('C')) {
        printf("Leaving keyboard debugging mode (on ctrl-C)\n");
        fflush(stdout);
        return -2;
      }
    }
  }
#endif  // _DEBUG_LINUX_KEYBOARD

  EscapeSequenceProcessing::thisKeyMetaCtrl =
      0;  // no modifiers yet at initialDispatch
  return EscapeSequenceProcessing::doDispatch(
      c, EscapeSequenceProcessing::initialDispatch);
#endif  // #_WIN32
}

/**
 * Free memory used in a recent command completion session
 *
 * @param lc pointer to a linenoiseCompletions struct
 */
static void freeCompletions(linenoiseCompletions* lc) {
  lc->completionStrings.clear();
}

/**
 * convert {CTRL + 'A'}, {CTRL + 'a'} and {CTRL + ctrlChar( 'A' )} into
 * ctrlChar( 'A' )
 * leave META alone
 *
 * @param c character to clean up
 * @return cleaned-up character
 */
static int cleanupCtrl(int c) {
  if (c & CTRL) {
    int d = c & 0x1FF;
    if (d >= 'a' && d <= 'z') {
      c = (c + ('a' - ctrlChar('A'))) & ~CTRL;
    }
    if (d >= 'A' && d <= 'Z') {
      c = (c + ('A' - ctrlChar('A'))) & ~CTRL;
    }
    if (d >= ctrlChar('A') && d <= ctrlChar('Z')) {
      c = c & ~CTRL;
    }
  }
  return c;
}

// break characters that may precede items to be completed
static const char breakChars[] = " =+-/\\*?\"'`&<>;|@{([])}";

// maximum number of completions to display without asking
static const size_t completionCountCutoff = 100;

/**
 * Handle command completion, using a completionCallback() routine to provide
 * possible substitutions
 * This routine handles the mechanics of updating the user's input buffer with
 * possible replacement
 * of text as the user selects a proposed completion string, or cancels the
 * completion attempt.
 * @param pi     PromptBase struct holding information about the prompt and our
 * screen position
 */
int InputBuffer::completeLine(PromptBase& pi) {
  linenoiseCompletions lc;
  char32_t c = 0;

  // completionCallback() expects a parsable entity, so find the previous break
  // character and
  // extract a copy to parse.  we also handle the case where tab is hit while
  // not at end-of-line.
  int startIndex = pos;
  while (--startIndex >= 0) {
    if (strchr(breakChars, buf32[startIndex])) {
      break;
    }
  }
  ++startIndex;
  int itemLength = pos - startIndex;
  Utf32String unicodeCopy(&buf32[startIndex], itemLength);
  Utf8String parseItem(unicodeCopy);

  // get a list of completions
  completionCallback(parseItem.get(), &lc);

  // if no completions, we are done
  if (lc.completionStrings.size() == 0) {
    beep();
    freeCompletions(&lc);
    return 0;
  }

  // at least one completion
  int longestCommonPrefix = 0;
  int displayLength = 0;
  if (lc.completionStrings.size() == 1) {
    longestCommonPrefix = static_cast<int>(lc.completionStrings[0].length());
  } else {
    bool keepGoing = true;
    while (keepGoing) {
      for (size_t j = 0; j < lc.completionStrings.size() - 1; ++j) {
        char32_t c1 = lc.completionStrings[j][longestCommonPrefix];
        char32_t c2 = lc.completionStrings[j + 1][longestCommonPrefix];
        if ((0 == c1) || (0 == c2) || (c1 != c2)) {
          keepGoing = false;
          break;
        }
      }
      if (keepGoing) {
        ++longestCommonPrefix;
      }
    }
  }
  if (lc.completionStrings.size() != 1) {  // beep if ambiguous
    beep();
  }

  // if we can extend the item, extend it and return to main loop
  if (longestCommonPrefix > itemLength) {
    displayLength = len + longestCommonPrefix - itemLength;
    if (displayLength > buflen) {
      longestCommonPrefix -= displayLength - buflen;  // don't overflow buffer
      displayLength = buflen;                         // truncate the insertion
      beep();                                         // and make a noise
    }
    Utf32String displayText(displayLength + 1);
    memcpy(displayText.get(), buf32, sizeof(char32_t) * startIndex);
    memcpy(&displayText[startIndex], &lc.completionStrings[0][0],
           sizeof(char32_t) * longestCommonPrefix);
    int tailIndex = startIndex + longestCommonPrefix;
    memcpy(&displayText[tailIndex], &buf32[pos],
           sizeof(char32_t) * (displayLength - tailIndex + 1));
    copyString32(buf32, displayText.get(), displayLength);
    pos = startIndex + longestCommonPrefix;
    len = displayLength;
    refreshLine(pi);
    return 0;
  }

  // we can't complete any further, wait for second tab
  do {
    c = linenoiseReadChar();
    c = cleanupCtrl(c);
  } while (c == static_cast<char32_t>(-1));

  // if any character other than tab, pass it to the main loop
  if (c != ctrlChar('I')) {
    freeCompletions(&lc);
    return c;
  }

  // we got a second tab, maybe show list of possible completions
  bool showCompletions = true;
  bool onNewLine = false;
  if (lc.completionStrings.size() > completionCountCutoff) {
    int savePos =
        pos;  // move cursor to EOL to avoid overwriting the command line
    pos = len;
    refreshLine(pi);
    pos = savePos;
    printf("\nDisplay all %u possibilities? (y or n)",
           static_cast<unsigned int>(lc.completionStrings.size()));
    fflush(stdout);
    onNewLine = true;
    while (c != 'y' && c != 'Y' && c != 'n' && c != 'N' && c != ctrlChar('C')) {
      do {
        c = linenoiseReadChar();
        c = cleanupCtrl(c);
      } while (c == static_cast<char32_t>(-1));
    }
    switch (c) {
      case 'n':
      case 'N':
        showCompletions = false;
        freeCompletions(&lc);
        break;
      case ctrlChar('C'):
        showCompletions = false;
        freeCompletions(&lc);
        if (write(1, "^C", 2) == -1) return -1;  // Display the ^C we got
        c = 0;
        break;
    }
  }

  // if showing the list, do it the way readline does it
  bool stopList = false;
  if (showCompletions) {
    int longestCompletion = 0;
    for (size_t j = 0; j < lc.completionStrings.size(); ++j) {
      itemLength = static_cast<int>(lc.completionStrings[j].length());
      if (itemLength > longestCompletion) {
        longestCompletion = itemLength;
      }
    }
    longestCompletion += 2;
    int columnCount = pi.promptScreenColumns / longestCompletion;
    if (columnCount < 1) {
      columnCount = 1;
    }
    if (!onNewLine) {  // skip this if we showed "Display all %d possibilities?"
      int savePos =
          pos;  // move cursor to EOL to avoid overwriting the command line
      pos = len;
      refreshLine(pi);
      pos = savePos;
    }
    size_t pauseRow = getScreenRows() - 1;
    size_t rowCount =
        (lc.completionStrings.size() + columnCount - 1) / columnCount;
    for (size_t row = 0; row < rowCount; ++row) {
      if (row == pauseRow) {
        printf("\n--More--");
        fflush(stdout);
        c = 0;
        bool doBeep = false;
        while (c != ' ' && c != '\r' && c != '\n' && c != 'y' && c != 'Y' &&
               c != 'n' && c != 'N' && c != 'q' && c != 'Q' &&
               c != ctrlChar('C')) {
          if (doBeep) {
            beep();
          }
          doBeep = true;
          do {
            c = linenoiseReadChar();
            c = cleanupCtrl(c);
          } while (c == static_cast<char32_t>(-1));
        }
        switch (c) {
          case ' ':
          case 'y':
          case 'Y':
            printf("\r        \r");
            pauseRow += getScreenRows() - 1;
            break;
          case '\r':
          case '\n':
            printf("\r        \r");
            ++pauseRow;
            break;
          case 'n':
          case 'N':
          case 'q':
          case 'Q':
            printf("\r        \r");
            stopList = true;
            break;
          case ctrlChar('C'):
            if (write(1, "^C", 2) == -1) return -1;  // Display the ^C we got
            stopList = true;
            break;
        }
      } else {
        printf("\n");
      }
      if (stopList) {
        break;
      }
      for (int column = 0; column < columnCount; ++column) {
        size_t index = (column * rowCount) + row;
        if (index < lc.completionStrings.size()) {
          itemLength = static_cast<int>(lc.completionStrings[index].length());
          fflush(stdout);
          if (write32(1, lc.completionStrings[index].get(), itemLength) == -1)
            return -1;
          if (((column + 1) * rowCount) + row < lc.completionStrings.size()) {
            for (int k = itemLength; k < longestCompletion; ++k) {
              printf(" ");
            }
          }
        }
      }
    }
    fflush(stdout);
    freeCompletions(&lc);
  }

  // display the prompt on a new line, then redisplay the input buffer
  if (!stopList || c == ctrlChar('C')) {
    if (write(1, "\n", 1) == -1) return 0;
  }
  if (!pi.write()) return 0;
#ifndef _WIN32
  // we have to generate our own newline on line wrap on Linux
  if (pi.promptIndentation == 0 && pi.promptExtraLines > 0)
    if (write(1, "\n", 1) == -1) return 0;
#endif
  pi.promptCursorRowOffset = pi.promptExtraLines;
  refreshLine(pi);
  return 0;
}

/**
 * Clear the screen ONLY (no redisplay of anything)
 */
void linenoiseClearScreen(void) {
#ifdef _WIN32
  COORD coord = {0, 0};
  CONSOLE_SCREEN_BUFFER_INFO inf;
  HANDLE screenHandle = GetStdHandle(STD_OUTPUT_HANDLE);
  GetConsoleScreenBufferInfo(screenHandle, &inf);
  SetConsoleCursorPosition(screenHandle, coord);
  DWORD count;
  FillConsoleOutputCharacterA(screenHandle, ' ', inf.dwSize.X * inf.dwSize.Y,
                              coord, &count);
#else
  if (write(1, "\x1b[H\x1b[2J", 7) <= 0) return;
#endif
}

void InputBuffer::clearScreen(PromptBase& pi) {
  linenoiseClearScreen();
  if (!pi.write()) return;
#ifndef _WIN32
  // we have to generate our own newline on line wrap on Linux
  if (pi.promptIndentation == 0 && pi.promptExtraLines > 0)
    if (write(1, "\n", 1) == -1) return;
#endif
  pi.promptCursorRowOffset = pi.promptExtraLines;
  refreshLine(pi);
}

/**
 * Incremental history search -- take over the prompt and keyboard as the user
 * types a search
 * string, deletes characters from it, changes direction, and either accepts the
 * found line (for
 * execution orediting) or cancels.
 * @param pi        PromptBase struct holding information about the (old,
 * static) prompt and our
 *                  screen position
 * @param startChar the character that began the search, used to set the initial
 * direction
 */
int InputBuffer::incrementalHistorySearch(PromptBase& pi, int startChar) {
  size_t bufferSize;
  size_t ucharCount = 0;

  // if not already recalling, add the current line to the history list so we
  // don't have to
  // special case it
  if (historyIndex == historyLen - 1) {
    free(history[historyLen - 1]);
    bufferSize = sizeof(char32_t) * len + 1;
    unique_ptr<char[]> tempBuffer(new char[bufferSize]);
    copyString32to8(tempBuffer.get(), bufferSize, buf32);
    history[historyLen - 1] = strdup8(tempBuffer.get());
  }
  int historyLineLength = len;
  int historyLinePosition = pos;
  char32_t emptyBuffer[1];
  char emptyWidths[1];
  InputBuffer empty(emptyBuffer, emptyWidths, 1);
  empty.refreshLine(pi);  // erase the old input first
  DynamicPrompt dp(pi, (startChar == ctrlChar('R')) ? -1 : 1);

  dp.promptPreviousLen = pi.promptPreviousLen;
  dp.promptPreviousInputLen = pi.promptPreviousInputLen;
  dynamicRefresh(dp, buf32, historyLineLength,
                 historyLinePosition);  // draw user's text with our prompt

  // loop until we get an exit character
  int c = 0;
  bool keepLooping = true;
  bool useSearchedLine = true;
  bool searchAgain = false;
  char32_t* activeHistoryLine = 0;
  while (keepLooping) {
    c = linenoiseReadChar();
    c = cleanupCtrl(c);  // convert CTRL + <char> into normal ctrl

    switch (c) {
      // these characters keep the selected text but do not execute it
      case ctrlChar('A'):  // ctrl-A, move cursor to start of line
      case HOME_KEY:
      case ctrlChar('B'):  // ctrl-B, move cursor left by one character
      case LEFT_ARROW_KEY:
      case META + 'b':  // meta-B, move cursor left by one word
      case META + 'B':
      case CTRL + LEFT_ARROW_KEY:
      case META + LEFT_ARROW_KEY:  // Emacs allows Meta, bash & readline don't
      case ctrlChar('D'):
      case META + 'd':  // meta-D, kill word to right of cursor
      case META + 'D':
      case ctrlChar('E'):  // ctrl-E, move cursor to end of line
      case END_KEY:
      case ctrlChar('F'):  // ctrl-F, move cursor right by one character
      case RIGHT_ARROW_KEY:
      case META + 'f':  // meta-F, move cursor right by one word
      case META + 'F':
      case CTRL + RIGHT_ARROW_KEY:
      case META + RIGHT_ARROW_KEY:  // Emacs allows Meta, bash & readline don't
      case META + ctrlChar('H'):
      case ctrlChar('J'):
      case ctrlChar('K'):  // ctrl-K, kill from cursor to end of line
      case ctrlChar('M'):
      case ctrlChar('N'):  // ctrl-N, recall next line in history
      case ctrlChar('P'):  // ctrl-P, recall previous line in history
      case DOWN_ARROW_KEY:
      case UP_ARROW_KEY:
      case ctrlChar('T'):  // ctrl-T, transpose characters
      case ctrlChar(
          'U'):  // ctrl-U, kill all characters to the left of the cursor
      case ctrlChar('W'):
      case META + 'y':  // meta-Y, "yank-pop", rotate popped text
      case META + 'Y':
      case 127:
      case DELETE_KEY:
      case META + '<':  // start of history
      case PAGE_UP_KEY:
      case META + '>':  // end of history
      case PAGE_DOWN_KEY:
        keepLooping = false;
        break;

      // these characters revert the input line to its previous state
      case ctrlChar('C'):  // ctrl-C, abort this line
      case ctrlChar('G'):
      case ctrlChar('L'):  // ctrl-L, clear screen and redisplay line
        keepLooping = false;
        useSearchedLine = false;
        if (c != ctrlChar('L')) {
          c = -1;  // ctrl-C and ctrl-G just abort the search and do nothing
                   // else
        }
        break;

      // these characters stay in search mode and update the display
      case ctrlChar('S'):
      case ctrlChar('R'):
        if (dp.searchTextLen ==
            0) {  // if no current search text, recall previous text
          if (previousSearchText.length()) {
            dp.updateSearchText(previousSearchText.get());
          }
        }
        if ((dp.direction == 1 && c == ctrlChar('R')) ||
            (dp.direction == -1 && c == ctrlChar('S'))) {
          dp.direction = 0 - dp.direction;  // reverse direction
          dp.updateSearchPrompt();          // change the prompt
        } else {
          searchAgain = true;  // same direction, search again
        }
        break;

// job control is its own thing
#ifndef _WIN32
      case ctrlChar('Z'):  // ctrl-Z, job control
        disableRawMode();  // Returning to Linux (whatever) shell, leave raw
                           // mode
        raise(SIGSTOP);    // Break out in mid-line
        enableRawMode();   // Back from Linux shell, re-enter raw mode
        {
          bufferSize = historyLineLength + 1;
          unique_ptr<char32_t[]> tempUnicode(new char32_t[bufferSize]);
          copyString8to32(tempUnicode.get(), bufferSize, ucharCount,
                          history[historyIndex]);
          dynamicRefresh(dp, tempUnicode.get(), historyLineLength,
                         historyLinePosition);
        }
        continue;
        break;
#endif

      // these characters update the search string, and hence the selected input
      // line
      case ctrlChar('H'):  // backspace/ctrl-H, delete char to left of cursor
        if (dp.searchTextLen > 0) {
          unique_ptr<char32_t[]> tempUnicode(new char32_t[dp.searchTextLen]);
          --dp.searchTextLen;
          dp.searchText[dp.searchTextLen] = 0;
          copyString32(tempUnicode.get(), dp.searchText.get(),
                       dp.searchTextLen);
          dp.updateSearchText(tempUnicode.get());
        } else {
          beep();
        }
        break;

      case ctrlChar('Y'):  // ctrl-Y, yank killed text
        break;

      default:
        if (!isControlChar(c) && c <= 0x0010FFFF) {  // not an action character
          unique_ptr<char32_t[]> tempUnicode(
              new char32_t[dp.searchTextLen + 2]);
          copyString32(tempUnicode.get(), dp.searchText.get(),
                       dp.searchTextLen);
          tempUnicode[dp.searchTextLen] = c;
          tempUnicode[dp.searchTextLen + 1] = 0;
          dp.updateSearchText(tempUnicode.get());
        } else {
          beep();
        }
    }  // switch

    // if we are staying in search mode, search now
    if (keepLooping) {
      bufferSize = historyLineLength + 1;
      if (activeHistoryLine) {
        delete[] activeHistoryLine;
        activeHistoryLine = nullptr;
      }
      activeHistoryLine = new char32_t[bufferSize];
      copyString8to32(activeHistoryLine, bufferSize, ucharCount,
                      history[historyIndex]);
      if (dp.searchTextLen > 0) {
        bool found = false;
        int historySearchIndex = historyIndex;
        int lineLength = static_cast<int>(ucharCount);
        int lineSearchPos = historyLinePosition;
        if (searchAgain) {
          lineSearchPos += dp.direction;
        }
        searchAgain = false;
        while (true) {
          while ((dp.direction > 0) ? (lineSearchPos < lineLength)
                                    : (lineSearchPos >= 0)) {
            if (strncmp32(dp.searchText.get(),
                          &activeHistoryLine[lineSearchPos],
                          dp.searchTextLen) == 0) {
              found = true;
              break;
            }
            lineSearchPos += dp.direction;
          }
          if (found) {
            historyIndex = historySearchIndex;
            historyLineLength = lineLength;
            historyLinePosition = lineSearchPos;
            break;
          } else if ((dp.direction > 0) ? (historySearchIndex < historyLen - 1)
                                        : (historySearchIndex > 0)) {
            historySearchIndex += dp.direction;
            bufferSize = strlen8(history[historySearchIndex]) + 1;
            delete[] activeHistoryLine;
            activeHistoryLine = nullptr;
            activeHistoryLine = new char32_t[bufferSize];
            copyString8to32(activeHistoryLine, bufferSize, ucharCount,
                            history[historySearchIndex]);
            lineLength = static_cast<int>(ucharCount);
            lineSearchPos =
                (dp.direction > 0) ? 0 : (lineLength - dp.searchTextLen);
          } else {
            beep();
            break;
          }
        };  // while
      }
      if (activeHistoryLine) {
        delete[] activeHistoryLine;
        activeHistoryLine = nullptr;
      }
      bufferSize = historyLineLength + 1;
      activeHistoryLine = new char32_t[bufferSize];
      copyString8to32(activeHistoryLine, bufferSize, ucharCount,
                      history[historyIndex]);
      dynamicRefresh(dp, activeHistoryLine, historyLineLength,
                     historyLinePosition);  // draw user's text with our prompt
    }
  }  // while

  // leaving history search, restore previous prompt, maybe make searched line
  // current
  PromptBase pb;
  pb.promptChars = pi.promptIndentation;
  pb.promptBytes = pi.promptBytes;
  Utf32String tempUnicode(pb.promptBytes + 1);

  copyString32(tempUnicode.get(), &pi.promptText[pi.promptLastLinePosition],
               pb.promptBytes - pi.promptLastLinePosition);
  tempUnicode.initFromBuffer();
  pb.promptText = tempUnicode;
  pb.promptExtraLines = 0;
  pb.promptIndentation = pi.promptIndentation;
  pb.promptLastLinePosition = 0;
  pb.promptPreviousInputLen = historyLineLength;
  pb.promptCursorRowOffset = dp.promptCursorRowOffset;
  pb.promptScreenColumns = pi.promptScreenColumns;
  pb.promptPreviousLen = dp.promptChars;
  if (useSearchedLine && activeHistoryLine) {
    historyRecallMostRecent = true;
    copyString32(buf32, activeHistoryLine, buflen + 1);
    len = historyLineLength;
    pos = historyLinePosition;
  }
  if (activeHistoryLine) {
    delete[] activeHistoryLine;
    activeHistoryLine = nullptr;
  }
  dynamicRefresh(pb, buf32, len,
                 pos);  // redraw the original prompt with current input
  pi.promptPreviousInputLen = len;
  pi.promptCursorRowOffset = pi.promptExtraLines + pb.promptCursorRowOffset;
  previousSearchText =
      dp.searchText;  // save search text for possible reuse on ctrl-R ctrl-R
  return c;           // pass a character or -1 back to main loop
}

static bool isCharacterAlphanumeric(char32_t testChar) {
#ifdef _WIN32
  return (iswalnum((wint_t)testChar) != 0 ? true : false);
#else
  return (iswalnum(testChar) != 0 ? true : false);
#endif
}

#ifndef _WIN32
static bool gotResize = false;
#endif
static int keyType = 0;

int InputBuffer::getInputLine(PromptBase& pi) {
  keyType = 0;

  // The latest history entry is always our current buffer
  if (len > 0) {
    size_t bufferSize = sizeof(char32_t) * len + 1;
    unique_ptr<char[]> tempBuffer(new char[bufferSize]);
    copyString32to8(tempBuffer.get(), bufferSize, buf32);
    linenoiseHistoryAdd(tempBuffer.get());
  } else {
    linenoiseHistoryAdd("");
  }
  historyIndex = historyLen - 1;
  historyRecallMostRecent = false;

  // display the prompt
  if (!pi.write()) return -1;

#ifndef _WIN32
  // we have to generate our own newline on line wrap on Linux
  if (pi.promptIndentation == 0 && pi.promptExtraLines > 0)
    if (write(1, "\n", 1) == -1) return -1;
#endif

  // the cursor starts out at the end of the prompt
  pi.promptCursorRowOffset = pi.promptExtraLines;

  // kill and yank start in "other" mode
  killRing.lastAction = KillRing::actionOther;

  // when history search returns control to us, we execute its terminating
  // keystroke
  int terminatingKeystroke = -1;

  // if there is already text in the buffer, display it first
  if (len > 0) {
    refreshLine(pi);
  }

  // loop collecting characters, respond to line editing characters
  while (true) {
    int c;
    if (terminatingKeystroke == -1) {
      c = linenoiseReadChar();  // get a new keystroke

      keyType = 0;
      if (c != 0) {
        // set flag that we got some input
        if (c == ctrlChar('C')) {
          keyType = 1;
        } else if (c == ctrlChar('D')) {
          keyType = 2;
        }
      }

#ifndef _WIN32
      if (c == 0 && gotResize) {
        // caught a window resize event
        // now redraw the prompt and line
        gotResize = false;
        pi.promptScreenColumns = getScreenColumns();
        dynamicRefresh(pi, buf32, len,
                       pos);  // redraw the original prompt with current input
        continue;
      }
#endif
    } else {
      c = terminatingKeystroke;   // use the terminating keystroke from search
      terminatingKeystroke = -1;  // clear it once we've used it
    }

    c = cleanupCtrl(c);  // convert CTRL + <char> into normal ctrl

    if (c == 0) {
      return len;
    }

    if (c == -1) {
      refreshLine(pi);
      continue;
    }

    if (c == -2) {
      if (!pi.write()) return -1;
      refreshLine(pi);
      continue;
    }

    // ctrl-I/tab, command completion, needs to be before switch statement
    if (c == ctrlChar('I') && completionCallback) {
      if (pos == 0)  // SERVER-4967 -- in earlier versions, you could paste
                     // previous output
        continue;    //  back into the shell ... this output may have leading
                     //  tabs.
      // This hack (i.e. what the old code did) prevents command completion
      //  on an empty line but lets users paste text with leading tabs.

      killRing.lastAction = KillRing::actionOther;
      historyRecallMostRecent = false;

      // completeLine does the actual completion and replacement
      c = completeLine(pi);

      if (c < 0)  // return on error
        return len;

      if (c == 0)  // read next character when 0
        continue;

      // deliberate fall-through here, so we use the terminating character
    }

    switch (c) {
      case ctrlChar('A'):  // ctrl-A, move cursor to start of line
      case HOME_KEY:
        killRing.lastAction = KillRing::actionOther;
        pos = 0;
        refreshLine(pi);
        break;

      case ctrlChar('B'):  // ctrl-B, move cursor left by one character
      case LEFT_ARROW_KEY:
        killRing.lastAction = KillRing::actionOther;
        if (pos > 0) {
          --pos;
          refreshLine(pi);
        }
        break;

      case META + 'b':  // meta-B, move cursor left by one word
      case META + 'B':
      case CTRL + LEFT_ARROW_KEY:
      case META + LEFT_ARROW_KEY:  // Emacs allows Meta, bash & readline don't
        killRing.lastAction = KillRing::actionOther;
        if (pos > 0) {
          while (pos > 0 && !isCharacterAlphanumeric(buf32[pos - 1])) {
            --pos;
          }
          while (pos > 0 && isCharacterAlphanumeric(buf32[pos - 1])) {
            --pos;
          }
          refreshLine(pi);
        }
        break;

      case ctrlChar('C'):  // ctrl-C, abort this line
        killRing.lastAction = KillRing::actionOther;
        historyRecallMostRecent = false;
        errno = EAGAIN;
        --historyLen;
        free(history[historyLen]);
        // we need one last refresh with the cursor at the end of the line
        // so we don't display the next prompt over the previous input line
        pos = len;  // pass len as pos for EOL
        refreshLine(pi);
        if (write(1, "^C", 2) == -1) return -1;  // Display the ^C we got
        return -1;

      case META + 'c':  // meta-C, give word initial Cap
      case META + 'C':
        killRing.lastAction = KillRing::actionOther;
        historyRecallMostRecent = false;
        if (pos < len) {
          while (pos < len && !isCharacterAlphanumeric(buf32[pos])) {
            ++pos;
          }
          if (pos < len && isCharacterAlphanumeric(buf32[pos])) {
            if (buf32[pos] >= 'a' && buf32[pos] <= 'z') {
              buf32[pos] += 'A' - 'a';
            }
            ++pos;
          }
          while (pos < len && isCharacterAlphanumeric(buf32[pos])) {
            if (buf32[pos] >= 'A' && buf32[pos] <= 'Z') {
              buf32[pos] += 'a' - 'A';
            }
            ++pos;
          }
          refreshLine(pi);
        }
        break;

      // ctrl-D, delete the character under the cursor
      // on an empty line, exit the shell
      case ctrlChar('D'):
        killRing.lastAction = KillRing::actionOther;
        if (len > 0 && pos < len) {
          historyRecallMostRecent = false;
          memmove(buf32 + pos, buf32 + pos + 1, sizeof(char32_t) * (len - pos));
          --len;
          refreshLine(pi);
        } else if (len == 0) {
          --historyLen;
          free(history[historyLen]);
          return -1;
        }
        break;

      case META + 'd':  // meta-D, kill word to right of cursor
      case META + 'D':
        if (pos < len) {
          historyRecallMostRecent = false;
          int endingPos = pos;
          while (endingPos < len &&
                 !isCharacterAlphanumeric(buf32[endingPos])) {
            ++endingPos;
          }
          while (endingPos < len && isCharacterAlphanumeric(buf32[endingPos])) {
            ++endingPos;
          }
          killRing.kill(&buf32[pos], endingPos - pos, true);
          memmove(buf32 + pos, buf32 + endingPos,
                  sizeof(char32_t) * (len - endingPos + 1));
          len -= endingPos - pos;
          refreshLine(pi);
        }
        killRing.lastAction = KillRing::actionKill;
        break;

      case ctrlChar('E'):  // ctrl-E, move cursor to end of line
      case END_KEY:
        killRing.lastAction = KillRing::actionOther;
        pos = len;
        refreshLine(pi);
        break;

      case ctrlChar('F'):  // ctrl-F, move cursor right by one character
      case RIGHT_ARROW_KEY:
        killRing.lastAction = KillRing::actionOther;
        if (pos < len) {
          ++pos;
          refreshLine(pi);
        }
        break;

      case META + 'f':  // meta-F, move cursor right by one word
      case META + 'F':
      case CTRL + RIGHT_ARROW_KEY:
      case META + RIGHT_ARROW_KEY:  // Emacs allows Meta, bash & readline don't
        killRing.lastAction = KillRing::actionOther;
        if (pos < len) {
          while (pos < len && !isCharacterAlphanumeric(buf32[pos])) {
            ++pos;
          }
          while (pos < len && isCharacterAlphanumeric(buf32[pos])) {
            ++pos;
          }
          refreshLine(pi);
        }
        break;

      case ctrlChar('H'):  // backspace/ctrl-H, delete char to left of cursor
        killRing.lastAction = KillRing::actionOther;
        if (pos > 0) {
          historyRecallMostRecent = false;
          memmove(buf32 + pos - 1, buf32 + pos,
                  sizeof(char32_t) * (1 + len - pos));
          --pos;
          --len;
          refreshLine(pi);
        }
        break;

      // meta-Backspace, kill word to left of cursor
      case META + ctrlChar('H'):
        if (pos > 0) {
          historyRecallMostRecent = false;
          int startingPos = pos;
          while (pos > 0 && !isCharacterAlphanumeric(buf32[pos - 1])) {
            --pos;
          }
          while (pos > 0 && isCharacterAlphanumeric(buf32[pos - 1])) {
            --pos;
          }
          killRing.kill(&buf32[pos], startingPos - pos, false);
          memmove(buf32 + pos, buf32 + startingPos,
                  sizeof(char32_t) * (len - startingPos + 1));
          len -= startingPos - pos;
          refreshLine(pi);
        }
        killRing.lastAction = KillRing::actionKill;
        break;

      case ctrlChar('J'):  // ctrl-J/linefeed/newline, accept line
      case ctrlChar('M'):  // ctrl-M/return/enter
        killRing.lastAction = KillRing::actionOther;
        // we need one last refresh with the cursor at the end of the line
        // so we don't display the next prompt over the previous input line
        pos = len;  // pass len as pos for EOL
        refreshLine(pi);
        historyPreviousIndex = historyRecallMostRecent ? historyIndex : -2;
        --historyLen;
        free(history[historyLen]);
        return len;

      case ctrlChar('K'):  // ctrl-K, kill from cursor to end of line
        killRing.kill(&buf32[pos], len - pos, true);
        buf32[pos] = '\0';
        len = pos;
        refreshLine(pi);
        killRing.lastAction = KillRing::actionKill;
        historyRecallMostRecent = false;
        break;

      case ctrlChar('L'):  // ctrl-L, clear screen and redisplay line
        clearScreen(pi);
        break;

      case META + 'l':  // meta-L, lowercase word
      case META + 'L':
        killRing.lastAction = KillRing::actionOther;
        if (pos < len) {
          historyRecallMostRecent = false;
          while (pos < len && !isCharacterAlphanumeric(buf32[pos])) {
            ++pos;
          }
          while (pos < len && isCharacterAlphanumeric(buf32[pos])) {
            if (buf32[pos] >= 'A' && buf32[pos] <= 'Z') {
              buf32[pos] += 'a' - 'A';
            }
            ++pos;
          }
          refreshLine(pi);
        }
        break;

      case ctrlChar('N'):  // ctrl-N, recall next line in history
      case ctrlChar('P'):  // ctrl-P, recall previous line in history
      case DOWN_ARROW_KEY:
      case UP_ARROW_KEY:
        killRing.lastAction = KillRing::actionOther;
        // if not already recalling, add the current line to the history list so
        // we don't
        // have to special case it
        if (historyIndex == historyLen - 1) {
          free(history[historyLen - 1]);
          size_t tempBufferSize = sizeof(char32_t) * len + 1;
          unique_ptr<char[]> tempBuffer(new char[tempBufferSize]);
          copyString32to8(tempBuffer.get(), tempBufferSize, buf32);
          history[historyLen - 1] = strdup8(tempBuffer.get());
        }
        if (historyLen > 1) {
          if (c == UP_ARROW_KEY) {
            c = ctrlChar('P');
          }
          if (historyPreviousIndex != -2 && c != ctrlChar('P')) {
            historyIndex =
                1 + historyPreviousIndex;  // emulate Windows down-arrow
          } else {
            historyIndex += (c == ctrlChar('P')) ? -1 : 1;
          }
          historyPreviousIndex = -2;
          if (historyIndex < 0) {
            historyIndex = 0;
            break;
          } else if (historyIndex >= historyLen) {
            historyIndex = historyLen - 1;
            break;
          }
          historyRecallMostRecent = true;
          size_t ucharCount = 0;
          copyString8to32(buf32, buflen, ucharCount, history[historyIndex]);
          len = pos = static_cast<int>(ucharCount);
          refreshLine(pi);
        }
        break;

      case ctrlChar('R'):  // ctrl-R, reverse history search
      case ctrlChar('S'):  // ctrl-S, forward history search
        terminatingKeystroke = incrementalHistorySearch(pi, c);
        break;

      case ctrlChar('T'):  // ctrl-T, transpose characters
        killRing.lastAction = KillRing::actionOther;
        if (pos > 0 && len > 1) {
          historyRecallMostRecent = false;
          size_t leftCharPos = (pos == len) ? pos - 2 : pos - 1;
          char32_t aux = buf32[leftCharPos];
          buf32[leftCharPos] = buf32[leftCharPos + 1];
          buf32[leftCharPos + 1] = aux;
          if (pos != len) ++pos;
          refreshLine(pi);
        }
        break;

      case ctrlChar(
          'U'):  // ctrl-U, kill all characters to the left of the cursor
        if (pos > 0) {
          historyRecallMostRecent = false;
          killRing.kill(&buf32[0], pos, false);
          len -= pos;
          memmove(buf32, buf32 + pos, sizeof(char32_t) * (len + 1));
          pos = 0;
          refreshLine(pi);
        }
        killRing.lastAction = KillRing::actionKill;
        break;

      case META + 'u':  // meta-U, uppercase word
      case META + 'U':
        killRing.lastAction = KillRing::actionOther;
        if (pos < len) {
          historyRecallMostRecent = false;
          while (pos < len && !isCharacterAlphanumeric(buf32[pos])) {
            ++pos;
          }
          while (pos < len && isCharacterAlphanumeric(buf32[pos])) {
            if (buf32[pos] >= 'a' && buf32[pos] <= 'z') {
              buf32[pos] += 'A' - 'a';
            }
            ++pos;
          }
          refreshLine(pi);
        }
        break;

      // ctrl-W, kill to whitespace (not word) to left of cursor
      case ctrlChar('W'):
        if (pos > 0) {
          historyRecallMostRecent = false;
          int startingPos = pos;
          while (pos > 0 && buf32[pos - 1] == ' ') {
            --pos;
          }
          while (pos > 0 && buf32[pos - 1] != ' ') {
            --pos;
          }
          killRing.kill(&buf32[pos], startingPos - pos, false);
          memmove(buf32 + pos, buf32 + startingPos,
                  sizeof(char32_t) * (len - startingPos + 1));
          len -= startingPos - pos;
          refreshLine(pi);
        }
        killRing.lastAction = KillRing::actionKill;
        break;

      case ctrlChar('Y'):  // ctrl-Y, yank killed text
        historyRecallMostRecent = false;
        {
          Utf32String* restoredText = killRing.yank();
          if (restoredText) {
            bool truncated = false;
            size_t ucharCount = restoredText->length();
            if (ucharCount > static_cast<size_t>(buflen - len)) {
              ucharCount = buflen - len;
              truncated = true;
            }
            memmove(buf32 + pos + ucharCount, buf32 + pos,
                    sizeof(char32_t) * (len - pos + 1));
            memmove(buf32 + pos, restoredText->get(),
                    sizeof(char32_t) * ucharCount);
            pos += static_cast<int>(ucharCount);
            len += static_cast<int>(ucharCount);
            refreshLine(pi);
            killRing.lastAction = KillRing::actionYank;
            killRing.lastYankSize = ucharCount;
            if (truncated) {
              beep();
            }
          } else {
            beep();
          }
        }
        break;

      case META + 'y':  // meta-Y, "yank-pop", rotate popped text
      case META + 'Y':
        if (killRing.lastAction == KillRing::actionYank) {
          historyRecallMostRecent = false;
          Utf32String* restoredText = killRing.yankPop();
          if (restoredText) {
            bool truncated = false;
            size_t ucharCount = restoredText->length();
            if (ucharCount >
                static_cast<size_t>(killRing.lastYankSize + buflen - len)) {
              ucharCount = killRing.lastYankSize + buflen - len;
              truncated = true;
            }
            if (ucharCount > killRing.lastYankSize) {
              memmove(buf32 + pos + ucharCount - killRing.lastYankSize,
                      buf32 + pos, sizeof(char32_t) * (len - pos + 1));
              memmove(buf32 + pos - killRing.lastYankSize, restoredText->get(),
                      sizeof(char32_t) * ucharCount);
            } else {
              memmove(buf32 + pos - killRing.lastYankSize, restoredText->get(),
                      sizeof(char32_t) * ucharCount);
              memmove(buf32 + pos + ucharCount - killRing.lastYankSize,
                      buf32 + pos, sizeof(char32_t) * (len - pos + 1));
            }
            pos += static_cast<int>(ucharCount - killRing.lastYankSize);
            len += static_cast<int>(ucharCount - killRing.lastYankSize);
            killRing.lastYankSize = ucharCount;
            refreshLine(pi);
            if (truncated) {
              beep();
            }
            break;
          }
        }
        beep();
        break;

#ifndef _WIN32
      case ctrlChar('Z'):  // ctrl-Z, job control
        disableRawMode();  // Returning to Linux (whatever) shell, leave raw
                           // mode
        raise(SIGSTOP);    // Break out in mid-line
        enableRawMode();   // Back from Linux shell, re-enter raw mode
        if (!pi.write()) break;  // Redraw prompt
        refreshLine(pi);         // Refresh the line
        break;
#endif

      // DEL, delete the character under the cursor
      case 127:
      case DELETE_KEY:
        killRing.lastAction = KillRing::actionOther;
        if (len > 0 && pos < len) {
          historyRecallMostRecent = false;
          memmove(buf32 + pos, buf32 + pos + 1, sizeof(char32_t) * (len - pos));
          --len;
          refreshLine(pi);
        }
        break;

      case META + '<':     // meta-<, beginning of history
      case PAGE_UP_KEY:    // Page Up, beginning of history
      case META + '>':     // meta->, end of history
      case PAGE_DOWN_KEY:  // Page Down, end of history
        killRing.lastAction = KillRing::actionOther;
        // if not already recalling, add the current line to the history list so
        // we don't
        // have to special case it
        if (historyIndex == historyLen - 1) {
          free(history[historyLen - 1]);
          size_t tempBufferSize = sizeof(char32_t) * len + 1;
          unique_ptr<char[]> tempBuffer(new char[tempBufferSize]);
          copyString32to8(tempBuffer.get(), tempBufferSize, buf32);
          history[historyLen - 1] = strdup8(tempBuffer.get());
        }
        if (historyLen > 1) {
          historyIndex =
              (c == META + '<' || c == PAGE_UP_KEY) ? 0 : historyLen - 1;
          historyPreviousIndex = -2;
          historyRecallMostRecent = true;
          size_t ucharCount = 0;
          copyString8to32(buf32, buflen, ucharCount, history[historyIndex]);
          len = pos = static_cast<int>(ucharCount);
          refreshLine(pi);
        }
        break;

      // not one of our special characters, maybe insert it in the buffer
      default:
        killRing.lastAction = KillRing::actionOther;
        historyRecallMostRecent = false;
        if (c & (META | CTRL)) {  // beep on unknown Ctrl and/or Meta keys
          beep();
          break;
        }
        if (len < buflen) {
          if (isControlChar(c)) {  // don't insert control characters
            beep();
            break;
          }
          if (len == pos) {  // at end of buffer
            buf32[pos] = c;
            ++pos;
            ++len;
            buf32[len] = '\0';
            int inputLen = calculateColumnPosition(buf32, len);
            if (pi.promptIndentation + inputLen < pi.promptScreenColumns) {
              if (inputLen > pi.promptPreviousInputLen)
                pi.promptPreviousInputLen = inputLen;
              /* Avoid a full update of the line in the
               * trivial case. */
              if (write32(1, reinterpret_cast<char32_t*>(&c), 1) == -1)
                return -1;
            } else {
              refreshLine(pi);
            }
          } else {  // not at end of buffer, have to move characters to our
                    // right
            memmove(buf32 + pos + 1, buf32 + pos,
                    sizeof(char32_t) * (len - pos));
            buf32[pos] = c;
            ++len;
            ++pos;
            buf32[len] = '\0';
            refreshLine(pi);
          }
        } else {
          beep();  // buffer is full, beep on new characters
        }
        break;
    }
  }
  return len;
}

static string preloadedBufferContents;  // used with linenoisePreloadBuffer
static string preloadErrorMessage;

/**
 * linenoisePreloadBuffer provides text to be inserted into the command buffer
 *
 * the provided text will be processed to be usable and will be used to preload
 * the input buffer on the next call to linenoise()
 *
 * @param preloadText text to begin with on the next call to linenoise()
 */
void linenoisePreloadBuffer(const char* preloadText) {
  if (!preloadText) {
    return;
  }
  int bufferSize = static_cast<int>(strlen(preloadText) + 1);
  unique_ptr<char[]> tempBuffer(new char[bufferSize]);
  strncpy(&tempBuffer[0], preloadText, bufferSize);

  // remove characters that won't display correctly
  char* pIn = &tempBuffer[0];
  char* pOut = pIn;
  bool controlsStripped = false;
  bool whitespaceSeen = false;
  while (*pIn) {
    unsigned char c =
        *pIn++;       // we need unsigned so chars 0x80 and above are allowed
    if ('\r' == c) {  // silently skip CR
      continue;
    }
    if ('\n' == c || '\t' == c) {  // note newline or tab
      whitespaceSeen = true;
      continue;
    }
    if (isControlChar(
            c)) {  // remove other control characters, flag for message
      controlsStripped = true;
      *pOut++ = ' ';
      continue;
    }
    if (whitespaceSeen) {  // convert whitespace to a single space
      *pOut++ = ' ';
      whitespaceSeen = false;
    }
    *pOut++ = c;
  }
  *pOut = 0;
  int processedLength = static_cast<int>(pOut - tempBuffer.get());
  bool lineTruncated = false;
  if (processedLength > (LINENOISE_MAX_LINE - 1)) {
    lineTruncated = true;
    tempBuffer[LINENOISE_MAX_LINE - 1] = 0;
  }
  preloadedBufferContents = tempBuffer.get();
  if (controlsStripped) {
    preloadErrorMessage +=
        " [Edited line: control characters were converted to spaces]\n";
  }
  if (lineTruncated) {
    preloadErrorMessage += " [Edited line: the line length was reduced from ";
    char buf[128];
    snprintf(buf, sizeof(buf), "%d to %d]\n", processedLength,
             (LINENOISE_MAX_LINE - 1));
    preloadErrorMessage += buf;
  }
}

/**
 * linenoise is a readline replacement.
 *
 * call it with a prompt to display and it will return a line of input from the
 * user
 *
 * @param prompt text of prompt to display to the user
 * @return       the returned string belongs to the caller on return and must be
 * freed to prevent
 *               memory leaks
 */
char* linenoise(const char* prompt) {
#ifndef _WIN32
  gotResize = false;
#endif
  if (isatty(STDIN_FILENO)) {  // input is from a terminal
    char32_t buf32[LINENOISE_MAX_LINE];
    char charWidths[LINENOISE_MAX_LINE];
    if (!preloadErrorMessage.empty()) {
      printf("%s", preloadErrorMessage.c_str());
      fflush(stdout);
      preloadErrorMessage.clear();
    }
    PromptInfo pi(prompt, getScreenColumns());
    if (isUnsupportedTerm()) {
      if (!pi.write()) return 0;
      fflush(stdout);
      if (preloadedBufferContents.empty()) {
        unique_ptr<char[]> buf8(new char[LINENOISE_MAX_LINE]);
        if (fgets(buf8.get(), LINENOISE_MAX_LINE, stdin) == NULL) {
          return NULL;
        }
        size_t len = strlen(buf8.get());
        while (len && (buf8[len - 1] == '\n' || buf8[len - 1] == '\r')) {
          --len;
          buf8[len] = '\0';
        }
        return strdup(buf8.get());  // caller must free buffer
      } else {
        char* buf8 = strdup(preloadedBufferContents.c_str());
        preloadedBufferContents.clear();
        return buf8;  // caller must free buffer
      }
    } else {
      if (enableRawMode() == -1) {
        return NULL;
      }
      InputBuffer ib(buf32, charWidths, LINENOISE_MAX_LINE);
      if (!preloadedBufferContents.empty()) {
        ib.preloadBuffer(preloadedBufferContents.c_str());
        preloadedBufferContents.clear();
      }
      int count = ib.getInputLine(pi);
      disableRawMode();
      printf("\n");
      if (count == -1) {
        return NULL;
      }
      size_t bufferSize = sizeof(char32_t) * ib.length() + 1;
      unique_ptr<char[]> buf8(new char[bufferSize]);
      copyString32to8(buf8.get(), bufferSize, buf32);
      return strdup(buf8.get());  // caller must free buffer
    }
  } else {  // input not from a terminal, we should work with piped input, i.e.
            // redirected stdin
    unique_ptr<char[]> buf8(new char[LINENOISE_MAX_LINE]);
    if (fgets(buf8.get(), LINENOISE_MAX_LINE, stdin) == NULL) {
      return NULL;
    }

    // if fgets() gave us the newline, remove it
    int count = static_cast<int>(strlen(buf8.get()));
    if (count > 0 && buf8[count - 1] == '\n') {
      --count;
      buf8[count] = '\0';
    }
    return strdup(buf8.get());  // caller must free buffer
  }
}

/* Register a callback function to be called for tab-completion. */
void linenoiseSetCompletionCallback(linenoiseCompletionCallback* fn) {
  completionCallback = fn;
}

void linenoiseAddCompletion(linenoiseCompletions* lc, const char* str) {
  lc->completionStrings.push_back(Utf32String(str));
}

int linenoiseHistoryAdd(const char* line) {
  if (historyMaxLen == 0) {
    return 0;
  }
  if (history == NULL) {
    history =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * historyMaxLen));
    if (history == NULL) {
      return 0;
    }
    memset(history, 0, (sizeof(char*) * historyMaxLen));
  }
  char8_t* linecopy = strdup8(line);
  if (!linecopy) {
    return 0;
  }

  // convert newlines in multi-line code to spaces before storing
  char8_t* p = linecopy;
  while (*p) {
    if (*p == '\n') {
      *p = ' ';
    }
    ++p;
  }

  // prevent duplicate history entries
  if (historyLen > 0 && history[historyLen - 1] != nullptr &&
      strcmp(reinterpret_cast<char const*>(history[historyLen - 1]),
             reinterpret_cast<char const*>(linecopy)) == 0) {
    free(linecopy);
    return 0;
  }

  if (historyLen == historyMaxLen) {
    free(history[0]);
    memmove(history, history + 1, sizeof(char*) * (historyMaxLen - 1));
    --historyLen;
    if (--historyPreviousIndex < -1) {
      historyPreviousIndex = -2;
    }
  }

  history[historyLen] = linecopy;
  ++historyLen;
  return 1;
}

int linenoiseHistorySetMaxLen(int len) {
  if (len < 1) {
    return 0;
  }
  if (history) {
    int tocopy = historyLen;
    char8_t** newHistory =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * len));
    if (newHistory == NULL) {
      return 0;
    }
    if (len < tocopy) {
      tocopy = len;
    }
    memcpy(newHistory, history + historyMaxLen - tocopy,
           sizeof(char8_t*) * tocopy);
    free(history);
    history = newHistory;
  }
  historyMaxLen = len;
  if (historyLen > historyMaxLen) {
    historyLen = historyMaxLen;
  }
  return 1;
}

/* Fetch a line of the history by (zero-based) index.  If the requested
 * line does not exist, NULL is returned.  The return value is a heap-allocated
 * copy of the line, and the caller is responsible for de-allocating it. */
char* linenoiseHistoryLine(int index) {
  if (index < 0 || index >= historyLen) return NULL;

  return strdup(reinterpret_cast<char const*>(history[index]));
}

/* Save the history in the specified file. On success 0 is returned
 * otherwise -1 is returned. */
int linenoiseHistorySave(const char* filename) {
#if _WIN32
  FILE* fp = fopen(filename, "wt");
#else
  int fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR);

  if (fd < 0) {
    return -1;
  }

  FILE* fp = fdopen(fd, "wt");
#endif

  if (fp == NULL) {
    return -1;
  }

  for (int j = 0; j < historyLen; ++j) {
    if (history[j][0] != '\0') {
      fprintf(fp, "%s\n", history[j]);
    }
  }

  fclose(fp);

  return 0;
}

/* Load the history from the specified file. If the file does not exist
 * zero is returned and no operation is performed.
 *
 * If the file exists and the operation succeeded 0 is returned, otherwise
 * on error -1 is returned. */
int linenoiseHistoryLoad(const char* filename) {
  FILE* fp = fopen(filename, "rt");
  if (fp == NULL) {
    return -1;
  }

  char buf[LINENOISE_MAX_LINE];
  while (fgets(buf, LINENOISE_MAX_LINE, fp) != NULL) {
    char* p = strchr(buf, '\r');
    if (!p) {
      p = strchr(buf, '\n');
    }
    if (p) {
      *p = '\0';
    }
    if (p != buf) {
      linenoiseHistoryAdd(buf);
    }
  }
  fclose(fp);
  return 0;
}

/* Set if to use or not the multi line mode. */
/* note that this is a stub only, as linenoise-ng always multi-line */
void linenoiseSetMultiLine(int) {}

/* This special mode is used by linenoise in order to print scan codes
 * on screen for debugging / development purposes. It is implemented
 * by the linenoise_example program using the --keycodes option. */
void linenoisePrintKeyCodes(void) {
  char quit[4];

  printf(
      "Linenoise key codes debugging mode.\n"
      "Press keys to see scan codes. Type 'quit' at any time to exit.\n");
  if (enableRawMode() == -1) return;
  memset(quit, ' ', 4);
  while (1) {
    char c;
#if _WIN32
    /* Windows' _read() seems to return int, which is stupid */
    int nread = _read(STDIN_FILENO, &c, 1);
#else
    long nread = read(STDIN_FILENO, &c, 1);
#endif
    if (nread <= 0) continue;
    memmove(quit, quit + 1, sizeof(quit) - 1); /* shift string to left. */
    quit[sizeof(quit) - 1] = c; /* Insert current char on the right. */
    if (memcmp(quit, "quit", sizeof(quit)) == 0) break;

    printf("'%c' %02x (%d) (type quit to exit)\n", isprint(c) ? c : '?',
            (unsigned int)c, (int)c);
    printf("\r"); /* Go left edge manually, we are in raw mode. */
    fflush(stdout);
  }
  disableRawMode();
}

#ifndef _WIN32
static void WindowSizeChanged(int) {
  // do nothing here but setting this flag
  gotResize = true;
}
#endif

int linenoiseInstallWindowChangeHandler(void) {
#ifndef _WIN32
  struct sigaction sa;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;
  sa.sa_handler = &WindowSizeChanged;

  if (sigaction(SIGWINCH, &sa, nullptr) == -1) {
    return errno;
  }
#endif
  return 0;
}

int linenoiseKeyType(void) {
  return keyType;
}