aboutsummaryrefslogtreecommitdiff
path: root/tsalis/src
diff options
context:
space:
mode:
authorPaul Oliver <contact@pauloliver.dev>2024-02-29 01:50:44 +0100
committerPaul Oliver <contact@pauloliver.dev>2024-02-29 01:50:44 +0100
commit2dc9d118efb64de6ea54a5a9eb4474f8e5ef3145 (patch)
tree74039957b10390da4875d676303a781bd0792e45 /tsalis/src
Initial commit
Diffstat (limited to 'tsalis/src')
-rw-r--r--tsalis/src/handler.c317
-rw-r--r--tsalis/src/printer.c749
-rw-r--r--tsalis/src/tsalis.c118
3 files changed, 1184 insertions, 0 deletions
diff --git a/tsalis/src/handler.c b/tsalis/src/handler.c
new file mode 100644
index 0000000..21aa706
--- /dev/null
+++ b/tsalis/src/handler.c
@@ -0,0 +1,317 @@
+#include <stdlib.h>
+#include <string.h>
+#include <curses.h>
+#include <salis.h>
+#include "printer.h"
+#include "handler.h"
+#include "tsalis.h"
+
+#define CONSOLE_INPUT_LENGTH 64
+
+static sbyte
+symbolToInst(char charSymbol)
+{
+#define SINST(name, symbol) case symbol: return name;
+#define SILST(name, symbol) case symbol: return name;
+
+ switch (charSymbol) {
+ SINST_LIST
+ }
+
+#undef SINST
+#undef SILST
+ return (sbyte)(-1);
+}
+
+static void
+writeInstructions(const char *command)
+{
+ sword addr = atoi(command);
+ char *symbol = strchr(command, '_');
+
+ if (symbol) {
+ symbol++;
+
+ while (sm_isValidAt(addr) && *symbol) {
+ sbyte svalue = symbolToInst(*symbol);
+
+ if (si_isInst(svalue)) {
+ sm_setInstAt(addr, svalue);
+ } else {
+ sm_setInstAt(addr, 0);
+ }
+
+ addr++;
+ symbol++;
+ }
+ }
+}
+
+static void
+compileGenome(const char *command)
+{
+ sword addr = atoi(command);
+ char *fileName = strchr(command, '_');
+
+ if (fileName) {
+ FILE *file = fopen(fileName + 1, "r");
+
+ if (file) {
+ while (addr < sm_getSize()) {
+ int symbol = fgetc(file);
+ sbyte svalue = symbolToInst((char)symbol);
+
+ if (symbol == EOF) {
+ break;
+ }
+
+ if (si_isInst(svalue)) {
+ sm_setInstAt(addr, svalue);
+ } else {
+ sm_setInstAt(addr, 0);
+ }
+
+ addr++;
+ }
+ }
+ }
+}
+
+static void
+createOrganism(const char *command)
+{
+ sword addr = atoi(command);
+ char *sizep = strchr(command, '_');
+
+ if (sizep) {
+ sword size = atoi(sizep + 1);
+
+ if (sm_isValidAt(addr) && sm_isValidAt(addr + size - 1)) {
+ sword offset;
+
+ for (offset = 0; offset < size; offset++) {
+ if (sm_isAllocatedAt(addr + offset)) {
+ return;
+ }
+ }
+
+ sp_create(addr, size);
+ }
+ }
+}
+
+static void
+killOrganism(void)
+{
+ sp_kill();
+}
+
+static void
+moveTo(const char *command)
+{
+ sword loc = atoi(command);
+ tsp_moveTo(loc);
+}
+
+static void
+selectProc(const char *command)
+{
+ sword proc = atoi(command);
+ tsp_selectProcess(proc);
+}
+
+static void
+saveSim(void)
+{
+ s_save(g_simName);
+}
+
+static void
+renameSim(const char *name)
+{
+ if (strlen(name) <= NAME_MAX_SIZE) {
+ strncpy(g_simName, name, NAME_MAX_SIZE);
+ }
+}
+
+static void
+setAutoSave(const char *command)
+{
+ g_autoSaveInterval = atoi(command);
+}
+
+static void
+clearConsoleLine(void)
+{
+ move(LINES - 1, 0);
+ clrtoeol();
+}
+
+static void
+runConsole(void)
+{
+ char command[CONSOLE_INPUT_LENGTH] = {0};
+ clearConsoleLine();
+ echo();
+ mvprintw(LINES - 1, 1, "$ ");
+ curs_set(TRUE);
+ getnstr(command, CONSOLE_INPUT_LENGTH - 1);
+ curs_set(FALSE);
+ noecho();
+ clearConsoleLine();
+
+ switch (command[0]) {
+ case 'q':
+ g_exit = STRUE;
+ break;
+
+ case 'i':
+ writeInstructions(&command[1]);
+ break;
+
+ case 'c':
+ compileGenome(&command[1]);
+ break;
+
+ case 'n':
+ createOrganism(&command[1]);
+ break;
+
+ case 'k':
+ killOrganism();
+ break;
+
+ case 'm':
+ moveTo(&command[1]);
+ break;
+
+ case 'p':
+ selectProc(&command[1]);
+ break;
+
+ case 's':
+ saveSim();
+ break;
+
+ case 'r':
+ renameSim(&command[1]);
+ break;
+
+ case 'a':
+ setAutoSave(&command[1]);
+ break;
+ }
+}
+
+void
+tsh_handleEvent(int event)
+{
+ switch (event) {
+ case KEY_RESIZE:
+ tsp_onResize();
+ break;
+
+ case KEY_LEFT:
+ tsp_prevPage();
+ break;
+
+ case KEY_RIGHT:
+ tsp_nextPage();
+ break;
+
+ case 'w':
+ tsp_scrollDown();
+ break;
+
+ case 'a':
+ tsp_scrollLeft();
+ break;
+
+ case 's':
+ tsp_scrollUp();
+ break;
+
+ case 'd':
+ tsp_scrollRight();
+ break;
+
+ case 'W':
+ tsp_scrollToTop();
+ break;
+
+ case 'A':
+ tsp_scrollToLeft();
+ break;
+
+ case 'z':
+ tsp_zoomIn();
+ break;
+
+ case 'x':
+ tsp_zoomOut();
+ break;
+
+ case 'o':
+ tsp_prevOrganism();
+ break;
+
+ case 'p':
+ tsp_nextOrganism();
+ break;
+
+ case 'g':
+ g_processShowGenes = !g_processShowGenes;
+ break;
+
+ case 'c':
+ g_running = SFALSE;
+ nodelay(stdscr, SFALSE);
+ tsp_printData();
+ runConsole();
+ break;
+
+ case ' ':
+ g_running = !g_running;
+ nodelay(stdscr, g_running);
+ break;
+
+ case 'j':
+ if (sp_getCount()) {
+ g_selectedProcess = sp_getFirst();
+ }
+
+ break;
+
+ case 'l':
+ if (sp_getCount()) {
+ g_selectedProcess = sp_getLast();
+ }
+
+ break;
+
+ case 'k':
+ tsp_gotoSelectedProc();
+ break;
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '0':
+ if (!g_running) {
+ int power = ((event - '0') ? (event - '0') : 10) - 1;
+ int cycles = 1 << power;
+
+ while (cycles--) {
+ s_cycle();
+ }
+ }
+
+ break;
+ }
+}
diff --git a/tsalis/src/printer.c b/tsalis/src/printer.c
new file mode 100644
index 0000000..a3f60b6
--- /dev/null
+++ b/tsalis/src/printer.c
@@ -0,0 +1,749 @@
+#include <stdarg.h>
+#include <curses.h>
+#include <salis.h>
+#include "printer.h"
+#include "tsalis.h"
+
+enum {
+ PAIR_NORMAL = 1,
+ PAIR_HEADER = 2,
+ PAIR_SELECTED_PROC = 3,
+ PAIR_FREE_CELL = 4,
+ PAIR_ALLOC_CELL = 5,
+ PAIR_MEM_BLOCK_START = 6,
+ PAIR_MEM_BLOCK_2 = 7,
+ PAIR_MEM_BLOCK_1 = 8,
+ PAIR_SELECTED_SP = 9,
+ PAIR_SELECTED_IP = 10
+};
+
+enum {
+ PAGE_MEMORY,
+ PAGE_EVOLVER,
+ PAGE_PROCESS,
+ PAGE_WORLD,
+ PAGE_COUNT
+};
+
+const char *g_instNames[] = {
+#define SINST(name, symbol) #name,
+#define SILST(name, symbol) #name
+ SINST_LIST
+#undef SINST
+#undef SILST
+};
+
+const char g_instSymbols[] = {
+#define SINST(name, symbol) symbol,
+#define SILST(name, symbol) symbol
+ SINST_LIST
+#undef SINST
+#undef SILST
+};
+
+const char *g_procElems[] = {
+ "mb1a",
+ "mb1s",
+ "mb2a",
+ "mb2s",
+ "ip",
+ "sp",
+ "reg[0]",
+ "reg[1]",
+ "reg[2]",
+ "reg[3]",
+ "stack[0]",
+ "stack[1]",
+ "stack[2]",
+ "stack[3]",
+ "stack[4]",
+ "stack[5]",
+ "stack[6]",
+ "stack[7]"
+};
+
+const int PROC_ELEMENT_COUNT = (sizeof(g_procElems) / sizeof(*g_procElems));
+const int DATA_WIDTH = 25;
+
+int g_currentPage;
+sword g_selectedProcess;
+sbool g_processShowGenes;
+sword g_processVertScroll;
+sword g_processDataScroll;
+sword g_processGeneScroll;
+sword g_worldPos;
+sword g_worldZoom;
+sword g_worldLineWidth;
+sword g_worldLineCoverage;
+sword g_worldArea;
+
+static void
+adjustWorld(void)
+{
+ g_worldLineWidth = COLS - DATA_WIDTH;
+ g_worldLineCoverage = g_worldLineWidth * g_worldZoom;
+ g_worldArea = LINES * g_worldLineCoverage;
+
+ while ((g_worldArea > (sm_getSize() * 2)) && (g_worldZoom > 1)) {
+ g_worldZoom /= 2;
+ }
+}
+
+void
+tsp_init(void)
+{
+ initscr();
+ cbreak();
+ noecho();
+ curs_set(0);
+ keypad(stdscr, TRUE);
+ start_color();
+ init_pair(PAIR_NORMAL, COLOR_WHITE, COLOR_BLACK);
+ init_pair(PAIR_HEADER, COLOR_CYAN, COLOR_BLACK);
+ init_pair(PAIR_SELECTED_PROC, COLOR_YELLOW, COLOR_BLACK);
+ init_pair(PAIR_FREE_CELL, COLOR_CYAN, COLOR_BLUE);
+ init_pair(PAIR_ALLOC_CELL, COLOR_BLUE, COLOR_CYAN);
+ init_pair(PAIR_MEM_BLOCK_START, COLOR_BLUE, COLOR_WHITE);
+ init_pair(PAIR_MEM_BLOCK_1, COLOR_BLACK, COLOR_YELLOW);
+ init_pair(PAIR_MEM_BLOCK_2, COLOR_BLACK, COLOR_GREEN);
+ init_pair(PAIR_SELECTED_SP, COLOR_BLACK, COLOR_MAGENTA);
+ init_pair(PAIR_SELECTED_IP, COLOR_BLACK, COLOR_RED);
+ g_worldZoom = 1;
+ adjustWorld();
+}
+
+void
+tsp_quit(void)
+{
+ endwin();
+}
+
+void
+tsp_onResize(void)
+{
+ clear();
+ adjustWorld();
+}
+
+void
+tsp_prevPage(void)
+{
+ clear();
+ g_currentPage += (PAGE_COUNT - 1);
+ g_currentPage %= PAGE_COUNT;
+}
+
+void
+tsp_nextPage(void)
+{
+ clear();
+ g_currentPage++;
+ g_currentPage %= PAGE_COUNT;
+}
+
+void
+tsp_scrollUp(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ if (g_processVertScroll) {
+ g_processVertScroll--;
+ }
+
+ break;
+
+ case PAGE_WORLD:
+ if (g_worldPos >= g_worldLineCoverage) {
+ g_worldPos -= g_worldLineCoverage;
+ }
+
+ break;
+ }
+
+ refresh();
+}
+
+void
+tsp_scrollDown(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ if (g_processVertScroll < (sp_getCap() - 1)) {
+ g_processVertScroll++;
+ }
+
+ break;
+
+ case PAGE_WORLD:
+ if ((g_worldPos + g_worldLineCoverage) < sm_getSize()) {
+ g_worldPos += g_worldLineCoverage;
+ }
+
+ break;
+ }
+
+ refresh();
+}
+
+void
+tsp_scrollLeft(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ if (g_processShowGenes) {
+ if (g_processGeneScroll) {
+ g_processGeneScroll--;
+ }
+ } else {
+ if (g_processDataScroll) {
+ g_processDataScroll--;
+ }
+ }
+
+ break;
+
+ case PAGE_WORLD:
+ if (g_worldPos >= g_worldZoom) {
+ g_worldPos -= g_worldZoom;
+ } else {
+ g_worldPos = 0;
+ }
+
+ break;
+ }
+
+ refresh();
+}
+
+void
+tsp_scrollRight(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ if (g_processShowGenes) {
+ g_processGeneScroll++;
+ } else {
+ if (g_processDataScroll < (sword)(PROC_ELEMENT_COUNT - 1)) {
+ g_processDataScroll++;
+ }
+ }
+
+ break;
+
+ case PAGE_WORLD:
+ if ((g_worldPos + g_worldZoom) < sm_getSize()) {
+ g_worldPos += g_worldZoom;
+ }
+
+ break;
+ }
+
+ refresh();
+}
+
+void
+tsp_scrollToTop(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ g_processVertScroll = 0;
+ break;
+
+ case PAGE_WORLD:
+ g_worldPos = 0;
+ break;
+ }
+}
+
+void
+tsp_scrollToLeft(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ if (g_processShowGenes) {
+ g_processGeneScroll = 0;
+ } else {
+ g_processDataScroll = 0;
+ }
+
+ break;
+ }
+}
+
+void
+tsp_zoomIn(void)
+{
+ if (g_currentPage == PAGE_WORLD) {
+ if (g_worldZoom > 1) {
+ g_worldZoom /= 2;
+ }
+
+ adjustWorld();
+ }
+}
+
+void
+tsp_zoomOut(void)
+{
+ if (g_currentPage == PAGE_WORLD) {
+ if (g_worldArea < sm_getSize()) {
+ g_worldZoom *= 2;
+ refresh();
+ }
+
+ adjustWorld();
+ }
+}
+
+void
+tsp_prevOrganism(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ case PAGE_WORLD:
+ if (g_selectedProcess < sp_getCap()) {
+ g_selectedProcess += (sp_getCap() - 1);
+ g_selectedProcess %= sp_getCap();
+ }
+
+ break;
+ }
+
+ refresh();
+}
+
+void
+tsp_nextOrganism(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ case PAGE_WORLD:
+ if (g_selectedProcess < sp_getCap()) {
+ g_selectedProcess++;
+ g_selectedProcess %= sp_getCap();
+ }
+
+ break;
+ }
+
+ refresh();
+}
+
+void
+tsp_gotoSelectedProc(void)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ g_processVertScroll = g_selectedProcess;
+ break;
+
+ case PAGE_WORLD:
+ g_worldPos = sp_getProc(g_selectedProcess).mb1a;
+ break;
+ }
+}
+
+void
+tsp_selectProcess(sword proc)
+{
+ if (proc < sp_getCap()) {
+ g_selectedProcess = proc;
+ }
+}
+
+void
+tsp_moveTo(sword loc)
+{
+ switch (g_currentPage) {
+ case PAGE_PROCESS:
+ if (loc < sp_getCap()) {
+ g_processVertScroll = loc;
+ }
+
+ break;
+
+ case PAGE_WORLD:
+ if (loc < sm_getSize()) {
+ g_worldPos = loc;
+ }
+
+ break;
+ }
+}
+
+static void
+printWidget(int line, const char *format, ...)
+{
+ if (line < LINES) {
+ va_list args;
+ char dataLine[24];
+ va_start(args, format);
+ vsprintf(dataLine, format, args);
+ mvprintw(line, 1, "%.*s", COLS - 1, dataLine);
+ va_end(args);
+ }
+}
+
+static void
+printHeader(int line, const char *string)
+{
+ attron(COLOR_PAIR(PAIR_HEADER));
+ printWidget(line, string);
+ standend();
+}
+
+#define PHEADER(label) printHeader((*line)++, label)
+#define PWIDGET(label, data) printWidget((*line)++, "%-10s : %10u", label, data)
+#define PSIDGET(label, data) printWidget((*line)++, "%-10s : %10s", label, data)
+#define INCREMENT_LINE (*line)++
+
+static void
+printMemoryPage(int *line)
+{
+ PHEADER("MEMORY");
+ PWIDGET("order", sm_getOrder());
+ PWIDGET("size", sm_getSize());
+ PWIDGET("blocks", sm_getMemBlockCount());
+ PWIDGET("alloc", sm_getAllocated());
+ PWIDGET("cap", sm_getCap());
+}
+
+static void
+printEvolverPage(int *line)
+{
+ PHEADER("EVOLVER");
+ PWIDGET("lastAddr", se_getLastAddress());
+ PSIDGET("lastInst", g_instNames[se_getLastInst()] + 1);
+ PWIDGET("state0", se_getState(0));
+ PWIDGET("state1", se_getState(1));
+ PWIDGET("state2", se_getState(2));
+ PWIDGET("state3", se_getState(3));
+}
+
+static void
+printField(int y, int x, const char *field, sbool lalign)
+{
+ if ((y < LINES) && (x < COLS)) {
+ if (lalign) {
+ mvprintw(y, x, "%-.*s", COLS - x, field);
+ } else {
+ mvprintw(y, x, "%.*s", COLS - x, field);
+ }
+ }
+}
+
+static void
+printSingleProcessGenome(int line, sword pidx)
+{
+ char sidx[11];
+ SProc proc = sp_getProc(pidx);
+ sword gidx = g_processGeneScroll;
+ int xpos = 14;
+
+ if (pidx == g_selectedProcess) {
+ attron(COLOR_PAIR(PAIR_SELECTED_PROC));
+ } else if (!sp_isFree(pidx)) {
+ attron(COLOR_PAIR(PAIR_HEADER));
+ }
+
+ sprintf(sidx, "%-10u |", pidx);
+ printField(line, 1, sidx, STRUE);
+ move(line, xpos);
+
+ while ((gidx < proc.mb1s) && (xpos < COLS)) {
+ sword gaddr = proc.mb1a + gidx;
+
+ if (gaddr == proc.ip) {
+ attron(COLOR_PAIR(PAIR_SELECTED_IP));
+ } else if (gaddr == proc.sp) {
+ attron(COLOR_PAIR(PAIR_SELECTED_SP));
+ } else {
+ attron(COLOR_PAIR(PAIR_MEM_BLOCK_1));
+ }
+
+ addch(g_instSymbols[sm_getInstAt(gaddr)]);
+ gidx++;
+ xpos++;
+ }
+
+ if (proc.mb1s < g_processGeneScroll) {
+ gidx = g_processGeneScroll - proc.mb1s;
+ } else {
+ gidx = 0;
+ }
+
+ while ((gidx < proc.mb2s) && (xpos < COLS)) {
+ sword gaddr = proc.mb2a + gidx;
+
+ if (gaddr == proc.ip) {
+ attron(COLOR_PAIR(PAIR_SELECTED_IP));
+ } else if (gaddr == proc.sp) {
+ attron(COLOR_PAIR(PAIR_SELECTED_SP));
+ } else {
+ attron(COLOR_PAIR(PAIR_MEM_BLOCK_2));
+ }
+
+ addch(g_instSymbols[sm_getInstAt(gaddr)]);
+ gidx++;
+ xpos++;
+ }
+
+ standend();
+}
+
+static void
+printProcessGenes(int *line)
+{
+ sword pidx = g_processVertScroll;
+ attron(COLOR_PAIR(PAIR_HEADER));
+ printField(*line, 1, "pidx", STRUE);
+
+ standend();
+ INCREMENT_LINE;
+
+ while ((*line < LINES) && (pidx < sp_getCap())) {
+ printSingleProcessGenome(*line, pidx);
+ INCREMENT_LINE;
+ pidx++;
+ }
+
+ standend();
+}
+
+static void
+printSingleProcessData(int line, sword pidx)
+{
+ char sidx[11];
+ int eidx = g_processDataScroll;
+ int xpos = 12;
+ SProc proc = sp_getProc(pidx);
+ sword *data = (sword *)&proc;
+
+ if (pidx == g_selectedProcess) {
+ attron(COLOR_PAIR(PAIR_SELECTED_PROC));
+ } else if (!sp_isFree(pidx)) {
+ attron(COLOR_PAIR(PAIR_HEADER));
+ }
+
+ sprintf(sidx, "%u", pidx);
+ printField(line, 1, sidx, STRUE);
+
+ while (eidx < PROC_ELEMENT_COUNT) {
+ char element[13];
+ sprintf(element, "| %10u", data[eidx]);
+ printField(line, xpos, element, SFALSE);
+ eidx++;
+ xpos += 13;
+ }
+
+ standend();
+}
+
+static void
+printProcessData(int *line)
+{
+ sword pidx = g_processVertScroll;
+ int eidx = g_processDataScroll;
+ int xpos = 12;
+ attron(COLOR_PAIR(PAIR_HEADER));
+ printField(*line, 1, "pidx", STRUE);
+
+ while (eidx < PROC_ELEMENT_COUNT) {
+ char element[13];
+ sprintf(element, "| %10s", g_procElems[eidx]);
+ printField(*line, xpos, element, SFALSE);
+ eidx++;
+ xpos += 13;
+ }
+
+ standend();
+ INCREMENT_LINE;
+
+ while ((*line < LINES) && (pidx < sp_getCap())) {
+ printSingleProcessData(*line, pidx);
+ INCREMENT_LINE;
+ pidx++;
+ }
+
+ standend();
+}
+
+static void
+printProcessPage(int *line)
+{
+ int cline;
+ sbool fnull = (sp_getFirst() == (sword) - 1);
+ sbool lnull = (sp_getLast() == (sword) - 1);
+ PHEADER("PROCESS");
+ PWIDGET("count", sp_getCount());
+ PWIDGET("cap", sp_getCap());
+ fnull ? PSIDGET("first", "---") : PWIDGET("first", sp_getFirst());
+ lnull ? PSIDGET("last", "---") : PWIDGET("last", sp_getLast());
+ PWIDGET("selected", g_selectedProcess);
+ INCREMENT_LINE;
+
+ for (cline = *line; cline < LINES; cline++) {
+ move(cline, 0);
+ clrtoeol();
+ }
+
+ if (g_processShowGenes) {
+ printProcessGenes(line);
+ } else {
+ printProcessData(line);
+ }
+}
+
+static int
+getColorOf(sword addr)
+{
+ if (!sp_isFree(g_selectedProcess)) {
+ SProc proc = sp_getProc(g_selectedProcess);
+
+ if (addr == proc.ip) {
+ return PAIR_SELECTED_IP;
+ } else if (addr == proc.sp) {
+ return PAIR_SELECTED_SP;
+ } else if ((addr >= proc.mb1a) && (addr < (proc.mb1a + proc.mb1s))) {
+ return PAIR_MEM_BLOCK_1;
+ } else if ((addr >= proc.mb2a) && (addr < (proc.mb2a + proc.mb2s))) {
+ return PAIR_MEM_BLOCK_2;
+ }
+ }
+
+ if (sm_isMemBlockStartAt(addr)) {
+ return PAIR_MEM_BLOCK_START;
+ } else if (sm_isAllocatedAt(addr)) {
+ return PAIR_ALLOC_CELL;
+ } else {
+ return PAIR_FREE_CELL;
+ }
+}
+
+static void
+printWorld(void)
+{
+ sword y;
+
+ for (y = 0; y < (sword)LINES; y++) {
+ sword x;
+
+ for (x = 0; x < g_worldLineWidth; x++) {
+ sword addr = g_worldPos + (((y * g_worldLineWidth) + x) * g_worldZoom);
+ sbool atEnd = !sm_isValidAt(addr);
+ int xpos = DATA_WIDTH + x;
+
+ if (atEnd) {
+ mvaddch(y, xpos, ' ');
+ continue;
+ }
+
+ if (g_worldZoom == 1) {
+ char symbol = g_instSymbols[sm_getInstAt(addr)];
+ attron(COLOR_PAIR(getColorOf(addr)));
+ mvaddch(y, xpos, symbol);
+ } else {
+ sword offset;
+ char symbol;
+ sword instSum = 0;
+ int color = PAIR_FREE_CELL;
+
+ for (offset = 0; offset < g_worldZoom; offset++) {
+ int testColor;
+ sword offsetAddr = addr + offset;
+
+ if (!sm_isValidAt(offsetAddr)) {
+ break;
+ }
+
+ instSum += sm_getInstAt(offsetAddr);
+ testColor = getColorOf(offsetAddr);
+
+ if (testColor > color) {
+ color = testColor;
+ }
+ }
+
+ instSum /= g_worldZoom;
+
+ if (!instSum) {
+ symbol = ' ';
+ } else if (instSum < 32) {
+ symbol = '-';
+ } else {
+ symbol = '=';
+ }
+
+ attron(COLOR_PAIR(color));
+ mvaddch(y, xpos, symbol);
+ }
+
+ standend();
+ }
+ }
+}
+
+static void
+printWorldPage(int *line)
+{
+ int eidx;
+ SProc proc = sp_getProc(g_selectedProcess);
+ sword *data = (sword *)&proc;
+ PHEADER("WORLD");
+ PWIDGET("pos", g_worldPos);
+ PWIDGET("zoom", g_worldZoom);
+ PWIDGET("selected", g_selectedProcess);
+ INCREMENT_LINE;
+ PHEADER("SELECTED");
+
+ if (!sp_isFree(g_selectedProcess)) {
+ attron(COLOR_PAIR(PAIR_SELECTED_PROC));
+ }
+
+ for (eidx = 0; eidx < PROC_ELEMENT_COUNT; eidx++) {
+ PWIDGET(g_procElems[eidx], data[eidx]);
+ }
+
+ standend();
+ printWorld();
+}
+
+void
+tsp_printData(void)
+{
+ int linev = 1;
+ int *line = &linev;
+ PHEADER("SALIS");
+ PSIDGET("name", g_simName);
+ PSIDGET("state", g_running ? "running" : "paused");
+
+ if (g_autoSaveInterval) {
+ PWIDGET("autosave", g_autoSaveInterval);
+ } else {
+ PSIDGET("autosave", "---");
+ }
+
+ PWIDGET("cycle", s_getCycle());
+ PWIDGET("epoch", s_getEpoch());
+ INCREMENT_LINE;
+
+ switch (g_currentPage) {
+ case PAGE_MEMORY:
+ printMemoryPage(line);
+ break;
+
+ case PAGE_EVOLVER:
+ printEvolverPage(line);
+ break;
+
+ case PAGE_PROCESS:
+ printProcessPage(line);
+ break;
+
+ case PAGE_WORLD:
+ printWorldPage(line);
+ break;
+ }
+
+ refresh();
+}
diff --git a/tsalis/src/tsalis.c b/tsalis/src/tsalis.c
new file mode 100644
index 0000000..ab24c61
--- /dev/null
+++ b/tsalis/src/tsalis.c
@@ -0,0 +1,118 @@
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <curses.h>
+#include <salis.h>
+#include "printer.h"
+#include "handler.h"
+#include "tsalis.h"
+
+#define DEFAULT_ORDER 16
+
+sbool g_exit;
+sbool g_running;
+sword g_autoSaveInterval;
+char g_simName[NAME_MAX_SIZE + 1] = "def.sim";
+
+static void
+onDefault(void)
+{
+ FILE *testFile = fopen(g_simName, "r");
+
+ if (testFile) {
+ fclose(testFile);
+ s_load(g_simName);
+ } else {
+ s_init(DEFAULT_ORDER);
+ }
+}
+
+static void
+onLoad(const char *fileName)
+{
+ FILE *testFile;
+
+ if (strlen(fileName) > NAME_MAX_SIZE) {
+ fputs("ERROR: File name too long", stderr);
+ exit(1);
+ }
+
+ strncpy(g_simName, fileName, NAME_MAX_SIZE);
+ testFile = fopen(g_simName, "r");
+
+ if (testFile) {
+ fclose(testFile);
+ s_load(g_simName);
+ } else {
+ fputs("ERROR: File does not exist", stderr);
+ exit(1);
+ }
+}
+
+static void
+init(int argc, char **argv)
+{
+ if (argc == 1) {
+ onDefault();
+ } else if (argc == 2) {
+ char cmd = argv[1][0];
+ char *val = &argv[1][1];
+
+ if (cmd == 'n') {
+ s_init(atoi(val));
+ } else if (cmd == 'l') {
+ onLoad(val);
+ } else {
+ fputs("ERROR: Incorrect arguments", stderr);
+ exit(1);
+ }
+ } else {
+ fputs("ERROR: Incorrect argument count", stderr);
+ exit(1);
+ }
+
+ tsp_init();
+}
+
+static void
+exec(void)
+{
+ while (!g_exit) {
+ if (g_running) {
+ clock_t beg = clock();
+ clock_t end;
+ float delay;
+
+ do {
+ s_cycle();
+
+ if (g_autoSaveInterval && !(s_getCycle() % g_autoSaveInterval)) {
+ s_save(g_simName);
+ }
+
+ end = clock();
+ delay = (float)(end - beg) / CLOCKS_PER_SEC;
+ } while (delay < (1.0 / 60.0));
+ }
+
+ tsp_printData();
+ tsh_handleEvent(getch());
+ }
+}
+
+static void
+quit(void)
+{
+ tsp_quit();
+ s_save(g_simName);
+ s_quit();
+}
+
+int
+main(int argc, char **argv)
+{
+ init(argc, argv);
+ exec();
+ quit();
+ return 0;
+}