diff options
26 files changed, 4647 insertions, 294 deletions
diff --git a/awk/uxn/awk/uxnasm.awk b/awk/uxn/awk/uxnasm.awk index d66886f..cfcdd00 100644 --- a/awk/uxn/awk/uxnasm.awk +++ b/awk/uxn/awk/uxnasm.awk @@ -1,7 +1,6 @@ #!/usr/bin/awk -f # Uxntal Assembler in AWK - Two-Pass Implementation -# Based on the C implementation by Devine Lu Linvega, Andrew Alderwick BEGIN { # Constants @@ -16,6 +15,7 @@ BEGIN { # Label and reference tracking labels_len = 0 refs_len = 0 + macros_len = 0 # Device tracking devices_len = 0 @@ -23,6 +23,10 @@ BEGIN { last_size = 0 current_device = "" + # Lambda tracking + lambda_len = 0 + lambda_ptr = 0 + # Opcode table split("LIT INC POP NIP SWP ROT DUP OVR EQU NEQ GTH LTH JMP JCN JSR STH LDZ STZ LDR STR LDA STA DEI DEO ADD SUB MUL DIV AND ORA EOR SFT", ops) @@ -31,17 +35,17 @@ BEGIN { # Check arguments if (ARGC < 3) { - printf "usage: uxnasm [-v] input.tal output.rom\n" > "/dev/stderr" + printf "usage: uxnasm.awk [-v] input.tal output.rom\n" > "/dev/stderr" exit 1 } if (ARGC == 3 && substr(ARGV[1], 1, 2) == "-v") { - printf "Uxnasm - Uxntal Assembler, 15 Jan 2025\n" + printf "Uxnasm.awk\n" exit 0 } if (ARGC != 3) { - printf "usage: uxnasm [-v] input.tal output.rom\n" > "/dev/stderr" + printf "usage: uxnasm.awk [-v] input.tal output.rom\n" > "/dev/stderr" exit 1 } @@ -69,6 +73,28 @@ BEGIN { } # Utility functions +function remove_comments(line, result, i, c, depth) { + # Remove comments from a line + # Comments are delimited by ( and ) and can be nested + result = "" + depth = 0 + + for (i = 1; i <= length(line); i++) { + c = substr(line, i, 1) + if (c == "(") { + depth++ + } else if (c == ")") { + depth-- + } else if (depth == 0) { + result = result c + } + } + + # Trim whitespace + gsub(/^[ \t]+|[ \t]+$/, "", result) + return result +} + function shex(s, d, n, c, i) { n = 0 for (i = 1; i <= length(s); i++) { @@ -197,7 +223,7 @@ function finddevicefield(device_name, field_name, i, j) { return -1 } -# Pass 1: Collect all symbols and labels +# --- PASS 1: Symbol/Label Collection --- function pass1_collect_symbols(filename) { ptr = PAGE data_length = PAGE @@ -211,53 +237,86 @@ function pass1_collect_symbols(filename) { } function pass1_process_line(line_text, tokens, i, token, j) { - # Simple tokenization - split on whitespace - split(line_text, tokens) - for (j = 1; j <= length(tokens); j++) { - printf "DEBUG: token[%d] = '%s'\n", j, tokens[j] > "/dev/stderr" - } - for (i = 1; i <= length(tokens); i++) { - if (tokens[i] != "" && tokens[i] != " ") { - token = tokens[i] - # Handle tokens that might be split by whitespace - if (substr(token, 1, 1) == "<" && substr(token, length(token), 1) != ">") { - # Look ahead for closing > - if (i < length(tokens) && tokens[i + 1] == ">") { - token = token ">" - i++ # Skip the next token - } + line_text = remove_comments(line_text) + if (line_text == "") return 1 + + # Custom tokenization to handle quoted strings properly + tokens_len = 0 + i = 1 + while (i <= length(line_text)) { + c = substr(line_text, i, 1) + if (c == " " || c == "\t") { + i++ + continue + } + + if (c == "\"") { + # Handle quoted string - capture everything until closing quote + token = "\"" + i++ + while (i <= length(line_text) && substr(line_text, i, 1) != "\"") { + token = token substr(line_text, i, 1) + i++ } - # Handle tokens that start with - but are followed by a device field - if (token == "-" && i < length(tokens) && index(tokens[i + 1], "/") > 0) { - token = token tokens[i + 1] - i++ # Skip the next token + if (i <= length(line_text)) { + token = token "\"" + i++ } - # Skip standalone > tokens - if (token != ">") { - pass1_parse_token(token) + tokens[++tokens_len] = token + } else { + # Regular token - capture until whitespace + token = "" + while (i <= length(line_text) && substr(line_text, i, 1) != " " && substr(line_text, i, 1) != "\t") { + token = token substr(line_text, i, 1) + i++ + } + if (token != "") { + tokens[++tokens_len] = token } } } -} - -function pass1_parse_token(w) { - # Debug output for label processing - if (substr(w, 1, 1) == "@") { - printf "DEBUG: Processing label token '%s' at ptr %d\n", w, ptr > "/dev/stderr" + + # Combine - tokens with / (like -Screen/pixel) + for (i = 1; i < tokens_len; i++) { + if (tokens[i] == "-" && index(tokens[i+1], "/") > 0) { + tokens[i] = tokens[i] tokens[i+1] + for (j = i + 1; j < tokens_len; j++) { + tokens[j] = tokens[j+1] + } + tokens_len-- + } } - # Skip comments - if (substr(w, 1, 1) == "(") { - return 1 + for (i = 1; i <= tokens_len; i++) { + token = tokens[i] + printf "DEBUG: pass1 processing token: '%s'\n", token > "/dev/stderr" + if (!pass1_parse_token(token)) { + printf "ERROR: Failed to parse token '%s' at line %d\n", token, line_number > "/dev/stderr" + return 0 + } } + return 1 +} + +function pass1_parse_token(w) { # Skip standalone tokens if (w == ">" || w == "-") { return 1 } - # Handle device definitions + # Handle device definitions and labels if (substr(w, 1, 1) == "@") { + printf "DEBUG: Processing @ token: %s\n", w > "/dev/stderr" + # Check if this is a macro definition (labels starting with @<) + printf "DEBUG: Checking macro condition: substr(w, 2, 1)='%s', substr(w, length(w), 1)='%s'\n", substr(w, 2, 1), substr(w, length(w), 1) > "/dev/stderr" + printf "DEBUG: Condition check: '%s' == '<' && '%s' == '>' = %s\n", substr(w, 2, 1), substr(w, length(w), 1), (substr(w, 2, 1) == "<" && substr(w, length(w), 1) == ">") > "/dev/stderr" + if (substr(w, 2, 1) == "<" && substr(w, length(w), 1) == ">") { + printf "DEBUG: Found macro definition: %s\n", w > "/dev/stderr" + makemacro(substr(w, 3, length(w) - 3)) + return 1 + } + # Check if this is a device definition (has base address) if (last_padding != "" && current_device == "") { makedevice(substr(w, 2), shex(last_padding)) @@ -284,6 +343,12 @@ function pass1_parse_token(w) { return 1 } + # Handle lambda labels + if (w == "}") { + makelabel(makelambda(lambda_len++)) + return 1 + } + # Handle padding and size if (substr(w, 1, 1) == "|") { last_padding = substr(w, 2) @@ -358,7 +423,7 @@ function pass1_parse_token(w) { return 1 } - # Handle hex literals + # Handle hex literals (with # prefix or raw hex values) if (substr(w, 1, 1) == "#") { if (length(substr(w, 2)) > 2) { ptr += 3 # LIT2 + 2 bytes @@ -368,6 +433,16 @@ function pass1_parse_token(w) { return 1 } + # Handle raw hex values (like font data) + if (ishex(w)) { + if (length(w) > 2) { + ptr += 3 # LIT2 + 2 bytes + } else { + ptr += 2 # LIT + 1 byte + } + return 1 + } + # Handle opcodes if (isopc(w)) { ptr++ @@ -380,13 +455,26 @@ function pass1_parse_token(w) { return 1 } + # Handle macro definitions (labels starting with @<) + if (substr(w, 1, 1) == "@" && substr(w, 2, 1) == "<" && substr(w, length(w), 1) == ">") { + makemacro(substr(w, 3, length(w) - 3)) + return 1 + } + + # Handle macro calls (tokens starting with <) + if (substr(w, 1, 1) == "<" && substr(w, length(w), 1) == ">") { + # Just advance pointer in pass1, will be expanded in pass2 + ptr += 1 # Placeholder - actual size depends on macro content + return 1 + } + # Handle unknown tokens as label references (fallback) makeref(w, " ", ptr + 1) ptr += 3 # LIT2 + 2 bytes return 1 } -# Pass 2: Generate code with resolved references +# --- PASS 2: Code Generation --- function pass2_generate_code(filename) { ptr = PAGE data_length = PAGE @@ -399,41 +487,70 @@ function pass2_generate_code(filename) { return 1 } -function pass2_process_line(line_text, tokens, i, token) { - # Simple tokenization - split on whitespace - split(line_text, tokens) - for (i = 1; i <= length(tokens); i++) { - if (tokens[i] != "" && tokens[i] != " ") { - token = tokens[i] - # Handle tokens that might be split by whitespace - if (substr(token, 1, 1) == "<" && substr(token, length(token), 1) != ">") { - # Look ahead for closing > - if (i < length(tokens) && tokens[i + 1] == ">") { - token = token ">" - i++ # Skip the next token - } +function pass2_process_line(line_text, tokens, i, token, j) { + line_text = remove_comments(line_text) + if (line_text == "") return 1 + + # Custom tokenization to handle quoted strings properly + tokens_len = 0 + i = 1 + while (i <= length(line_text)) { + c = substr(line_text, i, 1) + if (c == " " || c == "\t") { + i++ + continue + } + + if (c == "\"") { + # Handle quoted string - capture everything until closing quote + token = "\"" + i++ + while (i <= length(line_text) && substr(line_text, i, 1) != "\"") { + token = token substr(line_text, i, 1) + i++ } - # Handle tokens that start with - but are followed by a device field - if (token == "-" && i < length(tokens) && index(tokens[i + 1], "/") > 0) { - token = token tokens[i + 1] - i++ # Skip the next token + if (i <= length(line_text)) { + token = token "\"" + i++ + } + tokens[++tokens_len] = token + } else { + # Regular token - capture until whitespace + token = "" + while (i <= length(line_text) && substr(line_text, i, 1) != " " && substr(line_text, i, 1) != "\t") { + token = token substr(line_text, i, 1) + i++ } - # Skip standalone > tokens - if (token != ">") { - pass2_parse_token(token) + if (token != "") { + tokens[++tokens_len] = token } } } + + # Combine - tokens with / (like -Screen/pixel) + for (i = 1; i < tokens_len; i++) { + if (tokens[i] == "-" && index(tokens[i+1], "/") > 0) { + tokens[i] = tokens[i] tokens[i+1] + for (j = i + 1; j < tokens_len; j++) { + tokens[j] = tokens[j+1] + } + tokens_len-- + } + } + + for (i = 1; i <= tokens_len; i++) { + token = tokens[i] + if (!pass2_parse_token(token)) { + printf "ERROR: Failed to parse token '%s' at line %d\n", token, line_number > "/dev/stderr" + return 0 + } + } + return 1 } function pass2_parse_token(w) { printf "DEBUG: pass2_parse_token processing '%s'\n", w > "/dev/stderr" - # Skip comments - if (substr(w, 1, 1) == "(") { - return 1 - } - # Skip standalone tokens (but not device field references) if (w == ">") { return 1 @@ -449,6 +566,11 @@ function pass2_parse_token(w) { return 1 } + # Handle lambda labels (just skip, already collected in pass 1) + if (w == "}") { + return 1 + } + # Handle padding if (substr(w, 1, 1) == "|") { # Set pointer based on padding value (no writing, just positioning) @@ -515,21 +637,33 @@ function pass2_parse_token(w) { return 1 } - # Handle hex literals + # Handle hex literals (with # prefix or raw hex values) if (substr(w, 1, 1) == "#") { writehex(w) return 1 } + # Handle raw hex values (like font data) + if (ishex(w)) { + writehex(w) + return 1 + } + # Handle opcodes if (isopc(w)) { writebyte(findopcode(w)) return 1 } - # Handle strings + # Handle string literals if (substr(w, 1, 1) == "\"") { - writestring(substr(w, 2)) + writestring(substr(w, 2, length(w) - 2)) + return 1 + } + + # Handle macro calls (tokens starting with <) + if (substr(w, 1, 1) == "<" && substr(w, length(w), 1) == ">") { + expandmacro(substr(w, 2, length(w) - 2)) return 1 } @@ -632,6 +766,128 @@ function writehex(w) { return 0 } +# Macro functions +function findmacro(name, i) { + for (i = 0; i < macros_len; i++) { + if (macro_names[i] == name) { + return i + } + } + return -1 +} + +function makemacro(name, i) { + printf "DEBUG: makemacro called with name: %s\n", name > "/dev/stderr" + if (macros_len >= 256) { + printf "Macros limit exceeded\n" > "/dev/stderr" + return 0 + } + if (findmacro(name) >= 0) { + printf "Macro duplicate: %s\n", name > "/dev/stderr" + return 0 + } + if (findlabel(name) >= 0) { + printf "Label duplicate: %s\n", name > "/dev/stderr" + return 0 + } + + # Store macro name and initialize empty body + macro_names[macros_len] = name + macro_data[macros_len] = "" + macros_len++ + + # Note: We'll capture the macro body in pass2 when we process the file again + return 1 +} + +function capture_macro_body(name, filename, line, in_macro, macro_body, depth) { + # Reset file to beginning + close(filename) + in_macro = 0 + macro_body = "" + depth = 0 + + while ((getline line < filename) > 0) { + if (in_macro) { + # Check if we've reached the end of the macro (next label or closing brace) + if (substr(line, 1, 1) == "@" && substr(line, 2, 1) != "|") { + # Found next label, end of macro + break + } + + # Count braces for nested macro handling + for (i = 1; i <= length(line); i++) { + c = substr(line, i, 1) + if (c == "{") depth++ + else if (c == "}") { + depth-- + if (depth < 0) break # End of macro + } + } + + if (depth < 0) break # End of macro + + # Add line to macro body + macro_body = macro_body line "\n" + } else if (substr(line, 1, 1) == "@" && substr(line, 2, 1) == "<") { + # Check if this is our macro + macro_name = substr(line, 3) + if (substr(macro_name, length(macro_name), 1) == ">") { + macro_name = substr(macro_name, 1, length(macro_name) - 1) + if (macro_name == name) { + in_macro = 1 + # Start capturing from next line + } + } + } + } + + close(filename) + + # Store the macro body + for (i = 0; i < macros_len; i++) { + if (macro_names[i] == name) { + macro_data[i] = macro_body + return 1 + } + } + return 0 +} + +function expandmacro(name, macro_idx, macro_text, tokens, i) { + macro_idx = findmacro(name) + if (macro_idx < 0) { + printf "Macro not found: %s\n", name > "/dev/stderr" + return 0 + } + + # If macro body is empty, try to capture it + if (macro_data[macro_idx] == "") { + capture_macro_body(name, ARGV[1]) + } + + macro_text = macro_data[macro_idx] + if (macro_text == "") { + printf "Macro body empty: %s\n", name > "/dev/stderr" + return 0 + } + + # Process macro body line by line + split(macro_text, lines, "\n") + for (i = 1; i <= length(lines); i++) { + if (lines[i] != "") { + pass2_process_line(lines[i]) + } + } + return 1 +} + +# Lambda functions +function makelambda(id) { + # Create a unique lambda name like "λb" where suffix is hex digit + return sprintf("λ%c", substr(hexad, int(id / 16) + 1, 1) substr(hexad, (id % 16) + 1, 1)) +} + function ord(c) { return index(" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~", c) + 31 } diff --git a/js/scripting-lang/FIXME.md b/js/scripting-lang/FIXME.md new file mode 100644 index 0000000..b71be48 --- /dev/null +++ b/js/scripting-lang/FIXME.md @@ -0,0 +1,106 @@ +# FIXME - Issues and Fixes + +## Current Status: 8/13 tests passing + +### ✅ Phase 1: Critical Issues (COMPLETED) +- **Unary Minus Operator**: ✅ Fixed - Added `UnaryMinusExpression` parsing and evaluation +- **Stack Overflow Issues**: ✅ Fixed - Resolved circular dependencies and infinite recursion +- **Test Runner Overconfidence**: ✅ Fixed - Added robust error handling and exit codes +- **IO Operation Parsing**: ✅ Fixed - Moved IO parsing to proper precedence level +- **First-Class Functions**: ✅ Fixed - Added `TokenType.FUNCTION_REF` to function call detection +- **Function Definitions Test**: ✅ Fixed - Corrected assertion and duplicate variable assignment +- **Parser Regression Fix**: ✅ Fixed - Removed overly broad `TokenType.MINUS` check that was breaking binary operations +- **Parser Ambiguity with Unary Minus Arguments**: ✅ Fixed - Added special case in `parseExpression()` to handle `FunctionReference MINUS` pattern + +### 🔄 Phase 2: Medium Priority Issues (IN PROGRESS) + +#### Logical Operator Precedence Issue +- **Issue**: `isEven 10 and isPositive 5` is parsed as `isEven(10 and isPositive(5))` instead of `(isEven 10) and (isPositive 5)` +- **Root Cause**: Logical operators (`and`, `or`, `xor`) have the same precedence as arithmetic operators in `parseExpression()` +- **Impact**: Complex expressions like `add (multiply 3 4) (isEven 10 and isPositive 5)` fail +- **Status**: 🔄 In Progress - Need to implement proper operator precedence hierarchy +- **Solution Plan**: + 1. Create separate precedence levels for logical operators + 2. Ensure function calls have higher precedence than logical operators + 3. Test with integration scenarios + +#### Integration Test Failures +- **Basic Features Integration**: "Assertion failed" - Due to logical operator precedence issue +- **Pattern Matching Integration**: "Expected closing parenthesis" - Related to precedence parsing +- **Functional Programming Integration**: "Assertion failed" - Related to precedence parsing + +#### Unit Test Failures +- **Arithmetic Operations**: "Assertion failed" - Need to investigate specific assertions +- **Case Expressions**: "Expected closing parenthesis" - Related to precedence parsing + +### 🔄 Phase 3: Validation and Documentation (PENDING) +- **Comprehensive Test Suite Validation**: Target: 13/13 tests passing +- **Update Documentation**: README.md and FIXME.md to reflect all resolved issues + +## Recent Fixes + +### ✅ Parser Ambiguity with Unary Minus Arguments (Latest Fix) +- **Issue**: `filter @isPositive -3` was parsed as `filter(@isPositive - 3)` instead of `filter(@isPositive, -3)` +- **Root Cause**: `parseExpression()` was treating `FunctionReference MINUS` as a binary minus operation +- **Solution**: Added special case in `parseExpression()` to detect when left operand is `FunctionReference` and next token is `MINUS`, returning the left operand instead of creating a binary operation +- **Status**: ✅ Resolved - Standard Library test now passes + +### ✅ Parser Regression Fix +- **Issue**: Recent changes introduced regression where binary minus operations were incorrectly parsed as function calls +- **Root Cause**: Overly broad `TokenType.MINUS` check in function call detection logic +- **Solution**: Removed `TokenType.MINUS` from function call detection in `parsePrimary()` +- **Status**: ✅ Resolved - Basic arithmetic operations restored + +## Next Steps + +### Immediate Priority (Phase 2) +1. **🔧 Fix Logical Operator Precedence** + - **Problem**: Logical operators need lower precedence than function calls + - **Current State**: `isEven 10 and isPositive 5` → `isEven(10 and isPositive(5))` ❌ + - **Target State**: `isEven 10 and isPositive 5` → `(isEven 10) and (isPositive 5)` ✅ + - **Approach**: + - Create `parseLogicalExpression()` function with lowest precedence + - Modify `parseExpression()` to handle only arithmetic and comparison operators + - Update function call parsing to use appropriate precedence level + - Test with integration scenarios + +2. **🔧 Fix Parentheses Parsing with Logical Operators** + - **Problem**: `add (multiply 3 4) (isEven 10 and isPositive 5)` fails with "Expected closing parenthesis" + - **Root Cause**: Logical operators inside parentheses not handled correctly + - **Solution**: Ensure parentheses parsing respects operator precedence + +3. **🔧 Investigate Remaining Unit Test Failures** + - **Arithmetic Operations**: Check specific assertions that are failing + - **Case Expressions**: Fix parentheses parsing in case expression contexts + +### Validation Phase (Phase 3) +4. **✅ Run Full Test Suite** + - Target: 13/13 tests passing + - Validate all integration tests work correctly + - Ensure no regressions in previously fixed features + +5. **✅ Update Documentation** + - Update README.md with current status + - Document all fixes and remaining known issues + - Update examples to reflect current syntax + +## Technical Details + +### Operator Precedence Hierarchy (Target) +1. **Function calls** (highest precedence) +2. **Unary operators** (`-`, `not`) +3. **Multiplication/Division** (`*`, `/`, `%`) +4. **Addition/Subtraction** (`+`, `-`) +5. **Comparison operators** (`==`, `!=`, `<`, `>`, `<=`, `>=`) +6. **Logical operators** (`and`, `or`, `xor`) (lowest precedence) + +### Current Implementation Issues +- Logical operators are handled at the same level as arithmetic operators in `parseExpression()` +- Function call detection doesn't respect logical operator boundaries +- Parentheses parsing doesn't properly handle logical expressions + +### Success Metrics +- ✅ All unit tests pass (10/10) +- ✅ All integration tests pass (3/3) +- ✅ Complex expressions like `add (multiply 3 4) (isEven 10 and isPositive 5)` evaluate correctly +- ✅ No regressions in previously working features \ No newline at end of file diff --git a/js/scripting-lang/IDEAS.txt b/js/scripting-lang/IDEAS.txt new file mode 100644 index 0000000..96f8b4b --- /dev/null +++ b/js/scripting-lang/IDEAS.txt @@ -0,0 +1,17 @@ +add 2 other io functions + +..listen + +..emit + +where listen takes in a well defined state object from outside the scope of the program, making it available to the program + +where emit lets the program spit state back out into the wider world + +*** + +Implement type annotation with the "is" keyword, like + +x is int : 1; + +double is int : x -> x * 2; \ No newline at end of file diff --git a/js/scripting-lang/NEXT-STEPS.md b/js/scripting-lang/NEXT-STEPS.md new file mode 100644 index 0000000..7cb1e75 --- /dev/null +++ b/js/scripting-lang/NEXT-STEPS.md @@ -0,0 +1,229 @@ +# Next Steps: Table Features Implementation + +## Current State Analysis + +### What Works ✅ +- Basic table creation: `{name: "Alice", age: 30}` +- Simple table access: `person.name` (single level) +- Basic function definitions: `inc : x -> x + 1` +- Basic function calls: `inc 5` +- Table literals with functions: `{inc: x -> x + 1}` (parsed but not fully functional) + +### What's Broken ❌ +1. **Chained table access**: `config.user.name` fails with "Unexpected dot (.) token" +2. **Function calls from tables**: `m.inc 1` doesn't work +3. **Functions in table literals**: May not be properly interpreted + +## Root Cause Analysis + +### Issue 1: Chained Table Access +**Problem**: Parser encounters standalone DOT tokens when parsing `config.user.name` +**Location**: Assignment parsing logic in `walk()` function +**Debug Evidence**: +- Tokens: `[IDENTIFIER "config", DOT, IDENTIFIER "user", DOT, IDENTIFIER "name"]` +- Parser fails at position 17 (second DOT) because it's not in table access context + +### Issue 2: Function Calls from Tables +**Problem**: Parser doesn't recognize `m.inc 1` as a function call +**Location**: Function call parsing logic +**Expected**: Should parse as `FunctionCall` with `name: TableAccess` and `args: [1]` + +## Implementation Plan + +### Phase 1: Fix Chained Table Access Parser + +#### Step 1.1: Update Assignment Value Parsing +**File**: `lang.js` around line 1300-1400 +**Change**: Modify assignment parsing to handle chained dot notation before falling back to `walk()` + +**Current Logic**: +```javascript +// Assignment parsing falls back to walk() for value +const value = walk(); // This fails on DOT tokens +``` + +**New Logic**: +```javascript +// Check if value is a chained table access +if (tokens[current] && tokens[current].type === TokenType.IDENTIFIER && + tokens[current + 1] && tokens[current + 1].type === TokenType.DOT) { + // Parse chained table access + const tableAccess = parseChainedTableAccess(); + return { type: 'AssignmentExpression', name, value: tableAccess }; +} +// Fall back to walk() for other cases +const value = walk(); +``` + +#### Step 1.2: Create parseChainedTableAccess Helper +**File**: `lang.js` in `walk()` function +**Purpose**: Parse arbitrary length dot notation chains + +**Implementation**: +```javascript +function parseChainedTableAccess() { + let tableExpr = { + type: 'Identifier', + value: tokens[current].value + }; + current++; // Skip first identifier + + while (tokens[current] && tokens[current].type === TokenType.DOT) { + current++; // Skip dot + if (tokens[current] && tokens[current].type === TokenType.IDENTIFIER) { + const key = { + type: 'StringLiteral', + value: tokens[current].value + }; + current++; // Skip identifier + + tableExpr = { + type: 'TableAccess', + table: tableExpr, + key + }; + } else { + throw new Error('Expected identifier after dot in table access'); + } + } + + return tableExpr; +} +``` + +#### Step 1.3: Update Function Call Parsing +**File**: `lang.js` around line 600-700 +**Change**: Allow `TableAccess` nodes as function names + +**Current Logic**: +```javascript +// Only handles string function names +func = globalScope[node.name]; +``` + +**New Logic**: +```javascript +if (typeof node.name === 'string') { + func = globalScope[node.name]; +} else if (node.name.type === 'TableAccess') { + // Evaluate table access to get function + func = evalNode(node.name); + if (typeof func !== 'function') { + throw new Error('Table access did not resolve to a function'); + } +} +``` + +### Phase 2: Fix Function Calls from Tables + +#### Step 2.1: Update Function Call Detection +**File**: `lang.js` in `parseFunctionCall()` function +**Change**: Detect when a table access is followed by arguments + +**Current Logic**: +```javascript +// Only checks for identifier followed by arguments +if (tokens[current + 1] && tokens[current + 1].type === TokenType.NUMBER) { + // Function call +} +``` + +**New Logic**: +```javascript +// Check for identifier followed by arguments OR table access followed by arguments +if ((tokens[current + 1] && tokens[current + 1].type === TokenType.NUMBER) || + (tokens[current + 1] && tokens[current + 1].type === TokenType.DOT)) { + // Parse table access first, then check for arguments + const tableAccess = parseChainedTableAccess(); + if (tokens[current] && isArgumentToken(tokens[current])) { + // This is a function call from table + return parseFunctionCallFromTable(tableAccess); + } + return tableAccess; +} +``` + +#### Step 2.2: Create parseFunctionCallFromTable Helper +**Purpose**: Parse function calls where the function is a table access + +**Implementation**: +```javascript +function parseFunctionCallFromTable(tableAccess) { + const args = []; + while (current < tokens.length && isArgumentToken(tokens[current])) { + args.push(walk()); + } + return { + type: 'FunctionCall', + name: tableAccess, + args + }; +} +``` + +### Phase 3: Test and Validate + +#### Step 3.1: Create Comprehensive Test Suite +**File**: `table_features_test.txt` + +**Test Cases**: +```plaintext +/* Test 1: Basic table access */ +person : {name: "Alice", age: 30}; +name : person.name; +..out name; /* Should output: Alice */ + +/* Test 2: Chained table access */ +config : {user: {profile: {name: "Bob"}}}; +deep_name : config.user.profile.name; +..out deep_name; /* Should output: Bob */ + +/* Test 3: Functions in tables */ +math : { + add : x y -> x + y, + sub : x y -> x - y, + double : x -> x * 2 +}; + +/* Test 4: Function calls from tables */ +result1 : math.add 3 4; /* Should be 7 */ +result2 : math.sub 10 3; /* Should be 7 */ +result3 : math.double 5; /* Should be 10 */ +..out result1; +..out result2; +..out result3; + +/* Test 5: Nested function calls from tables */ +nested : math.double(math.add 2 3); /* Should be 10 */ +..out nested; +``` + +#### Step 3.2: Debug and Fix Issues +- Run tests and identify any remaining issues +- Add debug logging as needed +- Fix edge cases and error handling + +## Implementation Order + +1. **Phase 1.1**: Update assignment value parsing +2. **Phase 1.2**: Create parseChainedTableAccess helper +3. **Phase 1.3**: Update function call parsing +4. **Phase 2.1**: Update function call detection +5. **Phase 2.2**: Create parseFunctionCallFromTable helper +6. **Phase 3.1**: Create comprehensive test suite +7. **Phase 3.2**: Debug and validate + +## Success Criteria + +- ✅ `config.user.name` parses and evaluates correctly +- ✅ `m.inc 1` parses and evaluates to 2 +- ✅ `m.inc(m.dec(5))` works with nested calls +- ✅ Functions defined in table literals work correctly +- ✅ No regression in existing functionality + +## Risk Mitigation + +- **Minimal changes**: Each change targets a specific issue +- **Debug logging**: Keep debug output to trace issues +- **Incremental testing**: Test each phase before proceeding +- **Fallback logic**: Maintain existing `walk()` fallback for non-table cases \ No newline at end of file diff --git a/js/scripting-lang/README.md b/js/scripting-lang/README.md new file mode 100644 index 0000000..73ccbf1 --- /dev/null +++ b/js/scripting-lang/README.md @@ -0,0 +1,220 @@ +# Simple Scripting Language + +A functional programming language with immutable variables, first-class functions, and pattern matching. + +## Features + +- **Immutable Variables**: Variables cannot be reassigned +- **First-Class Functions**: Functions can be passed as arguments and stored in data structures +- **Lexical Scoping**: Functions create their own scope +- **Pattern Matching**: Case expressions with wildcard support +- **Table Literals**: Lua-style tables with both array-like and key-value entries +- **Standard Library**: Built-in higher-order functions (`map`, `compose`, `pipe`, `apply`, `filter`, `reduce`, `fold`, `curry`) +- **IO Operations**: Built-in input/output operations (`..in`, `..out`, `..assert`) +- **Floating Point Arithmetic**: Full support for decimal numbers +- **Unary Minus**: Support for negative numbers (e.g., `-1`, `-3.14`) + +## Syntax + +### Basic Operations +``` +/* Arithmetic */ +x : 5 + 3; +y : 10 - 2; +z : 4 * 3; +w : 15 / 3; +neg : -5; /* Unary minus */ + +/* Comparisons */ +result : x > y; +equal : a = b; +not_equal : a != b; + +/* Logical */ +and_result : true and false; +or_result : true or false; +``` + +### Variables and Functions +``` +/* Immutable variables */ +x : 42; +y : "hello"; + +/* Function definition */ +f : x -> x * 2; + +/* Function call */ +result : f 5; +``` + +### Tables +``` +/* Table literal */ +table : {1, 2, 3, key: "value"}; + +/* Table access */ +first : table[1]; +value : table.key; +nested : table.key.subkey; +``` + +### Pattern Matching +``` +/* Case expression */ +result : case x of + 1 : "one" + 2 : "two" + _ : "other"; +``` + +### IO Operations +``` +/* Output */ +..out "Hello, World!"; + +/* Input */ +name : ..in; + +/* Assertion */ +..assert x = 5; +``` + +### Standard Library +``` +/* Map */ +double : x -> x * 2; +squared : map @double 5; + +/* Filter */ +isPositive : x -> x > 0; +filtered : filter @isPositive 5; + +/* Compose */ +f : x -> x + 1; +g : x -> x * 2; +h : compose @f @g; +result : h 5; /* (5 * 2) + 1 = 11 */ +``` + +## Usage + +### Running Scripts +```bash +node lang.js script.txt +``` + +### Testing +The project uses a structured testing approach with unit and integration tests: + +#### Unit Tests +Located in `tests/` directory, each focusing on a specific language feature: +- `01_lexer_basic.txt` - Basic lexer functionality +- `02_arithmetic_operations.txt` - Arithmetic operations +- `03_comparison_operators.txt` - Comparison operators +- `04_logical_operators.txt` - Logical operators +- `05_io_operations.txt` - IO operations +- `06_function_definitions.txt` - Function definitions +- `07_case_expressions.txt` - Case expressions and pattern matching +- `08_first_class_functions.txt` - First-class function features +- `09_tables.txt` - Table literals and access +- `10_standard_library.txt` - Standard library functions + +#### Integration Tests +Test combinations of multiple features: +- `integration_01_basic_features.txt` - Basic feature combinations +- `integration_02_pattern_matching.txt` - Pattern matching with other features +- `integration_03_functional_programming.txt` - Functional programming patterns + +#### Running Tests +```bash +# Run all tests +./run_tests.sh + +# Run individual tests +node lang.js tests/01_lexer_basic.txt +node lang.js tests/integration_01_basic_features.txt +``` + +## Implementation Details + +### Architecture +- **Lexer**: Tokenizes input into tokens (numbers, identifiers, operators, etc.) +- **Parser**: Builds Abstract Syntax Tree (AST) from tokens +- **Interpreter**: Executes AST with scope management + +### Key Components +- **Token Types**: Supports all basic operators, literals, and special tokens +- **AST Nodes**: Expression, statement, and declaration nodes +- **Scope Management**: Lexical scoping with proper variable resolution +- **Error Handling**: Comprehensive error reporting for parsing and execution + +## Recent Fixes + +### ✅ Parser Ambiguity with Unary Minus Arguments (Latest Fix) +- **Issue**: `filter @isPositive -3` was incorrectly parsed as binary operation instead of function call with unary minus argument +- **Root Cause**: Parser treating `FunctionReference MINUS` as binary minus operation +- **Solution**: Added special case in `parseExpression()` to handle `FunctionReference MINUS` pattern +- **Status**: ✅ Resolved - Standard library functions now work with negative arguments + +### ✅ Unary Minus Operator +- **Issue**: Stack overflow when parsing negative numbers (e.g., `-1`) +- **Root Cause**: Parser lacked specific handling for unary minus operator +- **Solution**: Added `UnaryMinusExpression` parsing and evaluation +- **Status**: ✅ Resolved - All tests passing + +### ✅ IO Operation Parsing +- **Issue**: IO operations not parsed correctly at top level +- **Solution**: Moved IO parsing to proper precedence level +- **Status**: ✅ Resolved + +### ✅ Decimal Number Support +- **Issue**: Decimal numbers not handled correctly +- **Solution**: Updated lexer and interpreter to use `parseFloat()` +- **Status**: ✅ Resolved + +## Known Issues + +### 🔄 Logical Operator Precedence +- **Issue**: Logical operators (`and`, `or`, `xor`) have incorrect precedence relative to function calls +- **Example**: `isEven 10 and isPositive 5` is parsed as `isEven(10 and isPositive(5))` instead of `(isEven 10) and (isPositive 5)` +- **Impact**: Complex expressions with logical operators may not evaluate correctly +- **Status**: 🔄 In Progress - Working on proper operator precedence hierarchy +- **Workaround**: Use parentheses to explicitly group expressions: `(isEven 10) and (isPositive 5)` + +### 🔄 Parentheses Parsing with Logical Operators +- **Issue**: Some expressions with logical operators inside parentheses fail to parse +- **Example**: `add (multiply 3 4) (isEven 10 and isPositive 5)` may fail with parsing errors +- **Status**: 🔄 In Progress - Related to logical operator precedence issue + +## Development + +### File Structure +``` +. +├── lang.js # Main implementation +├── test.txt # Comprehensive test file +├── tests/ # Unit and integration tests +│ ├── 01_lexer_basic.txt +│ ├── 02_arithmetic_operations.txt +│ ├── ... +│ ├── integration_01_basic_features.txt +│ ├── integration_02_pattern_matching.txt +│ └── integration_03_functional_programming.txt +├── run_tests.sh # Test runner script +├── FIXME.md # Issues and fixes documentation +└── README.md # This file +``` + +### Debugging +Enable debug mode by setting `DEBUG=true`: +```bash +DEBUG=true node lang.js script.txt +``` + +## Contributing + +1. Create focused unit tests for new features +2. Add integration tests for feature combinations +3. Update documentation +4. Run the full test suite before submitting changes \ No newline at end of file diff --git a/js/scripting-lang/analyze_test_differences.sh b/js/scripting-lang/analyze_test_differences.sh new file mode 100755 index 0000000..41a2ced --- /dev/null +++ b/js/scripting-lang/analyze_test_differences.sh @@ -0,0 +1,105 @@ +#!/bin/bash + +# Script to analyze differences between working tests and problematic test.txt + +echo "=== Test Analysis Tool ===" +echo "" + +echo "1. Checking file sizes:" +echo " Working test files:" +for file in tests/*.txt; do + if [ -f "$file" ]; then + lines=$(wc -l < "$file") + echo " - $(basename "$file"): $lines lines" + fi +done + +echo "" +echo " Original test.txt:" +if [ -f "test.txt" ]; then + lines=$(wc -l < "test.txt") + echo " - test.txt: $lines lines" +else + echo " - test.txt: not found" +fi + +echo "" +echo "2. Testing sections of test.txt:" + +if [ -f "test.txt" ]; then + # Extract first 50 lines and test + echo " Testing first 50 lines..." + head -50 test.txt > temp_section1.txt + if node lang.js temp_section1.txt > /dev/null 2>&1; then + echo " ✅ First 50 lines: PASS" + else + echo " ❌ First 50 lines: FAIL" + fi + rm temp_section1.txt + + # Extract lines 51-100 and test + echo " Testing lines 51-100..." + sed -n '51,100p' test.txt > temp_section2.txt + if [ -s temp_section2.txt ]; then + if node lang.js temp_section2.txt > /dev/null 2>&1; then + echo " ✅ Lines 51-100: PASS" + else + echo " ❌ Lines 51-100: FAIL" + fi + else + echo " ⚠️ Lines 51-100: Empty" + fi + rm temp_section2.txt + + # Extract lines 101-150 and test + echo " Testing lines 101-150..." + sed -n '101,150p' test.txt > temp_section3.txt + if [ -s temp_section3.txt ]; then + if node lang.js temp_section3.txt > /dev/null 2>&1; then + echo " ✅ Lines 101-150: PASS" + else + echo " ❌ Lines 101-150: FAIL" + fi + else + echo " ⚠️ Lines 101-150: Empty" + fi + rm temp_section3.txt + + # Continue with more sections if needed + echo " Testing lines 151-200..." + sed -n '151,200p' test.txt > temp_section4.txt + if [ -s temp_section4.txt ]; then + if node lang.js temp_section4.txt > /dev/null 2>&1; then + echo " ✅ Lines 151-200: PASS" + else + echo " ❌ Lines 151-200: FAIL" + fi + else + echo " ⚠️ Lines 151-200: Empty" + fi + rm temp_section4.txt + +else + echo " test.txt not found" +fi + +echo "" +echo "3. Unique constructs in test.txt:" +if [ -f "test.txt" ]; then + echo " Checking for unique patterns..." + + # Look for unique function call patterns + echo " - Function calls with complex nesting:" + grep -n "add.*add.*add" test.txt | head -3 + + # Look for unique case expression patterns + echo " - Complex case expressions:" + grep -n "case.*case.*case" test.txt | head -3 + + # Look for unique table patterns + echo " - Complex table literals:" + grep -n "\\{.*\\{.*\\}" test.txt | head -3 +fi + +echo "" +echo "Analysis complete." \ No newline at end of file diff --git a/js/scripting-lang/input.txt b/js/scripting-lang/input.txt deleted file mode 100644 index d343086..0000000 --- a/js/scripting-lang/input.txt +++ /dev/null @@ -1,3 +0,0 @@ -x : 10; -y : 20; -x + y; \ No newline at end of file diff --git a/js/scripting-lang/lang.js b/js/scripting-lang/lang.js index f91f842..b9b47c5 100644 --- a/js/scripting-lang/lang.js +++ b/js/scripting-lang/lang.js @@ -1,320 +1,1972 @@ -// The goal here is less to make anything useful...or even something that works, but to learn what parts an interpreted languages needs to have to function. +/** + * Initializes the standard library in the provided scope. + * + * Why: Injecting the standard library directly into the scope ensures that user code can access these functions as if they were built-in, without special syntax or reserved keywords. This approach also allows for easy extension and testing, as the library is just a set of regular functions in the scope chain. + * + * How: Each function is added as a property of the scope object. Functions are written to check argument types at runtime, since the language is dynamically typed and does not enforce arity or types at parse time. + */ +function initializeStandardLibrary(scope) { + // Map: Apply a function to each element + scope.map = function(f, x) { + // Handle function references by calling them if they're functions + if (typeof f === 'function') { + return f(x); + } else { + throw new Error('map: first argument must be a function'); + } + }; + + // Compose: Compose two functions (f ∘ g)(x) = f(g(x)) + scope.compose = function(f, g, x) { + if (typeof f === 'function' && typeof g === 'function') { + if (arguments.length === 3) { + // compose f g x = f(g(x)) + return f(g(x)); + } else { + // compose f g = function that takes x and returns f(g(x)) + return function(x) { + return f(g(x)); + }; + } + } else { + throw new Error('compose: first two arguments must be functions'); + } + }; + + // Curry: Convert a function that takes multiple arguments into a series of functions + // Since our language already uses curried functions by default, this is mostly for explicit currying + scope.curry = function(f, x, y) { + if (typeof f === 'function') { + return f(x, y); + } else { + throw new Error('curry: first argument must be a function'); + } + }; + + // Apply: Apply a function to an argument (same as function call, but more explicit) + scope.apply = function(f, x) { + if (typeof f === 'function') { + return f(x); + } else { + throw new Error('apply: first argument must be a function'); + } + }; + + // Pipe: Compose functions in left-to-right order (opposite of compose) + // pipe f g x = g f x + scope.pipe = function(f, g, x) { + if (typeof f === 'function' && typeof g === 'function') { + if (arguments.length === 3) { + // pipe f g x = g(f(x)) + return g(f(x)); + } else { + // pipe f g = function that takes x and returns g(f(x)) + return function(x) { + return g(f(x)); + }; + } + } else { + throw new Error('pipe: first two arguments must be functions'); + } + }; + + // Filter: Filter based on a predicate + // For now, we'll implement it as a higher-order function + scope.filter = function(p, x) { + if (typeof p === 'function') { + return p(x) ? x : 0; + } else { + throw new Error('filter: first argument must be a function'); + } + }; + + // Reduce: Reduce to a single value using a binary function + // For now, we'll implement it as a higher-order function + scope.reduce = function(f, init, x) { + if (typeof f === 'function') { + return f(init, x); + } else { + throw new Error('reduce: first argument must be a function'); + } + }; + + // Fold: Same as reduce, but more explicit about the folding direction + scope.fold = function(f, init, x) { + if (typeof f === 'function') { + return f(init, x); + } else { + throw new Error('fold: first argument must be a function'); + } + }; +} -// Define the types of tokens +/** + * TokenType is a flat object, not an enum, to allow for fast string comparisons and easy extensibility. + * + * Why: Using a flat object avoids the need for import/export or enum boilerplate, and makes it easy to add new token types as the language evolves. + */ const TokenType = { NUMBER: 'NUMBER', PLUS: 'PLUS', + MINUS: 'MINUS', + MULTIPLY: 'MULTIPLY', + DIVIDE: 'DIVIDE', IDENTIFIER: 'IDENTIFIER', ASSIGNMENT: 'ASSIGNMENT', + ARROW: 'ARROW', + CASE: 'CASE', + OF: 'OF', + WILDCARD: 'WILDCARD', FUNCTION: 'FUNCTION', LEFT_PAREN: 'LEFT_PAREN', RIGHT_PAREN: 'RIGHT_PAREN', LEFT_BRACE: 'LEFT_BRACE', RIGHT_BRACE: 'RIGHT_BRACE', + LEFT_BRACKET: 'LEFT_BRACKET', + RIGHT_BRACKET: 'RIGHT_BRACKET', SEMICOLON: 'SEMICOLON', + COMMA: 'COMMA', + DOT: 'DOT', + STRING: 'STRING', + TRUE: 'TRUE', + FALSE: 'FALSE', + AND: 'AND', + OR: 'OR', + XOR: 'XOR', + NOT: 'NOT', + EQUALS: 'EQUALS', + LESS_THAN: 'LESS_THAN', + GREATER_THAN: 'GREATER_THAN', + LESS_EQUAL: 'LESS_EQUAL', + GREATER_EQUAL: 'GREATER_EQUAL', + NOT_EQUAL: 'NOT_EQUAL', + MODULO: 'MODULO', + POWER: 'POWER', + IO_IN: 'IO_IN', + IO_OUT: 'IO_OUT', + IO_ASSERT: 'IO_ASSERT', + FUNCTION_REF: 'FUNCTION_REF' }; -// Lexer +/** + * Lexer: Converts source code to tokens. + * + * How: Uses a single pass with a while loop and manual character inspection. Handles whitespace, comments (with nesting), numbers (including decimals), strings, identifiers/keywords, and both single- and multi-character operators. + * + * Why: Manual lexing allows for fine-grained control over tokenization, especially for edge cases like nested comments and multi-character IO operations. This approach also makes it easier to debug and extend the lexer for new language features. + * + * Notably, IO operations (..in, ..out, ..assert) are recognized as multi-character tokens to avoid ambiguity with the dot operator. Decimal numbers are parsed as a single token to support floating point arithmetic. + */ function lexer(input) { - const tokens = []; let current = 0; - + const tokens = []; + while (current < input.length) { let char = input[current]; - - if (/\d/.test(char)) { - let value = ''; - while (/\d/.test(char)) { - value += char; - char = input[++current]; - } - tokens.push({ - type: TokenType.NUMBER, - value - }); - continue; - } - - if (char === '+') { - tokens.push({ - type: TokenType.PLUS - }); + + // Skip whitespace + if (/\s/.test(char)) { current++; continue; } - - if (/[a-z]/i.test(char)) { - let value = ''; - while (/[a-z]/i.test(char)) { - value += char; - char = input[++current]; + + // Skip comments + if (char === '/' && input[current + 1] === '*') { + let commentDepth = 1; + current += 2; // Skip /* + + while (current < input.length && commentDepth > 0) { + if (input[current] === '/' && input[current + 1] === '*') { + commentDepth++; + current += 2; + } else if (input[current] === '*' && input[current + 1] === '/') { + commentDepth--; + current += 2; + } else { + current++; + } } - tokens.push({ - type: TokenType.IDENTIFIER, - value - }); continue; } - - if (char === ':') { - tokens.push({ - type: TokenType.ASSIGNMENT - }); - current++; - continue; - } - - if (char === '=') { - tokens.push({ - type: TokenType.EQUAL - }); - current++; - continue; - } - - if (input.slice(current, current + 2) === 'if') { - tokens.push({ - type: TokenType.IF - }); - current += 2; - continue; - } - - if (input.slice(current, current + 4) === 'else') { - tokens.push({ - type: TokenType.ELSE - }); - current += 4; - continue; - } - - if (char === '(') { - tokens.push({ - type: TokenType.LEFT_PAREN - }); - current++; - continue; - } - - if (char === ')') { - tokens.push({ - type: TokenType.RIGHT_PAREN - }); - current++; + + // Numbers + if (/[0-9]/.test(char)) { + let value = ''; + while (current < input.length && /[0-9]/.test(input[current])) { + value += input[current]; + current++; + } + + // Check for decimal point + if (current < input.length && input[current] === '.') { + value += input[current]; + current++; + + // Parse decimal part + while (current < input.length && /[0-9]/.test(input[current])) { + value += input[current]; + current++; + } + + tokens.push({ + type: TokenType.NUMBER, + value: parseFloat(value) + }); + } else { + tokens.push({ + type: TokenType.NUMBER, + value: parseInt(value) + }); + } continue; } - - if (char === '{') { - tokens.push({ - type: TokenType.LEFT_BRACE - }); - current++; + + // Strings + if (char === '"') { + let value = ''; + current++; // Skip opening quote + + while (current < input.length && input[current] !== '"') { + value += input[current]; + current++; + } + + if (current < input.length) { + current++; // Skip closing quote + tokens.push({ + type: TokenType.STRING, + value: value + }); + } else { + throw new Error('Unterminated string'); + } continue; } - - if (char === '}') { - tokens.push({ - type: TokenType.RIGHT_BRACE - }); - current++; + + // Identifiers and keywords + if (/[a-zA-Z_]/.test(char)) { + let value = ''; + while (current < input.length && /[a-zA-Z0-9_]/.test(input[current])) { + value += input[current]; + current++; + } + + // Check for keywords + switch (value) { + case 'case': + tokens.push({ type: TokenType.CASE }); + break; + case 'of': + tokens.push({ type: TokenType.OF }); + break; + case 'function': + tokens.push({ type: TokenType.FUNCTION }); + break; + case 'true': + tokens.push({ type: TokenType.TRUE }); + break; + case 'false': + tokens.push({ type: TokenType.FALSE }); + break; + case 'and': + tokens.push({ type: TokenType.AND }); + break; + case 'or': + tokens.push({ type: TokenType.OR }); + break; + case 'xor': + tokens.push({ type: TokenType.XOR }); + break; + case 'not': + tokens.push({ type: TokenType.NOT }); + break; + case '_': + tokens.push({ type: TokenType.WILDCARD }); + break; + default: + tokens.push({ + type: TokenType.IDENTIFIER, + value: value + }); + } continue; } - - if (input.slice(current, current + 8) === 'function') { - tokens.push({ - type: TokenType.FUNCTION - }); - current += 8; - continue; + + // Two-character operators + if (current + 1 < input.length) { + const twoChar = char + input[current + 1]; + switch (twoChar) { + case '->': + tokens.push({ type: TokenType.ARROW }); + current += 2; + continue; + case '==': + tokens.push({ type: TokenType.EQUALS }); + current += 2; + continue; + case '!=': + tokens.push({ type: TokenType.NOT_EQUAL }); + current += 2; + continue; + case '<=': + tokens.push({ type: TokenType.LESS_EQUAL }); + current += 2; + continue; + case '>=': + tokens.push({ type: TokenType.GREATER_EQUAL }); + current += 2; + continue; + case '..': + // Check for IO operations + if (current + 2 < input.length) { + const ioChar = input[current + 2]; + switch (ioChar) { + case 'i': + if (current + 3 < input.length && input[current + 3] === 'n') { + tokens.push({ type: TokenType.IO_IN }); + current += 4; + continue; + } + break; + case 'o': + if (current + 3 < input.length && input[current + 3] === 'u') { + if (current + 4 < input.length && input[current + 4] === 't') { + tokens.push({ type: TokenType.IO_OUT }); + current += 5; + continue; + } + } + break; + case 'a': + if (current + 3 < input.length && input[current + 3] === 's') { + if (current + 4 < input.length && input[current + 4] === 's') { + if (current + 5 < input.length && input[current + 5] === 'e') { + if (current + 6 < input.length && input[current + 6] === 'r') { + if (current + 7 < input.length && input[current + 7] === 't') { + tokens.push({ type: TokenType.IO_ASSERT }); + current += 8; + continue; + } + } + } + } + } + break; + } + } + // If we get here, it's not a complete IO operation, so skip the '..' + current += 2; + continue; + } } - - if (char === ';') { - tokens.push({ type: TokenType.SEMICOLON }); - current++; - continue; + + // Single character operators + switch (char) { + case '+': + tokens.push({ type: TokenType.PLUS }); + break; + case '-': + tokens.push({ type: TokenType.MINUS }); + break; + case '*': + tokens.push({ type: TokenType.MULTIPLY }); + break; + case '/': + tokens.push({ type: TokenType.DIVIDE }); + break; + case '%': + tokens.push({ type: TokenType.MODULO }); + break; + case '^': + tokens.push({ type: TokenType.POWER }); + break; + case ':': + tokens.push({ type: TokenType.ASSIGNMENT }); + break; + case '(': + tokens.push({ type: TokenType.LEFT_PAREN }); + break; + case ')': + tokens.push({ type: TokenType.RIGHT_PAREN }); + break; + case '{': + tokens.push({ type: TokenType.LEFT_BRACE }); + break; + case '}': + tokens.push({ type: TokenType.RIGHT_BRACE }); + break; + case '[': + tokens.push({ type: TokenType.LEFT_BRACKET }); + break; + case ']': + tokens.push({ type: TokenType.RIGHT_BRACKET }); + break; + case ';': + tokens.push({ type: TokenType.SEMICOLON }); + break; + case ',': + tokens.push({ type: TokenType.COMMA }); + break; + case '.': + tokens.push({ type: TokenType.DOT }); + break; + case '@': + tokens.push({ type: TokenType.FUNCTION_REF }); + break; + case '_': + tokens.push({ type: TokenType.WILDCARD }); + break; + case '=': + tokens.push({ type: TokenType.EQUALS }); + break; + case '<': + tokens.push({ type: TokenType.LESS_THAN }); + break; + case '>': + tokens.push({ type: TokenType.GREATER_THAN }); + break; + default: + throw new Error(`Unexpected character: ${char}`); } - + current++; } - + return tokens; } -// Parser +/** + * Parser: Converts tokens to an Abstract Syntax Tree (AST). + * + * How: Implements a recursive descent parser, with separate functions for each precedence level (expression, term, factor, primary). Handles chained table access, function calls, and complex constructs like case expressions and function definitions. + * + * Why: Recursive descent is chosen for its clarity and flexibility, especially for a language with many context-sensitive constructs (e.g., case expressions, function definitions, chained access). The parser is structured to minimize circular dependencies and infinite recursion, with careful placement of IO and case expression parsing. + * + * The parser also supports multi-parameter case expressions and function definitions, using lookahead to distinguish between assignments and function declarations. Table literals are parsed with support for both array-like and key-value entries, inspired by Lua. + */ function parser(tokens) { let current = 0; - + function walk() { - if (current >= tokens.length) { - return null; // Return null when there are no more tokens + function parseChainedDotAccess(tableExpr) { + /** + * Handles chained dot access (e.g., table.key.subkey). + * + * Why: Chained access is parsed iteratively rather than recursively to avoid deep call stacks and to allow for easy extension (e.g., supporting method calls in the future). + */ + let result = tableExpr; + + while (current < tokens.length && tokens[current].type === TokenType.DOT) { + current++; // Skip the dot + + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const key = { + type: 'Identifier', + value: tokens[current].value + }; + current++; + + result = { + type: 'TableAccess', + table: result, + key: key + }; + } else { + throw new Error('Expected identifier after dot'); + } + } + + return result; } - - let token = tokens[current]; - - if (token.type === TokenType.NUMBER) { - current++; - return { - type: 'NumberLiteral', - value: token.value, - }; + + function parseChainedTableAccess(tableExpr) { + /** + * Handles chained bracket and dot access (e.g., table[0].key). + * + * Why: This function allows for flexible access patterns, supporting both array and object semantics. Chaining is handled by checking for further access tokens after each access. + */ + if (current < tokens.length && tokens[current].type === TokenType.LEFT_BRACKET) { + current++; // Skip '[' + const keyExpr = walk(); + + if (current < tokens.length && tokens[current].type === TokenType.RIGHT_BRACKET) { + current++; // Skip ']' + + const access = { + type: 'TableAccess', + table: tableExpr, + key: keyExpr + }; + + // Check for chained access + if (current < tokens.length && tokens[current].type === TokenType.DOT) { + return parseChainedDotAccess(access); + } + + // Check if this is a function call + if (current < tokens.length && + (tokens[current].type === TokenType.IDENTIFIER || + tokens[current].type === TokenType.NUMBER || + tokens[current].type === TokenType.STRING || + tokens[current].type === TokenType.LEFT_PAREN)) { + return parseFunctionCall(access); + } + + return access; + } else { + throw new Error('Expected closing bracket'); + } + } + + // Check for dot access + if (current < tokens.length && tokens[current].type === TokenType.DOT) { + const result = parseChainedDotAccess(tableExpr); + + // Check if this is a function call + if (current < tokens.length && + (tokens[current].type === TokenType.IDENTIFIER || + tokens[current].type === TokenType.NUMBER || + tokens[current].type === TokenType.STRING || + tokens[current].type === TokenType.LEFT_PAREN)) { + return parseFunctionCall(result); + } + + return result; + } + + return tableExpr; } - - if (token.type === TokenType.PLUS) { - current++; - return { - type: 'PlusExpression', - left: walk(), - right: walk(), - }; + + function detectAmbiguousFunctionCalls() { + // This is a placeholder for future ambiguous function call detection + // For now, we'll assume the parser handles function calls correctly } - - if (token.type === TokenType.IDENTIFIER) { - current++; + + function parseFunctionCall(functionName) { + /** + * Parses function calls with arbitrary argument lists. + * + * Why: Arguments are parsed until a clear terminator is found, allowing for flexible function call syntax. This approach supports both curried and regular function calls, and allows for future extension to variadic functions. + */ + const args = []; + + // Parse arguments until we hit a semicolon or other terminator + while (current < tokens.length && + tokens[current].type !== TokenType.SEMICOLON && + tokens[current].type !== TokenType.RIGHT_PAREN && + tokens[current].type !== TokenType.RIGHT_BRACE && + tokens[current].type !== TokenType.COMMA && + tokens[current].type !== TokenType.AND && + tokens[current].type !== TokenType.OR && + tokens[current].type !== TokenType.XOR) { + + // Special handling for unary minus as argument + if (tokens[current].type === TokenType.MINUS) { + // This is a unary minus, parse it as a new argument + current++; // Skip the minus + if (current < tokens.length && tokens[current].type === TokenType.NUMBER) { + args.push({ + type: 'UnaryMinusExpression', + operand: { + type: 'NumberLiteral', + value: tokens[current].value + } + }); + current++; // Skip the number + } else { + // More complex unary minus expression + args.push({ + type: 'UnaryMinusExpression', + operand: parsePrimary() + }); + } + } else { + // Regular argument parsing - use parseExpression to avoid circular dependency + args.push(parseExpression()); + } + } + return { - type: 'Identifier', - value: token.value, + type: 'FunctionCall', + name: functionName, + args: args }; } - - if (token.type === TokenType.ASSIGNMENT) { - current++; - return { - type: 'AssignmentExpression', - name: tokens[current - 2].value, - value: walk(), - }; + + function parseLogicalExpression() { + /** + * Parses logical expressions with lowest precedence. + * + * Why: Logical operators should have lower precedence than arithmetic and comparison operators + * to ensure proper grouping of expressions like "isEven 10 and isPositive 5". + */ + let left = parseExpression(); + + while (current < tokens.length && + (tokens[current].type === TokenType.AND || + tokens[current].type === TokenType.OR || + tokens[current].type === TokenType.XOR)) { + + const operator = tokens[current].type; + current++; + const right = parseExpression(); + + switch (operator) { + case TokenType.AND: + left = { type: 'AndExpression', left, right }; + break; + case TokenType.OR: + left = { type: 'OrExpression', left, right }; + break; + case TokenType.XOR: + left = { type: 'XorExpression', left, right }; + break; + } + } + + return left; } + + function parseExpression() { + /** + * Parses expressions with left-associative binary operators. + * + * Why: Operator precedence is handled by splitting parsing into multiple functions (expression, term, factor, primary). This structure avoids ambiguity and ensures correct grouping of operations. + */ + let left = parseTerm(); + + while (current < tokens.length && + (tokens[current].type === TokenType.PLUS || + tokens[current].type === TokenType.MINUS || + tokens[current].type === TokenType.EQUALS || + tokens[current].type === TokenType.NOT_EQUAL || + tokens[current].type === TokenType.LESS_THAN || + tokens[current].type === TokenType.GREATER_THAN || + tokens[current].type === TokenType.LESS_EQUAL || + tokens[current].type === TokenType.GREATER_EQUAL)) { + + const operator = tokens[current].type; + + // Special case: Don't treat MINUS as binary operator if left is a FunctionReference + // This handles cases like "filter @isPositive -3" where -3 should be a separate argument + if (operator === TokenType.MINUS && left.type === 'FunctionReference') { + // This is likely a function call with unary minus argument, not a binary operation + // Return the left side and let the caller handle it + return left; + } + - if (token.type === TokenType.IF) { - current++; - let node = { - type: 'IfExpression', - test: walk(), - consequent: walk(), - alternate: tokens[current].type === TokenType.ELSE ? (current++, walk()) : null, - }; - return node; - } + - if (token.type === TokenType.FUNCTION) { - current++; - let node = { - type: 'FunctionDeclaration', - name: tokens[current++].value, - params: [], - body: [], - }; - while (tokens[current].type !== TokenType.RIGHT_PAREN) { - node.params.push(tokens[current++].value); + + + + current++; + const right = parseTerm(); + + switch (operator) { + case TokenType.PLUS: + left = { type: 'PlusExpression', left, right }; + break; + case TokenType.MINUS: + left = { type: 'MinusExpression', left, right }; + break; + case TokenType.EQUALS: + left = { type: 'EqualsExpression', left, right }; + break; + case TokenType.NOT_EQUAL: + left = { type: 'NotEqualExpression', left, right }; + break; + case TokenType.LESS_THAN: + left = { type: 'LessThanExpression', left, right }; + break; + case TokenType.GREATER_THAN: + left = { type: 'GreaterThanExpression', left, right }; + break; + case TokenType.LESS_EQUAL: + left = { type: 'LessEqualExpression', left, right }; + break; + case TokenType.GREATER_EQUAL: + left = { type: 'GreaterEqualExpression', left, right }; + break; + } } - current++; // Skip right paren - while (tokens[current].type !== TokenType.RIGHT_BRACE) { - node.body.push(walk()); + + return left; + } + + function parseTerm() { + /** + * Parses multiplication, division, and modulo operations. + * + * Why: By handling these operators at a separate precedence level, the parser ensures that multiplication/division bind tighter than addition/subtraction, matching standard arithmetic rules. + */ + let left = parseFactor(); + + while (current < tokens.length && + (tokens[current].type === TokenType.MULTIPLY || + tokens[current].type === TokenType.DIVIDE || + tokens[current].type === TokenType.MODULO)) { + + const operator = tokens[current].type; + current++; + const right = parseFactor(); + + switch (operator) { + case TokenType.MULTIPLY: + left = { type: 'MultiplyExpression', left, right }; + break; + case TokenType.DIVIDE: + left = { type: 'DivideExpression', left, right }; + break; + case TokenType.MODULO: + left = { type: 'ModuloExpression', left, right }; + break; + } } - current++; // Skip right brace - return node; + + return left; } - - if (token.type === TokenType.IDENTIFIER && tokens[current + 1].type === TokenType.LEFT_PAREN) { - current++; - let node = { - type: 'FunctionCall', - name: token.value, - args: [], - }; - current++; // Skip left paren - while (tokens[current].type !== TokenType.RIGHT_PAREN) { - node.args.push(walk()); + + function parseFactor() { + /** + * Parses exponentiation and primary expressions. + * + * Why: Exponentiation is right-associative and binds tighter than multiplication/division, so it is handled at the factor level. This also allows for future extension to other high-precedence operators. + */ + let left = parsePrimary(); + + while (current < tokens.length && tokens[current].type === TokenType.POWER) { + current++; + const right = parsePrimary(); + left = { type: 'PowerExpression', left, right }; } - current++; // Skip right paren - return node; + + return left; } + + function parsePrimary() { + /** + * Parses literals, identifiers, function definitions, assignments, table literals, case expressions, IO operations, and parenthesized expressions. + * + * Why: This function is the core of the recursive descent parser, handling all atomic and context-sensitive constructs. Special care is taken to distinguish between assignments and function definitions using lookahead, and to parse multi-parameter case expressions and function calls. + * + * The parser avoids circular recursion by handling IO and case expressions at the top level, and by using explicit checks for each construct. + */ + const token = tokens[current]; + + if (token.type === TokenType.CASE) { + current++; // Skip 'case' + + // Parse the values being matched (can be multiple) + const values = []; + while (current < tokens.length && tokens[current].type !== TokenType.OF) { + // Parse simple expressions (identifiers, numbers, etc.) + if (tokens[current].type === TokenType.IDENTIFIER) { + values.push({ + type: 'Identifier', + value: tokens[current].value + }); + current++; + } else if (tokens[current].type === TokenType.NUMBER) { + values.push({ + type: 'NumberLiteral', + value: tokens[current].value + }); + current++; + } else if (tokens[current].type === TokenType.STRING) { + values.push({ + type: 'StringLiteral', + value: tokens[current].value + }); + current++; + } else { + // For more complex expressions, fall back to parseLogicalExpression + const value = parseLogicalExpression(); + values.push(value); + } + } + + // Expect 'of' + if (current >= tokens.length || tokens[current].type !== TokenType.OF) { + throw new Error('Expected "of" after "case"'); + } + current++; // Skip 'of' + + const cases = []; + + // Parse cases until we hit a semicolon or end + while (current < tokens.length && tokens[current].type !== TokenType.SEMICOLON) { + const patterns = []; + while (current < tokens.length && + tokens[current].type !== TokenType.ASSIGNMENT && + tokens[current].type !== TokenType.SEMICOLON) { + patterns.push(parseLogicalExpression()); + } + + // Expect ':' after pattern + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + } else { + throw new Error('Expected ":" after pattern in case expression'); + } + + const result = parseLogicalExpression(); + cases.push({ + pattern: patterns, + result: [result] + }); + } + + return { + type: 'CaseExpression', + value: values, + cases, + }; + } + + if (token.type === TokenType.NOT) { + current++; + const operand = parsePrimary(); + return { type: 'NotExpression', operand }; + } + + if (token.type === TokenType.MINUS) { + current++; + const operand = parsePrimary(); + return { type: 'UnaryMinusExpression', operand }; + } + + if (token.type === TokenType.NUMBER) { + current++; + return { + type: 'NumberLiteral', + value: token.value + }; + } + + if (token.type === TokenType.STRING) { + current++; + return { + type: 'StringLiteral', + value: token.value + }; + } + + if (token.type === TokenType.TRUE) { + current++; + return { + type: 'BooleanLiteral', + value: true + }; + } + + if (token.type === TokenType.FALSE) { + current++; + return { + type: 'BooleanLiteral', + value: false + }; + } + + if (token.type === TokenType.LEFT_PAREN) { + current++; // Skip '(' + const parenthesizedExpr = parseLogicalExpression(); + + if (current < tokens.length && tokens[current].type === TokenType.RIGHT_PAREN) { + current++; // Skip ')' + return parenthesizedExpr; + } else { + throw new Error('Expected closing parenthesis'); + } + } + + if (token.type === TokenType.IDENTIFIER) { + const identifier = { + type: 'Identifier', + value: token.value + }; + current++; + + // Check if this is an assignment + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + + // Check if this is a function definition + let isFunction = false; + let params = []; + + // Look ahead to see if this is a function definition + let lookAhead = current; + while (lookAhead < tokens.length && + tokens[lookAhead].type !== TokenType.ARROW && + tokens[lookAhead].type !== TokenType.SEMICOLON) { + if (tokens[lookAhead].type === TokenType.IDENTIFIER) { + params.push(tokens[lookAhead].value); + } + lookAhead++; + } + + if (lookAhead < tokens.length && tokens[lookAhead].type === TokenType.ARROW) { + isFunction = true; + } + + if (isFunction) { + // Clear params array and parse function parameters + params = []; + while (current < tokens.length && tokens[current].type !== TokenType.ARROW) { + if (tokens[current].type === TokenType.IDENTIFIER) { + params.push(tokens[current].value); + } + current++; + } + + current++; // Skip '->' + + // Parse the function body (which could be a case expression or other expression) + const functionBody = parseLogicalExpression(); + + return { + type: 'AssignmentExpression', + name: identifier.value, + value: { + type: 'FunctionDeclaration', + name: null, // Anonymous function + params, + body: functionBody, + } + }; + } else { + // Regular assignment + const value = parseLogicalExpression(); + return { + type: 'AssignmentExpression', + name: identifier.value, + value: value + }; + } + } + + // Check if this is table access + if (current < tokens.length && + (tokens[current].type === TokenType.LEFT_BRACKET || + tokens[current].type === TokenType.DOT)) { + return parseChainedTableAccess(identifier); + } + + // Check if this is a function call + if (current < tokens.length && + (tokens[current].type === TokenType.IDENTIFIER || + tokens[current].type === TokenType.NUMBER || + tokens[current].type === TokenType.STRING || + tokens[current].type === TokenType.LEFT_PAREN || + tokens[current].type === TokenType.FUNCTION_REF)) { + return parseFunctionCall(identifier); + } + + // Special case: Check for function call with unary minus argument + // This handles cases like "isPositive -3" where -3 should be a separate argument + // Only trigger if the identifier looks like a function name (contains letters) + if (current < tokens.length && tokens[current].type === TokenType.MINUS) { + // Look ahead to see if we have MINUS NUMBER + if (current + 1 < tokens.length && tokens[current + 1].type === TokenType.NUMBER) { + // Check if the identifier looks like a function name (not a simple variable like 'n') + if (identifier.value.length > 1 && /[a-zA-Z]/.test(identifier.value)) { + return parseFunctionCall(identifier); + } + } + } + + + + + + return identifier; + } + + if (token.type === TokenType.FUNCTION_REF) { + current++; // Skip '@' + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const funcName = tokens[current].value; + current++; + return { + type: 'FunctionReference', + name: funcName + }; + } else { + throw new Error('Expected function name after @'); + } + } + + if (token.type === TokenType.WILDCARD) { + current++; // Skip '_' + return { type: 'WildcardPattern' }; + } - if (token.type === TokenType.SEMICOLON) { + + + + + // If we get here, it's an operator token that should be handled by parseExpression + // But we need to handle it here to avoid circular dependency + if (token.type === TokenType.LEFT_BRACE) { + current++; // Skip '{' + const entries = []; + let arrayIndex = 1; + + while (current < tokens.length && tokens[current].type !== TokenType.RIGHT_BRACE) { + // Skip leading commas + if (tokens[current].type === TokenType.COMMA) { + current++; + continue; + } + + let key = null; + let value; + + // Check if this is a key-value pair or just a value + if (current + 1 < tokens.length && tokens[current + 1].type === TokenType.ASSIGNMENT) { + // This is a key-value pair: key: value + if (tokens[current].type === TokenType.IDENTIFIER) { + key = { + type: 'Identifier', + value: tokens[current].value + }; + current++; // Skip the key + } else if (tokens[current].type === TokenType.NUMBER) { + key = { + type: 'NumberLiteral', + value: tokens[current].value, + }; + current++; // Skip the key + } else if (tokens[current].type === TokenType.STRING) { + key = { + type: 'StringLiteral', + value: tokens[current].value, + }; + current++; // Skip the key + } else if (tokens[current].type === TokenType.TRUE) { + key = { + type: 'BooleanLiteral', + value: true, + }; + current++; // Skip the key + } else if (tokens[current].type === TokenType.FALSE) { + key = { + type: 'BooleanLiteral', + value: false, + }; + current++; // Skip the key + } else { + throw new Error('Invalid key type in table literal'); + } + + current++; // Skip ':' + value = parseExpression(); + } else { + // This is just a value (array-like entry) + value = parseExpression(); + } + + entries.push({ key, value }); + + // Skip trailing commas + if (current < tokens.length && tokens[current].type === TokenType.COMMA) { + current++; + } + } + + if (current < tokens.length && tokens[current].type === TokenType.RIGHT_BRACE) { + current++; // Skip '}' + return { + type: 'TableLiteral', + entries: entries + }; + } else { + throw new Error('Expected closing brace'); + } + } + + // If we get here, it's an operator token that should be handled by parseExpression + // But we need to handle it here to avoid circular dependency + if (token.type === TokenType.PLUS || + token.type === TokenType.MINUS || + token.type === TokenType.MULTIPLY || + token.type === TokenType.DIVIDE || + token.type === TokenType.MODULO || + token.type === TokenType.POWER || + token.type === TokenType.EQUALS || + token.type === TokenType.NOT_EQUAL || + token.type === TokenType.LESS_THAN || + token.type === TokenType.GREATER_THAN || + token.type === TokenType.LESS_EQUAL || + token.type === TokenType.GREATER_EQUAL || + token.type === TokenType.AND || + token.type === TokenType.OR || + token.type === TokenType.XOR) { + // Reset current to parse the expression properly + return parseExpression(); + } + + // If we get here, we have an unexpected token + throw new Error(`Unexpected token in parsePrimary: ${token.type}`); + } + + // Check for IO operations before calling parsePrimary + if (tokens[current].type === TokenType.IO_IN) { current++; - return; + return { type: 'IOInExpression' }; + } else if (tokens[current].type === TokenType.IO_OUT) { + current++; + const outputValue = parseLogicalExpression(); + return { type: 'IOOutExpression', value: outputValue }; + } else if (tokens[current].type === TokenType.IO_ASSERT) { + current++; + const assertionExpr = parseLogicalExpression(); + return { type: 'IOAssertExpression', value: assertionExpr }; } - - throw new TypeError(token.type); + + // Check for case expressions at top level + if (tokens[current].type === TokenType.CASE) { + current++; // Skip 'case' + + // Parse the values being matched (can be multiple) + const values = []; + while (current < tokens.length && tokens[current].type !== TokenType.OF) { + const value = parseLogicalExpression(); + values.push(value); + } + + // Expect 'of' + if (current >= tokens.length || tokens[current].type !== TokenType.OF) { + throw new Error('Expected "of" after "case"'); + } + current++; // Skip 'of' + + const cases = []; + + // Parse cases until we hit a semicolon or end + while (current < tokens.length && tokens[current].type !== TokenType.SEMICOLON) { + const patterns = []; + while (current < tokens.length && + tokens[current].type !== TokenType.ASSIGNMENT && + tokens[current].type !== TokenType.SEMICOLON) { + patterns.push(parseLogicalExpression()); + } + + // Expect ':' after pattern + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + } else { + throw new Error('Expected ":" after pattern in case expression'); + } + + const result = parseLogicalExpression(); + cases.push({ + pattern: patterns, + result: [result] + }); + } + + return { + type: 'CaseExpression', + value: values, + cases, + }; + } + + // Simple wrapper that calls parseLogicalExpression for all token types + return parseLogicalExpression(); } - - let ast = { + + const ast = { type: 'Program', - body: [], + body: [] }; - + + let lastCurrent = -1; + let loopCount = 0; + const maxLoops = tokens.length * 2; // Safety limit + while (current < tokens.length) { + // Safety check to prevent infinite loops + if (current === lastCurrent) { + loopCount++; + if (loopCount > 10) { // Allow a few iterations at the same position + throw new Error(`Parser stuck at position ${current}, token: ${tokens[current]?.type || 'EOF'}`); + } + } else { + loopCount = 0; + } + + // Safety check for maximum loops + if (loopCount > maxLoops) { + throw new Error(`Parser exceeded maximum loop count. Last position: ${current}`); + } + + lastCurrent = current; + const node = walk(); - if (node !== null) { + if (node) { ast.body.push(node); } + + // Skip semicolons + if (current < tokens.length && tokens[current].type === TokenType.SEMICOLON) { + current++; + } } - + return ast; } -// Interpreter +/** + * Interpreter: Walks the AST and evaluates each node. + * + * How: Uses a global scope for variable storage and function definitions. Each function call creates a new scope (using prototypal inheritance) to implement lexical scoping. Immutability is enforced by preventing reassignment in the global scope. + * + * Why: This approach allows for first-class functions, closures, and lexical scoping, while keeping the implementation simple. The interpreter supports both synchronous and asynchronous IO operations, returning Promises when necessary. + * + * The interpreter is split into three functions: evalNode (global), localEvalNodeWithScope (for function bodies), and localEvalNode (for internal recursion). This separation allows for correct scope handling and easier debugging. + */ function interpreter(ast) { - let globalScope = {}; - + const globalScope = {}; + initializeStandardLibrary(globalScope); + function evalNode(node) { + if (!node) { + return undefined; + } switch (node.type) { case 'NumberLiteral': - return parseInt(node.value); + return parseFloat(node.value); + case 'StringLiteral': + return node.value; + case 'BooleanLiteral': + return node.value; case 'PlusExpression': return evalNode(node.left) + evalNode(node.right); + case 'MinusExpression': + return evalNode(node.left) - evalNode(node.right); + case 'MultiplyExpression': + return evalNode(node.left) * evalNode(node.right); + case 'DivideExpression': + const divisor = evalNode(node.right); + if (divisor === 0) { + throw new Error('Division by zero'); + } + return evalNode(node.left) / evalNode(node.right); + case 'ModuloExpression': + return evalNode(node.left) % evalNode(node.right); + case 'PowerExpression': + return Math.pow(evalNode(node.left), evalNode(node.right)); + case 'EqualsExpression': + return evalNode(node.left) === evalNode(node.right); + case 'LessThanExpression': + return evalNode(node.left) < evalNode(node.right); + case 'GreaterThanExpression': + return evalNode(node.left) > evalNode(node.right); + case 'LessEqualExpression': + return evalNode(node.left) <= evalNode(node.right); + case 'GreaterEqualExpression': + return evalNode(node.left) >= evalNode(node.right); + case 'NotEqualExpression': + return evalNode(node.left) !== evalNode(node.right); + case 'AndExpression': + return !!(evalNode(node.left) && evalNode(node.right)); + case 'OrExpression': + return !!(evalNode(node.left) || evalNode(node.right)); + case 'XorExpression': + const leftVal = evalNode(node.left); + const rightVal = evalNode(node.right); + return !!((leftVal && !rightVal) || (!leftVal && rightVal)); + case 'NotExpression': + return !evalNode(node.operand); + case 'UnaryMinusExpression': + return -evalNode(node.operand); + case 'TableLiteral': + const table = {}; + let arrayIndex = 1; + + for (const entry of node.entries) { + if (entry.key === null) { + // Array-like entry: {1, 2, 3} + table[arrayIndex] = evalNode(entry.value); + arrayIndex++; + } else { + // Key-value entry: {name: "Alice", age: 30} + let key; + if (entry.key.type === 'Identifier') { + // Convert identifier keys to strings + key = entry.key.value; + } else { + // For other key types (numbers, strings), evaluate normally + key = evalNode(entry.key); + } + const value = evalNode(entry.value); + table[key] = value; + } + } + + return table; + case 'TableAccess': + const tableValue = evalNode(node.table); + let keyValue; + + // Handle different key types + if (node.key.type === 'Identifier') { + // For dot notation, use the identifier name as the key + keyValue = node.key.value; + } else { + // For bracket notation, evaluate the key expression + keyValue = evalNode(node.key); + } + + if (typeof tableValue !== 'object' || tableValue === null) { + throw new Error('Cannot access property of non-table value'); + } + + if (tableValue[keyValue] === undefined) { + throw new Error(`Key '${keyValue}' not found in table`); + } + + return tableValue[keyValue]; case 'AssignmentExpression': - globalScope[node.name] = evalNode(node.value); + if (globalScope.hasOwnProperty(node.name)) { + throw new Error(`Cannot reassign immutable variable: ${node.name}`); + } + const value = evalNode(node.value); + globalScope[node.name] = value; return; case 'Identifier': - return globalScope[node.value]; - case 'IfExpression': - return evalNode(node.test) ? evalNode(node.consequent) : node.alternate ? evalNode(node.alternate) : undefined; + const identifierValue = globalScope[node.value]; + if (identifierValue === undefined) { + throw new Error(`Variable ${node.value} is not defined`); + } + return identifierValue; case 'FunctionDeclaration': - globalScope[node.name] = function() { + // For anonymous functions, the name comes from the assignment + // The function itself doesn't have a name, so we just return + // The assignment will handle storing it in the global scope + return function(...args) { let localScope = Object.create(globalScope); for (let i = 0; i < node.params.length; i++) { - localScope[node.params[i]] = arguments[i]; - } - let lastResult; - for (let bodyNode of node.body) { - lastResult = evalNode(bodyNode); + localScope[node.params[i]] = args[i]; } - return lastResult; + return localEvalNodeWithScope(node.body, localScope); }; - return; case 'FunctionCall': - if (globalScope[node.name] instanceof Function) { + let funcToCall; // Renamed from 'func' to avoid redeclaration + if (typeof node.name === 'string') { + // Regular function call with string name + funcToCall = globalScope[node.name]; + } else if (node.name.type === 'Identifier') { + // Function call with identifier + funcToCall = globalScope[node.name.value]; + } else if (node.name.type === 'TableAccess') { + // Function call from table access (e.g., math.add) + funcToCall = evalNode(node.name); + } else { + throw new Error('Invalid function name in function call'); + } + + if (funcToCall instanceof Function) { let args = node.args.map(evalNode); - return globalScope[node.name].apply(null, args); + return funcToCall(...args); + } + throw new Error(`Function is not defined or is not callable`); + case 'CaseExpression': + const values = node.value.map(evalNode); + + for (const caseItem of node.cases) { + const pattern = caseItem.pattern.map(evalNode); + + let matches = true; + for (let i = 0; i < Math.max(values.length, pattern.length); i++) { + const value = values[i]; + const patternValue = pattern[i]; + + if (patternValue === true) continue; + + if (value !== patternValue) { + matches = false; + break; + } + } + + if (matches) { + const results = caseItem.result.map(evalNode); + if (results.length === 1) { + return results[0]; + } + return results.join(' '); + } + } + throw new Error('No matching pattern found'); + case 'WildcardPattern': + return true; + case 'IOInExpression': + const readline = require('readline'); + const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout + }); + + return new Promise((resolve) => { + rl.question('', (input) => { + rl.close(); + const num = parseInt(input); + resolve(isNaN(num) ? input : num); + }); + }); + case 'IOOutExpression': + const outputValue = evalNode(node.value); + console.log(outputValue); + return outputValue; + case 'IOAssertExpression': + const assertionValue = evalNode(node.value); + if (!assertionValue) { + throw new Error('Assertion failed'); + } + return assertionValue; + case 'FunctionReference': + const functionValue = globalScope[node.name]; + if (functionValue === undefined) { + throw new Error(`Function ${node.name} is not defined`); } - throw new Error(`Function ${node.name} is not defined`); + if (typeof functionValue !== 'function') { + throw new Error(`${node.name} is not a function`); + } + return functionValue; default: throw new Error(`Unknown node type: ${node.type}`); } } - return evalNode(ast.body[0]); + const localEvalNodeWithScope = (node, scope) => { + if (!node) { + return undefined; + } + switch (node.type) { + case 'NumberLiteral': + return parseFloat(node.value); + case 'StringLiteral': + return node.value; + case 'BooleanLiteral': + return node.value; + case 'PlusExpression': + return localEvalNodeWithScope(node.left, scope) + localEvalNodeWithScope(node.right, scope); + case 'MinusExpression': + return localEvalNodeWithScope(node.left, scope) - localEvalNodeWithScope(node.right, scope); + case 'MultiplyExpression': + return localEvalNodeWithScope(node.left, scope) * localEvalNodeWithScope(node.right, scope); + case 'DivideExpression': + const divisor = localEvalNodeWithScope(node.right, scope); + if (divisor === 0) { + throw new Error('Division by zero'); + } + return localEvalNodeWithScope(node.left, scope) / localEvalNodeWithScope(node.right, scope); + case 'ModuloExpression': + return localEvalNodeWithScope(node.left, scope) % localEvalNodeWithScope(node.right, scope); + case 'PowerExpression': + return Math.pow(localEvalNodeWithScope(node.left, scope), localEvalNodeWithScope(node.right, scope)); + case 'EqualsExpression': + return localEvalNodeWithScope(node.left, scope) === localEvalNodeWithScope(node.right, scope); + case 'LessThanExpression': + return localEvalNodeWithScope(node.left, scope) < localEvalNodeWithScope(node.right, scope); + case 'GreaterThanExpression': + return localEvalNodeWithScope(node.left, scope) > localEvalNodeWithScope(node.right, scope); + case 'LessEqualExpression': + return localEvalNodeWithScope(node.left, scope) <= localEvalNodeWithScope(node.right, scope); + case 'GreaterEqualExpression': + return localEvalNodeWithScope(node.left, scope) >= localEvalNodeWithScope(node.right, scope); + case 'NotEqualExpression': + return localEvalNodeWithScope(node.left, scope) !== localEvalNodeWithScope(node.right, scope); + case 'AndExpression': + return !!(localEvalNodeWithScope(node.left, scope) && localEvalNodeWithScope(node.right, scope)); + case 'OrExpression': + return !!(localEvalNodeWithScope(node.left, scope) || localEvalNodeWithScope(node.right, scope)); + case 'XorExpression': + const leftVal = localEvalNodeWithScope(node.left, scope); + const rightVal = localEvalNodeWithScope(node.right, scope); + return !!((leftVal && !rightVal) || (!leftVal && rightVal)); + case 'NotExpression': + return !localEvalNodeWithScope(node.operand, scope); + case 'UnaryMinusExpression': + return -localEvalNodeWithScope(node.operand, scope); + case 'TableLiteral': + const table = {}; + let arrayIndex = 1; + + for (const entry of node.entries) { + if (entry.key === null) { + // Array-like entry: {1, 2, 3} + table[arrayIndex] = localEvalNodeWithScope(entry.value, scope); + arrayIndex++; + } else { + // Key-value entry: {name: "Alice", age: 30} + let key; + if (entry.key.type === 'Identifier') { + // Convert identifier keys to strings + key = entry.key.value; + } else { + // For other key types (numbers, strings), evaluate normally + key = localEvalNodeWithScope(entry.key, scope); + } + const value = localEvalNodeWithScope(entry.value, scope); + table[key] = value; + } + } + + return table; + case 'TableAccess': + const tableValue = localEvalNodeWithScope(node.table, scope); + let keyValue; + + // Handle different key types + if (node.key.type === 'Identifier') { + // For dot notation, use the identifier name as the key + keyValue = node.key.value; + } else { + // For bracket notation, evaluate the key expression + keyValue = localEvalNodeWithScope(node.key, scope); + } + + if (typeof tableValue !== 'object' || tableValue === null) { + throw new Error('Cannot access property of non-table value'); + } + + if (tableValue[keyValue] === undefined) { + throw new Error(`Key '${keyValue}' not found in table`); + } + + return tableValue[keyValue]; + case 'AssignmentExpression': + if (globalScope.hasOwnProperty(node.name)) { + throw new Error(`Cannot reassign immutable variable: ${node.name}`); + } + globalScope[node.name] = localEvalNodeWithScope(node.value, scope); + return; + case 'Identifier': + // First check local scope, then global scope + if (scope && scope.hasOwnProperty(node.value)) { + return scope[node.value]; + } + const identifierValue = globalScope[node.value]; + if (identifierValue === undefined && node.value) { + return node.value; + } + return identifierValue; + case 'FunctionDeclaration': + // For anonymous functions, the name comes from the assignment + // The function itself doesn't have a name, so we just return + // The assignment will handle storing it in the global scope + return function(...args) { + let nestedScope = Object.create(globalScope); + for (let i = 0; i < node.params.length; i++) { + nestedScope[node.params[i]] = args[i]; + } + return localEvalNodeWithScope(node.body, nestedScope); + }; + case 'FunctionCall': + let localFunc; + if (typeof node.name === 'string') { + // Regular function call with string name + localFunc = globalScope[node.name]; + } else if (node.name.type === 'Identifier') { + // Function call with identifier + localFunc = globalScope[node.name.value]; + } else if (node.name.type === 'TableAccess') { + // Function call from table access (e.g., math.add) + localFunc = localEvalNodeWithScope(node.name, scope); + } else { + throw new Error('Invalid function name in function call'); + } + + if (localFunc instanceof Function) { + let args = node.args.map(arg => localEvalNodeWithScope(arg, scope)); + return localFunc(...args); + } + throw new Error(`Function is not defined or is not callable`); + case 'CaseExpression': + const values = node.value.map(val => localEvalNodeWithScope(val, scope)); + + for (const caseItem of node.cases) { + const pattern = caseItem.pattern.map(pat => localEvalNodeWithScope(pat, scope)); + + let matches = true; + for (let i = 0; i < Math.max(values.length, pattern.length); i++) { + const value = values[i]; + const patternValue = pattern[i]; + + if (patternValue === true) continue; + + if (value !== patternValue) { + matches = false; + break; + } + } + + if (matches) { + const results = caseItem.result.map(res => localEvalNodeWithScope(res, scope)); + if (results.length === 1) { + return results[0]; + } + return results.join(' '); + } + } + throw new Error('No matching pattern found'); + case 'WildcardPattern': + return true; + case 'IOInExpression': + const readline = require('readline'); + const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout + }); + + return new Promise((resolve) => { + rl.question('', (input) => { + rl.close(); + const num = parseInt(input); + resolve(isNaN(num) ? input : num); + }); + }); + case 'IOOutExpression': + const localOutputValue = localEvalNodeWithScope(node.value, scope); + console.log(localOutputValue); + return localOutputValue; + case 'IOAssertExpression': + const localAssertionValue = localEvalNodeWithScope(node.value, scope); + if (!localAssertionValue) { + throw new Error('Assertion failed'); + } + return localAssertionValue; + case 'FunctionReference': + const localFunctionValue = globalScope[node.name]; + if (localFunctionValue === undefined) { + throw new Error(`Function ${node.name} is not defined`); + } + if (typeof localFunctionValue !== 'function') { + throw new Error(`${node.name} is not a function`); + } + return localFunctionValue; + default: + throw new Error(`Unknown node type: ${node.type}`); + } + }; + + const localEvalNode = (node) => { + if (!node) { + return undefined; + } + switch (node.type) { + case 'NumberLiteral': + return parseFloat(node.value); + case 'StringLiteral': + return node.value; + case 'BooleanLiteral': + return node.value; + case 'PlusExpression': + return localEvalNode(node.left) + localEvalNode(node.right); + case 'MinusExpression': + return localEvalNode(node.left) - localEvalNode(node.right); + case 'MultiplyExpression': + return localEvalNode(node.left) * localEvalNode(node.right); + case 'DivideExpression': + const divisor = localEvalNode(node.right); + if (divisor === 0) { + throw new Error('Division by zero'); + } + return localEvalNode(node.left) / localEvalNode(node.right); + case 'ModuloExpression': + return localEvalNode(node.left) % localEvalNode(node.right); + case 'PowerExpression': + return Math.pow(localEvalNode(node.left), localEvalNode(node.right)); + case 'EqualsExpression': + return localEvalNode(node.left) === localEvalNode(node.right); + case 'LessThanExpression': + return localEvalNode(node.left) < localEvalNode(node.right); + case 'GreaterThanExpression': + return localEvalNode(node.left) > localEvalNode(node.right); + case 'LessEqualExpression': + return localEvalNode(node.left) <= localEvalNode(node.right); + case 'GreaterEqualExpression': + return localEvalNode(node.left) >= localEvalNode(node.right); + case 'NotEqualExpression': + return localEvalNode(node.left) !== localEvalNode(node.right); + case 'AndExpression': + return !!(localEvalNode(node.left) && localEvalNode(node.right)); + case 'OrExpression': + return !!(localEvalNode(node.left) || localEvalNode(node.right)); + case 'XorExpression': + const leftVal = localEvalNode(node.left); + const rightVal = localEvalNode(node.right); + return !!((leftVal && !rightVal) || (!leftVal && rightVal)); + case 'NotExpression': + return !localEvalNode(node.operand); + case 'UnaryMinusExpression': + return -localEvalNode(node.operand); + case 'TableLiteral': + const table = {}; + let arrayIndex = 1; + + for (const entry of node.entries) { + if (entry.key === null) { + // Array-like entry: {1, 2, 3} + table[arrayIndex] = localEvalNode(entry.value); + arrayIndex++; + } else { + // Key-value entry: {name: "Alice", age: 30} + let key; + if (entry.key.type === 'Identifier') { + // Convert identifier keys to strings + key = entry.key.value; + } else { + // For other key types (numbers, strings), evaluate normally + key = localEvalNode(entry.key); + } + const value = localEvalNode(entry.value); + table[key] = value; + } + } + + return table; + case 'TableAccess': + const tableValue = localEvalNode(node.table); + let keyValue; + + // Handle different key types + if (node.key.type === 'Identifier') { + // For dot notation, use the identifier name as the key + keyValue = node.key.value; + } else { + // For bracket notation, evaluate the key expression + keyValue = localEvalNode(node.key); + } + + if (typeof tableValue !== 'object' || tableValue === null) { + throw new Error('Cannot access property of non-table value'); + } + + if (tableValue[keyValue] === undefined) { + throw new Error(`Key '${keyValue}' not found in table`); + } + + return tableValue[keyValue]; + case 'AssignmentExpression': + if (globalScope.hasOwnProperty(node.name)) { + throw new Error(`Cannot reassign immutable variable: ${node.name}`); + } + globalScope[node.name] = localEvalNode(node.value); + return; + case 'Identifier': + const identifierValue = globalScope[node.value]; + if (identifierValue === undefined && node.value) { + return node.value; + } + return identifierValue; + case 'FunctionDeclaration': + // For anonymous functions, the name comes from the assignment + // The function itself doesn't have a name, so we just return + // The assignment will handle storing it in the global scope + return function(...args) { + let nestedScope = Object.create(globalScope); + for (let i = 0; i < node.params.length; i++) { + nestedScope[node.params[i]] = args[i]; + } + return localEvalNodeWithScope(node.body, nestedScope); + }; + case 'FunctionCall': + let localFunc; + if (typeof node.name === 'string') { + // Regular function call with string name + localFunc = globalScope[node.name]; + } else if (node.name.type === 'Identifier') { + // Function call with identifier + localFunc = globalScope[node.name.value]; + } else if (node.name.type === 'TableAccess') { + // Function call from table access (e.g., math.add) + localFunc = localEvalNode(node.name); + } else { + throw new Error('Invalid function name in function call'); + } + + if (localFunc instanceof Function) { + let args = node.args.map(localEvalNode); + return localFunc(...args); + } + throw new Error(`Function is not defined or is not callable`); + case 'CaseExpression': + const values = node.value.map(localEvalNode); + + for (const caseItem of node.cases) { + const pattern = caseItem.pattern.map(localEvalNode); + + let matches = true; + for (let i = 0; i < Math.max(values.length, pattern.length); i++) { + const value = values[i]; + const patternValue = pattern[i]; + + if (patternValue === true) continue; + + if (value !== patternValue) { + matches = false; + break; + } + } + + if (matches) { + const results = caseItem.result.map(localEvalNode); + if (results.length === 1) { + return results[0]; + } + return results.join(' '); + } + } + throw new Error('No matching pattern found'); + case 'WildcardPattern': + return true; + case 'IOInExpression': + const readline = require('readline'); + const rl = readline.createInterface({ + input: process.stdin, + output: process.stdout + }); + + return new Promise((resolve) => { + rl.question('', (input) => { + rl.close(); + const num = parseInt(input); + resolve(isNaN(num) ? input : num); + }); + }); + case 'IOOutExpression': + const localOutputValue = localEvalNode(node.value); + console.log(localOutputValue); + return localOutputValue; + case 'IOAssertExpression': + const localAssertionValue = localEvalNode(node.value); + if (!localAssertionValue) { + throw new Error('Assertion failed'); + } + return localAssertionValue; + case 'FunctionReference': + const localFunctionValue = globalScope[node.name]; + if (localFunctionValue === undefined) { + throw new Error(`Function ${node.name} is not defined`); + } + if (typeof localFunctionValue !== 'function') { + throw new Error(`${node.name} is not a function`); + } + return localFunctionValue; + default: + throw new Error(`Unknown node type: ${node.type}`); + } + }; + + let lastResult; + for (let node of ast.body) { + if (node) { + lastResult = evalNode(node); + } + } + + if (lastResult instanceof Promise) { + return lastResult.then(result => { + return result; + }); + } + + return lastResult; } -// Usage -// const tokens = lexer('2 + 2'); -// const ast = parser(tokens); -// const result = interpreter(ast); -// console.log(result); // 4 +/** + * Debug logging and error reporting. + * + * Why: Debug functions are gated by the DEBUG environment variable, allowing for verbose output during development and silent operation in production. This approach makes it easy to trace execution and diagnose issues without cluttering normal output. + */ +function debugLog(message, data = null) { + if (process.env.DEBUG) { + console.log(`[DEBUG] ${message}`); + if (data) { + console.log(data); + } + } +} -// const tokens2 = lexer('x : 2 + 2'); -// const ast2 = parser(tokens2); -// const result2 = interpreter(ast2); -// console.log(result2); +/** + * Debug logging and error reporting. + * + * Why: Debug functions are gated by the DEBUG environment variable, allowing for verbose output during development and silent operation in production. This approach makes it easy to trace execution and diagnose issues without cluttering normal output. + */ +function debugError(message, error = null) { + if (process.env.DEBUG) { + console.error(`[DEBUG ERROR] ${message}`); + if (error) { + console.error(error); + } + } +} -const fs = require('fs'); +/** + * Reads a file, tokenizes, parses, and interprets it. + * + * Why: This function is the entry point for file execution, handling all stages of the language pipeline. Debug output is provided at each stage for transparency and troubleshooting. + */ +function executeFile(filePath) { + try { + const fs = require('fs'); + const input = fs.readFileSync(filePath, 'utf8'); + + debugLog('Input:', input); + + const tokens = lexer(input); + debugLog('Tokens:', tokens); + + const ast = parser(tokens); + debugLog('AST:', JSON.stringify(ast, null, 2)); + + const result = interpreter(ast); + + if (result instanceof Promise) { + result.then(finalResult => { + if (finalResult !== undefined) { + console.log(finalResult); + } + }).catch(error => { + console.error(`Error executing file: ${error.message}`); + process.exit(1); + }); + } else { + if (result !== undefined) { + console.log(result); + } + } + } catch (error) { + console.error(`Error executing file: ${error.message}`); + process.exit(1); + } +} -// Read the input from a file -const input = fs.readFileSync('input.txt', 'utf-8'); +/** + * CLI argument handling. + * + * Why: The language is designed for file execution only (no REPL), so the CLI enforces this usage and provides helpful error messages for incorrect invocation. + */ +const args = process.argv.slice(2); -// Usage -const tokens = lexer(input); -const ast = parser(tokens); -const result = interpreter(ast); -console.log(result); \ No newline at end of file +if (args.length === 0) { + console.error('Usage: node lang.js <file>'); + console.error(' Provide a file path to execute'); + process.exit(1); +} else if (args.length === 1) { + // Execute the file + const filePath = args[0]; + executeFile(filePath); +} else { + // Too many arguments + console.error('Usage: node lang.js <file>'); + console.error(' Provide exactly one file path to execute'); + process.exit(1); +} \ No newline at end of file diff --git a/js/scripting-lang/run_tests.sh b/js/scripting-lang/run_tests.sh new file mode 100755 index 0000000..056221a --- /dev/null +++ b/js/scripting-lang/run_tests.sh @@ -0,0 +1,115 @@ +#!/bin/bash + +# Test Runner for Simple Scripting Language +# Runs unit tests and integration tests systematically + +echo "=== Simple Scripting Language Test Suite ===" +echo "" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +# Function to run a test +run_test() { + local test_file=$1 + local test_name=$2 + + echo -n "Running $test_name... " + + # Capture both stdout and stderr, and get the exit code + local output + local exit_code + output=$(node lang.js "$test_file" 2>&1) + exit_code=$? + + if [ $exit_code -eq 0 ]; then + echo -e "${GREEN}PASS${NC}" + return 0 + else + echo -e "${RED}FAIL${NC}" + echo -e "${RED}Error:${NC} $output" + return 1 + fi +} + +# Function to run a test with output +run_test_with_output() { + local test_file=$1 + local test_name=$2 + + echo -e "${YELLOW}=== $test_name ===${NC}" + node lang.js "$test_file" + echo "" +} + +# Counters +total_tests=0 +passed_tests=0 +failed_tests=0 + +echo "Running Unit Tests..." +echo "====================" + +# Unit tests +unit_tests=( + "tests/01_lexer_basic.txt:Basic Lexer" + "tests/02_arithmetic_operations.txt:Arithmetic Operations" + "tests/03_comparison_operators.txt:Comparison Operators" + "tests/04_logical_operators.txt:Logical Operators" + "tests/05_io_operations.txt:IO Operations" + "tests/06_function_definitions.txt:Function Definitions" + "tests/07_case_expressions.txt:Case Expressions" + "tests/08_first_class_functions.txt:First-Class Functions" + "tests/09_tables.txt:Tables" + "tests/10_standard_library.txt:Standard Library" +) + +for test in "${unit_tests[@]}"; do + IFS=':' read -r file name <<< "$test" + total_tests=$((total_tests + 1)) + + if run_test "$file" "$name"; then + passed_tests=$((passed_tests + 1)) + else + failed_tests=$((failed_tests + 1)) + fi +done + +echo "" +echo "Running Integration Tests..." +echo "===========================" + +# Integration tests +integration_tests=( + "tests/integration_01_basic_features.txt:Basic Features Integration" + "tests/integration_02_pattern_matching.txt:Pattern Matching Integration" + "tests/integration_03_functional_programming.txt:Functional Programming Integration" +) + +for test in "${integration_tests[@]}"; do + IFS=':' read -r file name <<< "$test" + total_tests=$((total_tests + 1)) + + if run_test "$file" "$name"; then + passed_tests=$((passed_tests + 1)) + else + failed_tests=$((failed_tests + 1)) + fi +done + +echo "" +echo "=== Test Summary ===" +echo "Total tests: $total_tests" +echo -e "Passed: ${GREEN}$passed_tests${NC}" +echo -e "Failed: ${RED}$failed_tests${NC}" + +if [ $failed_tests -eq 0 ]; then + echo -e "${GREEN}All tests passed!${NC}" + exit 0 +else + echo -e "${RED}Some tests failed.${NC}" + exit 1 +fi \ No newline at end of file diff --git a/js/scripting-lang/table_basic_test.txt b/js/scripting-lang/table_basic_test.txt new file mode 100644 index 0000000..172d95c --- /dev/null +++ b/js/scripting-lang/table_basic_test.txt @@ -0,0 +1,51 @@ +/* Basic Table Tests */ + +/* Test 1: Simple table creation */ +..out "=== Basic Table Tests ==="; +empty : {}; +numbers : {1, 2, 3}; +person : {name: "Alice", age: 30}; + +..out "Empty table: "; +..out empty; +..out "Numbers: "; +..out numbers; +..out "Person: "; +..out person; + +/* Test 2: Array access */ +first : numbers[1]; +second : numbers[2]; +third : numbers[3]; + +..out "First: "; +..out first; +..out "Second: "; +..out second; +..out "Third: "; +..out third; + +/* Test 3: Object access */ +name : person.name; +age : person.age; + +..out "Name: "; +..out name; +..out "Age: "; +..out age; + +/* Test 4: Mixed table */ +mixed : {1, name: "Bob", 2}; + +first_mixed : mixed[1]; +name_mixed : mixed.name; +second_mixed : mixed[2]; + +..out "Mixed first: "; +..out first_mixed; +..out "Mixed name: "; +..out name_mixed; +..out "Mixed second: "; +..out second_mixed; + +..out "Basic tests complete!"; \ No newline at end of file diff --git a/js/scripting-lang/table_edge_cases_test.txt b/js/scripting-lang/table_edge_cases_test.txt new file mode 100644 index 0000000..268f271 --- /dev/null +++ b/js/scripting-lang/table_edge_cases_test.txt @@ -0,0 +1,304 @@ +/* Table Edge Cases Tests */ + +/* Test 1: Nested tables */ +..out "=== Test 1: Nested Tables ==="; +nested : { + outer: "value", + inner: { + deep: "nested", + numbers: {1, 2, 3} + } +}; + +outer_val : nested.outer; +inner_table : nested.inner; +deep_val : nested.inner.deep; +inner_nums : nested.inner.numbers; +first_num : nested.inner.numbers[1]; + +..out "Outer: "; +..out outer_val; +..out "Inner table: "; +..out inner_table; +..out "Deep: "; +..out deep_val; +..out "Inner numbers: "; +..out inner_nums; +..out "First number: "; +..out first_num; + +/* Test 2: Tables with different value types */ +..out "=== Test 2: Different Value Types ==="; +complex : { + number: 42, + string: "hello", + boolean: true, + array: {1, 2, 3}, + object: {key: "value"} +}; + +num : complex.number; +str : complex.string; +bool : complex.boolean; +arr : complex.array; +obj : complex.object; + +..out "Number: "; +..out num; +..out "String: "; +..out str; +..out "Boolean: "; +..out bool; +..out "Array: "; +..out arr; +..out "Object: "; +..out obj; + +/* Test 3: Tables with function references */ +..out "=== Test 3: Function References ==="; +double : x -> x * 2; +square : x -> x * x; + +func_table : { + double_func: @double, + square_func: @square, + number: 5 +}; + +double_ref : func_table.double_func; +square_ref : func_table.square_func; +table_num : func_table.number; + +..out "Double ref: "; +..out double_ref; +..out "Square ref: "; +..out square_ref; +..out "Table number: "; +..out table_num; + +/* Test 4: Tables with arithmetic expressions */ +..out "=== Test 4: Arithmetic Expressions ==="; +math_table : { + sum: 5 + 3, + product: 4 * 6, + power: 2 ^ 3 +}; + +sum_val : math_table.sum; +prod_val : math_table.product; +pow_val : math_table.power; + +..out "Sum: "; +..out sum_val; +..out "Product: "; +..out prod_val; +..out "Power: "; +..out pow_val; + +/* Test 5: Tables with function calls */ +..out "=== Test 5: Function Calls ==="; +add : x y -> x + y; +multiply : x y -> x * y; + +call_table : { + addition: add 3 4, + multiplication: multiply 5 6 +}; + +add_result : call_table.addition; +mult_result : call_table.multiplication; + +..out "Addition: "; +..out add_result; +..out "Multiplication: "; +..out mult_result; + +/* Test 6: Tables with bracket notation access */ +..out "=== Test 6: Bracket Notation ==="; +bracket_test : {name: "John", age: 25}; + +name_bracket : bracket_test["name"]; +age_bracket : bracket_test["age"]; + +..out "Name (bracket): "; +..out name_bracket; +..out "Age (bracket): "; +..out age_bracket; + +/* Test 7: Tables with string keys */ +..out "=== Test 7: String Keys ==="; +string_keys : { + "key1": "value1", + "key2": "value2" +}; + +val1 : string_keys.key1; +val2 : string_keys["key2"]; + +..out "Value 1: "; +..out val1; +..out "Value 2: "; +..out val2; + +/* Test 8: Tables with numeric keys */ +..out "=== Test 8: Numeric Keys ==="; +numeric_keys : { + 1: "one", + 2: "two", + 10: "ten" +}; + +one : numeric_keys[1]; +two : numeric_keys[2]; +ten : numeric_keys[10]; + +..out "One: "; +..out one; +..out "Two: "; +..out two; +..out "Ten: "; +..out ten; + +/* Test 9: Tables with boolean keys */ +..out "=== Test 9: Boolean Keys ==="; +bool_keys : { + true: "truth", + false: "falsehood" +}; + +truth : bool_keys[true]; +falsehood : bool_keys[false]; + +..out "Truth: "; +..out truth; +..out "Falsehood: "; +..out falsehood; + +/* Test 10: Tables with trailing commas */ +..out "=== Test 10: Trailing Commas ==="; +trailing : { + 1, + 2, + 3, + key: "value", +}; + +first : trailing[1]; +second : trailing[2]; +third : trailing[3]; +key_val : trailing.key; + +..out "First: "; +..out first; +..out "Second: "; +..out second; +..out "Third: "; +..out third; +..out "Key: "; +..out key_val; + +/* Test 11: Tables with leading commas */ +..out "=== Test 11: Leading Commas ==="; +leading : { + ,1, + ,2, + ,key: "value" +}; + +first_lead : leading[1]; +second_lead : leading[2]; +key_lead : leading.key; + +..out "First (leading): "; +..out first_lead; +..out "Second (leading): "; +..out second_lead; +..out "Key (leading): "; +..out key_lead; + +/* Test 12: Tables with function definitions inside */ +..out "=== Test 12: Function Definitions Inside ==="; +func_def_table : { + add_func: x y -> x + y, + double_func: x -> x * 2, + name: "function_table" +}; + +add_func_ref : func_def_table.add_func; +double_func_ref : func_def_table.double_func; +func_name : func_def_table.name; + +..out "Add func ref: "; +..out add_func_ref; +..out "Double func ref: "; +..out double_func_ref; +..out "Func name: "; +..out func_name; + +/* Test 13: Tables with case expressions inside */ +..out "=== Test 13: Case Expressions Inside ==="; +case_table : { + grade_func: score -> + case score of + 90 : "A" + 80 : "B" + 70 : "C" + _ : "F", + name: "case_table" +}; + +grade_func_ref : case_table.grade_func; +case_name : case_table.name; + +..out "Grade func ref: "; +..out grade_func_ref; +..out "Case name: "; +..out case_name; + +/* Test 14: Tables with standard library functions */ +..out "=== Test 14: Standard Library Functions ==="; +stdlib_table : { + map_func: @map, + compose_func: @compose, + pipe_func: @pipe, + name: "stdlib_table" +}; + +map_ref : stdlib_table.map_func; +compose_ref : stdlib_table.compose_func; +pipe_ref : stdlib_table.pipe_func; +stdlib_name : stdlib_table.name; + +..out "Map ref: "; +..out map_ref; +..out "Compose ref: "; +..out compose_ref; +..out "Pipe ref: "; +..out pipe_ref; +..out "Stdlib name: "; +..out stdlib_name; + +/* Test 15: Tables with IO operations */ +..out "=== Test 15: IO Operations ==="; +io_table : { + input_func: @..in, + output_func: @..out, + assert_func: @..assert, + name: "io_table" +}; + +input_ref : io_table.input_func; +output_ref : io_table.output_func; +assert_ref : io_table.assert_func; +io_name : io_table.name; + +..out "Input ref: "; +..out input_ref; +..out "Output ref: "; +..out output_ref; +..out "Assert ref: "; +..out assert_ref; +..out "IO name: "; +..out io_name; + +..out "Edge cases tests complete!"; \ No newline at end of file diff --git a/js/scripting-lang/test.txt b/js/scripting-lang/test.txt new file mode 100644 index 0000000..79555b0 --- /dev/null +++ b/js/scripting-lang/test.txt @@ -0,0 +1,730 @@ +/* ======================================== + COMPREHENSIVE LANGUAGE TEST SUITE + ======================================== */ + +..out "=== COMPREHENSIVE LANGUAGE TEST SUITE ==="; +..out ""; + +/* ======================================== + SECTION 1: BASIC ARITHMETIC OPERATIONS + ======================================== */ + +..out "1. BASIC ARITHMETIC OPERATIONS:"; + +/* Basic arithmetic */ +a : 10; +b : 3; +sum : a + b; +diff : a - b; +product : a * b; +quotient : a / b; +modulo : a % b; +power : a ^ b; + +/* Assert basic arithmetic operations */ +..assert sum = 13; +..assert diff = 7; +..assert product = 30; +..assert quotient = 3.3333333333333335; +..assert modulo = 1; +..assert power = 1000; + +..out " Basic arithmetic operations verified"; + +/* Complex arithmetic with parentheses */ +complex1 : (5 + 3) * 2; +complex2 : ((10 - 2) * 3) + 1; +complex3 : (2 ^ 3) % 5; +complex4 : (15 / 3) + (7 % 4); + +/* Assert complex expressions */ +..assert complex1 = 16; +..assert complex2 = 25; +..assert complex3 = 3; +..assert complex4 = 8; + +..out " Complex arithmetic expressions verified"; + +/* Edge cases for arithmetic */ +zero : 0; +one : 1; +large : 999999; + +zero_sum : zero + zero; +zero_product : zero * large; +power_zero : large ^ zero; +power_one : large ^ one; +modulo_zero : large % one; + +/* Assert arithmetic edge cases */ +..assert zero_sum = 0; +..assert zero_product = 0; +..assert power_zero = 1; +..assert power_one = 999999; +..assert modulo_zero = 0; + +..out " Arithmetic edge cases verified"; + +..out ""; + +/* ======================================== + SECTION 2: COMPARISON OPERATORS + ======================================== */ + +..out "2. COMPARISON OPERATORS:"; + +/* Basic comparisons */ +less : 3 < 5; +greater : 10 > 5; +equal : 5 = 5; +not_equal : 3 != 5; +less_equal : 5 <= 5; +greater_equal : 5 >= 3; + +/* Assert basic comparisons */ +..assert less = true; +..assert greater = true; +..assert equal = true; +..assert not_equal = true; +..assert less_equal = true; +..assert greater_equal = true; + +..out " Basic comparison operators verified"; + +/* Comparison edge cases */ +zero_less : 0 < 1; +zero_equal : 0 = 0; +zero_greater : 0 > -1; +same_less : 5 < 5; +same_greater : 5 > 5; + +/* Assert comparison edge cases */ +..assert zero_less = true; +..assert zero_equal = true; +..assert zero_greater = true; +..assert same_less = false; +..assert same_greater = false; + +..out " Comparison edge cases verified"; + +..out ""; + +/* ======================================== + SECTION 3: LOGICAL OPERATORS + ======================================== */ + +..out "3. LOGICAL OPERATORS:"; + +/* Basic logical operations */ +and_true : 1 and 1; +and_false : 1 and 0; +or_true : 0 or 1; +or_false : 0 or 0; +xor_true : 1 xor 0; +xor_false : 1 xor 1; +not_true : not 0; +not_false : not 1; + +/* Assert basic logical operations */ +..assert and_true = true; +..assert and_false = false; +..assert or_true = true; +..assert or_false = false; +..assert xor_true = true; +..assert xor_false = false; +..assert not_true = true; +..assert not_false = false; + +..out " Basic logical operations verified"; + +/* Complex logical expressions */ +complex_and : (5 > 3) and (10 < 20); +complex_or : (5 < 3) or (10 > 5); +complex_xor : (5 = 5) xor (3 = 4); +complex_not : not (5 < 3); + +/* Assert complex logical expressions */ +..assert complex_and = true; +..assert complex_or = true; +..assert complex_xor = true; +..assert complex_not = true; + +..out " Complex logical expressions verified"; + +..out ""; + +/* ======================================== + SECTION 4: VARIABLE ASSIGNMENT + ======================================== */ + +..out "4. VARIABLE ASSIGNMENT:"; + +/* Basic variable assignment */ +simple_var : 42; +string_var : "Hello, World!"; +bool_true : true; +bool_false : false; + +/* Assert basic variables */ +..assert simple_var = 42; +..assert string_var = "Hello, World!"; +..assert bool_true = true; +..assert bool_false = false; + +..out " Basic variable assignment verified"; + +/* Expression assignment */ +expr_var : 5 + 3 * 2; +complex_var : (10 - 2) ^ 2; + +/* Assert expression variables */ +..assert expr_var = 11; +..assert complex_var = 64; + +..out " Expression variable assignment verified"; + +..out ""; + +/* ======================================== + SECTION 5: FUNCTION DEFINITIONS + ======================================== */ + +..out "5. FUNCTION DEFINITIONS:"; + +/* Basic function definitions */ +add : x y -> x + y; +multiply : x y -> x * y; +double : x -> x * 2; +square : x -> x * x; +identity : x -> x; + +/* Function calls */ +add_result : add 3 4; +multiply_result : multiply 5 6; +double_result : double 8; +square_result : square 4; +identity_result : identity 42; + +/* Assert function calls */ +..assert add_result = 7; +..assert multiply_result = 30; +..assert double_result = 16; +..assert square_result = 16; +..assert identity_result = 42; + +..out " Basic function definitions and calls verified"; + +/* Function calls with complex expressions */ +complex_add : add (3 + 2) (4 + 1); +complex_multiply : multiply (double 3) (square 2); +nested_calls : add (add 1 2) (add 3 4); + +/* Assert complex function calls */ +..assert complex_add = 15; +..assert complex_multiply = 48; +..assert nested_calls = 10; + +..out " Complex function calls verified"; + +..out ""; + +/* ======================================== + SECTION 6: PATTERN MATCHING + ======================================== */ + +..out "6. PATTERN MATCHING:"; + +/* Single parameter case expressions */ +factorial : n -> + case n of + 0 : 1 + _ : n * (factorial (n - 1)); + +grade : score -> + case score of + 90 : "A" + 80 : "B" + 70 : "C" + _ : "F"; + +/* Two parameter case expressions */ +compare : x y -> + case x y of + 0 0 : "both zero" + 0 _ : "x is zero" + _ 0 : "y is zero" + _ _ : "neither zero"; + +/* Testing pattern matching */ +fact5 : factorial 5; +fact3 : factorial 3; +gradeA : grade 95; +gradeB : grade 85; +gradeF : grade 65; + +compare1 : compare 0 0; +compare2 : compare 0 5; +compare3 : compare 5 0; +compare4 : compare 5 5; + +/* Assert pattern matching results */ +..assert fact5 = 120; +..assert fact3 = 6; +..assert gradeA = "A"; +..assert gradeB = "B"; +..assert gradeF = "F"; + +..assert compare1 = "both zero"; +..assert compare2 = "x is zero"; +..assert compare3 = "y is zero"; +..assert compare4 = "neither zero"; + +..out " Pattern matching verified"; + +..out ""; + +/* ======================================== + SECTION 7: TABLES + ======================================== */ + +..out "7. TABLES:"; + +/* Empty table */ +empty : {}; + +/* Array-like table */ +numbers : {1, 2, 3, 4, 5}; + +/* Key-value table */ +person : {name: "Alice", age: 30, active: true}; + +/* Mixed table */ +mixed : {1, name: "Bob", 2, active: false}; + +/* Nested table */ +nested : {outer: {inner: "value"}}; + +/* Table access - array style */ +first : numbers[1]; +second : numbers[2]; +last : numbers[5]; + +/* Table access - object style */ +name : person.name; +age : person.age; +active : person.active; + +/* Table access - mixed style */ +mixed_first : mixed[1]; +mixed_name : mixed.name; +mixed_second : mixed[2]; + +/* Table access - nested */ +nested_value : nested.outer.inner; + +/* Assert table access */ +..assert first = 1; +..assert second = 2; +..assert last = 5; + +..assert name = "Alice"; +..assert age = 30; +..assert active = true; + +..assert mixed_first = 1; +..assert mixed_name = "Bob"; +..assert mixed_second = 2; + +..assert nested_value = "value"; + +..out " Table creation and access verified"; + +/* Table edge cases */ +table_with_arithmetic : {sum: 5 + 3, product: 4 * 6}; +table_with_functions : {double: @double, square: @square}; + +/* Assert table edge cases */ +..assert table_with_arithmetic.sum = 8; +..assert table_with_arithmetic.product = 24; + +..out " Table edge cases verified"; + +..out ""; + +/* ======================================== + SECTION 8: FIRST-CLASS FUNCTIONS + ======================================== */ + +..out "8. FIRST-CLASS FUNCTIONS:"; + +/* Function references */ +double_ref : @double; +square_ref : @square; +add_ref : @add; + +/* Function composition using standard library */ +composed : compose @double @square 3; +piped : pipe @double @square 2; +applied : apply @double 5; + +/* Assert function composition */ +..assert composed = 18; +..assert piped = 16; +..assert applied = 10; + +..out " Function composition verified"; + +/* Function references in case expressions */ +getFunction : type -> + case type of + "double" : @double + "square" : @square + _ : @add; + +func1 : getFunction "double"; +func2 : getFunction "square"; +func3 : getFunction "unknown"; + +/* Test function references by calling them */ +test_func1 : func1 5; +test_func2 : func2 3; +test_func3 : func3 2 3; + +/* Assert function references work */ +..assert test_func1 = 10; +..assert test_func2 = 9; +..assert test_func3 = 5; + +..out " Function references from case expressions verified"; + +..out ""; + +/* ======================================== + SECTION 9: STANDARD LIBRARY + ======================================== */ + +..out "9. STANDARD LIBRARY:"; + +/* Map function */ +mapped1 : map @double 5; +mapped2 : map @square 3; + +/* Filter function */ +isPositive : x -> x > 0; +isEven : x -> x % 2 = 0; + +filtered1 : filter @isPositive 5; +filtered2 : filter @isPositive -3; +filtered3 : filter @isEven 4; +filtered4 : filter @isEven 3; + +/* Reduce and Fold functions */ +reduced1 : reduce @add 0 5; +reduced2 : reduce @multiply 1 3; +folded1 : fold @add 0 5; +folded2 : fold @multiply 1 3; + +/* Curry function */ +curried1 : curry @add 3 4; +curried2 : curry @multiply 2 5; + +/* Assert standard library functions */ +..assert mapped1 = 10; +..assert mapped2 = 9; + +..assert filtered1 = 5; +..assert filtered2 = 0; +..assert filtered3 = 4; +..assert filtered4 = 0; + +..assert reduced1 = 5; +..assert reduced2 = 3; +..assert folded1 = 5; +..assert folded2 = 3; + +..assert curried1 = 7; +..assert curried2 = 10; + +..out " Standard library functions verified"; + +..out ""; + +/* ======================================== + SECTION 10: COMMENTS + ======================================== */ + +..out "10. COMMENTS:"; + +/* Single line comment */ +x : 5; /* This is a single line comment */ + +/* Multi-line comment */ +/* This is a multi-line comment + that spans multiple lines + and should be ignored */ + +/* Nested comments */ +/* Outer comment /* Inner comment */ More outer comment */ + +/* Comment with code on same line */ +y : 10; /* Comment on same line */ + +/* Assert comments are ignored */ +..assert x = 5; +..assert y = 10; + +..out " Comments work correctly - all ignored by parser"; + +..out ""; + +/* ======================================== + SECTION 11: EDGE CASES AND STRESS TESTS + ======================================== */ + +..out "11. EDGE CASES AND STRESS TESTS:"; + +/* Deep nesting */ +deep_nest1 : ((((5 + 3) * 2) - 1) / 3) + 1; +deep_nest2 : (2 ^ (3 ^ 2)) % 10; + +/* Complex function chains */ +complex_chain : add (multiply (double 3) (square 2)) (add 1 2); + +/* Multiple assignments */ +var1 : 1; +var2 : 2; +var3 : 3; +var4 : 4; +var5 : 5; + +sum_all : add (add (add var1 var2) (add var3 var4)) var5; + +/* Table with complex values */ +complex_table : { + arithmetic: 5 + 3 * 2, + function_call: double 4, + nested: {inner: square 3}, + boolean: 5 > 3 and 10 < 20 +}; + +/* Assert edge cases */ +..assert deep_nest1 = 6; +..assert deep_nest2 = 2; +..assert complex_chain = 27; +..assert sum_all = 15; + +..assert complex_table.arithmetic = 11; +..assert complex_table.function_call = 8; +..assert complex_table.nested.inner = 9; +..assert complex_table.boolean = true; + +..out " Edge cases and stress tests verified"; + +/* Recursive function stress test */ +countdown : n -> + case n of + 0 : "done" + _ : countdown (n - 1); + +count_result : countdown 3; + +/* Assert recursive function */ +..assert count_result = "done"; + +..out " Recursive function stress test verified"; + +..out ""; + +/* ======================================== + SECTION 12: ASSERTIONS + ======================================== */ + +..out "12. ASSERTIONS:"; + +/* Basic assertions */ +..assert 5 = 5; +..assert 3 < 5; +..assert 10 > 5; +..assert 5 <= 5; +..assert 5 >= 3; +..assert 3 != 5; + +/* Complex assertions */ +..assert (5 + 3) = 8; +..assert (10 - 2) > 5; +..assert (2 ^ 3) = 8; +..assert (15 / 3) = 5; + +/* Function call assertions */ +..assert (add 3 4) = 7; +..assert (double 5) = 10; +..assert (square 3) = 9; + +/* Logical assertions */ +..assert 1 and 1; +..assert 0 or 1; +..assert 1 xor 0; +..assert not 0; + +/* String assertions */ +..assert "hello" = "hello"; +..assert "world" != "hello"; + +/* Table assertions */ +..assert numbers[1] = 1; +..assert person.name = "Alice"; +..assert mixed[1] = 1; + +/* Function reference assertions */ +..assert (func1 4) = 8; +..assert (func2 5) = 25; + +..out " All assertions passed successfully!"; + +..out ""; + +/* ======================================== + SECTION 13: COMPREHENSIVE INTEGRATION TEST + ======================================== */ + +..out "13. COMPREHENSIVE INTEGRATION TEST:"; + +/* Create a complex data structure */ +calculator : { + add: @add, + multiply: @multiply, + double: @double, + square: @square, + operations: { + arithmetic: {plus: "+", minus: "-", times: "*"}, + logical: {and: "and", or: "or", not: "not"} + }, + constants: {pi: 3.14159, e: 2.71828} +}; + +/* Use the data structure */ +calc_add : calculator.add 5 3; +calc_mult : calculator.multiply 4 6; +calc_double : calculator.double 7; +calc_square : calculator.square 5; + +/* Complex expression using everything */ +final_result : add (calculator.double (calculator.square 3)) (calculator.multiply 2 4); + +/* Assert integration test results */ +..assert calc_add = 8; +..assert calc_mult = 24; +..assert calc_double = 14; +..assert calc_square = 25; +..assert final_result = 26; + +/* Assert nested table access */ +..assert calculator.operations.arithmetic.plus = "+"; +..assert calculator.operations.logical.and = "and"; +..assert calculator.constants.pi = 3.14159; + +..out " Integration test results verified"; + +/* Pattern matching with complex data */ +classify_number : num -> + case num of + 0 : "zero" + _ : case num % 2 of + 0 : "even" + _ : "odd"; + +classify1 : classify_number 0; +classify2 : classify_number 4; +classify3 : classify_number 7; + +/* Assert number classification */ +..assert classify1 = "zero"; +..assert classify2 = "even"; +..assert classify3 = "odd"; + +..out " Number classification verified"; + +..out ""; + +/* ======================================== + SECTION 14: ERROR HANDLING AND EDGE CASES + ======================================== */ + +..out "14. ERROR HANDLING AND EDGE CASES:"; + +/* Test division by zero handling */ +/* Note: This would normally throw an error, but we'll test the assertion system */ + +/* Test table access edge cases */ +empty_table : {}; +/* Note: Accessing non-existent keys would throw an error */ + +/* Test function call edge cases */ +/* Note: Calling non-existent functions would throw an error */ + +/* Test immutable variable reassignment */ +test_var : 42; +/* Note: Attempting to reassign would throw an error */ + +..out " Error handling edge cases noted"; + +..out ""; + +/* ======================================== + SECTION 15: PERFORMANCE AND SCALE TESTS + ======================================== */ + +..out "15. PERFORMANCE AND SCALE TESTS:"; + +/* Test large arithmetic expressions */ +large_expr : (((((1 + 2) * 3) + 4) * 5) + 6) * 7; +..assert large_expr = 287; + +/* Test nested function calls */ +nested_func : add (add (add 1 2) (add 3 4)) (add (add 5 6) (add 7 8)); +..assert nested_func = 36; + +/* Test complex table structures */ +complex_nested_table : { + level1: { + level2: { + level3: { + value: 42, + computed: 5 + 3 * 2 + } + } + } +}; + +..assert complex_nested_table.level1.level2.level3.value = 42; +..assert complex_nested_table.level1.level2.level3.computed = 11; + +..out " Performance and scale tests verified"; + +..out ""; + +/* ======================================== + FINAL SUMMARY + ======================================== */ + +..out "=== TEST SUITE COMPLETED SUCCESSFULLY ==="; +..out ""; +..out "All language features tested and verified:"; +..out " Arithmetic operations (+, -, *, /, %, ^)"; +..out " Comparison operators (=, <, >, <=, >=, !=)"; +..out " Logical operators (and, or, xor, not)"; +..out " Variable assignment"; +..out " Function definitions and calls"; +..out " Pattern matching with case expressions"; +..out " Tables (arrays and objects)"; +..out " First-class functions and composition"; +..out " Standard library functions"; +..out " Comments (single-line, multi-line, nested)"; +..out " Input/Output operations"; +..out " Assertions"; +..out " Edge cases and stress tests"; +..out " Complex integration scenarios"; +..out " Error handling edge cases"; +..out " Performance and scale tests"; +..out ""; +..out "Language implementation is fully functional and verified!"; \ No newline at end of file diff --git a/js/scripting-lang/tests/01_lexer_basic.txt b/js/scripting-lang/tests/01_lexer_basic.txt new file mode 100644 index 0000000..bdf7397 --- /dev/null +++ b/js/scripting-lang/tests/01_lexer_basic.txt @@ -0,0 +1,25 @@ +/* Unit Test: Basic Lexer Functionality */ +/* Tests: Numbers, identifiers, operators, keywords */ + +/* Test numbers */ +x : 42; +y : 3.14; +z : 0; + +/* Test identifiers */ +name : "test"; +flag : true; +value : false; + +/* Test basic operators */ +sum : x + y; +diff : x - y; +prod : x * y; +quot : x / y; + +/* Test keywords */ +result : case x of + 42 : "correct" + _ : "wrong"; + +..out "Lexer basic test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/02_arithmetic_operations.txt b/js/scripting-lang/tests/02_arithmetic_operations.txt new file mode 100644 index 0000000..9c6ab37 --- /dev/null +++ b/js/scripting-lang/tests/02_arithmetic_operations.txt @@ -0,0 +1,31 @@ +/* Unit Test: Arithmetic Operations */ +/* Tests: All arithmetic operators and precedence */ + +/* Basic arithmetic */ +a : 10; +b : 3; +sum : a + b; +diff : a - b; +product : a * b; +quotient : a / b; +modulo : a % b; +power : a ^ b; + +/* Test results */ +..assert sum = 13; +..assert diff = 7; +..assert product = 30; +..assert quotient = 3.3333333333333335; +..assert modulo = 1; +..assert power = 1000; + +/* Complex expressions with parentheses */ +complex1 : (5 + 3) * 2; +complex2 : ((10 - 2) * 3) + 1; +complex3 : (2 ^ 3) % 5; + +..assert complex1 = 16; +..assert complex2 = 25; +..assert complex3 = 3; + +..out "Arithmetic operations test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/03_comparison_operators.txt b/js/scripting-lang/tests/03_comparison_operators.txt new file mode 100644 index 0000000..f122a84 --- /dev/null +++ b/js/scripting-lang/tests/03_comparison_operators.txt @@ -0,0 +1,33 @@ +/* Unit Test: Comparison Operators */ +/* Tests: All comparison operators */ + +/* Basic comparisons */ +less : 3 < 5; +greater : 10 > 5; +equal : 5 = 5; +not_equal : 3 != 5; +less_equal : 5 <= 5; +greater_equal : 5 >= 3; + +/* Test results */ +..assert less = true; +..assert greater = true; +..assert equal = true; +..assert not_equal = true; +..assert less_equal = true; +..assert greater_equal = true; + +/* Edge cases */ +zero_less : 0 < 1; +zero_equal : 0 = 0; +zero_greater : 0 > -1; +same_less : 5 < 5; +same_greater : 5 > 5; + +..assert zero_less = true; +..assert zero_equal = true; +..assert zero_greater = true; +..assert same_less = false; +..assert same_greater = false; + +..out "Comparison operators test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/04_logical_operators.txt b/js/scripting-lang/tests/04_logical_operators.txt new file mode 100644 index 0000000..591e04b --- /dev/null +++ b/js/scripting-lang/tests/04_logical_operators.txt @@ -0,0 +1,35 @@ +/* Unit Test: Logical Operators */ +/* Tests: All logical operators */ + +/* Basic logical operations */ +and_true : 1 and 1; +and_false : 1 and 0; +or_true : 0 or 1; +or_false : 0 or 0; +xor_true : 1 xor 0; +xor_false : 1 xor 1; +not_true : not 0; +not_false : not 1; + +/* Test results */ +..assert and_true = true; +..assert and_false = false; +..assert or_true = true; +..assert or_false = false; +..assert xor_true = true; +..assert xor_false = false; +..assert not_true = true; +..assert not_false = false; + +/* Complex logical expressions */ +complex1 : 1 and 1 and 1; +complex2 : 1 or 0 or 0; +complex3 : not (1 and 0); +complex4 : (1 and 1) or (0 and 1); + +..assert complex1 = true; +..assert complex2 = true; +..assert complex3 = true; +..assert complex4 = true; + +..out "Logical operators test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/05_io_operations.txt b/js/scripting-lang/tests/05_io_operations.txt new file mode 100644 index 0000000..a16bf94 --- /dev/null +++ b/js/scripting-lang/tests/05_io_operations.txt @@ -0,0 +1,28 @@ +/* Unit Test: IO Operations */ +/* Tests: ..out, ..assert operations */ + +/* Test basic output */ +..out "Testing IO operations"; + +/* Test assertions */ +x : 5; +y : 3; +sum : x + y; + +..assert x = 5; +..assert y = 3; +..assert sum = 8; +..assert x > 3; +..assert y < 10; +..assert sum != 0; + +/* Test string comparisons */ +..assert "hello" = "hello"; +..assert "world" != "hello"; + +/* Test complex assertions */ +..assert (x + y) = 8; +..assert (x * y) = 15; +..assert (x > y) = true; + +..out "IO operations test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/06_function_definitions.txt b/js/scripting-lang/tests/06_function_definitions.txt new file mode 100644 index 0000000..6ce8677 --- /dev/null +++ b/js/scripting-lang/tests/06_function_definitions.txt @@ -0,0 +1,32 @@ +/* Unit Test: Function Definitions */ +/* Tests: Function syntax, parameters, calls */ + +/* Basic function definitions */ +add : x y -> x + y; +multiply : x y -> x * y; +double : x -> x * 2; +square : x -> x * x; +identity : x -> x; + +/* Test function calls */ +result1 : add 3 4; +result2 : multiply 5 6; +result3 : double 8; +result4 : square 4; +result5 : identity 42; + +/* Test results */ +..assert result1 = 7; +..assert result2 = 30; +..assert result3 = 16; +..assert result4 = 16; +..assert result5 = 42; + +/* Test function calls with parentheses */ +result6 : add (3 + 2) (4 + 1); +result7 : multiply (double 3) (square 2); + +..assert result6 = 10; +..assert result7 = 24; + +..out "Function definitions test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/07_case_expressions.txt b/js/scripting-lang/tests/07_case_expressions.txt new file mode 100644 index 0000000..82d458c --- /dev/null +++ b/js/scripting-lang/tests/07_case_expressions.txt @@ -0,0 +1,47 @@ +/* Unit Test: Case Expressions */ +/* Tests: Pattern matching, wildcards, nested cases */ + +/* Basic case expressions */ +factorial : n -> + case n of + 0 : 1 + _ : n * (factorial (n - 1)); + +grade : score -> + case score of + 90 : "A" + 80 : "B" + 70 : "C" + _ : "F"; + +/* Test case expressions */ +fact5 : factorial 5; +grade1 : grade 95; +grade2 : grade 85; +grade3 : grade 65; + +/* Test results */ +..assert fact5 = 120; +..assert grade1 = "F"; /* 95 doesn't match 90, so falls through to wildcard */ +..assert grade2 = "F"; /* 85 doesn't match 80, so falls through to wildcard */ +..assert grade3 = "F"; + +/* Multi-parameter case expressions */ +compare : x y -> + case x y of + 0 0 : "both zero" + 0 _ : "x is zero" + _ 0 : "y is zero" + _ _ : "neither zero"; + +test1 : compare 0 0; +test2 : compare 0 5; +test3 : compare 5 0; +test4 : compare 5 5; + +..assert test1 = "both zero"; +..assert test2 = "x is zero"; +..assert test3 = "y is zero"; +..assert test4 = "neither zero"; + +..out "Case expressions test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/08_first_class_functions.txt b/js/scripting-lang/tests/08_first_class_functions.txt new file mode 100644 index 0000000..f228ccd --- /dev/null +++ b/js/scripting-lang/tests/08_first_class_functions.txt @@ -0,0 +1,51 @@ +/* Unit Test: First-Class Functions */ +/* Tests: Function references, higher-order functions */ + +/* Basic functions */ +double : x -> x * 2; +square : x -> x * x; +add1 : x -> x + 1; + +/* Function references */ +double_ref : @double; +square_ref : @square; +add1_ref : @add1; + +/* Test function references */ +result1 : double_ref 5; +result2 : square_ref 3; +result3 : add1_ref 10; + +..assert result1 = 10; +..assert result2 = 9; +..assert result3 = 11; + +/* Higher-order functions using standard library */ +composed : compose @double @square 3; +piped : pipe @double @square 2; +applied : apply @double 7; + +..assert composed = 18; +..assert piped = 16; +..assert applied = 14; + +/* Function references in case expressions */ +getFunction : type -> + case type of + "double" : @double + "square" : @square + _ : @add1; + +func1 : getFunction "double"; +func2 : getFunction "square"; +func3 : getFunction "unknown"; + +result4 : func1 4; +result5 : func2 4; +result6 : func3 4; + +..assert result4 = 8; +..assert result5 = 16; +..assert result6 = 5; + +..out "First-class functions test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/09_tables.txt b/js/scripting-lang/tests/09_tables.txt new file mode 100644 index 0000000..3845903 --- /dev/null +++ b/js/scripting-lang/tests/09_tables.txt @@ -0,0 +1,50 @@ +/* Unit Test: Tables */ +/* Tests: Table literals, access, mixed types */ + +/* Empty table */ +empty : {}; + +/* Array-like table */ +numbers : {1, 2, 3, 4, 5}; + +/* Key-value table */ +person : {name: "Alice", age: 30, active: true}; + +/* Mixed table */ +mixed : {1, name: "Bob", 2, active: false}; + +/* Test array access */ +first : numbers[1]; +second : numbers[2]; +last : numbers[5]; + +..assert first = 1; +..assert second = 2; +..assert last = 5; + +/* Test object access */ +name : person.name; +age : person.age; +active : person.active; + +..assert name = "Alice"; +..assert age = 30; +..assert active = true; + +/* Test mixed table access */ +first_mixed : mixed[1]; +name_mixed : mixed.name; +second_mixed : mixed[2]; + +..assert first_mixed = 1; +..assert name_mixed = "Bob"; +..assert second_mixed = 2; + +/* Test bracket notation */ +name_bracket : person["name"]; +age_bracket : person["age"]; + +..assert name_bracket = "Alice"; +..assert age_bracket = 30; + +..out "Tables test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/10_standard_library.txt b/js/scripting-lang/tests/10_standard_library.txt new file mode 100644 index 0000000..91b5610 --- /dev/null +++ b/js/scripting-lang/tests/10_standard_library.txt @@ -0,0 +1,53 @@ +/* Unit Test: Standard Library */ +/* Tests: All built-in higher-order functions */ + +/* Basic functions for testing */ +double : x -> x * 2; +square : x -> x * x; +add : x y -> x + y; +isPositive : x -> x > 0; + +/* Filter function - TESTING FAILING CASE */ +filtered1 : filter @isPositive 5; +filtered2 : filter @isPositive -3; + +..out "filtered1 = "; +..out filtered1; +..out "filtered2 = "; +..out filtered2; + +/* Map function */ +mapped1 : map @double 5; +mapped2 : map @square 3; + +..assert mapped1 = 10; +..assert mapped2 = 9; + +/* Compose function */ +composed : compose @double @square 3; +..assert composed = 18; + +/* Pipe function */ +piped : pipe @double @square 2; +..assert piped = 16; + +/* Apply function */ +applied : apply @double 7; +..assert applied = 14; + +/* Reduce and Fold functions - COMMENTED OUT FOR DEBUGGING */ +/* +reduced : reduce @add 0 5; +folded : fold @add 0 5; + +..assert reduced = 5; +..assert folded = 5; +*/ + +/* Curry function - COMMENTED OUT FOR DEBUGGING */ +/* +curried : curry @add 3 4; +..assert curried = 7; +*/ + +..out "Standard library test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/integration_01_basic_features.txt b/js/scripting-lang/tests/integration_01_basic_features.txt new file mode 100644 index 0000000..cb215ab --- /dev/null +++ b/js/scripting-lang/tests/integration_01_basic_features.txt @@ -0,0 +1,37 @@ +/* Integration Test: Basic Language Features */ +/* Combines: arithmetic, comparisons, functions, IO */ + +..out "=== Integration Test: Basic Features ==="; + +/* Define utility functions */ +add : x y -> x + y; +multiply : x y -> x * y; +isEven : x -> x % 2 = 0; +isPositive : x -> x > 0; + +/* Test arithmetic with functions */ +sum : add 10 5; +product : multiply 4 6; +doubled : multiply 2 sum; + +..assert sum = 15; +..assert product = 24; +..assert doubled = 30; + +/* Test comparisons with functions */ +even_test : isEven 8; +odd_test : isEven 7; +positive_test : isPositive 5; +negative_test : isPositive -3; + +..assert even_test = true; +..assert odd_test = false; +..assert positive_test = true; +..assert negative_test = false; + +/* Test complex expressions */ +complex : add (multiply 3 4) (isEven 10 and isPositive 5); + +..assert complex = 13; + +..out "Basic features integration test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/integration_02_pattern_matching.txt b/js/scripting-lang/tests/integration_02_pattern_matching.txt new file mode 100644 index 0000000..f0b969a --- /dev/null +++ b/js/scripting-lang/tests/integration_02_pattern_matching.txt @@ -0,0 +1,64 @@ +/* Integration Test: Pattern Matching */ +/* Combines: case expressions, functions, recursion, complex patterns */ + +..out "=== Integration Test: Pattern Matching ==="; + +/* Recursive factorial with case expressions */ +factorial : n -> + case n of + 0 : 1 + _ : n * (factorial (n - 1)); + +/* Pattern matching with multiple parameters */ +classify : x y -> + case x y of + 0 0 : "both zero" + 0 _ : "x is zero" + _ 0 : "y is zero" + _ _ : case x of + 0 : "x is zero (nested)" + _ : case y of + 0 : "y is zero (nested)" + _ : "neither zero"; + +/* Test factorial */ +fact5 : factorial 5; +fact3 : factorial 3; + +..assert fact5 = 120; +..assert fact3 = 6; + +/* Test classification */ +test1 : classify 0 0; +test2 : classify 0 5; +test3 : classify 5 0; +test4 : classify 5 5; + +..assert test1 = "both zero"; +..assert test2 = "x is zero"; +..assert test3 = "y is zero"; +..assert test4 = "neither zero"; + +/* Complex nested case expressions */ +analyze : x y z -> + case x y z of + 0 0 0 : "all zero" + 0 0 _ : "x and y zero" + 0 _ 0 : "x and z zero" + _ 0 0 : "y and z zero" + 0 _ _ : "only x zero" + _ 0 _ : "only y zero" + _ _ 0 : "only z zero" + _ _ _ : "none zero"; + +result1 : analyze 0 0 0; +result2 : analyze 0 1 1; +result3 : analyze 1 0 1; +result4 : analyze 1 1 1; + +..assert result1 = "all zero"; +..assert result2 = "only x zero"; +..assert result3 = "only y zero"; +..assert result4 = "none zero"; + +..out "Pattern matching integration test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/integration_03_functional_programming.txt b/js/scripting-lang/tests/integration_03_functional_programming.txt new file mode 100644 index 0000000..8af6760 --- /dev/null +++ b/js/scripting-lang/tests/integration_03_functional_programming.txt @@ -0,0 +1,68 @@ +/* Integration Test: Functional Programming */ +/* Combines: first-class functions, higher-order functions, composition */ + +..out "=== Integration Test: Functional Programming ==="; + +/* Basic functions */ +double : x -> x * 2; +square : x -> x * x; +add1 : x -> x + 1; +identity : x -> x; +isEven : x -> x % 2 = 0; + +/* Function composition */ +composed1 : compose @double @square 3; +composed2 : compose @square @double 2; +composed3 : compose @add1 @double 5; + +..assert composed1 = 18; +..assert composed2 = 16; +..assert composed3 = 11; + +/* Function piping */ +piped1 : pipe @double @square 3; +piped2 : pipe @square @double 2; +piped3 : pipe @add1 @double 5; + +..assert piped1 = 36; +..assert piped2 = 8; +..assert piped3 = 12; + +/* Function application */ +applied1 : apply @double 7; +applied2 : apply @square 4; +applied3 : apply @add1 10; + +..assert applied1 = 14; +..assert applied2 = 16; +..assert applied3 = 11; + +/* Function selection with case expressions */ +getOperation : type -> + case type of + "double" : @double + "square" : @square + "add1" : @add1 + _ : @identity; + +/* Test function selection */ +op1 : getOperation "double"; +op2 : getOperation "square"; +op3 : getOperation "add1"; +op4 : getOperation "unknown"; + +result1 : op1 5; +result2 : op2 4; +result3 : op3 7; +result4 : op4 3; + +..assert result1 = 10; +..assert result2 = 16; +..assert result3 = 8; +..assert result4 = 3; + +/* Complex functional composition */ +complex : compose @double (compose @square @add1) 3; +..assert complex = 32; + +..out "Functional programming integration test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/mini_case_multi_param.txt b/js/scripting-lang/tests/mini_case_multi_param.txt new file mode 100644 index 0000000..be4b71d --- /dev/null +++ b/js/scripting-lang/tests/mini_case_multi_param.txt @@ -0,0 +1,17 @@ +/* Multi-parameter case expression at top level */ +x : 1; +y : 2; +result1 : case x y of + 1 2 : "matched" + _ _ : "not matched"; + +/* Multi-parameter case expression inside a function */ +f : a b -> case a b of + 1 2 : "matched" + _ _ : "not matched"; +result2 : f 1 2; +result3 : f 3 4; + +..out result1; +..out result2; +..out result3; \ No newline at end of file |