Adds basic scaffolding for data server and client

1 files changed, 130 insertions, 215 deletions

diff --git a/ui/curses/ui.c b/ui/curses/ui.c
index dda6c5e..de4e190 100644
--- a/ui/curses/ui.c
+++ b/ui/curses/ui.c
@@ -2,6 +2,7 @@
 #include <locale.h>
 
 #include "logger.c"
+#include "tui.c"
 
 #define LOG_LINE_COUNT 1024
 #define PANE_WIDTH 27
@@ -28,20 +29,18 @@ enum {
 };
 
 enum {
-    PAIR_NOUSE,
-    PAIR_NORMAL,
-    PAIR_HEADER,
-    PAIR_LIVE_PROC,
-    PAIR_SELECTED_PROC,
-    PAIR_FREE_CELL,
-    PAIR_ALLOC_CELL,
-    PAIR_MEM_BLOCK_START,
-    PAIR_SELECTED_MB1,
-    PAIR_SELECTED_MB2,
-    PAIR_SELECTED_IP,
-    PAIR_SELECTED_SP,
-    PAIR_INFO,
-    PAIR_WARN,
+    PAIR_HEADER = 1,
+    PAIR_LIVE_PROC = 2,
+    PAIR_SELECTED_PROC = 3,
+    PAIR_FREE_CELL = 4,
+    PAIR_ALLOC_CELL = 5,
+    PAIR_MEM_BLOCK_START = 6,
+    PAIR_SELECTED_MB1 = 7,
+    PAIR_SELECTED_MB2 = 8,
+    PAIR_SELECTED_IP = 9,
+    PAIR_SELECTED_SP = 10,
+    PAIR_INFO = 11,
+    PAIR_WARN = 12,
 };
 
 // GFX globals
@@ -80,7 +79,6 @@ uint64_t g_vsiz;
 uint64_t g_vlin_rng;
 uint64_t g_vsiz_rng;
 uint64_t g_ivpt_scroll;
-char *g_line_buff;
 uint64_t g_step_block;
 float g_steps_per_sec;
 
@@ -314,113 +312,30 @@ void gfx_render(const struct Core *core, uint64_t pos, uint64_t zoom, uint64_t p
 }
 
 // ----------------------------------------------------------------------------
-// UI generic functions
-// ----------------------------------------------------------------------------
-void ui_line_buff_free(void) {
-    if (g_line_buff) {
-        free(g_line_buff);
-    }
-
-    g_line_buff = NULL;
-}
-
-void ui_line_buff_resize(void) {
-    ui_line_buff_free();
-
-    g_line_buff = calloc(COLS + 1, sizeof(char));
-}
-
-void ui_line(bool clear, int line, int color, int attr, const char *format, ...) {
-    assert(line >= 0);
-    assert(format);
-
-    if (line >= LINES) {
-        return;
-    }
-
-    if (clear) {
-        move(line, 0);
-        clrtoeol();
-    }
-
-    va_list args;
-
-    attron(COLOR_PAIR(color) | attr);
-    va_start(args, format);
-
-    vsnprintf(g_line_buff, COLS, format, args);
-    mvprintw(line, 1, "%s", g_line_buff);
-
-    va_end(args);
-    attroff(COLOR_PAIR(color) | attr);
-}
-
-void ui_clear_line(int l) {
-    ui_line(true, l, PAIR_NORMAL, A_NORMAL, "");
-}
-
-void ui_field(int line, int col, int color, int attr, const char *format, ...) {
-    assert(line >= 0);
-    assert(col >= 0);
-    assert(format);
-
-    if (line >= LINES || col >= COLS) {
-        return;
-    }
-
-    va_list args;
-
-    attron(COLOR_PAIR(color) | attr);
-    va_start(args, format);
-
-    vsnprintf(g_line_buff, COLS - col, format, args);
-    mvprintw(line, col, "%s", g_line_buff);
-
-    va_end(args);
-    attroff(COLOR_PAIR(color) | attr);
-}
-
-void ui_str_field(int l, const char *label, const char *value) {
-    assert(label);
-    assert(value);
-    ui_line(false, l, PAIR_NORMAL, A_NORMAL, "%s : %18s", label, value);
-}
-
-void ui_ulx_field(int l, const char *label, uint64_t value) {
-    assert(label);
-    ui_line(false, l, PAIR_NORMAL, A_NORMAL, "%-4s : %#18lx", label, value);
-}
-
-void ui_float_field(int l, const char *label, float value) {
-    assert(label);
-    ui_line(false, l, PAIR_NORMAL, A_NORMAL, "%-4s : %18.1f", label, value);
-}
-
-// ----------------------------------------------------------------------------
 // Core page functions
 // ----------------------------------------------------------------------------
-void ui_print_core(int l) {
-    ui_line(false, ++l, PAIR_HEADER, A_BOLD, "CORE [%d]", g_core);
-    ui_ulx_field(++l, "cycl", g_cores[g_core].cycl);
-    ui_ulx_field(++l, "mall", g_cores[g_core].mall);
-    ui_ulx_field(++l, "mut0", g_cores[g_core].muta[0]);
-    ui_ulx_field(++l, "mut1", g_cores[g_core].muta[1]);
-    ui_ulx_field(++l, "mut2", g_cores[g_core].muta[2]);
-    ui_ulx_field(++l, "mut3", g_cores[g_core].muta[3]);
-    ui_ulx_field(++l, "pnum", g_cores[g_core].pnum);
-    ui_ulx_field(++l, "pcap", g_cores[g_core].pcap);
-    ui_ulx_field(++l, "pfst", g_cores[g_core].pfst);
-    ui_ulx_field(++l, "plst", g_cores[g_core].plst);
-    ui_ulx_field(++l, "pcur", g_cores[g_core].pcur);
-    ui_ulx_field(++l, "psli", g_cores[g_core].psli);
-    ui_ulx_field(++l, "ivpt", g_cores[g_core].ivpt);
+void tui_print_core(int l) {
+    tui_line(false, ++l, PAIR_HEADER, A_BOLD, "CORE [%d]", g_core);
+    tui_ulx_field(++l, "cycl", g_cores[g_core].cycl);
+    tui_ulx_field(++l, "mall", g_cores[g_core].mall);
+    tui_ulx_field(++l, "mut0", g_cores[g_core].muta[0]);
+    tui_ulx_field(++l, "mut1", g_cores[g_core].muta[1]);
+    tui_ulx_field(++l, "mut2", g_cores[g_core].muta[2]);
+    tui_ulx_field(++l, "mut3", g_cores[g_core].muta[3]);
+    tui_ulx_field(++l, "pnum", g_cores[g_core].pnum);
+    tui_ulx_field(++l, "pcap", g_cores[g_core].pcap);
+    tui_ulx_field(++l, "pfst", g_cores[g_core].pfst);
+    tui_ulx_field(++l, "plst", g_cores[g_core].plst);
+    tui_ulx_field(++l, "pcur", g_cores[g_core].pcur);
+    tui_ulx_field(++l, "psli", g_cores[g_core].psli);
+    tui_ulx_field(++l, "ivpt", g_cores[g_core].ivpt);
 
     ++l;
 
 #if CORE_FIELD_COUNT != 0
-    ui_line(false, ++l, PAIR_HEADER, A_BOLD, "ARCH SPECIFIC");
+    tui_line(false, ++l, PAIR_HEADER, A_BOLD, "ARCH SPECIFIC");
 
-#define CORE_FIELD(type, name, suffix) ui_ulx_field(++l, #name, (uint64_t)g_cores[g_core].name);
+#define CORE_FIELD(type, name, suffix) tui_ulx_field(++l, #name, (uint64_t)g_cores[g_core].name);
     CORE_FIELDS
 #undef CORE_FIELD
 #endif
@@ -429,7 +344,7 @@ void ui_print_core(int l) {
 // ----------------------------------------------------------------------------
 // Process page functions
 // ----------------------------------------------------------------------------
-int ui_proc_pair(uint64_t pix) {
+int tui_proc_pair(uint64_t pix) {
     if (pix == g_proc_selected) {
         return PAIR_SELECTED_PROC;
     } else if (mvec_proc_is_live(&g_cores[g_core], pix)) {
@@ -439,15 +354,15 @@ int ui_proc_pair(uint64_t pix) {
     }
 }
 
-const char *ui_proc_state(uint64_t pix) {
+const char *tui_proc_state(uint64_t pix) {
     return mvec_proc_is_live(&g_cores[g_core], pix) ? "live" : "dead";
 }
 
-void ui_print_process_genome_header(int l) {
-    ui_line(false, l++, PAIR_NORMAL, A_NORMAL, "%s : %18s : %s", "stat", "pix", "genome");
+void tui_print_process_genome_header(int l) {
+    tui_line(false, l++, PAIR_NORMAL, A_NORMAL, "%s : %18s : %s", "stat", "pix", "genome");
 }
 
-void ui_print_process_gene(int l, int gcol, uint64_t gidx, uint64_t mba, uint64_t pix, int pair) {
+void tui_print_process_gene(int l, int gcol, uint64_t gidx, uint64_t mba, uint64_t pix, int pair) {
     assert(gcol >= PANE_WIDTH + 2);
     assert(gcol < COLS);
     assert(mvec_proc_is_live(&g_cores[g_core], pix));
@@ -475,8 +390,8 @@ void ui_print_process_gene(int l, int gcol, uint64_t gidx, uint64_t mba, uint64_
     mvadd_wch(l, gcol, &cchar);
 }
 
-void ui_print_process_genes(int l, uint64_t pix) {
-    ui_line(true, l, ui_proc_pair(pix), A_NORMAL, "%s : %#18lx :", ui_proc_state(pix), pix);
+void tui_print_process_genes(int l, uint64_t pix) {
+    tui_line(true, l, tui_proc_pair(pix), A_NORMAL, "%s : %#18lx :", tui_proc_state(pix), pix);
 
     if (!mvec_proc_is_live(&g_cores[g_core], pix)) {
         return;
@@ -493,20 +408,20 @@ void ui_print_process_genes(int l, uint64_t pix) {
 
     for (uint64_t gidx = 0; gidx < mb0s && gcol < COLS; ++gidx, ++gcol) {
         if (gcol >= scol) {
-            ui_print_process_gene(l, gcol, gidx, mb0a, pix, PAIR_SELECTED_MB1);
+            tui_print_process_gene(l, gcol, gidx, mb0a, pix, PAIR_SELECTED_MB1);
         }
     }
 
     for (uint64_t gidx = 0; gidx < mb1s && gcol < COLS; ++gidx, ++gcol) {
         if (gcol >= scol) {
-            ui_print_process_gene(l, gcol, gidx, mb1a, pix, PAIR_SELECTED_MB2);
+            tui_print_process_gene(l, gcol, gidx, mb1a, pix, PAIR_SELECTED_MB2);
         }
     }
 
     clrtoeol();
 }
 
-void ui_print_process_field_header_element(int l, int fidx, const char *name) {
+void tui_print_process_field_header_element(int l, int fidx, const char *name) {
     assert(fidx >= 0);
     assert(name);
 
@@ -517,20 +432,20 @@ void ui_print_process_field_header_element(int l, int fidx, const char *name) {
     int foff = fidx - g_proc_field_scroll;
     int fcol = foff * PROC_FIELD_WIDTH + PANE_WIDTH - 1;
 
-    ui_field(l, fcol, PAIR_NORMAL, A_NORMAL, " : %18s", name);
+    tui_field(l, fcol, PAIR_NORMAL, A_NORMAL, " : %18s", name);
 }
 
-void ui_print_process_field_header(int l) {
-    ui_line(true, l, PAIR_NORMAL, A_NORMAL, "%s : %18s", "stat", "pix");
+void tui_print_process_field_header(int l) {
+    tui_line(true, l, PAIR_NORMAL, A_NORMAL, "%s : %18s", "stat", "pix");
 
     int fidx = 0;
 
-#define PROC_FIELD(type, name) ui_print_process_field_header_element(l, fidx++, #name);
+#define PROC_FIELD(type, name) tui_print_process_field_header_element(l, fidx++, #name);
     PROC_FIELDS
 #undef PROC_FIELD
 }
 
-void ui_print_process_field_element(int l, int fidx, int fclr, uint64_t field) {
+void tui_print_process_field_element(int l, int fidx, int fclr, uint64_t field) {
     assert(fidx >= 0);
 
     if (fidx < (int)g_proc_field_scroll) {
@@ -540,26 +455,26 @@ void ui_print_process_field_element(int l, int fidx, int fclr, uint64_t field) {
     int foff = fidx - g_proc_field_scroll;
     int fcol = foff * PROC_FIELD_WIDTH + PANE_WIDTH - 1;
 
-    ui_field(l, fcol, fclr, A_NORMAL, " : %#18lx", field);
+    tui_field(l, fcol, fclr, A_NORMAL, " : %#18lx", field);
 }
 
-void ui_print_process_fields(int l, uint64_t pix) {
-    ui_line(true, l, ui_proc_pair(pix), A_NORMAL, "%s : %#18lx", ui_proc_state(pix), pix);
+void tui_print_process_fields(int l, uint64_t pix) {
+    tui_line(true, l, tui_proc_pair(pix), A_NORMAL, "%s : %#18lx", tui_proc_state(pix), pix);
 
     const struct Proc *proc = proc_get(&g_cores[g_core], pix);
 
     int fidx = 0;
-    int fclr = ui_proc_pair(pix);
+    int fclr = tui_proc_pair(pix);
 
-#define PROC_FIELD(type, name) ui_print_process_field_element(l, fidx++, fclr, proc->name);
+#define PROC_FIELD(type, name) tui_print_process_field_element(l, fidx++, fclr, proc->name);
     PROC_FIELDS
 #undef PROC_FIELD
 }
 
-void ui_print_process(int l) {
+void tui_print_process(int l) {
     l++;
 
-    ui_line(true, l++, PAIR_HEADER, A_BOLD,
+    tui_line(true, l++, PAIR_HEADER, A_BOLD,
         "PROCESS [vs:%#lx | ps:%#lx | pf:%#lx | pl:%#lx | fs:%#lx | gs:%#lx]",
         g_proc_scroll,
         g_proc_selected,
@@ -572,16 +487,16 @@ void ui_print_process(int l) {
     uint64_t pix = g_proc_scroll;
 
     if (g_proc_genes) {
-        ui_print_process_genome_header(l++);
+        tui_print_process_genome_header(l++);
 
         while (l < LINES) {
-            ui_print_process_genes(l++, pix++);
+            tui_print_process_genes(l++, pix++);
         }
     } else {
-        ui_print_process_field_header(l++);
+        tui_print_process_field_header(l++);
 
         while (l < LINES) {
-            ui_print_process_fields(l++, pix++);
+            tui_print_process_fields(l++, pix++);
         }
     }
 }
@@ -589,7 +504,7 @@ void ui_print_process(int l) {
 // ----------------------------------------------------------------------------
 // World page functions
 // ----------------------------------------------------------------------------
-void ui_world_resize(void) {
+void tui_world_resize(void) {
     assert(g_wrld_zoom);
 
     g_vlin = 0;
@@ -608,9 +523,9 @@ void ui_world_resize(void) {
 }
 
 #if defined(MVEC_LOOP)
-void ui_print_cell(uint64_t i, uint64_t r, uint64_t x, uint64_t y) {
+void tui_print_cell(uint64_t i, uint64_t r, uint64_t x, uint64_t y) {
 #else
-void ui_print_cell(uint64_t i, uint64_t r, uint64_t x, uint64_t y, uint64_t a) {
+void tui_print_cell(uint64_t i, uint64_t r, uint64_t x, uint64_t y, uint64_t a) {
 #endif
     wchar_t inst_nstr[2] = { L'\0', L'\0' };
     cchar_t cchar = { 0 };
@@ -652,8 +567,8 @@ void ui_print_cell(uint64_t i, uint64_t r, uint64_t x, uint64_t y, uint64_t a) {
     mvadd_wch(y, x, &cchar);
 }
 
-void ui_print_wcursor_bar(void) {
-    ui_clear_line(LINES - 1);
+void tui_print_wcursor_bar(void) {
+    tui_clear_line(LINES - 1);
 
     const struct Core *core = &g_cores[g_core];
 
@@ -687,24 +602,24 @@ void ui_print_wcursor_bar(void) {
     );
 }
 
-void ui_print_world(int l) {
+void tui_print_world(int l) {
     l++;
 
-    ui_line(false, l++, PAIR_HEADER, A_BOLD, "WORLD");
-    ui_ulx_field(l++, "wrlp", g_wrld_pos);
-    ui_ulx_field(l++, "wrlz", g_wrld_zoom);
-    ui_ulx_field(l++, "psel", g_proc_selected);
-    ui_ulx_field(l++, "pabs", g_proc_selected % g_cores[g_core].pcap);
-    ui_ulx_field(l++, "vrng", g_vsiz_rng);
-    ui_str_field(l++, "curs", g_wcursor_mode ? "on" : "off");
+    tui_line(false, l++, PAIR_HEADER, A_BOLD, "WORLD");
+    tui_ulx_field(l++, "wrlp", g_wrld_pos);
+    tui_ulx_field(l++, "wrlz", g_wrld_zoom);
+    tui_ulx_field(l++, "psel", g_proc_selected);
+    tui_ulx_field(l++, "pabs", g_proc_selected % g_cores[g_core].pcap);
+    tui_ulx_field(l++, "vrng", g_vsiz_rng);
+    tui_str_field(l++, "curs", g_wcursor_mode ? "on" : "off");
 
     l++;
 
-    ui_line(false, l++, PAIR_HEADER, A_BOLD, "SELECTED");
+    tui_line(false, l++, PAIR_HEADER, A_BOLD, "SELECTED");
 
     const struct Proc *psel = proc_get(&g_cores[g_core], g_proc_selected);
 
-#define PROC_FIELD(type, name) ui_ulx_field(l++, #name, psel->name);
+#define PROC_FIELD(type, name) tui_ulx_field(l++, #name, psel->name);
     PROC_FIELDS
 #undef PROC_FIELD
 
@@ -728,37 +643,37 @@ void ui_print_world(int l) {
         uint64_t y = i / g_vlin;
 
 #if defined(MVEC_LOOP)
-        ui_print_cell(i, r, x, y);
+        tui_print_cell(i, r, x, y);
 #else
         uint64_t a = g_wrld_pos + (i * g_wrld_zoom);
-        ui_print_cell(i, r, x, y, a);
+        tui_print_cell(i, r, x, y, a);
 #endif
     }
 
     if (g_wcursor_mode) {
-        ui_print_wcursor_bar();
+        tui_print_wcursor_bar();
     }
 }
 
 // ----------------------------------------------------------------------------
 // IPC page functions
 // ----------------------------------------------------------------------------
-void ui_print_ipc_field(int l, uint64_t i, int color) {
+void tui_print_ipc_field(int l, uint64_t i, int color) {
     uint8_t iinst = g_cores[g_core].iviv[i];
     uint64_t iaddr = g_cores[g_core].ivav[i];
 
-    ui_field(l, PANE_WIDTH, color, A_NORMAL, "%#18x : %#18x : %#18x", i, iinst, iaddr);
+    tui_field(l, PANE_WIDTH, color, A_NORMAL, "%#18x : %#18x : %#18x", i, iinst, iaddr);
 }
 
-void ui_print_ipc_data(void) {
-    ui_field(0, PANE_WIDTH, PAIR_NORMAL, A_NORMAL, "%18s : %18s : %18s", "ipci", "inst", "addr");
+void tui_print_ipc_data(void) {
+    tui_field(0, PANE_WIDTH, PAIR_NORMAL, A_NORMAL, "%18s : %18s : %18s", "ipci", "inst", "addr");
 
     int l = 1 - g_ivpt_scroll;
 
     for (uint64_t i = 0; i < SYNC_INTERVAL; ++i) {
         if (i == g_cores[g_core].ivpt) {
             if (l >= 1) {
-                ui_print_ipc_field(l++, i, PAIR_SELECTED_PROC);
+                tui_print_ipc_field(l++, i, PAIR_SELECTED_PROC);
             }
 
             continue;
@@ -768,7 +683,7 @@ void ui_print_ipc_data(void) {
 
         if ((iinst & IPC_FLAG) != 0) {
             if (l >= 1) {
-                ui_print_ipc_field(l++, i, PAIR_LIVE_PROC);
+                tui_print_ipc_field(l++, i, PAIR_LIVE_PROC);
             }
 
             continue;
@@ -783,23 +698,23 @@ void ui_print_ipc_data(void) {
     }
 }
 
-void ui_print_ipc(int l) {
+void tui_print_ipc(int l) {
     l++;
 
     const struct Core *core = &g_cores[g_core];
 
-    ui_line(true, l++, PAIR_HEADER, A_BOLD, "IPC [%#lx]", g_ivpt_scroll);
-    ui_ulx_field(l++, "ivpt", core->ivpt);
-    ui_ulx_field(l++, "ivpi", core->iviv[core->ivpt]);
-    ui_ulx_field(l++, "ivpa", core->ivav[core->ivpt]);
+    tui_line(true, l++, PAIR_HEADER, A_BOLD, "IPC [%#lx]", g_ivpt_scroll);
+    tui_ulx_field(l++, "ivpt", core->ivpt);
+    tui_ulx_field(l++, "ivpi", core->iviv[core->ivpt]);
+    tui_ulx_field(l++, "ivpa", core->ivav[core->ivpt]);
 
-    ui_print_ipc_data();
+    tui_print_ipc_data();
 }
 
 // ----------------------------------------------------------------------------
 // Log page functions
 // ----------------------------------------------------------------------------
-void ui_info_impl(const char *format, ...) {
+void tui_info_impl(const char *format, ...) {
     assert(format);
 
     va_list args;
@@ -812,7 +727,7 @@ void ui_info_impl(const char *format, ...) {
     g_log_ptr = (g_log_ptr + 1) % LOG_LINE_COUNT;
 }
 
-void ui_warn_impl(const char *format, ...) {
+void tui_warn_impl(const char *format, ...) {
     assert(format);
 
     va_list args;
@@ -825,30 +740,30 @@ void ui_warn_impl(const char *format, ...) {
     g_log_ptr = (g_log_ptr + 1) % LOG_LINE_COUNT;
 }
 
-void ui_clear_log_line(int line) {
+void tui_clear_log_line(int line) {
     assert(line >= 0 && line < LINES);
     move(line, PANE_WIDTH);
     clrtoeol();
 }
 
-void ui_print_log_line(unsigned lptr, int line) {
+void tui_print_log_line(unsigned lptr, int line) {
     assert(lptr < LOG_LINE_COUNT);
     assert(line >= 0 && line < LINES);
-    ui_clear_log_line(line);
+    tui_clear_log_line(line);
 
     if (strlen(g_logs[lptr])) {
-        ui_field(line, PANE_WIDTH + 2, g_log_levels[lptr] == LOG_INFO ? PAIR_INFO : PAIR_WARN, A_NORMAL, "%.38s", g_logs[lptr]);
-        ui_field(line, PANE_WIDTH + 40, PAIR_NORMAL, A_NORMAL, g_logs[lptr] + 38);
+        tui_field(line, PANE_WIDTH + 2, g_log_levels[lptr] == LOG_INFO ? PAIR_INFO : PAIR_WARN, A_NORMAL, "%.38s", g_logs[lptr]);
+        tui_field(line, PANE_WIDTH + 40, PAIR_NORMAL, A_NORMAL, g_logs[lptr] + 38);
     }
 }
 
-void ui_print_log(int l) {
+void tui_print_log(int l) {
     l++;
 
-    ui_line(true, l++, PAIR_HEADER, A_BOLD, "LOG");
-    ui_ulx_field(l++, "lscr", g_log_scroll);
-    ui_ulx_field(l++, "lcnt", g_log_cnt);
-    ui_ulx_field(l++, "lptr", g_log_ptr);
+    tui_line(true, l++, PAIR_HEADER, A_BOLD, "LOG");
+    tui_ulx_field(l++, "lscr", g_log_scroll);
+    tui_ulx_field(l++, "lcnt", g_log_cnt);
+    tui_ulx_field(l++, "lptr", g_log_ptr);
 
     unsigned lptr = g_log_ptr;
     int line = LINES + g_log_scroll;
@@ -858,7 +773,7 @@ void ui_print_log(int l) {
         line--;
 
         if (line < LINES) {
-            ui_print_log_line(lptr, line);
+            tui_print_log_line(lptr, line);
         }
 
         if (lptr == g_log_ptr) {
@@ -868,48 +783,48 @@ void ui_print_log(int l) {
 
     while (line) {
         line--;
-        ui_clear_log_line(line);
+        tui_clear_log_line(line);
     }
 }
 
 // ----------------------------------------------------------------------------
 // Main print function
 // ----------------------------------------------------------------------------
-void ui_print(void) {
+void tui_print(void) {
     int l = 1;
 
-    ui_line(false, l++, PAIR_HEADER, A_BOLD, "SALIS [%d:%d]", g_core, CORES);
-    ui_str_field(l++, "name", NAME);
-    ui_ulx_field(l++, "seed", SEED);
+    tui_line(false, l++, PAIR_HEADER, A_BOLD, "SALIS [%d:%d]", g_core, CORES);
+    tui_str_field(l++, "name", NAME);
+    tui_ulx_field(l++, "seed", SEED);
 #if defined(MUTA_FLIP)
-    ui_str_field(l++, "fbit", "yes");
+    tui_str_field(l++, "fbit", "yes");
 #else
-    ui_str_field(l++, "fbit", "no");
+    tui_str_field(l++, "fbit", "no");
 #endif
-    ui_ulx_field(l++, "asav", AUTOSAVE_INTERVAL);
-    ui_str_field(l++, "arch", ARCH);
-    ui_ulx_field(l++, "size", MVEC_SIZE);
-    ui_ulx_field(l++, "syni", SYNC_INTERVAL);
-    ui_ulx_field(l++, "step", g_steps);
-    ui_ulx_field(l++, "sync", g_syncs);
-    ui_ulx_field(l++, "step", g_step_block);
-    ui_float_field(l++, "stps", g_steps_per_sec);
+    tui_ulx_field(l++, "asav", AUTOSAVE_INTERVAL);
+    tui_str_field(l++, "arch", ARCH);
+    tui_ulx_field(l++, "size", MVEC_SIZE);
+    tui_ulx_field(l++, "syni", SYNC_INTERVAL);
+    tui_ulx_field(l++, "step", g_steps);
+    tui_ulx_field(l++, "sync", g_syncs);
+    tui_ulx_field(l++, "step", g_step_block);
+    tui_float_field(l++, "stps", g_steps_per_sec);
 
     switch (g_page) {
     case PAGE_CORE:
-        ui_print_core(l);
+        tui_print_core(l);
         break;
     case PAGE_PROCESS:
-        ui_print_process(l);
+        tui_print_process(l);
         break;
     case PAGE_WORLD:
-        ui_print_world(l);
+        tui_print_world(l);
         break;
     case PAGE_IPC:
-        ui_print_ipc(l);
+        tui_print_ipc(l);
         break;
     case PAGE_LOG:
-        ui_print_log(l);
+        tui_print_log(l);
         break;
     default:
         break;
@@ -1083,11 +998,11 @@ void ev_zoom(int ev) {
         switch (ev) {
         case 'x':
             g_wrld_zoom *= (g_vlin != 0 && g_vsiz_rng < MVEC_SIZE) ? 2 : 1;
-            ui_world_resize();
+            tui_world_resize();
             break;
         case 'z':
             g_wrld_zoom /= (g_wrld_zoom != 1) ? 2 : 1;
-            ui_world_resize();
+            tui_world_resize();
             break;
         default:
             break;
@@ -1198,13 +1113,13 @@ void ev_handle(void) {
         break;
     case KEY_RESIZE:
         clear();
-        ui_line_buff_resize();
-        ui_world_resize();
+        tui_line_buff_resize();
+        tui_world_resize();
 
         if (g_vlin) {
             while (g_vsiz_rng >= MVEC_SIZE * 2 && g_wrld_zoom != 1) {
                 g_wrld_zoom /= 2;
-                ui_world_resize();
+                tui_world_resize();
             }
         }
 
@@ -1309,8 +1224,8 @@ void init(void) {
     init_pair(PAIR_INFO, COLOR_GREEN, COLOR_BLACK);
     init_pair(PAIR_WARN, COLOR_RED, COLOR_BLACK);
 
-    g_info = ui_info_impl;
-    g_warn = ui_warn_impl;
+    g_info = tui_info_impl;
+    g_warn = tui_warn_impl;
 
 #if defined(COMMAND_NEW)
     salis_init();
@@ -1321,8 +1236,8 @@ void init(void) {
     g_wrld_zoom = 1;
     g_step_block = 1;
 
-    ui_line_buff_resize();
-    ui_world_resize();
+    tui_line_buff_resize();
+    tui_world_resize();
 }
 
 void exec(void) {
@@ -1344,14 +1259,14 @@ void exec(void) {
             g_steps_per_sec = (float)g_step_block / secs;
         }
 
-        ui_print();
+        tui_print();
         ev_handle();
     }
 }
 
 void quit(void) {
     gfx_free();
-    ui_line_buff_free();
+    tui_line_buff_free();
     salis_save(SIM_PATH);
     salis_free();
     endwin();