syntax iskeyword a-z
highlight link RpxCmdStart Keyword
syntax match RpxCmdStart /^:/ contained
highlight link RpxTglCmd Special
highlight link RpxTglItem Identifier
syntax match RpxTglCmd /t/ contained
syntax match RpxTgl /^:t/ contained contains=RpxCmdStart,RpxTglCmd
syntax match RpxTglItem /\l/ contained
syntax match RpxToggle /^:t\l/ contains=RpxTgl,RpxTglItem
highlight link RpxStgCmd Special
highlight link RpxStgItem Identifier
syntax match RpxStgCmd /s/ contained
syntax match RpxStg /^:s/ contained contains=RpxCmdStart,RpxStgCmd
syntax match RpxStgItem /\l/ contained
syntax match RpxSetting /^:s\l\l/ contains=RpxStg,RpxStgItem,RpxStgItem
highlight link RpxFormulaFollowsCmd Special
syntax match RpxFormulaFollowsCmd /[op]/ contained
syntax match RpxFormulaFollows /^:[op]/ contains=RpxCmdStart,RpxFormulaFollowsCmd
syntax match Comment /;.*/
syntax match Delimiter /,/
syntax match Operator "\V\[-+/*=^><%]"
syntax match Constant "\\."
syntax match Identifier "\$."
syntax match Identifier "&."
syntax match Function "!"
syntax match SpecialChar "@."
syntax match Number "\d"
syntax match Number "\."
syntax match Keyword "s"
syntax match Keyword "c"
syntax match Keyword "t"
syntax match Keyword "as"
syntax match Keyword "as"
syntax match Keyword "as"
syntax match Keyword "hs"
syntax match Keyword "hc"
syntax match Keyword "ht"
syntax match Keyword "l2"
syntax match Keyword "lc"
syntax match Keyword "le"
syntax match Keyword "m"
syntax match Keyword "ig"
syntax match Keyword "il"
syntax match Keyword "ic"
syntax match Keyword "ip"
syntax match Keyword "A"
syntax match Keyword "C"
syntax match Keyword "F"
syntax match Keyword "R"
syntax match Keyword "d"
syntax match Keyword "r"
syntax match Keyword "L"

/**
 * @file src/testing.c
 */
#include "testing.h"
#undef main
#ifdef TEST_MODE
int test__success;
int test__count;
int main() {
  PRINT("\n" ESCBLU "Passed" ESCLR ": ", test__success, "/", test__count, "\n");
  // pre-commit: make test || exit 1
  return test__count - test__success;
}
test (testing_test) {
  expect(1 + 1 == 2);
  expecteq(3, 3);
  expectneq(1, 10);
  test_filter("testing test") {
    expect(false);
    expect(1 + 1 == 1);
    expecteq(5, 3);
    expecteq(3, 3 + 3);
    expectneq(3 + 7, 50 / 5 + 6 * 0);
    expect(false);
  }
}
#endif

/**
 * @file src/term.c
 */
#include "term.h"
/**
 * @brief Get terminal window size
 * @return Struct in which window size if stored
 */
struct winsize getWinSize() {
  struct winsize w = err_winsize;
  ioctl(stdout_fileno, TIOCGWINSZ, &w);
  return w;
}
/**
 * @brief getchar() becomes like getch() in MSVC
 * @return Original termios
 */
struct termios enableRawMode() {
  struct termios orig;
  tcgetattr(stdin_fileno, &orig);
  struct termios raw = orig;
  raw.c_lflag &= ~0xaU; // ~(ICANON | ECHO)
  tcsetattr(stdin_fileno, TCSAFLUSH, &raw);
  return orig;
}
void disableRawMode(struct termios *orig) {
  tcsetattr(stdin_fileno, TCSAFLUSH, orig);
}

/**
 * @file src/str.c
 */
#include "str.h"
#include "chore.h"
#include <stdbit.h>
#include <stdlib.h>
[[gnu::const]] overloadable slice_t
slice(mut_slice_t ms, size_t start, size_t end) {
  return (slice_t){
    .s = ms.s + start,
    .len = end - start,
  };
}
[[gnu::const]] overloadable slice_t slice(slice_t s, size_t start, size_t end) {
  return (slice_t){
    .s = s.s + start,
    .len = end - start,
  };
}
#define DEF_SLICE_GENE(T) \
  overloadable bool eq(T x, T y) { \
    if (x.len != y.len) return false; \
    if (x.s == y.s) return true; \
    return !memcmp(x.s, y.s, x.len); \
  } \
  overloadable void printany(T x) { \
    printf("%.*s", (int)x.len, x.s); \
  } \
  overloadable void printanyf(T x) { \
    printf("\"%.*s\"", (int)x.len, x.s); \
  }
MAP(DEF_SLICE_GENE, mut_slice_t, slice_t)
slice_t referEntire(mut_slice_t ms) {
  return slice(ms, 0, ms.len);
}
slice_t fromString(char const *s) {
  return (slice_t){
    .s = s,
    .len = strlen(s),
  };
}
mut_slice_t mutFromString(char const *s) {
  size_t len = strlen(s);
  size_t cap = stdc_bit_ceil(len);
  char *dup = xalloc(char, cap);
  memcpy(dup, s, len);
  return (mut_slice_t){
    .s = dup,
    .len = len,
    .cap = cap,
    .owned = true,
  };
}
void freeMutSlice(mut_slice_t const *ms) {
  if (ms->owned) free(ms->s);
}
mut_slice_t concat(slice_t l, slice_t r) {
  size_t len = l.len + r.len;
  size_t cap = stdc_bit_ceil(len);
  char *s = xalloc(char, cap);
  memcpy(s, l.s, l.len);
  memcpy(s + l.len, r.s, r.len);
  return (mut_slice_t){
    .s = s,
    .len = len,
    .cap = cap,
    .owned = true,
  };
}

/**
 * @file src/rtconf.c
 */
#include "rtconf.h"
plotcfg_t pcfg;
rrtinfo_t info_r = {.histi = -1UL};
rtinfo_t info_c = {.histi = -1UL};
plotcfg_t getPlotCfg() {
  return pcfg;
}
void setPlotCfg(plotcfg_t pc) {
  pcfg = pc;
}
rtinfo_t getRuntimeInfo() {
  return info_c;
}
rrtinfo_t getRRuntimeInfo() {
  return info_r;
}
void setRuntimeInfo(rtinfo_t info) {
  info_c = info;
}
void setRRuntimeInfo(rrtinfo_t info) {
  info_r = info;
}

/**
 * @file src/rc.c
 * @brief Define run commands processing functions
 */
#include "chore.h"
#include "exproriented.h"
#include "main.h"
[[gnu::nonnull(3)]] static void
setCfgPath(char const *specified_cfgpath, size_t len, char *restrict cfgpath) {
  char const *configdir = specified_cfgpath ?: ".config/rpx/";
  char const *homedir = getenv("HOME") ?: ".";
  size_t const hdlen = strlen(homedir);
  strncpy(cfgpath, homedir, len);
  cfgpath += hdlen;
  *cfgpath++ = '/';
  strncpy(cfgpath, configdir, len - hdlen - 1);
}
void loadInitScript(char const *path) {
  char configpath[buf_size];
  setCfgPath(path, buf_size, configpath);
  size_t const configpathlen = strlen(configpath);
  char fname[buf_size];
  strncpy(fname, configpath, configpathlen);
  DIR *dp dropdir = opendir(configpath) ?: p$return();
  for (struct dirent const *entry; (entry = readdir(dp));) {
    if (entry->d_name[0] == '.') continue; // ignore hidden files
    strncpy(fname + configpathlen, entry->d_name, buf_size - configpathlen);
    FILE *fp dropfile = fopen(fname, "r");
    readerLoop(fp);
  }
}

/**
 * @file src/rand.c
 * @brief Define xorshift
 */
#include "rand.h"
#include "benchmarking.h"
#include "mathdef.h"
#include "testing.h"
#include <stdlib.h>
#include <time.h>
thread_local uint64_t state;
uint64_t xorsh() {
  state ^= state << 13;
  state ^= state >> 7;
  state ^= state << 17;
  return state;
}
double xorsh0to1() {
  return (double)xorsh() / (double)-1UL;
}
void sxorsh(uint64_t s) {
  state = s;
}
[[gnu::constructor(101)]] void initXorsh() {
  sxorsh((uint64_t)clock());
  _ = xorsh();
}
test (rand) {
  expect(true);
  test_filter("all,rand") {
    constexpr size_t n = 10'000;
    srand((unsigned)clock());
    unsigned rand_arr[n];
    unsigned xors_arr[n];
    double rand_av = 0;
    double xors_av = 0;
    for (size_t i = 0; i < n; i++) {
      rand_arr[i] = (unsigned _BitInt(31))rand();
      xors_arr[i] = (unsigned _BitInt(31))xorsh();
      rand_av += rand_arr[i] / n;
      xors_av += xors_arr[i] / n;
    }
    double rand_vari = 0;
    double xors_vari = 0;
    for (size_t i = 0; i < n; i++) {
      rand_vari += pow(rand_arr[i] - rand_av, 2) / n;
      xors_vari += pow(xors_arr[i] - xors_av, 2) / n;
    }
    puts("");
    printf("rand: av %lf vari %lf\n", rand_av, rand_vari);
    printf("xors: av %lf vari %lf\n", xors_av, xors_vari);
  }
}
bench (rand) { // 0.0173 ms
  _ = rand();
}
bench (xorsh) { // 0.0045 ms
  _ = xorsh();
}
bench_cycle(rand) {
  _ = rand();
}
bench_cycle(xors) {
  _ = xorsh();
}

/**
 * @file src/phyconst.c
 * @brief Define physical constants
 */
#include "phyconst.h"
#include "mathdef.h"
#include "testing.h"
#include <ctype.h>
constexpr static double const consts[alpha_n * 2] = {
  0,               // A
  0,               // B
  0,               // C
  0,               // D
  euler,           // E Euler's number
  96485.33212331,  // F Faraday constant
  6.6743015e-11,   // G
  0,               // H
  0,               // I
  0,               // J
  0,               // K
  6.02214076e23,   // L Avogadro constant
  0,               // M
  0,               // N
  0,               // O
  pi,              // P pie
  0,               // Q
  8.3144626181532, // R gas constant
  0,               // S
  0,               // T
  0,               // U
  0,               // V
  0,               // W
  0,               // X
  0,               // Y
  0,               // Z
  0,               // a
  0,               // b
  299'792'458,     // c speed of light
  0,               // d
  1.602176634e-19, // e elementary charge
  0,               // f
  0,               // g
  6.62607015e-34,  // h Planck constant
  0,               // i
  0,               // j
  1.380649e-23,    // k Boltzmann constant
  0,               // l
  0,               // m
  0,               // n
  0,               // o
  0,               // p
  0,               // q
  0,               // r
  0,               // s
  0,               // t
  0,               // u
  0,               // v
  0,               // w
  0,               // x
  0,               // y
  0,               // z
};
double getConst(char idx) {
  if (!isalpha(idx)) return NAN;
  [[clang::likely]];
  return consts[idx - 'A' - (idx >= 'a') * ('a' - 'Z' - 1)];
}
test_table(
  get_const, getConst, (double, char),
  {
    {    299'792'458, 'c'},
    {             pi, 'P'},
    {8.3144626181532, 'R'},
    {          euler, 'E'},
    {   1.380649e-23, 'k'}
}
)

/**
 * @file src/optexpr.c
 */
#include "optexpr.h"
#include "mem.h"
#include "testing.h"
#include <ctype.h>
#include <string.h>
static void rmExprSpaces(char **expr) {
  char const *start = *expr;
  for (; **expr != '\0'; (*expr)++) {
    if (isspace(**expr)) { // skip unnecessary spaces
      char *dstptr = *expr;
      *expr += skipByte(*expr, ' ');
      dstptr += dstptr != start && isdigit(*(dstptr - 1)) && isdigit(**expr);
      memmove(dstptr, *expr, strlen(*expr) + 1);
      *expr = dstptr;
    }
  }
}
void optexpr(char *arg_expr) {
  char *expr = arg_expr;
  rmExprSpaces(&expr);
}
test (optexpr) {
  char str1[] = "4   5   6   +";
  optexpr(str1);
  expecteq("4 5 6+", (char *)str1);
  char str2[] = "(1 s 2 ^) (1 c 2 ^) +";
  optexpr(str2);
  expecteq("(1s2^)(1c2^)+", (char *)str2);
}

/**
 * @file src/mem.c
 */
#include "mem.h"
#include "bit.h"
#include "chore.h"
#include "exproriented.h"
#include "testing.h"
/**
 * @brief Skip index to first non-white-space char
 */
size_t skipByteDirectly(char const *restrict str, byte_t b, size_t len) {
  size_t i = 0;
  for (; i < len && str[i] == b; i++);
  return i;
}
[[gnu::const]] static size_t skipByteSize(size_t s, byte_t c) {
  return stdc_trailing_zeros(s ^ repeatBytes(c)) / p_size;
}
size_t skipByte(char const *restrict str, byte_t b) {
  char const *s = alignForward(str, p_size);
  size_t i = skipByteDirectly(str, b, -(size_t)str & p_size - 1);
  if (str + i < s) return i;
  while (!isNulExist(*bit_cast(size_t const *, s))) {
    size_t skip = skipByteSize(*bit_cast(size_t const *, s), b);
    i += skip;
    if (skip < p_size) return i;
    s += p_size;
  }
  return i + skipByteDirectly(s, b, -1UL);
}
test (skip) {
  char const *s = "             a";
  for (size_t i = 13; 0 < i; i--, s++) expecteq(i, skipByte(s, ' '));
}
/**
 * @brief Skip pointer to the char following the comma
 * @param[in,out] s String pointer
 */
size_t skipUntil(char const *restrict s, byte_t b) {
  char const *str = strchr(s, b) ?: p$return(strlen(s));
  return (size_t)(str - s + 1);
}
char *memrchr(char const *restrict s, int c, size_t n) {
  size_t i = n;
  for (; 0 < i && s[i] != c; i--);
  return (char *)($if(i != 0) s + i $else $if(*s == c) s $else nullptr);
}

/**
 * @file src/matop.c
 * @brief Define matrix related functions
 */
#include "matop.h"
#include "benchmarking.h"
#include "chore.h"
#include "errcode.h"
#include "error.h"
static matrix_t nanMatrix(size_t rows, size_t cols) {
  matrix_t result = newMatrix(rows, cols);
  for (size_t i = 0; i < rows * cols; i++) result.matrix[i] = NAN;
  return result;
}
matrix_t newMatrix(size_t rows, size_t cols) {
  return (matrix_t){
    .rows = rows,
    .cols = cols,
    .matrix = xalloc(comp, rows * cols),
  };
}
void freeMatr(matrix_t *restrict x) {
  free(x->matrix);
}
static bool mCheckDim(matrix_t const *lhs, matrix_t const *rhs) {
  return lhs->rows == rhs->rows && lhs->cols == rhs->cols;
}
bool mEq(matrix_t const *lhs, matrix_t const *rhs) {
  if (!mCheckDim(lhs, rhs)) return false;
  for (size_t i = 0; i < lhs->cols * lhs->rows; i++)
    if (!eq(lhs->matrix[i], rhs->matrix[i])) return false;
  return true;
}
overloadable bool eq(matrix_t const *lhs, matrix_t const *rhs) {
  return mEq(lhs, rhs);
}
/**
 * @brief Add/Sub between matrices
 */
#define MOPS(name, op) \
  matrix_t m##name( \
    matrix_t const *restrict lhs, matrix_t const *restrict rhs \
  ) { \
    if (!mCheckDim(lhs, rhs)) { \
      DISPERR( \
        codetomsg(ERR_DIMENTION_MISMATCH), \
        ": ", \
        lhs->rows, \
        "x", \
        lhs->cols, \
        " vs ", \
        rhs->rows, \
        "x", \
        rhs->cols \
      ); \
      return nanMatrix(lhs->rows, lhs->cols); \
    } \
    matrix_t result = newMatrix(lhs->rows, lhs->cols); \
    for (size_t i = 0; i < lhs->rows * lhs->cols; i++) \
      result.matrix[i] = lhs->matrix[i] op rhs->matrix[i]; \
    return result; \
  }
APPLY_ADDSUB(MOPS)
/**
 * @brief Mul between matrices
 */
matrix_t mMul(matrix_t const *restrict lhs, matrix_t const *restrict rhs) {
  if (lhs->cols != rhs->rows) [[clang::unlikely]] {
    DISPERR(
      codetomsg(ERR_DIMENTION_MISMATCH),
      ": ",
      lhs->rows,
      "x",
      lhs->cols,
      " vs ",
      rhs->rows,
      "x",
      rhs->cols
    );
    return nanMatrix(lhs->rows, lhs->cols);
  }
  matrix_t result = newMatrix(lhs->rows, rhs->cols);
  for (size_t i = 0; i < lhs->rows; i++)
    for (size_t j = 0; j < rhs->cols; j++)
      for (size_t k = 0; k < lhs->cols; k++)
        result.matrix[rhs->cols * i + j]
          += lhs->matrix[lhs->cols * i + k] * rhs->matrix[rhs->cols * k + j];
  return result;
}
/**
 * @brief Calculate determinant
 * @note No benefit of vectorization in the current implementation
 */
static double det(matrix_t const *restrict a) {
  if (a->rows != a->cols) [[clang::unlikely]] {
    DISPERR(codetomsg(ERR_NON_SQUARE_MATRIX));
    return 0;
  }
  double result = 1;
  size_t dim = a->rows;
  for (size_t i = 0; i < dim - 1; i++)
    for (size_t j = 0; j < dim - 1; j++) {
      for (size_t k = 1; eq(0.0i, a->matrix[dim * i + i]); k++) {
        for (size_t l = i; l < dim; l++) {
          if (k >= dim) [[clang::unlikely]] // case of singular matrix
            return 0;
          double temp = creal(a->matrix[dim * i + l]);
          a->matrix[dim * i + l] = a->matrix[dim * (i + k) + l];
          a->matrix[dim * (i + k) + l] = -temp;
        }
      }
      // elimination
      double temp
        = creal(a->matrix[dim * (j + 1) + i] / a->matrix[dim * i + i]);
      for (size_t k = i; k < dim; k++)
        a->matrix[dim * (j + 1) + k] -= temp * a->matrix[dim * i + k];
    }
  for (size_t i = 0; i < dim; i++) result *= a->matrix[dim * i + i];
  return result;
}
// for vectorization benchmarking
bench (det2x2) {
  comp m[] = {3, 5, 2, 7};
  matrix_t a = {.rows = 2, .cols = 2, .matrix = m};
  det(&a);
}
bench (det3x3) {
  comp m[] = {3, 5, 2, 7, 6, 1, 9, 6};
  matrix_t a = {.rows = 3, .cols = 3, .matrix = m};
  det(&a);
}
/**
 * @brief Calculate inverse matrix with Gaussian elimination
 * @param[in] a Matrix
 * @return Inverted A
 */
matrix_t inverseMatrix(matrix_t const *restrict a) {
  size_t dim = a->rows;
  if (a->rows != a->cols) [[clang::unlikely]] {
    DISPERR(codetomsg(ERR_NON_SQUARE_MATRIX));
    return *a;
  }
  matrix_t result = newMatrix(dim, dim);
  for (size_t i = 0; i < dim; i++) result.matrix[i * dim + i] = 1;
  // to diagonal matrix
  for (size_t i = 0; i < dim; i++) {
    if (a->matrix[i * dim + i] == 0) {
      size_t j;
      for (j = (i + 1) % dim; a->matrix[j * dim + i] == 0; j = (j + 1) % dim)
        if (j == i) [[clang::unlikely]] {
          free(result.matrix);
          DISPERR(codetomsg(ERR_IRREGULAR_MATRIX));
          return *a;
        }
      for (size_t k = 0; k < dim; k++) {
        comp temp = a->matrix[i * dim + k];
        a->matrix[i * dim + k] = a->matrix[j * dim + k];
        a->matrix[j * dim + k] = -temp;
        temp = result.matrix[i * dim + k];
        result.matrix[i * dim + k] = result.matrix[j * dim + k];
        result.matrix[j * dim + k] = -temp;
      }
    }
    for (size_t j = (i + 1) % dim; j != i; j = (j + 1) % dim) {
      comp coef = a->matrix[j * dim + i] / a->matrix[i * dim + i];
      for (size_t k = 0; k < dim; k++) {
        size_t id = (k + i) % dim;
        a->matrix[j * dim + id] -= coef * a->matrix[i * dim + id];
        result.matrix[j * dim + id] -= coef * result.matrix[i * dim + id];
      }
    }
  }
  // A->matrix to unit matrix
  for (size_t i = 0; i < dim; i++)
    for (size_t j = 0; j < dim; j++) {
      if (eq(fabs(a->matrix[i * dim + i]), 0.0)) [[clang::unlikely]] {
        free(result.matrix);
        DISPERR(codetomsg(ERR_IRREGULAR_MATRIX));
        return *a;
      }
      result.matrix[i * dim + j] /= a->matrix[i * dim + i];
    }
  return result;
}
/**
 * @brief Scalar mul
 * @param[in,out] lhs Matrix
 * @param[in] rhs Scalar
 */
void smul(matrix_t *restrict lhs, comp rhs) {
  for (size_t i = 0; i < lhs->rows * lhs->cols; i++) lhs->matrix[i] *= rhs;
}

/**
 * @file src/mathdef.c
 * @brief Define arithmetic functions
 */
#include "mathdef.h"
#include "gene.h"
#include "testing.h"
double gcd(double n, double m) {
  return eq(m, 0.0) ? n : gcd(m, fmod(n, m));
}
test_table(
  gcd, gcd, (double, double, double),
  {
    { 6,  12, 18},
    { 5,  30, 25},
    {10, 110, 90},
}
)
double lcm(double n, double m) {
  return n / gcd(n, m) * m;
}
test_table(
  lcm, lcm, (double, double, double),
  {
    { 36,  12, 18},
    {150,  30, 25},
    {990, 110, 90},
}
)
double permutation(double n, double r) {
  return tgamma(n + 1) / tgamma(n - r + 1);
}
test_table(
  P, permutation, (double, double, double),
  {
    {       2520,  7, 5},
    {        504,  9, 3},
    {164'490'480, 46, 5},
}
)
double combination(double n, double r) {
  return permutation(n, r) / tgamma(r + 1);
}
test_table(
  C, combination, (double, double, double),
  {
    {       21,  7, 5},
    {       84,  9, 3},
    {1'370'754, 46, 5},
}
)

/**
 * @file src/main.c
 * @brief Define proc_cmds
 */
#include "main.h"
#include "benchmarking.h"
#include "editline.h"
#include "elemop.h"
#include "error.h"
#include "evalfn.h"
#include "exproriented.h"
#include "graphplot.h"
#include "mem.h"
#include "optexpr.h"
#include "rand.h"
#include "rc.h"
#include "testing.h"
auto eval_f = evalExprReal;
void (*print_complex)(comp) = printComplexComplex;
int main(int argc, char const **argv) {
  initPlotCfg();
  loadInitScript(nullptr);
  procAList(argc - 1, argv + 1);
  readerLoop(stdin);
  return 0;
}
//! @brief Display help message
static void startupMsg() {
  PRINT(
    "===========================================================\n",
    "     RPX - Reverse Polish notation calculator eXtended\n",
    "===========================================================\n",
    " A powerful RPN calculator supporting multiple modes:\n",
    "  - Real numbers      (default)\n",
    "  - comp numbers   (:tc to toggle)\n",
    "\n",
    " Features:\n",
    "  - Register ($a to $z)\n",
    "  - Result history (@a, @h)\n",
    "  - Special constants (\\P for pi, \\E for e)\n",
    "  - Advanced functions (sin, cos, log, etc.)\n",
    "  - Matrix operations (in comp mode)\n",
    "\n",
    " Usage:\n",
    "  - Enter RPN expressions directly\n",
    "  - Use ':' for commands (e.g., :tc for comp mode)\n",
    "\n",
    " Examples:\n",
    "  3 4 + 5 *     -> 35\n",
    "  2 \\P * s      -> 0 (approximately)\n",
    "  [2 2,2,][2 1,2,3,4,]*  -> [8,12] (matrix multiplication)\n",
    "\n",
    " Press Ctrl+D to exit the program.\n",
    "===========================================================\n",
  );
}
/**
 * @brief Process input
 * @param[in] input_buf input
 */
[[gnu::nonnull]] void procInput(char const *restrict input_buf) {
  *input_buf == ':' ? procCmds(input_buf + 1) : printElem(eval_f(input_buf));
}
/**
 * @brief Process argument list
 * @param[in] argc arg count
 * @param[in] argv arg value
 */
void procAList(int argc, char const **argv) {
  if (argc == 0) return;
  if (**argv != '-') { // interpreted as a file name
    FILE *fp dropfile
      = fopen(*argv, "r") ?: p$panic(ERR_FILE_NOT_FOUND, "%s ", *argv);
    readerLoop(fp);
  } else switch ((*argv)[1]) { // interpreted as a option
    case 'h':
      startupMsg();
      break;
    case 'r':
      procInput(*++argv);
      break;
    case 'q':
      exit(0);
    default:
      panic(ERR_UNKNOWN_OPTION, "%c ", (*argv)[1]);
    }
  procAList(argc - 1, argv + 1);
}
/**
 * @brief Read raw line from fp
 * @return is reached EOF
 */
static bool readRawLine(char *buf, size_t len, FILE *fp) {
  return fgets(buf, (int)len, fp) != nullptr;
}
/**
 * @brief Read from stdin
 * @return is pressed ctrl_d
 */
static bool readerInteractiveLine(char *buf, size_t len, FILE *__) {
  return editline(len, buf);
}
/**
 * @brief File reading loop
 * @param[in] fp File stream
 */
[[gnu::nonnull]] void readerLoop(FILE *restrict fp) {
  char input_buf[buf_size];
  auto reader_fn = fp == stdin ? readerInteractiveLine : readRawLine;
  while (reader_fn(input_buf, buf_size, fp)) [[clang::likely]]
    procInput(input_buf);
}
/**
 * @brief Output elem_t in appropriate format
 * @param[in] elem Output comtent
 */
void printElem(elem_t elem) {
  switch (elem.rtype) {
  case RTYPE_REAL:
    printReal(elem.elem.real);
    break;
  case RTYPE_COMP:
    print_complex(elem.elem.comp);
    break;
  case RTYPE_MATR:
    printMatrix(elem.elem.matr);
    break;
  case RTYPE_LAMB:
    printLambda(elem.elem.lamb);
    break;
  default:
    [[clang::unlikely]];
  }
}
/**
 * @brief Output value of type double
 * @param[in] result Output value
 */
void printReal(double result) {
  if (result == (double)(long)result) PRINT("result: ", (long)result, "\n");
  else PRINT("result: ", result, "\n");
}
/**
 * @brief Output value of type comp
 */
void printComplexComplex(comp result) {
  PRINT("result: ", creal(result), " + ", cimag(result), "i\n");
}
/**
 * @brief Output value of type comp in phasor view
 */
void printComplexPolar(comp result) {
  comp res = result;
  if (isnan(creal(res)) || isnan(cimag(res))) return;
  PRINT(
    "result: ", cabs(res), " \\phasor ", atan2(cimag(res), creal(res)), "\n"
  );
}
/**
 * @brief Output value of type matrix_t
 */
void printMatrix(matrix_t result) {
  for (size_t i = 0; i < result.rows; i++) {
    for (size_t j = 0; j < result.cols; j++) {
      comp res = result.matrix[result.cols * i + j];
      putchar('\t');
      if (eq(cimag(res), 0.0)) PRINT(creal(res));
      else PRINT(creal(res), " + ", cimag(res), "i");
    }
    putchar('\n');
  }
}
[[gnu::nonnull]] void printLambda(char const *result) {
  PRINT("result: ", (char *)result, "\n");
}
/**
 * @brief Process command
 * @param[in] cmd Command input
 */
[[gnu::nonnull]] void procCmds(char const *restrict cmd) {
  plotcfg_t pcfg = getPlotCfg();
  // TODO save registers
  switch (*cmd++) {
  case 't':   // toggle
    switch (*cmd) {
    case 'c': // comp mode
      eval_f = eval_f == evalExprReal ? evalExprComplex : evalExprReal;
      break;
    case 'p': // plotcfg explicit implicit
      pcfg.plotexpr = pcfg.plotexpr == plotexpr ? plotexprImplicit : plotexpr;
      setPlotCfg(pcfg);
      break;
    case 'P': // print_complex
      print_complex = print_complex == printComplexComplex
                      ? printComplexPolar
                      : printComplexComplex;
      break;
    default:
      [[clang::unlikely]];
    }
    break;
  case 'o': {
    char buf[buf_size];
    strncpy(buf, cmd, buf_size);
    optexpr(buf);
    puts(buf);
  } break;
  case 'p':
    cmd += skipByte(cmd, ' ');
    if (*cmd == '\0') {
      plotexpr(pcfg.prevexpr);
      break;
    }
    pcfg.plotexpr(cmd);
    strncpy(pcfg.prevexpr, cmd, buf_size);
    setPlotCfg(pcfg);
    break;
  case 'r':   // rand
    switch (*cmd) {
    case 's': // set seed
      sxorsh((uint64_t)evalExprReal(cmd + 1).elem.real);
      break;
    default:
    }
    break;
  case 's':   // settings
    switch (*cmd) {
    case 'p': // plot
      changePlotCfg(cmd + 1);
      break;
    default:
      [[clang::unlikely]];
    }
    break;
  default:
    DISPERR("unknown command: ", *(cmd - 1));
  }
}

/**
 * @file src/ice.c
 */
#include <stdio.h>
#ifndef NDEBUG
 #include "ice.h"
ic_t ic_conf = {
  .enable = true,
  .context = false,
  .prefix = nullptr,
  .fp = nullptr,
};
 #include "chore.h"
 #include "testing.h"
test (ice) {
  expect(true);
  test_filter("all") {
    putchar('\n');
    ic(0);
    ic_conf.enable = false;
    ic();
    ic_conf.enable = true;
    _ = ic(42);
    ic_conf.context = true;
    ic("hello world!");
    ic();
  }
}
#endif

/**
 * @file src/graphplot.c
 * @brief Define graph related functions
 */
#include "graphplot.h"
#include "evalfn.h"
#include "mem.h"
#include "rtconf.h"
#include "term.h"
constexpr double fontrow = 2;
constexpr double fontcol = 1;
constexpr double font_ratio = fontcol / fontrow;
static void drawAxisX(double xn, int disp_size, double dx) {
  putchar('\t');
  putchar('+');
  for (int i = 0; i < disp_size / font_ratio; i++) putchar('-');
  putchar('\n');
  putchar('\t');
  printf("%.3lf", xn);
  for (int i = 0; i < disp_size / font_ratio / 2; i++) putchar(' ');
  printf("%.3lf", xn + dx * disp_size / 2 / font_ratio);
  putchar('\n');
}
plotbuf_t plotBuf(size_t row, size_t col) {
  char **b = xalloc(char *, row);
  for (size_t i = 0; i < row; i++) {
    b[i] = xalloc(char, col + 1);
    memset(b[i], ' ', col);
    b[i][col] = 0;
  }
  return (plotbuf_t){.buf = b, .row = row, .col = col};
}
void freePlotBuf(plotbuf_t *pb) {
  for (size_t i = 0; i < pb->row; i++) free(pb->buf[i]);
  free(pb->buf);
}
void displayPlotBuf(plotbuf_t pb, double yn, double dy) {
  for (int i = (int)pb.row - 1; 0 <= i; i--) {
    double y = yn + dy * i;
    printf("%.3lf\t|", y);
    puts(pb.buf[i]);
  }
}
[[gnu::nonnull]] void plotexpr(char const *restrict expr) {
  plotcfg_t const pcfg = getPlotCfg();
  machine_t m;
  size_t col = (size_t)(pcfg.dispx / font_ratio);
  real_t stack = {.elem = {.real = pcfg.xn}, .isnum = true};
  plotbuf_t pb ondrop(freePlotBuf) = plotBuf((size_t)pcfg.dispy, col);
  m.e.args = &stack - 7;
  m.c.expr = expr;
  initEvalinfo(&m);
  rpxEval(&m);
  double y0 = m.s.rsp->elem.real;
  for (size_t i = 0; i < col; i++) {
    double x1 = pcfg.xn + pcfg.dx * (double)i;
    stack.elem.real = x1;
    initEvalinfo(&m);
    rpxEval(&m);
    double y1 = m.s.rsp->elem.real;
    double gt = more(y0, y1);
    double lt = less(y0, y1);
    if (gt < pcfg.yn || pcfg.yx < lt) continue;
    size_t gt_index = (size_t)less(pcfg.dispy - 1, (gt - pcfg.yn) / pcfg.dy);
    size_t lt_index = (size_t)more(0, (lt - pcfg.yn) / pcfg.dy);
    for (size_t j = lt_index; j <= gt_index; j++) pb.buf[j][i] = '*';
    y0 = y1;
  }
  displayPlotBuf(pb, pcfg.yn, pcfg.dy);
  drawAxisX(pcfg.xn, pcfg.dispx, pcfg.dx);
}
[[gnu::nonnull]] void plotexprImplicit(char const *restrict expr) {
  plotcfg_t const pcfg = getPlotCfg();
  machine_t m;
  m.c.expr = expr;
  double err = pcfg.dy / 2; // allowable error
  double x0 = pcfg.xn - pcfg.dx;
  real_t stack[2] = {{.isnum = true}, {.isnum = true}};
  m.e.args = (real_t *)stack - 6;
  for (int i = 0; i < pcfg.dispy; i++) {
    double y0 = pcfg.yx - pcfg.dy * i;
    printf("%.3lf\t|", y0);
    stack[0].elem.real = y0;
    stack[1].elem.real = x0;
    initEvalinfo(&m);
    rpxEval(&m);
    double y1 = y0 - pcfg.dy;
    stack[0].elem.real = y1;
    double res0 = m.s.rsp->elem.real;
    for (int j = 0; j < pcfg.dispx / font_ratio; j++) {
      double x1 = pcfg.xn + pcfg.dx * j;
      stack[1].elem.real = x1;
      initEvalinfo(&m);
      rpxEval(&m);
      double res1 = m.s.rsp->elem.real;
      putchar(-err <= more(res0, res1) && less(res0, res1) <= err ? '*' : ' ');
      res0 = res1;
    }
    putchar('\n');
  }
  drawAxisX(pcfg.xn, pcfg.dispx, pcfg.dx);
}
static void setPlotBounds(double xx, double xn, double yx, double yn) {
  plotcfg_t pcfg = getPlotCfg();
  pcfg.xx = xx;
  pcfg.xn = xn;
  pcfg.yx = yx;
  pcfg.yn = yn;
  pcfg.dx = (xx - xn) / pcfg.dispx * font_ratio;
  pcfg.dy = (yx - yn) / pcfg.dispy;
  setPlotCfg(pcfg);
}
void initPlotCfg() {
  struct winsize w = getWinSize();
  int dispsz = (int)less((double)w.ws_row, w.ws_col * font_ratio);
  plotcfg_t pcfg = getPlotCfg();
  pcfg.dispx = pcfg.dispy = dispsz - 5;
  pcfg.plotexpr = plotexpr;
  setPlotCfg(pcfg);
  setPlotBounds(1, -1, 1, -1);
}
[[gnu::nonnull]] void changePlotCfg(char const *restrict cmd) {
  switch (*cmd++) {
  case 'd': { // display size
    plotcfg_t pcfg = getPlotCfg();
    double newx = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newy = evalExprReal(cmd).elem.real;
    double centerx = (pcfg.xx + pcfg.xn) / 2;
    double centery = (pcfg.yx + pcfg.yn) / 2;
    double coefx = newx / pcfg.dispx;
    double coefy = newy / pcfg.dispy;
    pcfg.xx = centerx + (pcfg.xx - centerx) * coefx;
    pcfg.xn = centerx + (pcfg.xn - centerx) * coefx;
    pcfg.yx = centery + (pcfg.yx - centery) * coefy;
    pcfg.yn = centery + (pcfg.yn - centery) * coefy;
    pcfg.dispx = (int)newx;
    pcfg.dispy = (int)newy;
    setPlotCfg(pcfg);
  } break;
  case 'r': { // range
    double newxx = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newxn = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newyx = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newyn = evalExprReal(cmd).elem.real;
    setPlotBounds(newxx, newxn, newyx, newyn);
  } break;
  default:
    [[clang::unlikely]];
  }
}

/**
 * @file src/gene.c
 * @brief Define generic functions
 */
#include "gene.h"
#include "mathdef.h"
#include "testing.h"
constexpr double eps = 1e-5;
static bool doubleEq(double a, double b) {
  if (fabs(b) < eps) return fabs(a) < eps; // prevent 0-div when b is near 0
  if (a < 0 != b < 0) return false;        // mis signed
  return fabs(a / b - 1.0) < eps;          // cmp based on ratios
}
static bool complexEq(comp a, comp b) {
  return doubleEq(creal(a), creal(b)) && doubleEq(cimag(a), cimag(b));
}
test_table(
  double_eq, doubleEq, (bool, double, double),
  {
    { true,      1.0,          1.0},
    { true,    1e-10,            0},
    { true,    1e100, 1e100 + 1e10},
    {false,        0,            1},
    {false,      NAN,          NAN},
    {false,      NAN,         1e10},
    {false, INFINITY,     INFINITY},
    {false, INFINITY,        1e100},
}
)
test_table(
  complex_eq, complexEq, (bool, comp, comp),
  {
    { true,                0,          0},
    { true,           1 + 3i, 1.0 + 3.0i},
    { true, 1.0 + 1e-10 + 3i,     1 + 3i},
    {false,                0,          1},
    {false,           3 + 5i,    -1 + 3i},
}
)
#pragma clang attribute push(overloadable, apply_to = function)
void printany(int x) {
  printf("%d", x);
}
void printany(size_t x) {
  printf("%zu", x);
}
void printany(double x) {
  printf("%lf", x);
}
void printany(char *x) {
  printf("%s", x);
}
void printany(char x) {
  printf("%c", x);
}
void printany(bool x) {
  printf(x ? "`true`" : "`false`");
}
void printany(long x) {
  printf("%ld", x);
}
void printany(long long x) {
  printf("%lld", x);
}
void printany(void *x) {
  if (x) printf("0x%p", x);
  else printf("`nullptr`");
}
void printanyf(int x) {
  PRINT(x);
}
void printanyf(size_t x) {
  PRINT(x, "LU");
}
void printanyf(double x) {
  PRINT(x);
}
void printanyf(char *x) {
  PRINT("\"", x, "\"");
}
void printanyf(char x) {
  PRINT("'", x, "'");
}
void printanyf(bool x) {
  PRINT(x);
}
void printanyf(long x) {
  PRINT(x, "L");
}
void printanyf(long long x) {
  PRINT(x, "LL");
}
void printanyf(void *x) {
  PRINT(x);
}
#define EQ_DIRECTLY(T) \
  bool eq(T x, T y) { \
    return x == y; \
  }
MAP(EQ_DIRECTLY, int, size_t, char, bool, void *)
bool eq(double x, double y) {
  return doubleEq(x, y);
}
bool eq(comp x, comp y) {
  return complexEq(x, y);
}
bool eq(char *x, char *y) {
  return !strcmp(x, y);
}
#pragma clang attribute pop

/**
 * @file src/exproriented.c
 */
/*
 * Usage
 * ----------------------------------------------------------------------------
 * if expression         | puts($if(lhs == rhs) "equal" $else "not equal");
 * ----------------------------------------------------------------------------
 * break expression      | p = next() ?: $break;
 * ----------------------------------------------------------------------------
 * continue expression   | is_validinput(input) ?: $continue;
 * ----------------------------------------------------------------------------
 * return expression     | char *homedir = getenv("HOME") ?: p$return(-1);
 * ----------------------------------------------------------------------------
 */
#include "exproriented.h"
#include "testing.h"
test (in_expr) {
  int i = 0;
  for (;;) {
    _ = $if(i == 1) 1 $else $break;
    expect(false);
  }
  for (i = 0; i < 5; i++) {
    _ = $continue;
    expect(false);
  }
}
test (in_statement) {
  for (;;) {
    $break;
    expect(false);
  }
  for (int i = 0; i < 5; i++) {
    $continue;
    expect(false);
  }
}
test (multi_statement) {
  int c = 0;
  int a = $if(!c)({
    int i = 1;
    i * 2;
  }) $else({
    int i = 5;
    (i + 1) * i;
  });
  expecteq(a, 2);
  a = $if(c)({
    int i = 9;
    i - 1;
  }) $else a;
  expecteq(a, 2);
  _ = a;
}
test (dollar_sign) {
  // $ expression returns 0.
  // For now.
  // unit type intention
  expecteq(0, $(int i = 5; _ = i;));
}

/**
 * @file src/evalfn.c
 * @brief Define eval_expr_real related functions
 */
#include "benchmarking.h"
#include "elemop.h"
#include "error.h"
#include "evalfn.h"
#include "exproriented.h"
#include "mem.h"
#include "phyconst.h"
#include "rand.h"
#include "testing.h"
#include <ctype.h>
#define PUSH (*++m->s.rsp)
#define POP  (*m->s.rsp--)
#define SET_REAL(v) \
  (real_t) { \
    .elem = {.real = v}, .isnum = true \
  }
#define SET_LAMB(v) \
  (real_t) { \
    .elem = {.lamb = v}, .isnum = false \
  }
#define DEF_ARTHMS(tok, op) \
  static void rpx##tok(machine_t *m) { \
    for (; m->s.rbp + 1 < m->s.rsp; \
         m->s.rbp[1].elem.real op## = POP.elem.real); \
  }
APPLY_ARTHM(DEF_ARTHMS)
#define DEF_BINOP(f) \
  static void rpx_##f(machine_t *m) { \
    for (; m->s.rbp + 1 < m->s.rsp; \
         m->s.rbp[1].elem.real = f(m->s.rbp[1].elem.real, POP.elem.real)); \
  }
MAP(DEF_BINOP, fmod, pow)
static void rpxEql(machine_t *m) {
  for (; m->s.rbp + 1 < m->s.rsp
         && eq(m->s.rsp[-1].elem.real, m->s.rsp->elem.real);
       POP);
  m->s.rbp[1].elem.real = m->s.rbp + 1 == m->s.rsp ?: NAN;
  m->s.rsp = m->s.rbp + 1;
}
#define DEF_LTGT(tok, op) \
  static void rpx##tok(machine_t *m) { \
    for (; m->s.rbp + 1 < m->s.rsp \
           && m->s.rsp[-1].elem.real op m->s.rsp->elem.real; \
         POP); \
    m->s.rbp[1].elem.real = m->s.rbp + 1 == m->s.rsp ?: NAN; \
    m->s.rsp = m->s.rbp + 1; \
  }
APPLY_LTGT(DEF_LTGT)
#define DEF_ONEARGFN(f) \
  static void rpx_##f(machine_t *m) { \
    m->s.rsp->elem.real = f(m->s.rsp->elem.real); \
  }
MAP(DEF_ONEARGFN, sin, cos, tan, fabs, tgamma, ceil, floor, round)
#define DEF_MULTI(name, factor) \
  static void rpx##name(machine_t *m) { \
    m->s.rsp->elem.real *= factor; \
  }
MAP_PAIR(DEF_MULTI, (Negate, -1), (ToRad, pi / 180), (ToDeg, 180 / pi))
#define DEF_TWOCHARFN(name, c1, f1, c2, f2, c3, f3) \
  static void rpx##name(machine_t *m) { \
    switch (*++m->c.rip) { \
      OVERWRITE_REAL(c1, f1) \
      OVERWRITE_REAL(c2, f2) \
      OVERWRITE_REAL(c3, f3) \
    default: \
      [[clang::unlikely]]; \
    } \
  }
MAP_PAIR(
  DEF_TWOCHARFN, (Hyp, 's', sinh, 'c', cosh, 't', tanh),
  (Arc, 's', asin, 'c', acos, 't', atan), (Log, '2', log2, 'c', log10, 'e', log)
)
static void rpxLogBase(machine_t *m) {
  double x = POP.elem.real;
  m->s.rsp->elem.real = log(m->s.rsp->elem.real) / log(x);
}
static void rpxConst(machine_t *m) {
  PUSH = SET_REAL(getConst(*++m->c.rip));
}
static void rpxParse(machine_t *m) {
  char *next = nullptr;
  PUSH = SET_REAL(strtod(m->c.rip, &next));
  m->c.rip = next - 1;
}
static void rpxSpace(machine_t *m) {
  m->c.rip += skipByte(m->c.rip, ' ') - 1;
}
#define CASE_TWOARGFN(c, f) \
  case c: { \
    double x = POP.elem.real; \
    m->s.rsp->elem.real = f(m->s.rsp->elem.real, x); \
  } break;
static void rpxIntFn(machine_t *m) {
  switch (*++m->c.rip) {
    CASE_TWOARGFN('g', gcd)
    CASE_TWOARGFN('l', lcm)
    CASE_TWOARGFN('p', permutation)
    CASE_TWOARGFN('c', combination)
  default:
    [[clang::unlikely]];
  }
}
static void rpxSysFn(machine_t *m) {
  switch (*++m->c.rip) {
  case 'a': // ANS
    PUSH = m->e.info.hist[less(m->e.info.histi, buf_size - 1)];
    break;
  case 'd': // display
    printany(m->s.rsp->elem.real);
    putchar('\n');
    break;
  case 'h':
    m->s.rsp->elem.real
      = m->e.info.hist[m->e.info.histi - (size_t)m->s.rsp->elem.real].elem.real;
    break;
  case 'n':
    PUSH = SET_REAL(NAN);
    break;
  case 'p':
    m->s.rsp[1] = *m->s.rsp;
    m->s.rsp++;
    break;
  case 'r':
    PUSH = SET_REAL(xorsh0to1());
    break;
  case 's':
    *m->s.rsp = *(m->s.rsp - (int)m->s.rsp->elem.real - 1);
    break;
  default:
    [[clang::unlikely]];
  }
}
static real_t handleFnArgs(machine_t *m) {
  char argnum = *m->c.rip - '0';
  if (m->d.argc[m->d.spi] < argnum) m->d.argc[m->d.spi] = argnum;
  return m->e.args[arg_n - argnum];
}
static void rpxLRegs(machine_t *m) {
  *++m->s.rsp = (isdigit(*++m->c.rip)) ? handleFnArgs(m)
              : (islower(*m->c.rip))   ? m->e.info.reg[*m->c.rip - 'a']
                                       : *(real_t *)$panic(ERR_CHAR_NOT_FOUND);
}
static void rpxWRegs(machine_t *m) {
  m->e.info.reg[*++m->c.rip - 'a'] = *m->s.rsp;
}
static void rpxEnd(machine_t *m) {
  m->e.iscontinue = false;
}
static void rpxGrpBgn(machine_t *m) {
  PUSH.elem.lamb = (char *)m->s.rbp;
  m->s.rbp = m->s.rsp;
}
static void rpxGrpEnd(machine_t *m) {
  real_t *rbp = m->s.rbp;
  m->s.rbp = *bit_cast(real_t **, m->s.rbp);
  *rbp = *m->s.rsp;
  m->s.rsp = rbp;
}
static void rpxLmdBgn(machine_t *m) {
  m->c.rip++;
  size_t i = 0;
  for (int nest = 1; *m->c.rip; i++)
    if (m->c.rip[i] == '{') nest++;
    else if (m->c.rip[i] == '}' && !--nest) break;
  *++m->s.rsp = SET_LAMB(xalloc(char, i + 1));
  memcpy(m->s.rsp->elem.lamb, m->c.rip, i);
  m->s.rsp->elem.lamb[i] = '\0';
  m->c.rip += i;
}
static void rpxLmbEnd(machine_t *m) {
  DISPERR("missing open bracket: col ", m->c.rip - m->c.expr);
}
static void callFn(machine_t *m, char const *expr) {
  m->d.spi++;
  m->d.exprs[m->d.spi] = m->c;
  m->c.expr = m->c.rip = expr;
  m->d.callstack[m->d.spi] = m->e.args;
  m->d.argc[m->d.spi] = 0;
  m->e.args = m->s.rsp - arg_n;
  rpxGrpBgn(m);
}
static void retFn(machine_t *m) {
  rpxGrpEnd(m);
  real_t ret = *m->s.rsp;
  m->s.rsp = m->e.args + arg_n;
  m->s.rsp -= m->d.argc[m->d.spi];
  *m->s.rsp = ret;
  m->e.args = m->d.callstack[m->d.spi];
  m->c = m->d.exprs[m->d.spi];
  m->d.spi--;
}
static void rpxRunLmd(machine_t *m) {
  callFn(m, m->s.rsp->elem.lamb);
  rpxEval(m);
  retFn(m);
}
static void rpxCond(machine_t *m) {
  m->s.rsp -= 2;
  real_t *rsp = m->s.rsp;
  *rsp = *(rsp + isnan(rsp[2].elem.real));
}
static void rpxUndfned(machine_t *m) {
  DISPERR(
    codetomsg(ERR_UNKNOWN_CHAR),
    ": ",
    *m->c.rip,
    " at col ",
    m->c.rip - m->c.expr
  );
}
void (*const eval_table['~' - ' ' + 1])(machine_t *) = {
  rpxSpace,   // ' '
  rpxRunLmd,  // '!'
  rpxUndfned, // '"'
  rpxUndfned, // '#'
  rpxLRegs,   // '$'
  rpx_fmod,   // '%'
  rpxWRegs,   // '&'
  rpxUndfned, // '''
  rpxGrpBgn,  // '('
  rpxGrpEnd,  // ')'
  rpxMul,     // '*'
  rpxAdd,     // '+'
  rpxEnd,     // ','
  rpxSub,     // '-'
  rpxUndfned, // '.'
  rpxDiv,     // '/'
  rpxParse,   // '0'
  rpxParse,   // '1'
  rpxParse,   // '2'
  rpxParse,   // '3'
  rpxParse,   // '4'
  rpxParse,   // '5'
  rpxParse,   // '6'
  rpxParse,   // '7'
  rpxParse,   // '8'
  rpxParse,   // '9'
  rpxUndfned, // ':'
  rpxEnd,     // ';'
  rpxLt,      // '<'
  rpxEql,     // '='
  rpxGt,      // '>'
  rpxCond,    // '?'
  rpxSysFn,   // '@'
  rpx_fabs,   // 'A'
  rpxUndfned, // 'B'
  rpx_ceil,   // 'C'
  rpxUndfned, // 'D'
  rpxUndfned, // 'E'
  rpx_floor,  // 'F'
  rpxUndfned, // 'G'
  rpxUndfned, // 'H'
  rpxUndfned, // 'I'
  rpxUndfned, // 'J'
  rpxUndfned, // 'K'
  rpxLogBase, // 'L'
  rpxUndfned, // 'M'
  rpxUndfned, // 'N'
  rpxUndfned, // 'O'
  rpxUndfned, // 'P'
  rpxUndfned, // 'Q'
  rpx_round,  // 'R'
  rpxUndfned, // 'S'
  rpxUndfned, // 'T'
  rpxUndfned, // 'U'
  rpxUndfned, // 'V'
  rpxUndfned, // 'W'
  rpxUndfned, // 'X'
  rpxUndfned, // 'Y'
  rpxUndfned, // 'Z'
  rpxUndfned, // '['
  rpxConst,   // '\'
  rpxUndfned, // ']'
  rpx_pow,    // '^'
  rpxUndfned, // '_'
  rpxUndfned, // '`'
  rpxArc,     // 'a'
  rpxUndfned, // 'b'
  rpx_cos,    // 'c'
  rpxToDeg,   // 'd'
  rpxUndfned, // 'e'
  rpxUndfned, // 'f'
  rpx_tgamma, // 'g'
  rpxHyp,     // 'h'
  rpxIntFn,   // 'i'
  rpxUndfned, // 'j'
  rpxUndfned, // 'k'
  rpxLog,     // 'l'
  rpxNegate,  // 'm'
  rpxUndfned, // 'n'
  rpxUndfned, // 'o'
  rpxUndfned, // 'p'
  rpxUndfned, // 'q'
  rpxToRad,   // 'r'
  rpx_sin,    // 's'
  rpx_tan,    // 't'
  rpxUndfned, // 'u'
  rpxUndfned, // 'v'
  rpxUndfned, // 'w'
  rpxUndfned, // 'x'
  rpxUndfned, // 'y'
  rpxUndfned, // 'z'
  rpxLmdBgn,  // '{'
  rpxUndfned, // '|'
  rpxLmbEnd,  // '}'
  rpxUndfned, // '~'
};
void (*getEvalTable(char c))(machine_t *) {
  return eval_table[c - ' '];
}
void rpxEval(machine_t *restrict m) {
  for (; *m->c.rip && m->e.iscontinue; m->c.rip++) [[clang::likely]]
    getEvalTable (*m->c.rip)(m);
}
void initEvalinfo(machine_t *restrict ret) {
  ret->s.rbp = ret->s.rsp = (real_t *)ret->s.payload - 1;
  ret->e.info = getRRuntimeInfo();
  ret->e.iscontinue = true;
  ret->c.rip = ret->c.expr;
  ret->d.spi = 0;
}
/**
 * @brief Evaluate real number expression
 * @param a_expr String of expression
 * @return Expression evaluation result
 */
elem_t evalExprReal(char const *restrict a_expr) {
  machine_t m;
  initEvalinfo(&m);
  m.c.expr = m.c.rip = a_expr;
  rpxEval(&m);
  if (++m.e.info.histi < buf_size) m.e.info.hist[m.e.info.histi] = *m.s.rsp;
  setRRuntimeInfo(m.e.info);
  return (elem_t){
    {m.s.rsp->elem.real},
    m.s.rsp->isnum ? RTYPE_REAL : RTYPE_LAMB,
  };
}
test_table(
  eval_lamb_fn, evalExprReal, (elem_t, char const *),
  {
    {{.rtype = RTYPE_LAMB, .elem = {.lamb = "$1$1+"}}, "{$1$1+}&f"},
    {   {.rtype = RTYPE_REAL, .elem = {.real = 10.0}},      "5$f!"},
}
)
#define eval_expr_real_return_double(expr) evalExprReal(expr).elem.real
test_table(
  eval_real, eval_expr_real_return_double, (double, char const *),
  {
    {11.0,              "5 6 + &x"}, // write reg
    {22.0,                "$x 2 *"}, // load reg
    {33.0, "4 5 (5 6 (6 7 +) +) +"}, // nest grp
    {66.0,               "@a @a +"}, // ans
    { 4.0,            "1 1 + @p +"}, // prev
    { 0.0,                 "\\P s"}, // const
}
)
test_table(
  eval_lamb, eval_expr_real_return_double, (double, char const *),
  {
    { 8.0,                                      "4 {$1 2 *}!"}, // lamb
    {19.0, "1 5 {$1 3 +}! {5 $1 * {$1 4 -}! {$1 2 /}! $2 +}!"}, // nest lamb
}
)
#undef eval_expr_real_return_double
bench (eval_expr_real) {
  evalExprReal("1 2 3 4 5 +");
  evalExprReal("4 5 ^");
  evalExprReal("1s2^(1c2^)+");
  evalExprReal("  5    6    10    - 5  /");
  evalExprReal("5");
  evalExprReal("@a");
  evalExprReal("10 &x");
  evalExprReal("$x 2 *");
  evalExprReal("2 3 ^ (4 5 *) + (6 7 /) -");
  evalExprReal("\\P 2 / s");
  evalExprReal("\\P 4 / c");
  evalExprReal("2 l2");
  evalExprReal("100 lc");
  evalExprReal("1 0 /");
}

/**
 * @file evalfn-comp.c
 * @brief Define evalExprComplex
 */
#include "benchmarking.h"
#include "elemop.h"
#include "error.h"
#include "evalfn.h"
#include "mem.h"
#include "phyconst.h"
#include "rand.h"
#include "testing.h"
#include <ctype.h>
/**
 * @brief Evaluate comp number expression
 * @param[in] expr String of expression
 * @return elem_t Expression evaluation result
 * @warning Possible stack overflow with very long expressions
 */
[[gnu::nonnull]] elem_t evalExprComplex(char const *expr) {
  elem_t operand_stack[buf_size] = {};
  elem_t *rsp = operand_stack, *rbp = operand_stack;
  rtinfo_t info_c = getRuntimeInfo();
  for (;; expr++) {
    if (*expr == '[') {
      (++rsp)->rtype = RTYPE_MATR;
      expr++;
      matrix_t val = {.matrix = xalloc(comp, mat_init_size)};
      matrix curelem = val.matrix;
      val.cols = (size_t)strtol(expr, (char **)&expr, 10);
      for (; *expr != ']'; expr += skipUntil(expr, ','))
        *curelem++ = evalExprComplex(expr).elem.comp;
      val.rows = (size_t)(curelem - val.matrix) / val.cols;
      rsp->elem.matr = val;
      continue;
    }
    if (isspace(*expr)) continue;
    if (*expr == '\0') break;
    switch (*expr) {
    case '0' ... '9':
      (++rsp)->rtype = RTYPE_COMP;
      rsp->elem.comp = strtod(expr, (char **)&expr);
      expr--;
      break;
    case '(':
      (++rsp)->elem.real = bit_cast(double, rbp - operand_stack);
      rbp = rsp;
      break;
    case ')':
      rbp = operand_stack + bit_cast(long, rbp->elem.real);
      rsp--;
      *rsp = *(rsp + 1);
      break;
      MAP_PAIR(OP_CASE_ELEM, (Add, +), (Sub, -), (Mul, *), (Div, /), (Pow, ^))
      MAP_PAIR(OVERWRITE_COMP, ('A', fabs), ('s', sin), ('c', cos), ('t', tan))
    case '~': {
      matrix_t __ dropmatr = rsp->elem.matr;
      rsp->elem.matr = inverseMatrix(&rsp->elem.matr);
    } break;
    case '=':
      for (; rbp + 1 < rsp && eq(rsp - 1, rsp); rsp--);
      (rbp + 1)->elem.real = rbp + 1 == rsp;
      if (rbp + 1 != rsp) rsp = rbp + 1;
      break;
    case 'a':
      switch (*++expr) {
        MAP_PAIR(OVERWRITE_COMP, ('s', asin), ('c', acos), ('t', atan))
      default:
        DISPERR("unknown fn: ", *expr);
      }
      break;
    case 'h':
      switch (*++expr) {
        MAP_PAIR(OVERWRITE_COMP, ('s', sinh), ('c', cosh), ('t', tanh))
      default:
        DISPERR("unknown fn: ", *expr);
      }
      break;
    case 'l':
      rsp->elem.comp = clog(rsp->elem.comp);
      break;
    case 'L': { // log with base
      double x = creal((rsp--)->elem.comp);
      rsp->elem.comp = log(rsp->elem.comp) / log(x);
    } break;
#define MUL(c, factor) \
  case c: \
    rsp->elem.comp *= factor; \
    break;
      MAP_PAIR(MUL, ('r', pi / 180), ('d', 180 / pi), ('m', -1), ('i', I))
    case 'p': { // polar
      comp theta = (rsp--)->elem.comp;
      rsp->elem.comp
        = rsp->elem.comp * cos(theta) + I * rsp->elem.comp * sin(theta);
    } break;
    case '@':   // system functions
      switch (*++expr) {
      case 'a': // ANS
        elemSet(++rsp, &info_c.hist[info_c.histi]);
        break;
      case 'd':
        print_complex(rsp->elem.comp);
        break;
      case 'h': // history operation
        elemSet(rsp, &info_c.hist[info_c.histi - (size_t)rsp->elem.real]);
        break;
      case 'n':
        elemSet(++rsp, &(elem_t){.rtype = RTYPE_COMP, .elem = {.comp = NAN}});
        break;
      case 'p': // prev stack value
        rsp++;
        elemSet(rsp, rsp - 1);
        break;
      case 'r':
        (++rsp)->elem.comp = xorsh0to1();
        break;
      case 's': // stack value operation
        elemSet(rsp, rsp - (int)rsp->elem.real - 1);
        break;
      default:
        [[clang::unlikely]];
      }
      break;
    case '\\': // special variables and CONSTANTS
      (++rsp)->elem.comp = getConst(*++expr);
      break;
    case '$': // register
      if (islower(*++expr)) [[clang::likely]] {
        elem_t const *rhs = &info_c.reg[*expr - 'a'];
        elemSet(++rsp, rhs);
      }
      break;
    case '&':
      elemSet(&info_c.reg[*++expr - 'a'], rsp);
      break;
    case ';': // comment
    case ',': // delimiter
      goto end;
    default:
      DISPERR("unknown char: ", *expr);
    }
  }
end:
  if (rsp->rtype == RTYPE_MATR) {
    elem_t *rhs = &info_c.hist[++info_c.histi];
    if (rhs->rtype == RTYPE_MATR) nfree(rhs->elem.matr.matrix);
    *rhs = *rsp;
  } else if (info_c.histi < buf_size)
    info_c.hist[++info_c.histi].elem.comp = rsp->elem.comp;
  setRuntimeInfo(info_c);
  return *rsp;
}
#define eval_expr_complex_return_complex(expr) evalExprComplex(expr).elem.comp
test_table(
  eval_complex, eval_expr_complex_return_complex, (comp, char const *),
  {
    {1.0 + 2.0i,        "1 2i +"},
    {   1024.0i,        "4i 5 ^"},
    {      4.0i, "1 1i+(2 2i+)*"},
}
)
test_table(
  eval_complex_comp, eval_expr_complex_return_complex, (comp, char const *),
  {
    {1.2984575814159773 + 0.6349639147847361i, "1 1i+s"},
    {1.1447298858494002 + 1.5707963267948967i,  "\\Pil"},
}
)
#undef eval_expr_complex_return_complex
test (eval_expr_complex) {
  matrix_t resultm;
  // Test matrix addition
  resultm = evalExprComplex("[2 1,2,3,4,][2 5,6,7,8,]+").elem.matr;
  expecteq(6.0, resultm.matrix[0]);
  expecteq(8.0, resultm.matrix[1]);
  expecteq(10.0, resultm.matrix[2]);
  expecteq(12.0, resultm.matrix[3]);
  // Test matrix multiplication
  char const *expr = "[2 1,2,3,4,][2 5,6,7,8,]*";
  resultm = evalExprComplex(expr).elem.matr;
  expecteq(2, resultm.rows);
  expecteq(2, resultm.cols);
  expecteq(19.0, resultm.matrix[0]);
  expecteq(22.0, resultm.matrix[1]);
  expecteq(43.0, resultm.matrix[2]);
  expecteq(50.0, resultm.matrix[3]);
  // Test matrix inverse
  expr = "[2 1,2,3,4,]~";
  resultm = evalExprComplex(expr).elem.matr;
  expecteq(2, resultm.rows);
  expecteq(2, resultm.cols);
  expecteq(-2.0, resultm.matrix[0]);
  expecteq(1.0, resultm.matrix[1]);
  expecteq(1.5, resultm.matrix[2]);
  expecteq(-0.5, resultm.matrix[3]);
  // Scalar multiplication
  expr = "[3 5,6,7,] 5 *";
  resultm = evalExprComplex(expr).elem.matr;
  expecteq(1, resultm.rows);
  expecteq(3, resultm.cols);
  expecteq(25, resultm.matrix[0]);
  expecteq(30, resultm.matrix[1]);
  expecteq(35, resultm.matrix[2]);
}
bench (eval_expr_complex) {
  evalExprComplex("1 2 3 4 5 +");
  evalExprComplex("4 5 ^");
  evalExprComplex("1s2^(1c2^)+");
  evalExprComplex("  5    6    10    - 5  /");
  evalExprComplex("5");
  evalExprComplex("@a");
  evalExprComplex("10 &x");
  evalExprComplex("$x 2 *");
  evalExprComplex("2 3 ^ (4 5 *) + (6 7 /) -");
  evalExprComplex("\\P 2 / s");
  evalExprComplex("\\P 4 / c");
  evalExprComplex("2 l2");
  evalExprComplex("100 lc");
  evalExprComplex("1 0 /");
}
bench (eval_matrix) {
  evalExprComplex("[2 1,2,3,4,][2 5,6,7,8,]+");
  evalExprComplex("[3 4,1,4,6,5,7,3,6,7,]~");
  evalExprComplex("[1 4,5,][2 6,7,]*");
  evalExprComplex("[2 7,6,5,4,] 6 *");
  evalExprComplex("[2 9,0,5,1,] 4 ^");
  evalExprComplex("[2 5,4,3,2,][2 4,8,2,1,]/");
}

/**
 * @file src/error.c
 */
#include "chore.h"
#include <stdarg.h>
overloadable void
dispErr(FILE *fp, char const *funcname, char const *errmsgfmt, ...) {
  va_list ap;
  va_start(ap);
#ifdef TEST_MODE
  _ = errmsgfmt;
  _ = funcname;
  _ = fp;
#else
 #include "ansiesc.h"
 #include <stdio.h>
  fprintf(fp, "\n[%s]\n", funcname);
  fprintf(fp, "  " ESCRED "Error: ");
  vfprintf(fp, errmsgfmt, ap);
  fputs(ESCLR "\n", stderr);
#endif
  va_end(ap);
}
overloadable void dispErr(char const *funcname, char const *errmsgfmt, ...) {
  va_list ap;
  va_start(ap);
  dispErr(stderr, funcname, errmsgfmt, ap);
  va_end(ap);
}

/**
 * @file src/errcode.c
 */
#include "errcode.h"
char const *codetomsg(errcode_t code) {
  switch (code) {
  case ERR_SUCCESS:
    return "success";
  case ERR_UNKNOWN_CHAR:
    return "Unknown character";
  case ERR_UNKNOWN_FN:
    return "Unknown function";
  case ERR_DIMENTION_MISMATCH:
    return "Dimention mismatch";
  case ERR_IRREGULAR_MATRIX:
    return "Irregular matrix";
  case ERR_NON_SQUARE_MATRIX:
    return "Non-square matrix";
  case ERR_TYPE_MISMATCH:
    return "Type mismatch";
  case ERR_FILE_NOT_FOUND:
    return "File not found";
  case ERR_BUFFER_DEPLETION:
    return "Buffer depletion";
  case ERR_CURSOR_OUT_OF_RANGE:
    return "Cursor out of range";
  case ERR_CHAR_NOT_FOUND:
    return "Character not found";
  case ERR_ALLOCATION_FAILURE:
    return "Allocation failure";
  case ERR_UNKNOWN_COMMAND:
    return "Unknown command";
  case ERR_REACHED_UNREACHABLE:
    return "Reached unreachable code";
  case ERR_UNKNOWN_OPTION:
    return "Unknown option";
  default:
    [[clang::unlikely]] return "";
  }
}

/**
 * @file src/elemop.c
 * @brief Define elem_t related functions
 */
#include "elemop.h"
#include "chore.h"
#include "errcode.h"
#include "error.h"
[[gnu::nonnull]] void
elemSet(elem_t *restrict lhs, elem_t const *restrict rhs) {
  if (lhs->rtype == RTYPE_MATR) free(lhs->elem.matr.matrix);
  *lhs = *rhs;
}
overloadable bool eq(elem_t lhs, elem_t rhs) {
  if (lhs.rtype != rhs.rtype) return false;
  switch (lhs.rtype) {
  case RTYPE_REAL:
    return eq(lhs.elem.real, rhs.elem.real);
  case RTYPE_COMP:
    return eq(lhs.elem.comp, rhs.elem.comp);
  case RTYPE_MATR:
    return eq(&lhs.elem.matr, &rhs.elem.matr);
  case RTYPE_LAMB:
    return eq(lhs.elem.lamb, lhs.elem.lamb);
  default:
    [[clang::unlikely]];
  }
  return false;
}
overloadable void printany(elem_t __) {
}
overloadable void printanyf(elem_t __) {
}
void elemAdd(elem_t *lhs, elem_t const *rhs) {
  if (lhs->rtype != rhs->rtype) {
    DISPERR(codetomsg(ERR_TYPE_MISMATCH));
    return;
  }
  if (rhs->rtype == RTYPE_MATR) {
    matrix_t __ dropmatr = lhs->elem.matr;
    lhs->elem.matr = mAdd(&lhs->elem.matr, &rhs->elem.matr);
    free(rhs->elem.matr.matrix);
    return;
  }
  lhs->elem.comp += rhs->elem.comp;
}
void elemSub(elem_t *lhs, elem_t const *rhs) {
  if (lhs->rtype != rhs->rtype) {
    DISPERR(codetomsg(ERR_TYPE_MISMATCH));
    return;
  }
  if (rhs->rtype == RTYPE_MATR) {
    matrix_t __ dropmatr = lhs->elem.matr;
    lhs->elem.matr = mSub(&lhs->elem.matr, &rhs->elem.matr);
    return;
  }
  lhs->elem.comp -= rhs->elem.comp;
}
rtype_t elemMul(elem_t *lhs, elem_t *rhs) {
  if (lhs->rtype == RTYPE_MATR && rhs->rtype == RTYPE_MATR) {
    matrix_t __ dropmatr = lhs->elem.matr;
    lhs->elem.matr = mMul(&lhs->elem.matr, &rhs->elem.matr);
    return RTYPE_MATR;
  } else if (lhs->rtype == RTYPE_MATR && rhs->rtype == RTYPE_COMP) {
    smul(&lhs->elem.matr, rhs->elem.comp);
    return RTYPE_MATR;
  } else if (lhs->rtype == RTYPE_COMP && rhs->rtype == RTYPE_MATR) {
    smul(&rhs->elem.matr, lhs->elem.comp);
    *lhs = *rhs;
    return RTYPE_MATR;
  }
  lhs->elem.comp *= rhs->elem.comp;
  return RTYPE_COMP;
}
void elemDiv(elem_t *lhs, elem_t const *rhs) {
  if (lhs->rtype == RTYPE_COMP) lhs->elem.comp /= rhs->elem.comp;
  else smul(&lhs->elem.matr, 1 / rhs->elem.comp);
}
void elemPow(elem_t *lhs, elem_t *rhs) {
  if (lhs->rtype == RTYPE_COMP) {
    lhs->elem.comp = pow(lhs->elem.comp, rhs->elem.comp);
    return;
  }
  if (creal(rhs->elem.comp) < 0) {
    matrix_t __ dropmatr = lhs->elem.matr;
    lhs->elem.matr = inverseMatrix(&lhs->elem.matr);
    rhs->elem.comp *= -1;
  }
  unsigned long n = (unsigned long)creal(rhs->elem.comp);
  matrix_t a dropmatr = newMatrix(lhs->elem.matr.rows, lhs->elem.matr.cols);
  memcpy(a.matrix, lhs->elem.matr.matrix, a.rows * a.cols * sizeof(comp));
  for (size_t i = 1; i < n; i++) {
    matrix_t __ dropmatr = lhs->elem.matr;
    lhs->elem.matr = mMul(&lhs->elem.matr, &a);
  }
}

/**
 * @file src/editline.c
 * @brief Define `editline()`
 */
#include "editline.h"
#include "error.h"
#include "exproriented.h"
#include "mem.h"
#include "term.h"
#include "testing.h"
#include <ctype.h>
#define getchar  (char)getchar
#define is_space (bool)isspace
#define is_alnum (bool)isalnum
mut_cursor_t movecur(int n, mut_cursor_t cur) {
  size_t len = cur.base->len;
  size_t pos = cur.pos;
  cur.pos = n > (int)(len - pos) ? len : -n > (int)pos ? 0 : pos + (size_t)n;
  return cur;
}
test (movecur) {
  mut_slice_t s dropslice = mutFromString("sample text.");
  mut_cursor_t ms = FROM_SLICE(s);
  ms = movecur(1, ms);
  expecteq(1, ms.pos);
  ms = movecur(3, ms);
  expecteq(4, ms.pos);
  ms = movecur(-4, ms);
  expecteq(0, ms.pos);
  ms = movecur(-1, ms);
  expecteq(0, ms.pos);
  ms = movecur(999, ms);
  expecteq(ms.base->len, ms.pos);
}
mut_cursor_t findmove(char ch, int dir, mut_cursor_t c) {
  size_t new
    = (size_t)((dir > 0) ? memchr(c.base->s + c.pos, ch, c.base->len - c.pos)
                         : memrchr(c.base->s, ch, c.pos))
      ?: $return(c);
  return (mut_cursor_t){
    .base = c.base,
    .pos = new - (size_t)c.base->s,
  };
}
test (findmove) {
  mut_slice_t s = mutFromString("sample text.");
  mut_cursor_t c = FROM_SLICE(s);
#define CASE(ch, d) \
  c = findmove(ch, d, c); \
  expecteq(ch, c.base->s[c.pos]);
  MAP_PAIR(CASE, (' ', 1), ('e', 1), ('s', -1), ('.', 1))
  size_t prev = c.pos;
  c = findmove('z', -1, c);
  expecteq(prev, c.pos);
}
mut_cursor_t fw(mut_cursor_t c) {
  char const *s = c.base->s + c.pos;
  if (is_space(*s)) return movecur((int)skipByte(s, ' '), c);
  for (bool was_alnum = is_alnum(*s);
       !is_space(*s) && s < c.base->s + c.base->len
       && (is_alnum(*s) == was_alnum);
       s++);
  s += skipByte(s, ' ');
  return (mut_cursor_t){.base = c.base, .pos = (size_t)(s - c.base->s)};
}
test (fw) {
  mut_slice_t s dropslice = mutFromString("sample text.");
  mut_cursor_t c = FROM_SLICE(s);
  c = fw(c);
  expecteq(7, c.pos);
  c = fw(c);
  expecteq(11, c.pos);
}
mut_cursor_t bw(mut_cursor_t c) {
  char const *s = c.base->s + c.pos - 1;
  for (; is_space(*s); s--);
  for (bool was_alnum = is_alnum(*s);
       !is_space(s[-1]) && c.base->s < s && (is_alnum(s[-1]) == was_alnum);
       s--);
  return (mut_cursor_t){.base = c.base, .pos = (size_t)(s - c.base->s)};
}
test (bw) {
  mut_slice_t s dropslice = mutFromString("sample text.");
  mut_cursor_t c = FROM_SLICE(s);
  c.pos = s.len;
  c = bw(c);
  expecteq(11, c.pos);
  c = bw(c);
  expecteq(7, c.pos);
}
mut_cursor_t fW(mut_cursor_t c) {
  char const *s = memchr(c.base->s + c.pos, ' ', c.base->len - c.pos)
                  ?: c.base->s + c.base->len;
  s += skipByte(s, ' ');
  return (mut_cursor_t){.base = c.base, .pos = (size_t)(s - c.base->s)};
}
test (fW) {
  mut_slice_t s dropslice = mutFromString("sample text.");
  mut_cursor_t c = FROM_SLICE(s);
  c = fW(c);
  expecteq(7, c.pos);
  c = fW(c);
  expecteq(12, c.pos);
}
mut_cursor_t bW(mut_cursor_t c) {
  char const *s = c.base->s + c.pos - 1;
  for (; is_space(*s) && c.base->s < s; s--);
  s = memrchr(c.base->s, ' ', (size_t)(s - c.base->s)) ?: c.base->s - 1;
  return (mut_cursor_t){.base = c.base, .pos = (size_t)(s - c.base->s + 1)};
}
test (bW) {
  mut_slice_t s dropslice = mutFromString("sample text.");
  mut_cursor_t c = FROM_SLICE(s);
  c.pos = s.len;
  c = bW(c);
  expecteq(7, c.pos);
  c = bW(c);
  expecteq(0, c.pos);
}
void deletes(mut_slice_t *ms, range_t range) {
  memmove(ms->s + range.begin, ms->s + range.end, ms->len - range.end);
  ms->len -= range.end - range.begin;
}
test (deletes) {
  mut_slice_t s dropslice = mutFromString("sample text.");
  deletes(&s, (range_t){0, 7});
  expecteq(mutFromString("text."), s);
}
/**
 * @brief Handle escape sequence
 * @param[in] key Escape sequence
 * @param[in,out] c Cursor
 */
static void handleEs(char key, mut_cursor_t *c) {
  switch (key) {
  case '3': // delete key
    if (getchar() != '~') break;
    if (c->pos == c->base->len) break;
    char *s = c->base->s + c->pos;
    memmove(s, s + 1, c->base->len - c->pos - 1);
    c->base->len--;
    break;
  case 'C': // right arrow
    *c = movecur(1, *c);
    break;
  case 'D': // left arrow
    *c = movecur(-1, *c);
    break;
  case 'F': // END
    c->pos = c->base->len;
    break;
  case 'H': // HOME
    c->pos = 0;
    break;
  default:
    DISPERR("unknown escape sequence: ", key);
  }
}
static range_t handleTxtObj(char txtobj, mut_cursor_t c) {
  switch (txtobj) {
  case 'w':
    return (range_t){.begin = fw(c).pos, .end = bw(c).pos};
  case 'W':
    return (range_t){.begin = fW(c).pos, .end = bW(c).pos};
  case 'b':
    return (range_t){
      .begin = findmove(')', 1, c).pos,
      .end = findmove('(', -1, c).pos,
    };
  case ']':
    return (range_t){
      .begin = findmove(']', 1, c).pos,
      .end = findmove('[', -1, c).pos,
    };
  default:
    return (range_t){};
  }
}
void inserts(slice_t s, mut_cursor_t *c) {
  size_t len = s.len + c->base->len;
  size_t cap = stdc_bit_ceil(len);
  if (c->base->cap < len) {
    c->base->s = realloc(c->base->s, cap);
    c->base->cap = cap;
  }
  char *str = c->base->s + c->pos;
  memmove(str + s.len, str, c->base->len - c->pos);
  memcpy(str, s.s, s.len);
  c->pos += s.len;
  c->base->len += s.len;
}
test (inserts) {
  auto s = mutFromString("sample text.");
  mut_cursor_t c = FROM_SLICE(s);
  c.pos = s.len - 1;
  inserts(fromString("new string"), &c);
  expecteq(mutFromString("sample textnew string."), *c.base);
  c.pos = 11;
  inserts(fromString("extra string"), &c);
  expecteq(mutFromString("sample textextra stringnew string."), *c.base);
}
/**
 * @brief Behavior in insert mode
 * @param[in] ch Typed character
 * @param[in,out] c Cursor
 */
static void insbind(char ch, mut_cursor_t *c) {
  switch (ch) {
  case '(': // autopair
    inserts(fromString("()"), c);
    c->pos--;
    break;
  case ')': {
    char const *pos = strchr(c->base->s + c->pos, ')') ?: p$(goto dflt);
    c->pos = (size_t)(pos - c->base->s + 1);
  } break;
  case '[': // autopair
    inserts(fromString("[]"), c);
    c->pos--;
    break;
  case ']': {
    char *pos = strchr(c->base->s + c->pos, ']') ?: p$(goto dflt);
    c->pos = (size_t)(pos - c->base->s + 1);
  } break;
dflt:
  default:
    inserts((slice_t){.s = &ch, .len = 1}, c);
  }
}
auto handle_printable = insbind;
/**
 * @brief Behavior in normal mode
 * @param[in] ch Typed character
 * @param[in,out] c Cursor
 * @see `$ vim -c ":h *{char}*<CR>"`
 */
static void nrmbind(char ch, mut_cursor_t *c) {
  switch (ch) {
  case 'h':
    *c = movecur(-1, *c);
    break;
  case 'l':
    *c = movecur(1, *c);
    break;
  case 'w':
    *c = fw(*c);
    break;
  case 'b':
    *c = bw(*c);
    break;
  case 'W':
    *c = fW(*c);
    break;
  case 'B':
    *c = bW(*c);
    break;
  case 'f':
    *c = findmove(getchar(), 1, *c);
    break;
  case 'F':
    *c = findmove(getchar(), -1, *c);
    break;
  case 'A':
    c->pos = c->base->len;
    [[fallthrough]];
  case 'a':
    c->pos += c->pos != c->base->len;
    handle_printable = insbind;
    break;
  case 'I':
    c->pos = 0;
    [[fallthrough]];
  case 'i':
    handle_printable = insbind;
    break;
  case 'c':
    handle_printable = insbind;
    [[fallthrough]];
  case 'd': {
    size_t orig_pos = c->pos;
    char input = getchar();
    range_t range
      = $if(input == 'i' || input == 'a')({ handleTxtObj(getchar(), *c); })
        $else({
          nrmbind(input, c);
          (range_t){
            .begin = less(c->pos, orig_pos),
            .end = more(c->pos, orig_pos),
          };
        });
    if (range.begin == range.end) break;
    deletes(c->base, range);
    c->pos = range.begin;
  } break;
  case 'C':
    handle_printable = insbind;
    [[fallthrough]];
  case 'D':
    c->base->len = c->pos;
    break;
  case 'r':
    c->base->s[c->pos] = getchar();
    break;
  case '[':
    handleEs(getchar(), c);
    handle_printable = insbind;
    break;
  default:
    DISPERR("unknown char: ", ch);
  }
}
/**
 * @brief Multi modal input function
 * @param[in] sz Buffer size
 * @param[out] buf Buffer
 * @return Is not CTRL-D pressed
 */
bool editline(size_t sz, char *buf) {
  mut_slice_t s = mutFromString("");
  mut_cursor_t c = FROM_SLICE(s);
  struct termios __ ondrop(disableRawMode) = enableRawMode();
  char ch;
  while (ch = getchar(), ch != ctrld && ch != '\n' && c.base->len < sz - 1) {
    switch (ch) {
    case es:
      handle_printable = nrmbind;
      break;
    case backspace:
      if (c.pos == 0) continue;
      memmove(c.base->s + c.pos - 1, c.base->s + c.pos, c.base->len - c.pos);
      c.pos--;
      c.base->len--;
      break;
    default:
      handle_printable(ch, &c);
      break;
    }
    PRINT(ESEL(2) "\r", *c.base, "\033[", (int)c.pos + 1, "G");
  }
  putchar('\n');
  memcpy(buf, c.base->s, c.base->len);
  buf[c.base->len] = '\0';
  free(c.base->s);
  return ch == '\n';
}

/**
 * @file src/chore.c
 * @brief Define util functions
 */
#include "chore.h"
#include "exproriented.h"
/**
 * @brief panic alloc
 * @param[in] sz Memory size
 * @warning Unrecoverable
 */
void *palloc(size_t sz) {
  return malloc(sz) ?: p$panic(ERR_ALLOCATION_FAILURE);
}
/**
 * @brief free for drop
 */
void freecl(void *p) {
  free(*bit_cast(void **, p));
}
void fclosecl(FILE **fp) {
  fclose(*fp);
}
void closedircl(DIR **fp) {
  closedir(*fp);
}

/**
 * @file src/bit.c
 */
#include "bit.h"
#include "testing.h"
[[gnu::const]] static size_t nulCheck(size_t x) {
  size_t m = repeatBytes(0x7f);
  return (x & m) + m | m;
}
/**
 * @brief Find zero all
 */
[[gnu::const]] bool fza(size_t x) {
  return ~(nulCheck(x) | x);
}
/**
 * @brief FZA for ascii string
 */
[[gnu::const]] bool isNulExist(size_t x) {
  return ~nulCheck(x);
}
test (zero_byte_check) {
  size_t x = 0x10'10'10'10'10'00'00'00;
  expect(fza(x));
  expect(isNulExist(x));
  x = 0xde'ad'be'ef'de'ad'be'ef;
  expect(!fza(x));
  expect(!isNulExist(x));
  x = 0x80'80'80'80'80'80'80'80;
  expect(!fza(x));
  expect(isNulExist(x));
}
[[gnu::const]] size_t repeatBytes(byte_t c) {
  return -1UL / 0xff * (size_t)c;
}
test_table(
  repeat_bytes, repeatBytes, (size_t, byte_t),
  {
    {0xff'ff'ff'ff'ff'ff'ff'ff, 0xff},
    {0x12'12'12'12'12'12'12'12, 0x12},
    {0x01'01'01'01'01'01'01'01, 0x01},
    {0x00'00'00'00'00'00'00'00, 0x00},
}
)
/**
 * @brief Align to multiples of size
 * @param[in] base Pointer
 * @param[in] size Size
 * @return Aligned pointer
 */
[[gnu::const]] void *alignBackward(void const *base, size_t size) {
  return (void *)((size_t)base & -size);
}
[[gnu::const]] void *alignForward(void const *base, size_t size) {
  return alignBackward(base + size - 1, size);
}
test_table(
  alignBack, alignBackward, (void *, void const *, size_t),
  {
    {(void *)8,  (void *)9, 8},
    {(void *)8, (void *)15, 8},
    {(void *)8,  (void *)8, 8},
}
)
test_table(
  alignFor, alignForward, (void *, void const *, size_t),
  {
    {(void *)8, (void *)5, 8},
    {(void *)8, (void *)1, 8},
    {(void *)8, (void *)8, 8},
}
)

/**
 * @file src/benchmarking.c
 */
#ifdef BENCHMARK_MODE
int main() {
}
#else
 #include "benchmarking.h"
bench (example) {
  int volatile a = 0;
  for (int i = 0; i < 100; i++)
    for (int j = 0; j < 100; j++) a++;
}
#endif

/**
 * @file src/ansiesc.c
 * @brief Test escape sequence macros
 */
#include "ansiesc.h"
#include "testing.h"
test (ansi_escape_sequence) {
  expect(true);
  test_filter("all") {
    puts(ESCLR);
#define PRINT_HELLO(x) puts(x "hello" ESCLR);
    MAP(
      PRINT_HELLO,
      ESBLD,
      ESTHN,
      ESITA,
      ESULN,
      ESBLN,
      ESFBLN,
      ESREV,
      ESHID,
      ESUDO,
      ESCRED,
      ESCGRN,
      ESCYEL,
      ESCBLU,
      ESCMGN,
      ESCCYN,
      ESCBLK,
      ESCBRED,
      ESCBGRN,
      ESCBYEL,
      ESCBBLU,
      ESCBMGN,
      ESCBCYN,
      ESCBBLK,
      ESCCODE(100),
      ESCCODE_RGB(100, 100, 100)
    )
  }
}

NPROC != nproc
MAKEFLAGS += -j$(NPROC)
MAKEFLAGS += -r -R
DEFAULT_OPTLEVEL := g
DEFAULT_PREFIX := /usr/local
DEFAULT_TYPE := default
DEFAULT_USE_CCACHE := y
DEFAULT_EMIT_LLVM := n
DEFAULT_BUILD_FROM_ASM := n
.PHONY: $(shell grep -ho "^[0-9a-z-]\\+:" $(MAKEFILE_LIST) | sed -e "s/://")
define ERROR_INVALID_VALUE
  $(error invalid value for $$($1): expected one of $(or $2,[yn]) but got $($1))
endef
CLANG21 != command -v clang-21
CLANG20 != command -v clang-20
CLANG19 != command -v clang-19
CLANG != command -v clang
CC := $(or $(CLANG21),$(CLANG20),$(CLANG19),$(CLANG),$(error CC not found: install clang (>=19)))
USE_CCACHE ?= $(DEFAULT_USE_CCACHE) ## use ccache [yn] (default: y)
ifeq ($(strip $(USE_CCACHE)),y)
  CCACHE != command -v ccache
  CC := $(CCACHE) $(CC)
else ifeq ($(strip $(USE_CCACHE)),n)
else
  $(call ERROR_INVALID_VALUE,USE_CCACHE)
endif
PROJECT_NAME := $(notdir $(CURDIR))
CDIR := src
INCDIR := include
BUILDDIR := .build
PREFIX ?= $(DEFAULT_PREFIX) ## install prefix (default: /usr/local)
OPTLEVEL ?= $(or $(OL), $(DEFAULT_OPTLEVEL)) ## optimization level [0-3|g] (default: g)
LOGLEVEL ?= $(or $(LL), $(DEFAULT_LOGLEVEL))
TYPE ?= $(or $(T), $(DEFAULT_TYPE)) ## build type [test|bench|default]
# compiler flags
CFLAGS != cat build/cflags
OPTFLAGS != cat build/optflags
# linker flags
LDFLAGS != cat build/ldflags
OPTLDFLAGS != cat build/optldflags
DEBUGFLAGS != cat build/debugflags
ASMFLAGS != cat build/asmflags
# Enables macro in the source
CFLAGS += -DLOGLEVEL=$(LOGLEVEL)
ifdef ASAN
  CFLAGS += -fsanitize=$(ASAN)
  LDFLAGS += -fsanitize=$(ASAN)
endif
ifeq ($(MAKECMDGOALS),coverage)
  CFLAGS += -fprofile-instr-generate -fcoverage-mapping
  LDFLAGS += -fprofile-instr-generate
  TYPE := test
  OPTLEVEL := 0
endif
ifeq ($(strip $(TYPE)),test)
  CFLAGS += -DTEST_MODE
else ifeq ($(strip $(TYPE)),bench)
  CFLAGS += -DBENCHMARK_MODE
else ifeq ($(strip $(TYPE)),default)
else
  $(call ERROR_INVALID_VALUE,TYPE,[test|bench|default])
endif
ifeq ($(strip $(OPTLEVEL)),g)
  CFLAGS += $(DEBUGFLAGS)
  LDFLAGS += $(DEBUGFLAGS)
  RUNNER ?= gdb ## runner (default in debug run: gdb)
else ifneq ($(filter 1 2 3,$(OPTLEVEL)),)
  CFLAGS += $(OPTFLAGS) -O$(OPTLEVEL)
  LDFLAGS += $(OPTLDFLAGS) -O$(OPTLEVEL)
else ifeq ($(strip $(OPTLEVEL)),0)
else
  $(call ERROR_INVALID_VALUE,OPTLEVEL,[0-3|g])
endif
ifeq ($(MAKECMDGOALS),profile)
  CFLAGS += -pg
  LDFLAGS += -pg
  LDFLAGS := $(filter-out -s,$(LDFLAGS))
endif
ifdef TEST_FILTER
  CFLAGS += -DTEST_FILTER="\"$(TEST_FILTER)\""
endif
# generate output path
GITBRANCH != git branch --show-current 2>/dev/null
SEED = $(CC)$(CFLAGS)$(LDFLAGS)$(GITBRANCH)$(IN_NIX_SHELL)
HASH != echo '$(SEED)' | md5sum | cut -d' ' -f1
OUTDIR := $(BUILDDIR)/$(HASH)
TARGET := $(OUTDIR)/$(PROJECT_NAME)
EMIT_LLVM ?= $(DEFAULT_EMIT_LLVM) ## use llvmIR instead of asm [yn] (default: n)
ifeq ($(strip $(EMIT_LLVM)),y)
  ASMFLAGS += -emit-llvm
  ASMEXT := ll
else ifeq ($(strip $(EMIT_LLVM)),n)
  ASMEXT := s
else
  $(call ERROR_INVALID_VALUE,EMIT_LLVM)
endif
# source files
SRCS := $(wildcard $(CDIR)/*.c)
OBJS := $(patsubst $(CDIR)/%.c,$(OUTDIR)/%.o,$(SRCS))
DEPS := $(OBJS:.o=.d)
ASMS := $(OBJS:.o=.$(ASMEXT))
# e.g.)
# $ make asm OL=3
# $ # edit asm files...
# $ make BUILD_FROM_ASM=y OL=3
BUILD_FROM_ASM ?= $(DEFAULT_BUILD_FROM_ASM) ## use asm instead of c files [yn] (default: n)
ifeq ($(strip $(BUILD_FROM_ASM)),y)
  SRCDIR := $(OUTDIR)
  SRCEXT := $(ASMEXT)
  CFLAGS =
else ifeq ($(strip $(BUILD_FROM_ASM)),n)
  SRCDIR := $(CDIR)
  SRCEXT := c
else
  $(call ERROR_INVALID_VALUE,BUILD_FROM_ASM)
endif
include $(realpath $(DEPS))
### build rules
.DEFAULT_GOAL := $(TARGET)
# link
$(TARGET): $(OBJS)
	$(CC) $(LDFLAGS) $^ -o $@
# compile
$(OBJS): $(OUTDIR)/%.o: $(SRCDIR)/%.$(SRCEXT) $(OUTDIR)/%.d | $(OUTDIR)/
	$(CC) $< $(CFLAGS) -c -o $@
define DEPFLAGS
  -MM -MP -MT $1.o -MF $1.d
endef
$(DEPS): $(OUTDIR)/%.d: $(CDIR)/%.c | $(OUTDIR)/
	$(CC) $< $(CFLAGS) $(call DEPFLAGS,$(@:.d=))
# e.g.) run with valgrind
# make run RUNNER=valgrind
# e.g.) don't use gdb (default debug RUNNER) in debug run
# make run RUNNER=
run: $(TARGET) ## run target
	$(RUNNER) $<
# `make run-foo` is same as `make run RUNNER=foo`
run-%: $(TARGET)
	$* $<
test: ; $(MAKE) run TYPE=test RUNNER= ## run test
asm: $(ASMS) ## generate asm files
$(ASMS): $(OUTDIR)/%.$(ASMEXT): $(CDIR)/%.c | $(OUTDIR)/
	$(CC) $< $(ASMFLAGS) $(CFLAGS) -o $@
clean-all: ; rm -rf $(BUILDDIR)
# e.g.) remove test build for opt level 3
# make clean OPTLEVEL=3 TYPE=test
clean:
ifneq ($(realpath $(OUTDIR)),)
	rm -rf $(OUTDIR)
endif
$(PREFIX)/bin/$(PROJECT_NAME): $(TARGET) | $(PREFIX)/bin/
	cp $< $@
install: $(PREFIX)/bin/$(PROJECT_NAME)
uninstall: ; rm $(PREFIX)/bin/$(PROJECT_NAME)
doc: doc/Doxyfile ## generate doc
	doxygen $<
doc/Doxyfile: doc/
	doxygen -g $@
fmt: ; clang-format -Werror --dry-run $(SRCS) $(INCDIR)/*.h
lint: $(SRCS)
	clang-tidy $^ -- $(CFLAGS)
	flawfinder $^
check: $(SRCS)
	cppcheck $^ --enable=all --suppress=missingIncludeSystem -I$(INCDIR)
pre-commit: fmt test ## .git/hooks/pre-commit
FP ?= /dev/stdout
log: ## show build flags
	@echo "Compiler: $(CC)" > $(FP)
	@echo "CFLAGS: $(CFLAGS)" >> $(FP)
	@echo "LDFLAGS: $(LDFLAGS)" >> $(FP)
	@echo "TARGET: $(TARGET)" >> $(FP)
	@echo "SRCS: $(SRCS)" >> $(FP)
	@echo "OBJS: $(OBJS)" >> $(FP)
	@echo "DEPS: $(DEPS)" >> $(FP)
info: $(TARGET) ## show target info
	@echo "target file size:"
	@size $(TARGET)
help: ## show help
	@echo "$$ make          # debug build"
	@echo "$$ make test     # run test"
	@echo "$$ make run OL=3 # run release build"
	@echo
	@echo "build files: .build/HASH/*"
	@echo
	@echo "Variables:"
	@grep -h "^[^\t].* ## " $(MAKEFILE_LIST) \
	| sed -En "s/^ *([0-9A-Z_]+) .?= .*## (.*)$$/\\1 = \\2/p"
	@echo
	@echo "Targets:"
	@grep -h "^[^\t].* ## " $(MAKEFILE_LIST) \
	| sed -En "s/^([0-9a-z-]+): .*## (.*)$$/\\1: \\2/p"
### llmfile
LLMFILE ?= llmfile.txt
FILES ?= makefile doc/t.typ doc/readme.typ doc/manual.typ
DIRS ?= build include src
FILES_IN_DIRS := $(wildcard $(addsuffix /*, $(DIRS)))
SORTED_FILES_IN_DIRS := $(sort $(notdir $(basename $(FILES_IN_DIRS))))
REAL_PATH_FILES_IN_DIRS := $(foreach f,$(SORTED_FILES_IN_DIRS),$(wildcard */$f.[ch]))
LIST_FILES ?= $(FILES) $(REAL_PATH_FILES_IN_DIRS)
$(LLMFILE): $(LIST_FILES)
	echo $^ | sed 's/ /\n/g' > $@
	echo >> $@ # newline
	# `head` automatically inserts the file name at the start of the file
	head -n 9999 $^ >> $@
llmfile: $(LLMFILE) ## for the llm to read
### compiledb
, = ,
LOCAL_CCJ = $(OUTDIR)/compile_commands.json
define STRINGIFY
  $(foreach f,$1,"$f"$,)
endef
$(LOCAL_CCJ).%: | $(dir $(LOCAL_CCJ))
	echo '{"arguments":[' > $@
	echo '"$(lastword $(CC))",' >> $@
	echo '$(call STRINGIFY,$(CFLAGS))' >> $@
	echo '$(call STRINGIFY,$(call COMPILEFLAGS,$(OUTDIR)/$*.o))' >> $@
	echo '"$(SRCDIR)/$*.c"],' >> $@
	echo '"directory":"$(CURDIR)",' >> $@
	echo '"file":"$(CURDIR)/$(SRCDIR)/$*.c",' >> $@
	echo '"output":"$(CURDIR)/$(OUTDIR)/$*.o"},' >> $@
$(LOCAL_CCJ): $(addprefix $(LOCAL_CCJ)., $(basename $(notdir $(SRCS))))
	echo "[" > $@
	cat $^ >> $@
	sed -i "\$$s/,$$/]/" $@
compile_commands.json: $(LOCAL_CCJ)
	cp $< $@
compiledb: compile_commands.json ## for lsp
### coverage
COVDIR ?= $(OUTDIR)/coverage-report
PROFRAW := $(OUTDIR)/default.profraw
PROFDATA := $(OUTDIR)/coverage.profdata
$(PROFRAW): $(TARGET)
	LLVM_PROFILE_FILE=$@ ./$<
$(PROFDATA): $(PROFRAW)
	llvm-profdata merge --sparse $< -o $@
$(COVDIR): $(PROFDATA)
	llvm-cov show $(TARGET) --format=html --instr-profile=$< --output-dir=$@
BROWSER ?= chawan
coverage: $(COVDIR) ## report test coverage
	$(BROWSER) $</index.html
### perf
$(OUTDIR)/perf.data: $(TARGET)
	perf record -o $@ -g ./$<
perf: $(OUTDIR)/perf.data ## run perf analysis
	perf report -i $<
### profile
gmon.out: $(TARGET) ; ./$<
$(OUTDIR)/gmon.out: gmon.out | $(OUTDIR)/
	mv $< $@
$(OUTDIR)/profile.txt: $(OUTDIR)/gmon.out
	gprof $(TARGET) $< > $@
profile: $(OUTDIR)/profile.txt
	less $<
### last resort
%/: ; mkdir -p $@

/**
 * @file include/testing.h
 * @brief Define macros for testing
 * @note Tests not in the test_filter block are always executed
 */
#pragma once
#include "chore.h"
#ifdef TEST_MODE
 #include "ansiesc.h"
 #include "gene.h"
extern int test__success;
extern int test__count;
 #define TEST_HEADER " ■ " ESCBLU "Testing " ESCLR
 #define ALIGN_COL(name) \
   do { \
     int col = 6 - ((int)strlen("   Testing " #name) - 2) / 8; \
     for (int i = 0; i < col; i++) putchar('\t'); \
   } while (0)
 #define PRINT_FAILED(cnt) PRINT("\n └" ESCRED ESBLD "[NG:", cnt, "]\n" ESCLR)
 #define PRINT_SUCCESS     puts("=> " ESCGRN "[OK]" ESCLR)
// zig style testing syntax
 #define test(name) \
   static void test__test##name(int *); \
   [[gnu::constructor]] static void test__run##name() { \
     test__count++; \
     printf(TEST_HEADER ESBLD "%.28s" ESCLR, #name); \
     int failed = 0; \
     test__test##name(&failed); \
     if (failed) { \
       PRINT_FAILED(failed); \
       return; \
     } \
     ALIGN_COL(name); \
     PRINT_SUCCESS; \
     test__success++; \
   } \
   static void test__test##name(int *test__failed)
 #ifdef TEST_FILTER
  #define test_filter(filter) if (strstr(filter, TEST_FILTER))
 #else
  #define test_filter(_) if (0)
 #endif
// generate function parameter
 #define PMAP(tok, _, ...) \
   t->tok __VA_OPT__(, RECURSE(PM, AP)(tok##p, __VA_ARGS__))
// generate struct member
// e.g.) T1 p /* expected */; T2 pp /* arg1 */; T3 ppp /* arg2 */; ...
 #define SMAP(tok, T1, ...) \
   T1 tok; \
   __VA_OPT__(RECURSE(SM, AP)(tok##p, __VA_ARGS__))
 #define CALL(fn, ...) fn(EVAL(PMAP(pp, __VA_ARGS__)))
 #define STDEF(...) \
   struct { \
     EVAL(SMAP(p, __VA_ARGS__)) \
   }
 #define test_table(name, fn, signature, ...) \
   test_table_with_cleanup(name, fn, EMP, signature, __VA_ARGS__)
 #define test_table_with_cleanup(name, fn, cl, signature, ...) \
   [[gnu::constructor]] static void test__tabletest##name() { \
     test__count++; \
     printf(TEST_HEADER ESBLD #name ESCLR); \
     int failed = 0; \
     typedef STDEF signature S; \
     S data[] = __VA_ARGS__; \
     for (size_t i = 0; i < _Countof data; i++) { \
       S *t = data + i; \
       int *test__failed /* for expecteq */ = &failed; \
       int pre = failed; \
       auto result = CALL(fn, CDR signature); \
       expecteq(t->p, result); \
       cl(result); \
       if (pre != failed) PRINT(" at test case ", i); \
     } \
     if (failed) { \
       PRINT_FAILED(failed); \
       return; \
     } \
     ALIGN_COL(name); \
     PRINT_SUCCESS; \
     test__success++; \
   }
// disable main function somewhere
 #define main test__dummymain
 #define expect(cond) \
   do { \
     if (cond) break; \
     puts("\n ├┬ Unexpected result at " HERE); \
     printf(" │└─ `" #cond "` " ESCRED ESBLD " [NG]" ESCLR); \
     (*test__failed)++; \
   } while (0)
 #define expecteq(expected, actual) \
   do { \
     typeof(actual) const lhs = expected; \
     auto const rhs = actual; \
     if (eq(lhs, rhs)) break; \
     puts("\n ├┬ Expected equal at " HERE); \
     printf(" │├─ " ESCGRN "Expected" ESCLR ": "); \
     printanyf(lhs); \
     printf("\n │└─ " ESCRED "Actual" ESCLR ":   "); \
     printanyf(rhs); \
     printf(ESCRED ESBLD " [NG]" ESCLR); \
     (*test__failed)++; \
   } while (0)
 #define expectneq(unexpected, actual) \
   do { \
     typeof(actual) const lhs = unexpected; \
     auto const rhs = actual; \
     if (!eq(lhs, rhs)) break; \
     int test__llen = (int)strlen(#unexpected); \
     int test__rlen = (int)strlen(#actual); \
     int test__lpad = more(0, test__rlen - test__llen); \
     int test__rpad = more(0, test__llen - test__rlen); \
     puts("\n ├┬ Unexpected equality at " HERE); \
     printf(" │├─ Left side:  `" #unexpected "` ─"); \
     for (int test__i = 0; test__i < test__lpad; test__i++) printf("─"); \
     puts("┐"); \
     printf(" │└─ Right side: `" #actual "` ─"); \
     for (int test__i = 0; test__i < test__rpad; test__i++) printf("─"); \
     printf("┴─➤ "); \
     printanyf(lhs); \
     printf(ESCRED ESBLD " [NG]" ESCLR); \
     (*test__failed)++; \
   } while (0)
#else
// --gc-sections
 #define test(name) \
   [[gnu::unused]] static void test__dum##name(int *test__failed)
 #define test_table(...)
 #define test_filter(filter)
 #define expect(cond) \
   do { \
     _ = cond; \
     _ = test__failed; \
   } while (0)
 #define expecteq(lhs, rhs) \
   do { \
     _ = lhs; \
     _ = rhs; \
     _ = test__failed; \
   } while (0)
 #define expectneq(lhs, rhs) \
   do { \
     _ = lhs; \
     _ = rhs; \
     _ = test__failed; \
   } while (0)
#endif

/**
 * @file include/term.h
 */
#pragma once
#include <sys/ioctl.h>
#include <termios.h>
constexpr struct winsize err_winsize = {};
constexpr int stdin_fileno = 0;
constexpr int stdout_fileno = 1;
constexpr int stderr_fileno = 2;
struct winsize getWinSize();
struct termios enableRawMode();
void disableRawMode(struct termios *);

/**
 * @file include/str.h
 */
#pragma once
#include "gene.h"
#include <stddef.h>
#define dropslice ondrop(freeMutSlice)
typedef struct {
  char *s;
  size_t len;
  size_t cap;
  bool owned;
} mut_slice_t;
/**
 * @brief Refer to somewhere
 */
typedef struct {
  char const *s;
  size_t len;
} slice_t;
MAP(DEF_PRIM, mut_slice_t, slice_t)
overloadable slice_t slice(mut_slice_t, size_t, size_t);
overloadable slice_t slice(slice_t, size_t, size_t);
slice_t referEntire(mut_slice_t);
slice_t fromString(char const *);
mut_slice_t mutFromString(char const *);
void freeMutSlice(mut_slice_t const *);
mut_slice_t concat(slice_t, slice_t);

/**
 * @file include/rtconf.h
 * @brief Define data types for runtime information
 */
#pragma once
#include "chore.h"
#include "main.h"
typedef struct {
  double xx; // max x
  double xn; // min x
  double yx; // max y
  double yn; // min y
  int dispx; // display x size
  int dispy; // display y size
  double dx; // increase in x per square
  double dy; // increase in y per square
  char prevexpr[buf_size];
  void (*plotexpr)(char const *);
} plotcfg_t /* plot config */;
typedef struct {
  real_t hist[buf_size];
  size_t histi;
  real_t reg[alpha_n];
} rrtinfo_t /* runtime info */;
typedef struct {
  elem_t hist[buf_size];
  size_t histi;
  elem_t reg[alpha_n];
} rtinfo_t /* runtime info */;
plotcfg_t getPlotCfg();
void setPlotCfg(plotcfg_t);
rtinfo_t getRuntimeInfo();
rrtinfo_t getRRuntimeInfo();
void setRuntimeInfo(rtinfo_t);
void setRRuntimeInfo(rrtinfo_t);

/**
 * @file include/rc.h
 */
#pragma once
void setCfgPath(char const *, int, char *);
void loadInitScript(char const *);

/**
 * @file include/rand.h
 */
#pragma once
#include <stdint.h>
uint64_t xorsh();
double xorsh0to1();
void sxorsh(uint64_t);

/**
 * @file include/phyconst.h
 */
#pragma once
double getConst(char);

/**
 * @file include/optexpr.h
 */
#pragma once
void optexpr(char *);

/**
 * @file include/mem.h
 */
#pragma once
#include "bit.h"
#include <stddef.h>
[[gnu::nonnull]] size_t skipByte(char const *, byte_t);
[[gnu::nonnull]] size_t skipUntil(char const *, byte_t);
[[gnu::nonnull]] char *memrchr(char const *, int, size_t);

/**
 * @file include/matop.h
 */
#pragma once
#include "gene.h"
#include "mathdef.h"
#include <stdlib.h>
#define dropmatr [[gnu::cleanup(freeMatr)]]
constexpr size_t mat_init_size = 32;
typedef comp *matrix;
typedef struct {
  size_t rows;
  size_t cols;
  matrix matrix;
} matrix_t;
[[nodiscard("allocation")]] matrix_t newMatrix(size_t, size_t);
[[gnu::nonnull]] void freeMatr(matrix_t *restrict);
[[gnu::nonnull]] bool mEq(matrix_t const *, matrix_t const *);
[[nodiscard("allocation"), gnu::nonnull]] matrix_t
mAdd(matrix_t const *, matrix_t const *);
[[nodiscard("allocation"), gnu::nonnull]] matrix_t
mSub(matrix_t const *, matrix_t const *);
[[nodiscard("allocation"), gnu::nonnull]] matrix_t
mMul(matrix_t const *, matrix_t const *);
[[nodiscard("allocation"), gnu::nonnull]] matrix_t
inverseMatrix(matrix_t const *);
[[gnu::nonnull]] void smul(matrix_t *, comp);
overloadable bool eq(matrix_t const *, matrix_t const *);

/**
 * @file include/mathdef.h
 * @brief Wrapper for tgmath.h
 */
#pragma once
#include <tgmath.h>
#pragma comment(lib, "m")
typedef double complex comp;
constexpr double pi = 3.14159265358979323846;
constexpr double euler = 2.7182818284590452354;
[[gnu::const]] double gcd(double, double);
[[gnu::const]] double lcm(double, double);
[[gnu::const]] double permutation(double, double);
[[gnu::const]] double combination(double, double);

/**
 * @file include/main.h
 * @brief Define macros and data types for evaluating expr of comp number
 */
#pragma once
#include "matop.h"
#include <stdio.h>
constexpr size_t buf_size = 64;
//! @brief Set of types to handle
typedef enum {
  RTYPE_REAL = 0x01,
  RTYPE_COMP = 0x02,
  RTYPE_MATR = 0x04,
  RTYPE_LAMB = 0x08,
} rtype_t /* result type */;
//! @brief Wrapper of types to handle
typedef union {
  double real;
  comp comp;
  matrix_t matr;
  char *lamb;
} result_t;
//! @brief Tagged union of types to handle
typedef struct {
  result_t elem;
  rtype_t rtype;
} elem_t;
typedef struct {
  union {
    double real;
    char *lamb;
  } elem;
  bool isnum;
} real_t;
void procAList(int, char const **);
void readerLoop(FILE *);
void printElem(elem_t);
void printReal(double);
void printComplexComplex(comp);
void printComplexPolar(comp);
void printMatrix(matrix_t);
void printLambda(char const *);
void procCmds(char const *);
overloadable void printany(elem_t);
extern void (*print_complex)(comp);

/**
 * @file include/ice.h
 */
#pragma once
#ifndef NDEBUG
 #include "gene.h"
 #include <stdio.h>
typedef struct {
  bool enable;
  bool context;
  char *prefix;
  FILE *fp;
} ic_t;
extern ic_t ic_conf;
// inspired by python
 #define ic(...) \
   ({ \
    __VA_OPT__(auto x = __VA_ARGS__;) \
    do { \
      if (!ic_conf.enable) break; \
      FILE *out_fp = ic_conf.fp ?: stderr; \
      fputs(ic_conf.prefix ?: "ic| ", out_fp); \
      if (ic_conf.context) \
        fprintf(out_fp, HERE " in %s()" __VA_OPT__("- "), __FUNCTION__); \
      __VA_OPT__(fputs(#__VA_ARGS__ ": ", out_fp); printany(x);) \
      putchar('\n'); \
    } while (0); \
    __VA_OPT__(x;) \
   })
#else
 #define ic(...) __VA_ARGS__
#endif

/**
 * @file include/graphplot.h
 */
#pragma once
#include <stddef.h>
typedef struct {
  char **buf;
  size_t row;
  size_t col;
} plotbuf_t;
void initPlotCfg();
void plotexpr(char const *);
void plotexprImplicit(char const *);
void changePlotCfg(char const *restrict);

/**
 * @file include/gene.h
 * @brief Define macros for generic programming
 */
#pragma once
#include "def.h"
#include <stddef.h>
#define overloadable [[clang::overloadable]]
#define DEF_PRIM(T) \
  overloadable void printany(T); \
  overloadable void printanyf(T); \
  overloadable bool eq(T, T);
#define DEF_GEN(T) DEF_PRIM(T) DEF_PRIM(T *)
#define TYPES bool, char, int, size_t, long, long long, double
#define PRIM_TYPES void *
#define APPLY_ADDSUB(M) M(Add, +) M(Sub, -)
#define APPLY_ARTHM(M)  APPLY_ADDSUB(M) M(Mul, *) M(Div, /)
#define APPLY_LTGT(M)   M(Lt, <) M(Gt, >)
MAP(DEF_GEN, TYPES)
MAP(DEF_PRIM, PRIM_TYPES)
#define _PRINTREC(first, ...) \
  printany(first); \
  __VA_OPT__(RECURSE(_PRINT, REC)(__VA_ARGS__))
#define PRINT(...) \
  do { EVAL(_PRINTREC(__VA_ARGS__)) } while (0)

/**
 * @file include/exproriented.h
 * @brief Define macros for expression oriented programming
 */
#pragma once
#include "errcode.h"
constexpr size_t exproriented_unit = 0;
#define $break       $(break)
#define $continue    $(continue)
#define $return(...) $(return __VA_ARGS__)
#define $panic(...)  $(panic(__VA_ARGS__))
// use in pointer calculation
#define p$break       p$(break)
#define p$continue    p$(continue)
#define p$return(...) p$(return __VA_ARGS__)
#define p$panic(...)  p$(panic(__VA_ARGS__))
#define $if(cond) (cond) ?
#define $else :
#define $(statements) \
  ({ \
    statements; \
    exproriented_unit; \
  })
#define p$(statements) \
  ({ \
    statements; \
    (void *)exproriented_unit; \
  })

/**
 * @file include/evalfn.h
 * @brief Define data types for evaluationg expressions in real number mode
 */
#pragma once
#include "rtconf.h"
constexpr char arg_n = 8;
#define OP_CASE_ELEM(tok, op) \
  case *#op: \
    while (rbp + 1 < rsp) elem##tok(rbp + 1, rsp--); \
    break;
#define OVERWRITE(cas, var, fn) \
  case cas: \
    var = fn(var); \
    break;
// overwrite the top of the stack with the function in the parameter
#define OVERWRITE_REAL(cas, fn) OVERWRITE(cas, m->s.rsp->elem.real, fn)
#define OVERWRITE_COMP(cas, fn) OVERWRITE(cas, rsp->elem.comp, fn)
typedef struct {
  real_t payload[buf_size];
  real_t *rbp, *rsp;
} stack_t;
typedef struct {
  rrtinfo_t info;
  real_t *args;
  bool iscontinue;
} env_t;
typedef struct {
  char const *expr;
  char const *rip;
} ctrl_t;
typedef struct {
  // stack pointer index
  unsigned spi;
  // to restore argv
  // register the list of args
  real_t *callstack[buf_size];
  // to restore rsp
  // register the number of args used
  char argc[buf_size];
  ctrl_t exprs[buf_size];
} dump_t;
/**
 * @brief Based on SECD machine
 */
typedef struct {
  stack_t s;
  env_t e;
  ctrl_t c;
  dump_t d;
} machine_t;
[[gnu::nonnull]] elem_t evalExprReal(char const *);
[[gnu::nonnull]] elem_t evalExprComplex(char const *);
[[gnu::nonnull]] void rpxEval(machine_t *);
[[gnu::nonnull]] void initEvalinfo(machine_t *);

/**
 * @file include/error.h
 */
#pragma once
#include "ansiesc.h"
#include "gene.h"
#include <stdio.h>
[[gnu::format(printf, 3, 4)]] overloadable void
dispErr(FILE *, char const *, char const *, ...);
[[gnu::format(printf, 2, 3)]] overloadable void
dispErr(char const *, char const *, ...);
#define DISPERR(...) \
  PRINT( \
    "\n[", \
    (char *)__FUNCTION__, \
    "]\n  " ESCRED "Error: ", \
    __VA_ARGS__, \
    "\n" ESCLR \
  );

/**
 * @file include/errcode.h
 * @brief Define error codes
 */
#pragma once
#include <stdlib.h>
typedef enum {
  ERR_SUCCESS,
  ERR_UNKNOWN_CHAR,
  ERR_UNKNOWN_FN,
  ERR_DIMENTION_MISMATCH,
  ERR_IRREGULAR_MATRIX,
  ERR_NON_SQUARE_MATRIX,
  ERR_TYPE_MISMATCH,
  ERR_FILE_NOT_FOUND,
  ERR_BUFFER_DEPLETION,
  ERR_CURSOR_OUT_OF_RANGE,
  ERR_CHAR_NOT_FOUND,
  ERR_ALLOCATION_FAILURE,
  ERR_UNKNOWN_COMMAND,
  ERR_REACHED_UNREACHABLE,
  ERR_UNKNOWN_OPTION,
} errcode_t;
#define panic(e, ...) \
  do { \
    printf("Panicked at " HERE " " __VA_ARGS__); \
    puts(codetomsg(e)); \
    abort(); \
  } while (0)
char const *codetomsg(errcode_t);

/**
 * @file include/elemop.h
 */
#include "main.h"
overloadable bool eq(elem_t, elem_t);
overloadable void printany(elem_t);
overloadable void printanyf(elem_t);
void elemSet(elem_t *, elem_t const *);
void elemAdd(elem_t *, elem_t const *);
void elemSub(elem_t *, elem_t const *);
rtype_t elemMul(elem_t *, elem_t *);
void elemDiv(elem_t *, elem_t const *);
void elemPow(elem_t *, elem_t *);

/**
 * @file include/editline.h
 */
#pragma once
#include "str.h"
typedef struct {
  slice_t const *base;
  size_t pos;
} cursor_t;
typedef struct {
  mut_slice_t *base;
  size_t pos;
} mut_cursor_t;
typedef struct {
  size_t begin;
  size_t end;
} range_t;
#define FROM_SLICE(ms) {.base = &ms, .pos = 0}
constexpr char es = '\033';
constexpr char backspace = 127;
constexpr char ctrld = 4;
bool editline(size_t, char *);

/**
 * @file include/def.h
 */
#pragma once
#define _TOSTR(x) #x
#define TOSTR(x)  _TOSTR(x)
#define EMP(...)
#define EXPAND(...) __VA_ARGS__
// max depth: 4 ^ 5 = 1024
#define EVAL(...)  EVAL1(EVAL1(EVAL1(EVAL1(__VA_ARGS__))))
#define EVAL1(...) EVAL2(EVAL2(EVAL2(EVAL2(__VA_ARGS__))))
#define EVAL2(...) EVAL3(EVAL3(EVAL3(EVAL3(__VA_ARGS__))))
#define EVAL3(...) EVAL4(EVAL4(EVAL4(EVAL4(__VA_ARGS__))))
#define EVAL4(...) EXPAND(EXPAND(EXPAND(EXPAND(__VA_ARGS__))))
#define PRIM_CAT(a, b) a##b
#define CAT(a, b)      PRIM_CAT(a, b)
#define PRIM_CAR(_1, ...) _1
#define PRIM_CDR(_1, ...) __VA_ARGS__
#define CAR(...) PRIM_CAR(__VA_ARGS__)
#define CDR(...) PRIM_CDR(__VA_ARGS__)
#define RECURSE(a, b) CAT EMP()(a, b)
#define PRIM_MAP(M, _1, ...) \
  M(_1) __VA_OPT__(RECURSE(PRIM, _MAP)(M, __VA_ARGS__))
#define MAP(...) EVAL(PRIM_MAP(__VA_ARGS__))
#define PRIM_MAP_PAIR(M, _1, ...) \
  M _1 __VA_OPT__(RECURSE(PRIM, _MAP_PAIR)(M, __VA_ARGS__))
#define MAP_PAIR(...) EVAL(PRIM_MAP_PAIR(__VA_ARGS__))

/**
 * @file include/chore.h
 * @brief Define util macros
 */
#pragma once
#include "def.h"
#include <dirent.h>
#include <stdio.h>
#include <string.h>
constexpr size_t alpha_n = 'z' - 'a' + 1;
#define HERE           __FILE__ ":" TOSTR(__LINE__)
#define less(lhs, rhs) ((lhs) < (rhs) ? (lhs) : (rhs))
#define more(lhs, rhs) ((lhs) > (rhs) ? (lhs) : (rhs))
#define overloadable   [[clang::overloadable]]
#define ondrop(cl)     [[gnu::cleanup(cl)]]
#define drop           ondrop(freecl)
#define dropfile       ondrop(fclosecl)
#define dropdir        ondrop(closedircl)
#define __             CAT(_DISCARD_, __COUNTER__) [[gnu::unused]]
#define _              auto __
#define xalloc(T, size) ((T *)palloc(size * sizeof(T)))
#define nfree(p) \
  do { \
    if (p == nullptr) break; \
    free(p); \
    p = nullptr; \
  } while (0)
#define bit_cast(T, ...) \
  ({ \
    auto src = __VA_ARGS__; \
    static_assert(sizeof(T) == sizeof src); \
    T dst; \
    memcpy(&dst, &src, sizeof(T)); \
    dst; \
  })
[[gnu::returns_nonnull, nodiscard("allocation")]] void *palloc(size_t);
[[gnu::nonnull]] void freecl(void *);
[[gnu::nonnull]] void fclosecl(FILE **);
[[gnu::nonnull]] void closedircl(DIR **);

/**
 * @file include/bit.h
 */
#pragma once
#include <stdbit.h>
// Types as just a bit sequence
#define void_t(b) unsigned _BitInt(b)
typedef void_t(8) byte_t;
constexpr size_t p_size = sizeof(size_t);
[[gnu::const]] bool fza(size_t);
[[gnu::const]] bool isNulExist(size_t);
[[gnu::const]] size_t repeatBytes(byte_t);
[[gnu::const]] void *alignBackward(void const *, size_t);
[[gnu::const]] void *alignForward(void const *, size_t);