aboutsummaryrefslogtreecommitdiffstats
path: root/forth/foreforthfourth/forth.js
diff options
context:
space:
mode:
authorelioat <{ID}+{username}@users.noreply.github.com>2025-08-21 18:39:31 -0400
committerelioat <{ID}+{username}@users.noreply.github.com>2025-08-21 18:39:31 -0400
commitaa2916ee04161301ae23f1425caaa692e63f458d (patch)
treeec673cc0e8ce23ffa2146993420e1f21bd52cb4c /forth/foreforthfourth/forth.js
parent9c3e5894d90bf069c2178d8a8ac82d157c83159b (diff)
downloadtour-aa2916ee04161301ae23f1425caaa692e63f458d.tar.gz
*
Diffstat (limited to 'forth/foreforthfourth/forth.js')
-rw-r--r--forth/foreforthfourth/forth.js538
1 files changed, 538 insertions, 0 deletions
diff --git a/forth/foreforthfourth/forth.js b/forth/foreforthfourth/forth.js
new file mode 100644
index 0000000..baf14df
--- /dev/null
+++ b/forth/foreforthfourth/forth.js
@@ -0,0 +1,538 @@
+// 4-Stack Toy Forth Interpreter
+// Pure functional implementation with immutable state
+
+// Pure functional approach to Forth interpreter state
+const createInitialState = () => ({
+ stacks: [[], [], [], []],
+ dictionary: new Map(),
+ output: [],
+ compilingWord: null,
+ compilingDefinition: []
+});
+
+// Pure function to update state
+const updateState = (state, updates) => ({
+ ...state,
+ ...updates
+});
+
+// Pure function to push to a specific stack
+const pushToStack = (stacks, stackIndex, value) => {
+ const newStacks = stacks.map((stack, i) => [...stack]);
+ newStacks[stackIndex].push(value);
+ return newStacks;
+};
+
+// Pure function to pop from a specific stack
+const popFromStack = (stacks, stackIndex) => {
+ const newStacks = stacks.map((stack, i) => [...stack]);
+ const value = newStacks[stackIndex].pop();
+ return { stacks: newStacks, value };
+};
+
+// Helper function to move value from one stack to another
+const moveBetweenStacks = (state, fromIndex, toIndex) => {
+ if (state.stacks[fromIndex].length === 0) {
+ return updateState(state, {
+ output: [...state.output, `Error: Stack ${fromIndex + 1} underflow`]
+ });
+ }
+ const { stacks, value } = popFromStack(state.stacks, fromIndex);
+ return updateState(state, {
+ stacks: pushToStack(stacks, toIndex, value)
+ });
+};
+
+// Helper function to pop and print from specific stack
+const popAndPrint = (state, stackIndex) => {
+ const stackNames = ['red', 'teal', 'blue', 'yellow'];
+ if (state.stacks[stackIndex].length === 0) {
+ return updateState(state, {
+ output: [...state.output, `Error: ${stackNames[stackIndex]} stack underflow`]
+ });
+ }
+ const { stacks, value } = popFromStack(state.stacks, stackIndex);
+ return updateState(state, {
+ stacks,
+ output: [...state.output, `${stackNames[stackIndex]}: ${value}`]
+ });
+};
+
+// Built-in word implementations
+const builtinWords = {
+ // Stack manipulation for stack 1 (default)
+ 'dup': (state) => {
+ if (state.stacks[0].length === 0) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on dup'] });
+ }
+ const top = state.stacks[0][state.stacks[0].length - 1];
+ return updateState(state, {
+ stacks: pushToStack(state.stacks, 0, top)
+ });
+ },
+
+ 'swap': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on swap'] });
+ }
+ const newStacks = state.stacks.map((stack, i) => [...stack]);
+ const a = newStacks[0].pop();
+ const b = newStacks[0].pop();
+ newStacks[0].push(a);
+ newStacks[0].push(b);
+ return updateState(state, { stacks: newStacks });
+ },
+
+ 'drop': (state) => {
+ if (state.stacks[0].length === 0) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on drop'] });
+ }
+ const { stacks } = popFromStack(state.stacks, 0);
+ return updateState(state, { stacks });
+ },
+
+ '2drop': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on 2drop'] });
+ }
+ const { stacks: stacks1 } = popFromStack(state.stacks, 0);
+ const { stacks } = popFromStack(stacks1, 0);
+ return updateState(state, { stacks });
+ },
+
+ 'over': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on over'] });
+ }
+ const second = state.stacks[0][state.stacks[0].length - 2];
+ return updateState(state, {
+ stacks: pushToStack(state.stacks, 0, second)
+ });
+ },
+
+ '2dup': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on 2dup'] });
+ }
+ const top = state.stacks[0][state.stacks[0].length - 1];
+ const second = state.stacks[0][state.stacks[0].length - 2];
+ const newStacks = pushToStack(state.stacks, 0, second);
+ return updateState(state, {
+ stacks: pushToStack(newStacks, 0, top)
+ });
+ },
+
+ 'rot': (state) => {
+ if (state.stacks[0].length < 3) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on rot'] });
+ }
+ const newStacks = state.stacks.map((stack, i) => [...stack]);
+ const a = newStacks[0].pop();
+ const b = newStacks[0].pop();
+ const c = newStacks[0].pop();
+ newStacks[0].push(b);
+ newStacks[0].push(a);
+ newStacks[0].push(c);
+ return updateState(state, { stacks: newStacks });
+ },
+
+ '-rot': (state) => {
+ if (state.stacks[0].length < 3) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on -rot'] });
+ }
+ const newStacks = state.stacks.map((stack, i) => [...stack]);
+ const a = newStacks[0].pop();
+ const b = newStacks[0].pop();
+ const c = newStacks[0].pop();
+ newStacks[0].push(a);
+ newStacks[0].push(c);
+ newStacks[0].push(b);
+ return updateState(state, { stacks: newStacks });
+ },
+
+ // Arithmetic operations on stack 1
+ '+': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on +'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a + b)
+ });
+ },
+
+ '-': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on -'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a - b)
+ });
+ },
+
+ '*': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on *'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a * b)
+ });
+ },
+
+ '/': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on /'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ if (b === 0) {
+ return updateState(state, {
+ stacks: pushToStack(pushToStack(stacks2, 0, a), 0, b),
+ output: [...state.output, 'Error: Division by zero']
+ });
+ }
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, Math.floor(a / b))
+ });
+ },
+
+ // Comparison operators
+ '=': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on ='] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a === b ? -1 : 0)
+ });
+ },
+
+ '<': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on <'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a < b ? -1 : 0)
+ });
+ },
+
+ '>': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on >'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a > b ? -1 : 0)
+ });
+ },
+
+ // Logical operators
+ 'and': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on and'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a && b ? -1 : 0)
+ });
+ },
+
+ 'or': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on or'] });
+ };
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a || b ? -1 : 0)
+ });
+ },
+
+ 'not': (state) => {
+ if (state.stacks[0].length === 0) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on not'] });
+ }
+ const { stacks, value } = popFromStack(state.stacks, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks, 0, value ? 0 : -1)
+ });
+ },
+
+ // Additional math operations
+ 'mod': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on mod'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ if (b === 0) {
+ return updateState(state, {
+ stacks: pushToStack(pushToStack(stacks2, 0, a), 0, b),
+ output: [...state.output, 'Error: Division by zero']
+ });
+ }
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, a % b)
+ });
+ },
+
+ 'abs': (state) => {
+ if (state.stacks[0].length === 0) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on abs'] });
+ }
+ const { stacks, value } = popFromStack(state.stacks, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks, 0, Math.abs(value))
+ });
+ },
+
+ 'min': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on min'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, Math.min(a, b))
+ });
+ },
+
+ 'max': (state) => {
+ if (state.stacks[0].length < 2) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on max'] });
+ }
+ const { stacks: stacks1, value: b } = popFromStack(state.stacks, 0);
+ const { stacks: stacks2, value: a } = popFromStack(stacks1, 0);
+ return updateState(state, {
+ stacks: pushToStack(stacks2, 0, Math.max(a, b))
+ });
+ },
+
+ // Print top of stack 1
+ '.': (state) => {
+ if (state.stacks[0].length === 0) {
+ return updateState(state, { output: [...state.output, 'Error: Stack underflow on .'] });
+ }
+ const { stacks, value } = popFromStack(state.stacks, 0);
+ return updateState(state, {
+ stacks,
+ output: [...state.output, value.toString()]
+ });
+ },
+
+ // Stack inspection (non-destructive)
+ '.s': (state) => {
+ const stackContents = state.stacks[0].map(item => item.toString()).join(' ');
+ return updateState(state, {
+ output: [...state.output, `<${state.stacks[0].length}> ${stackContents}`]
+ });
+ },
+
+ 'depth': (state) => {
+ return updateState(state, {
+ stacks: pushToStack(state.stacks, 0, state.stacks[0].length)
+ });
+ },
+
+ // Push operations
+ 'push.red': (state) => state,
+ 'push.teal': (state) => moveBetweenStacks(state, 0, 1),
+ 'push.blue': (state) => moveBetweenStacks(state, 0, 2),
+ 'push.yellow': (state) => moveBetweenStacks(state, 0, 3),
+
+ // Pop operations
+ 'pop.red': (state) => popAndPrint(state, 0),
+ 'pop.teal': (state) => popAndPrint(state, 1),
+ 'pop.blue': (state) => popAndPrint(state, 2),
+ 'pop.yellow': (state) => popAndPrint(state, 3),
+
+ // Move operation
+ 'move': (state) => {
+ if (!state.moveInProgress) {
+ return updateState(state, {
+ moveInProgress: true,
+ output: [...state.output, 'Move: Enter source stack number (1-4)']
+ });
+ } else {
+ return state; // This shouldn't happen in normal flow
+ }
+ },
+
+ // Utility words
+ 'words': (state) => {
+ const builtinWordNames = Object.keys(builtinWords);
+ const userWords = Array.from(state.dictionary.keys());
+ const allWords = [...builtinWordNames, ...userWords];
+
+ const builtinList = builtinWordNames.join(' ');
+ const userList = userWords.length > 0 ? userWords.join(' ') : 'none';
+
+ return updateState(state, {
+ output: [
+ ...state.output,
+ 'Built-in words: ' + builtinList,
+ 'User defined words: ' + userList,
+ 'Total words: ' + allWords.length
+ ]
+ });
+ },
+
+ 'clear': (state) => updateState(state, {
+ stacks: [[], [], [], []],
+ output: [...state.output, 'All stacks cleared']
+ })
+};
+
+// Parse and execute Forth input
+const parseAndExecute = (state, input) => {
+ const tokens = input.trim().split(/\s+/).filter(token => token.length > 0);
+ return tokens.reduce(executeToken, state);
+};
+
+// Execute a single token
+const executeToken = (state, token) => {
+ // Handle move operation state machine
+ if (state.moveInProgress) {
+ if (state.moveFromStack === null) {
+ // Expecting source stack number
+ const from = parseInt(token);
+ if (isNaN(from) || from < 1 || from > 4) {
+ return updateState(state, {
+ moveInProgress: false,
+ moveFromStack: null,
+ output: [...state.output, 'Error: Invalid source stack. Must be 1-4']
+ });
+ }
+ if (state.stacks[from - 1].length === 0) {
+ return updateState(state, {
+ moveInProgress: false,
+ moveFromStack: null,
+ output: [...state.output, `Error: Stack ${from} is empty`]
+ });
+ }
+ return updateState(state, {
+ moveInProgress: true,
+ moveFromStack: from - 1, // Convert to 0-based index
+ output: [...state.output, `Moving from stack ${from}. Enter destination stack (1-4):`]
+ });
+ } else {
+ // Expecting destination stack number
+ const to = parseInt(token);
+ if (isNaN(to) || to < 1 || to > 4) {
+ return updateState(state, {
+ moveInProgress: false,
+ moveFromStack: null,
+ output: [...state.output, 'Error: Invalid destination stack. Must be 1-4']
+ });
+ }
+ const toIndex = to - 1; // Convert to 0-based index
+ const fromIndex = state.moveFromStack;
+
+ // Reset move state
+ const newState = updateState(state, {
+ moveInProgress: false,
+ moveFromStack: null
+ });
+
+ // Perform the move
+ const { stacks, value } = popFromStack(newState.stacks, fromIndex);
+ return updateState(newState, {
+ stacks: pushToStack(stacks, toIndex, value),
+ output: [...newState.output, `Moved ${value} from stack ${fromIndex + 1} to stack ${toIndex + 1}`]
+ });
+ }
+ }
+
+ // Handle word definition compilation
+ if (state.compilingWord !== null) {
+ if (token === ';') {
+ const newDictionary = new Map(state.dictionary);
+ newDictionary.set(state.compilingWord, [...state.compilingDefinition]);
+ return updateState(state, {
+ dictionary: newDictionary,
+ compilingWord: null,
+ compilingDefinition: [],
+ output: [...state.output, `Word '${state.compilingWord}' defined`]
+ });
+ }
+
+ // If we're expecting a name, capture it
+ if (state.compilingWord === 'EXPECTING_NAME') {
+ return updateState(state, {
+ compilingWord: token,
+ compilingDefinition: []
+ });
+ }
+
+ // Otherwise, add to definition
+ return updateState(state, {
+ compilingDefinition: [...state.compilingDefinition, token]
+ });
+ }
+
+ // Start word definition
+ if (token === ':') {
+ return updateState(state, {
+ compilingWord: 'EXPECTING_NAME',
+ compilingDefinition: []
+ });
+ }
+
+ // Check if it's a number
+ if (!isNaN(token)) {
+ const number = parseFloat(token);
+ return updateState(state, {
+ stacks: pushToStack(state.stacks, 0, number)
+ });
+ }
+
+ // Check built-in words
+ if (builtinWords[token]) {
+ return builtinWords[token](state);
+ }
+
+ // Check user-defined words
+ if (state.dictionary.has(token)) {
+ const definition = state.dictionary.get(token);
+ return definition.reduce(executeToken, state);
+ }
+
+ // Unknown word
+ return updateState(state, {
+ output: [...state.output, `Error: Unknown word '${token}'`]
+ });
+};
+
+// Export for use in other modules or testing
+if (typeof module !== 'undefined' && module.exports) {
+ module.exports = {
+ createInitialState,
+ parseAndExecute,
+ executeToken,
+ builtinWords,
+ updateState,
+ pushToStack,
+ popFromStack
+ };
+} else if (typeof window !== 'undefined') {
+ // Browser environment
+ window.ForthInterpreter = {
+ createInitialState,
+ parseAndExecute,
+ executeToken,
+ builtinWords,
+ updateState,
+ pushToStack,
+ popFromStack
+ };
+}