diff options
| author | elioat <{ID}+{username}@users.noreply.github.com> | 2025-08-21 18:25:22 -0400 |
|---|---|---|
| committer | elioat <{ID}+{username}@users.noreply.github.com> | 2025-08-21 18:25:22 -0400 |
| commit | 9c3e5894d90bf069c2178d8a8ac82d157c83159b (patch) | |
| tree | 6a5b7dbc8452d68428ad5841a656ad1bcd954a81 /forth/foreforthfourth/index.html | |
| parent | 15d5325facd7e018cc85a75ff482d2a27bf9f9ff (diff) | |
| download | tour-9c3e5894d90bf069c2178d8a8ac82d157c83159b.tar.gz | |
*
Diffstat (limited to 'forth/foreforthfourth/index.html')
| -rw-r--r-- | forth/foreforthfourth/index.html | 624 |
1 files changed, 624 insertions, 0 deletions
diff --git a/forth/foreforthfourth/index.html b/forth/foreforthfourth/index.html new file mode 100644 index 0000000..9fd1228 --- /dev/null +++ b/forth/foreforthfourth/index.html @@ -0,0 +1,624 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <title>4-Stack Toy Forth</title> + <style> + body { + font-family: 'Courier New', monospace; + margin: 0; + padding: 10px; + background-color: #000; + color: #fff; + min-height: 100vh; + display: flex; + flex-direction: column; + } + + .container { + max-width: 100%; + flex: 1; + display: flex; + flex-direction: column; + } + + h1 { + font-size: 18px; + margin: 0 0 10px 0; + text-align: center; + } + + .help { + background-color: #111; + border: 1px solid #333; + padding: 10px; + margin-bottom: 10px; + font-size: 12px; + line-height: 1.3; + } + + .help h4 { + margin: 0 0 5px 0; + font-size: 13px; + } + + .stacks-container { + display: grid; + grid-template-columns: repeat(4, 1fr); + gap: 8px; + margin-bottom: 10px; + flex: 1; + min-height: 200px; + } + + .stack { + border: 2px solid; + padding: 8px; + display: flex; + flex-direction: column; + background-color: #111; + position: relative; + } + + .stack-1 { border-color: #ff6b6b; } + .stack-2 { border-color: #4ecdc4; } + .stack-3 { border-color: #45b7d1; } + .stack-4 { border-color: #f9ca24; } + + .stack h3 { + margin: 0 0 8px 0; + text-align: center; + font-size: 12px; + color: #fff; + } + + .stack-items { + flex: 1; + display: flex; + flex-direction: column-reverse; + gap: 2px; + align-items: stretch; + } + + .stack-item { + background-color: #222; + padding: 4px 6px; + text-align: center; + border: 1px solid #555; + font-size: 12px; + word-break: break-all; + } + + .input-section { + margin-bottom: 10px; + } + + .input-container { + display: flex; + gap: 5px; + margin-bottom: 8px; + } + + #forth-input { + flex: 1; + padding: 8px; + font-family: 'Courier New', monospace; + font-size: 14px; + border: 1px solid #555; + background-color: #111; + color: #fff; + } + + #forth-input:focus { + outline: none; + border-color: #fff; + } + + button { + padding: 8px 12px; + font-family: 'Courier New', monospace; + font-size: 12px; + border: 1px solid #fff; + background-color: #000; + color: #fff; + cursor: pointer; + } + + button:hover, button:active { + background-color: #fff; + color: #000; + } + + .output { + background-color: #111; + border: 1px solid #555; + padding: 8px; + height: 100px; + overflow-y: auto; + font-family: 'Courier New', monospace; + font-size: 12px; + line-height: 1.3; + } + + .error { + color: #fff; + } + + .success { + color: #fff; + } + + /* Mobile optimizations */ + @media (max-width: 768px) { + body { padding: 5px; } + + h1 { font-size: 16px; } + + .help { + font-size: 11px; + padding: 8px; + } + + .stacks-container { + gap: 4px; + min-height: 150px; + } + + .stack { + padding: 6px; + } + + .stack h3 { + font-size: 11px; + margin-bottom: 6px; + } + + .stack-item { + font-size: 11px; + padding: 3px 4px; + } + + #forth-input { + font-size: 16px; /* Prevents zoom on iOS */ + padding: 6px; + } + + button { + font-size: 11px; + padding: 6px 10px; + } + + .output { + height: 80px; + font-size: 11px; + padding: 6px; + } + } + + @media (max-width: 480px) { + .stacks-container { + grid-template-columns: repeat(2, 1fr); + grid-template-rows: repeat(2, 1fr); + } + + .input-container { + flex-direction: column; + } + + button { + width: 100%; + } + } + </style> +</head> +<body> + <div class="container"> + <h1>4-Stack Toy Forth Interpreter</h1> + + <div class="help"> + <h4>Built-in Words:</h4> + Numbers (push to stack 1/red) | push.red push.teal push.blue push.yellow (move top of red to target) | + pop.red pop.teal pop.blue pop.yellow (pop and print) | + - * / (red stack arithmetic) | + dup swap drop (red stack manipulation) | . (print top of red stack) | + move (usage: move 2 3 - moves top from stack 2 to stack 3) | + : name ... ; (define new word) | words (list defined words) | clear (clear all stacks) + </div> + + <div class="stacks-container"> + <div class="stack stack-1"> + <h3>Stack 1 (Red)</h3> + <div class="stack-items" id="stack-1-items"></div> + </div> + <div class="stack stack-2"> + <h3>Stack 2 (Teal)</h3> + <div class="stack-items" id="stack-2-items"></div> + </div> + <div class="stack stack-3"> + <h3>Stack 3 (Blue)</h3> + <div class="stack-items" id="stack-3-items"></div> + </div> + <div class="stack stack-4"> + <h3>Stack 4 (Yellow)</h3> + <div class="stack-items" id="stack-4-items"></div> + </div> + </div> + + <div class="input-section"> + <div class="input-container"> + <input type="text" id="forth-input" placeholder="Enter Forth commands here..." /> + <button onclick="executeForth()">Execute</button> + <button onclick="clearAll()">Clear All</button> + </div> + </div> + + <div class="output" id="output"></div> + </div> + + <script> + // Pure functional approach to Forth interpreter state + const createInitialState = () => ({ + stacks: [[], [], [], []], + dictionary: new Map(), + output: [], + compilingWord: null, + compilingDefinition: [] + }); + + let forthState = createInitialState(); + + // 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 }; + }; + + let moveInProgress = false; + let moveFromStack = null; + + // 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 }); + }, + + // 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)) + }); + }, + + // 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()] + }); + }, + + // 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 (!moveInProgress) { + moveInProgress = true; + return updateState(state, { + 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 userWords = Array.from(state.dictionary.keys()).join(' '); + return updateState(state, { + output: [...state.output, 'User defined words: ' + (userWords || 'none')] + }); + }, + + 'clear': (state) => updateState(state, { + stacks: [[], [], [], []], + output: [...state.output, 'All stacks cleared'] + }) + }; + + // 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}`] + }); + }; + + // 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 (moveInProgress) { + if (moveFromStack === null) { + // Expecting source stack number + const from = parseInt(token); + if (isNaN(from) || from < 1 || from > 4) { + moveInProgress = false; + return updateState(state, { + output: [...state.output, 'Error: Invalid source stack. Must be 1-4'] + }); + } + if (state.stacks[from - 1].length === 0) { + moveInProgress = false; + return updateState(state, { + output: [...state.output, `Error: Stack ${from} is empty`] + }); + } + moveFromStack = from - 1; // Convert to 0-based index + return updateState(state, { + 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) { + moveInProgress = false; + moveFromStack = null; + return updateState(state, { + output: [...state.output, 'Error: Invalid destination stack. Must be 1-4'] + }); + } + const toIndex = to - 1; // Convert to 0-based index + const fromIndex = moveFromStack; + + // Reset move state + moveInProgress = false; + moveFromStack = null; + + // Perform the move + const { stacks, value } = popFromStack(state.stacks, fromIndex); + return updateState(state, { + stacks: pushToStack(stacks, toIndex, value), + output: [...state.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`] + }); + } + return updateState(state, { + compilingDefinition: [...state.compilingDefinition, token] + }); + } + + // Start word definition + if (token === ':') { + return updateState(state, { + compilingWord: 'EXPECTING_NAME', + compilingDefinition: [] + }); + } + + // Capture word name during definition + if (state.compilingWord === 'EXPECTING_NAME') { + return updateState(state, { + compilingWord: token + }); + } + + // 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}'`] + }); + }; + + // Update visual display + const updateDisplay = () => { + // Update stacks + forthState.stacks.forEach((stack, index) => { + const container = document.getElementById(`stack-${index + 1}-items`); + container.innerHTML = ''; + stack.forEach(item => { + const div = document.createElement('div'); + div.className = 'stack-item'; + div.textContent = item.toString(); + container.appendChild(div); + }); + }); + + // Update output + const outputElement = document.getElementById('output'); + outputElement.innerHTML = forthState.output + .slice(-20) // Show last 20 messages + .map(msg => { + const className = msg.startsWith('Error:') ? 'error' : 'success'; + return `<div class="${className}">${msg}</div>`; + }) + .join(''); + outputElement.scrollTop = outputElement.scrollHeight; + }; + + // Execute Forth commands + const executeForth = () => { + const input = document.getElementById('forth-input'); + const command = input.value.trim(); + + if (command) { + forthState = parseAndExecute(forthState, command); + updateDisplay(); + input.value = ''; + } + }; + + // Clear all stacks + const clearAll = () => { + forthState = createInitialState(); + moveInProgress = false; + moveFromStack = null; + updateDisplay(); + }; + + // Handle Enter key in input + document.getElementById('forth-input').addEventListener('keypress', (e) => { + if (e.key === 'Enter') { + executeForth(); + } + }); + + // Initialize display + updateDisplay(); + </script> +</body> +</html>
\ No newline at end of file |