1 files changed, 293 insertions, 0 deletions
diff --git a/corewords.cpp b/corewords.cpp
new file mode 100644
index 0000000..6595e41
--- /dev/null
+++ b/corewords.cpp
@@ -0,0 +1,293 @@
+/**
+ * Alee Forth: A portable and concise Forth implementation in modern C++.
+ * Copyright (C) 2023  Clyne Sullivan <clyne@bitgloo.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "corewords.hpp"
+
+Func CoreWords::get(int index)
+{
+    switch (index) {
+    case 0: return op_drop;
+    case 1: return op_dup;
+    case 2: return op_swap;
+    case 3: return op_pick;
+    case 4: return op_sys;
+    case 5: return op_add;
+    case 6: return op_sub;
+    case 7: return op_mul;
+    case 8: return op_div;
+    case 9: return op_mod;
+    case 10: return op_peek;
+    case 11: return op_poke;
+    case 12: return op_rot;
+    case 13: return op_pushr;
+    case 14: return op_popr;
+    case 15: return op_eq;
+    case 16: return op_lt;
+    case 17: return op_allot;
+    case 18: return op_and;
+    case 19: return op_or;
+    case 20: return op_xor;
+    case 21: return op_shl;
+    case 22: return op_shr;
+    case 23: return op_comment;
+    case 24: return op_colon;
+    case 25: return op_semic;
+    case 26: return op_here;
+    case 27: return op_exit;
+    case 28: return op_imm;
+    case 29: return op_const;
+    case 30: return op_literal;
+    case 31: return op_jump;
+    default: return nullptr;
+    }
+}
+
+int CoreWords::op_drop(State& state)
+{
+    state.pop();
+    return 0;
+}
+
+int CoreWords::op_dup(State& state)
+{
+    state.push(state.top());
+    return 0;
+}
+
+int CoreWords::op_swap(State& state)
+{
+    std::swap(state.top(), state.pick(1));
+    return 0;
+}
+
+int CoreWords::op_pick(State& state)
+{
+    state.push(state.pick(state.pop()));
+    return 0;
+}
+
+int CoreWords::op_sys(State& state)
+{
+    return user_sys(state);
+}
+
+int CoreWords::op_add(State& state)
+{
+    const auto a = state.pop();
+    state.top() += a;
+    return 0;
+}
+
+int CoreWords::op_sub(State& state)
+{
+    const auto a = state.pop();
+    state.top() -= a;
+    return 0;
+}
+
+int CoreWords::op_mul(State& state) {
+    const auto a = state.pop();
+    state.top() *= a;
+    return 0;
+}
+
+int CoreWords::op_div(State& state) {
+    const auto a = state.pop();
+    state.top() /= a;
+    return 0;
+}
+
+int CoreWords::op_mod(State& state) {
+    const auto a = state.pop();
+    state.top() %= a;
+    return 0;
+}
+
+int CoreWords::op_peek(State& state) {
+    state.push(state.dict.read(state.pop()));
+    return 0;
+}
+
+int CoreWords::op_poke(State& state) {
+    const auto addr = state.pop();
+    state.dict.write(addr, state.pop());
+    return 0;
+}
+
+int CoreWords::op_rot(State& state) {
+    std::swap(state.pick(2), state.pick(1));
+    std::swap(state.pick(1), state.pick(0));
+    return 0;
+}
+
+int CoreWords::op_pushr(State& state) {
+    state.pushr(state.pop());
+    return 0;
+}
+
+int CoreWords::op_popr(State& state) {
+    state.push(state.popr());
+    return 0;
+}
+
+int CoreWords::op_eq(State& state) {
+    const auto a = state.pop();
+    state.top() = state.top() == a;
+    return 0;
+}
+
+int CoreWords::op_lt(State& state) {
+    const auto a = state.pop();
+    state.top() = state.top() < a;
+    return 0;
+}
+
+int CoreWords::op_allot(State& state) {
+    state.dict.allot(state.pop());
+    return 0;
+}
+
+int CoreWords::op_and(State& state) {
+    const auto a = state.pop();
+    state.top() &= a;
+    return 0;
+}
+
+int CoreWords::op_or(State& state) {
+    const auto a = state.pop();
+    state.top() |= a;
+    return 0;
+}
+
+int CoreWords::op_xor(State& state) {
+    const auto a = state.pop();
+    state.top() ^= a;
+    return 0;
+}
+
+int CoreWords::op_shl(State& state) {
+    const auto a = state.pop();
+    state.top() <<= a;
+    return 0;
+}
+
+int CoreWords::op_shr(State& state) {
+    const auto a = state.pop();
+    state.top() >>= a;
+    return 0;
+}
+
+int CoreWords::op_comment(State& state) {
+	state.pass = Pass::Comment;
+    return 0;
+}
+
+int CoreWords::op_colon(State& state) {
+    state.pass = Pass::Colon;
+    state.pushr(state.dict.here); // this is for EXIT
+    return 0;
+}
+
+int CoreWords::op_semic(State& state) {
+    if (!state.compiling) {
+        state.ip = state.popr();
+    } else {
+	auto begin = state.popr();
+
+	state.dict.write(begin,
+	    (state.dict.read(begin) & 0x1F) |
+	    ((begin - state.dict.latest) << 6));
+
+	state.dict.latest = begin;
+        state.compiling = false;
+    }
+
+    return 0;
+}
+
+int CoreWords::op_here(State& state) {
+	state.push(state.dict.here);
+    return 0;
+}
+
+int CoreWords::op_exit(State& state)
+{
+    state.ip = state.popr();
+    return 0;
+}
+
+int CoreWords::op_imm(State& state)
+{
+    state.dict.write(state.dict.latest,
+        state.dict.read(state.dict.latest) | Immediate);
+    return 0;
+}
+
+int CoreWords::op_const(State& state)
+{
+    state.pass = Pass::Constant;
+    state.pushr(state.dict.here);
+    return 0;
+}
+
+int CoreWords::op_literal(State& state)
+{
+    state.push(state.beyondip());
+    ++state.ip;
+    return 0;
+}
+
+int CoreWords::op_jump(State& state)
+{
+    state.pushr(state.ip + 1);
+    state.ip = state.beyondip() - 1;
+    return 0;
+}
+
+int CoreWords::findi(std::string_view str)
+{
+    std::size_t i;
+    int wordsi = 0;
+
+    std::string_view words (wordsarr, sizeof(wordsarr));
+
+	for (i = 0; i < words.size();) {
+        const auto end = words.find('\0', i);
+
+        if (words.compare(i, end - i, str) == 0)
+            break;
+
+        ++wordsi;
+        i = end + 1;
+    }
+
+    return wordsi < VisibleWordCount ? wordsi : -1;
+}
+
+Func CoreWords::find(std::string_view str)
+{
+    const auto i = findi(str);
+    return i >= 0 ? get(i) : nullptr;
+}
+
+void CoreWords::run(int i, State& state)
+{
+    if (i >= 0 && i < WordCount)
+        get(i)(state);
+}
+