diff options
| author | elioat <{ID}+{username}@users.noreply.github.com> | 2025-08-21 18:39:31 -0400 |
|---|---|---|
| committer | elioat <{ID}+{username}@users.noreply.github.com> | 2025-08-21 18:39:31 -0400 |
| commit | aa2916ee04161301ae23f1425caaa692e63f458d (patch) | |
| tree | ec673cc0e8ce23ffa2146993420e1f21bd52cb4c /forth/foreforthfourth/forth.js | |
| parent | 9c3e5894d90bf069c2178d8a8ac82d157c83159b (diff) | |
| download | tour-aa2916ee04161301ae23f1425caaa692e63f458d.tar.gz | |
*
Diffstat (limited to 'forth/foreforthfourth/forth.js')
| -rw-r--r-- | forth/foreforthfourth/forth.js | 538 |
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 + }; +} |