catch stack errors

7 files changed, 104 insertions, 42 deletions

diff --git a/source/core.cpp b/source/core.cpp
index c5d7f28..cc7c267 100644
--- a/source/core.cpp
+++ b/source/core.cpp
@@ -29,13 +29,13 @@ void jump(FuncList ip)
 
 // LITERAL's run-time semantics: push the given value onto the stack.
 static auto literall = WordWrap<[] {
-    *++SP = (Cell)*++IP;
+    push((Cell)*++IP);
 }>();
 
 void compileliteral()
 {
     comma((Cell)literall);
-    comma(*SP--);
+    comma(pop());
 }
 
 bool haskey()
@@ -114,11 +114,11 @@ void word()
     auto here = (char *)HERE;
     ++HERE;
 
-    readword(*SP);
+    readword(*sp());
 
     here[0] = strlen(here + 1);
     HERE = (Cell)here;
-    *SP = HERE;
+    *sp() = HERE;
 }
 
 void colon()
@@ -132,7 +132,7 @@ void colon()
     // Build the Word structure.
     comma(HERE + 4 * sizeof(Cell)); // exec ptr
     comma(name);                    // name ptr
-    *++SP = (Cell)comma(0);         // link (to be set by semic())
+    push((Cell)comma(0));           // link (to be set by semic())
     comma(0);                       // immediate
 
     // The word's execution begins with a prologue that technically performs
@@ -141,13 +141,13 @@ void colon()
     // about if it is running words or routines (i.e. pre-defined words).
     comma((Cell)+[](FuncList *ip) {
         ++ip;
-        *++RP = (Cell)IP;
+        rpush((Cell)IP);
         jump((FuncList)*ip);
     });
     // The actual function list will begin one Cell beyond here.
     comma(HERE + sizeof(Cell));
 
-    DICT[DIdxCompXt] = *SP - 2 * sizeof(Cell);
+    DICT[DIdxCompXt] = *sp() - 2 * sizeof(Cell);
 
     // Enter compiling state.
     STATE = -1;
@@ -159,7 +159,7 @@ void semic()
     comma((Cell)fexit);
 
     // Complete the new word's linkage to make it usable.
-    auto link = (Cell *)*SP--;
+    auto link = (Cell *)pop();
     *link = LATEST;
     LATEST = (Cell)(link - 2);
 
@@ -177,7 +177,7 @@ void tick()
     // Look up the name and push the result.
     int len = HERE - (Cell)name - 1;
     auto word = find(name, len);
-    *++SP = (Cell)word;
+    push((Cell)word);
 
     // Deallocate `name`.
     HERE = (Cell)name;
diff --git a/source/core.hpp b/source/core.hpp
index f5149cf..4e4c1e6 100644
--- a/source/core.hpp
+++ b/source/core.hpp
@@ -31,8 +31,8 @@ extern void getinput();
  */
 constexpr auto fexit = WordWrap<[] {
     extern FuncList IP;
-    extern Cell *RP;
-    IP = reinterpret_cast<FuncList>(*RP--);
+    extern Cell rpop();
+    IP = reinterpret_cast<FuncList>(rpop());
 }>();
 
 void jump(FuncList ip); /** Jumps to the given instruction pointer. */
diff --git a/source/parse.cpp b/source/parse.cpp
index cebf702..6f68c84 100644
--- a/source/parse.cpp
+++ b/source/parse.cpp
@@ -22,31 +22,38 @@
 #include <cctype>
 #include <cstdlib>
 
-static void parseword(const char *start, const char *end)
+[[nodiscard]]
+static Error parseword(const char *start, const char *end)
 {
+    auto result = Error::none;
+
     if (start != end) {
         if (auto word = find(start, end - start); word) {
             if (!word->immediate() && STATE) {
                 comma((Cell)word->list);
             } else {
-                execute1(word);
+                result = execute1(word);
             }
         } else if (isdigit(*start)) {
-            *++SP = std::atoi(start);
+            push(std::atoi(start));
 
             if (STATE)
                 compileliteral();
         }
     }
+
+    return result;
 }
 
-void parseSource()
+[[nodiscard]]
+static Error parseSource()
 {
+    auto result = Error::none;
     char *start = nullptr;
     char *end;
     char *s;
 
-    while (haskey()) {
+    while (result == Error::none && haskey()) {
         s = (char *)DICT[DIdxSource];
 
         ++DICT[DIdxSource];
@@ -54,7 +61,7 @@ void parseSource()
 
         if (isspace(*s)) {
             if (start) {
-                parseword(start, end + 1);
+                result = parseword(start, end + 1);
                 start = nullptr;
             }
         } else {
@@ -69,16 +76,19 @@ void parseSource()
 
     // Parse the final word if it is non-empty.
     if (start)
-        parseword(start, s + 1);
+        result = parseword(start, s + 1);
+
+    return result;
 }
 
-void parse()
+[[nodiscard]]
+Error parse()
 {
     // Reset source buffer and try to fill it with getinput().
     DICT[DIdxSource] = (Cell)&DICT[DIdxBegin];
     DICT[DIdxSrcLen] = 0;
     getinput();
 
-    parseSource();
+    return parseSource();
 }
 
diff --git a/source/parse.hpp b/source/parse.hpp
index a6816f3..757cdae 100644
--- a/source/parse.hpp
+++ b/source/parse.hpp
@@ -19,5 +19,6 @@
  * Resets the source buffer, calls getinput() to fill the source buffer, then
  * parses the source buffer's contents.
  */
-void parse();
+[[nodiscard]]
+Error parse();
 
diff --git a/source/state.cpp b/source/state.cpp
index a2f424c..5daa772 100644
--- a/source/state.cpp
+++ b/source/state.cpp
@@ -18,27 +18,63 @@
 #include "core.hpp"
 #include "state.hpp"
 
-//#include <csetjmp>
+#include <csetjmp>
 #include <cstring>
 
-//static std::jmp_buf jmpbuf;
-Cell *SP = DICT.data() + DICT.size() - DS;
-Cell *RP = DICT.data() + DICT.size() - DS - RS;
 FuncList IP = nullptr;
-
 std::array<Cell, DictSize> DICT;
 
 Cell& HERE   = DICT[DIdxHere];
 Cell& LATEST = DICT[DIdxLatest];
 Cell& STATE  = DICT[DIdxState];
 
-void executor(FuncList *list)
+static std::jmp_buf jmpbuf;
+static Cell *SP = DICT.data() + DICT.size() - DS;
+static Cell *RP = DICT.data() + DICT.size() - DS - RS;
+
+void push(Cell value) {
+    if (SP >= DICT.data() + DICT.size())
+        std::longjmp(jmpbuf, static_cast<int>(Error::push));
+
+    *++SP = value;
+}
+
+Cell pop() {
+    if (SP - 1 < DICT.data() + DICT.size() - DS)
+        std::longjmp(jmpbuf, static_cast<int>(Error::pop));
+
+    return *SP--;
+}
+
+Cell *sp() {
+    return SP;
+}
+
+void rpush(Cell value) {
+    if (RP >= DICT.data() + DICT.size() - DS)
+        std::longjmp(jmpbuf, static_cast<int>(Error::rpush));
+
+    *++RP = value;
+}
+
+Cell rpop() {
+    if (RP - 1 < DICT.data() + DICT.size() - DS - RS)
+        std::longjmp(jmpbuf, static_cast<int>(Error::rpop));
+
+    return *RP--;
+}
+
+Cell *rp() {
+    return RP;
+}
+
+Error executor(FuncList *list)
 {
-    // TODO Use setjmp to recover from errors?
-    /*if (setjmp(jmpbuf) == 0)*/ {
+    auto result = static_cast<Error>(setjmp(jmpbuf));
+    FuncList body;
 
-        FuncList body;
-        void (*entry)(FuncList);
+    if (static_cast<int>(result) == 0) {
+        result = Error::none;
 
         // We are given the pointer to a list of function pointers.
         // Dereference once to retrieve the function pointer list.
@@ -65,19 +101,19 @@ entry:
             // their "calls".
             // If the word is pre-defined then the argument will simply be
             // ignored.
-            entry = (void (*)(FuncList))*body;
-            entry(body);
+            auto func = (void (*)(FuncList))*body;
+            func(body);
         }
-
-        //std::longjmp(jmpbuf, 1);
     }
+
+    return result;
 }
 
-void execute1(Word *word)
+Error execute1(Word *word)
 {
     // IP must initially be zero if executing a word at the top level.
     IP = 0;
-    executor(&word->list);
+    return executor(&word->list);
 }
 
 Word *find(const char *s, int len)
diff --git a/source/state.hpp b/source/state.hpp
index 17d8e69..8bdc5dc 100644
--- a/source/state.hpp
+++ b/source/state.hpp
@@ -42,10 +42,15 @@ extern std::array<Cell, DictSize> DICT;
 extern Cell& HERE;   /** Linked to HERE's storage in DICT. */
 extern Cell& LATEST; /** Linked to LATEST's storage in DICT. */
 extern Cell& STATE;  /** Linked to STATE's storage in DICT. */
+extern FuncList IP;  /** Instruction pointer */
 
-extern Cell *SP;    /** Data stack pointer */
-extern Cell *RP;    /** Return stack pointer */
-extern FuncList IP; /** Instruction pointer */
+void push(Cell);
+[[nodiscard]] Cell pop();
+[[nodiscard]] Cell *sp();
+
+void rpush(Cell);
+[[nodiscard]] Cell rpop();
+[[nodiscard]] Cell *rp();
 
 /**
  * Initializes the dictionary to default values.
@@ -63,13 +68,15 @@ inline void initialize(const auto& wordset)
  * Begins execution with the given function pointer list.
  * @param list Function pointer list to execute
  */
-void executor(FuncList *list);
+[[nodiscard]]
+Error executor(FuncList *list);
 
 /**
  * Executes the given word by calling executor on its definition.
  * @param word The word to execute
  */
-void execute1(Word *word);
+[[nodiscard]]
+Error execute1(Word *word);
 
 /**
  * Looks up the definition of the given word.
diff --git a/source/types.hpp b/source/types.hpp
index 461d835..fd0b81e 100644
--- a/source/types.hpp
+++ b/source/types.hpp
@@ -108,5 +108,13 @@ auto WordWrap = [] {
     return list;
 };
 
+enum class Error : int {
+    none = 1,
+    push,
+    pop,
+    rpush,
+    rpop
+};
+
 #endif // TYPES_HPP