diff options
53 files changed, 8504 insertions, 469 deletions
diff --git a/awk/scheme/scheme/README.md b/awk/scheme/scheme/README.md index cf346c7..0b925f4 100644 --- a/awk/scheme/scheme/README.md +++ b/awk/scheme/scheme/README.md @@ -100,6 +100,8 @@ Test categories: - **Examples**: Demonstration programs - **Regression tests**: Edge cases +*Note: The test suite is comprehensive, but some advanced closure/currying and edge-case features are still being debugged. See Known Issues below.* + ## Debugging ### Enable Debug Mode @@ -109,6 +111,11 @@ DEBUG=1 ./scheme program.scm # File with debug echo "(+ 1 2)" | DEBUG=1 ./scheme # Single expression ``` +**S-expression Debugging:** +```bash +DEBUG_SEXPR=1 ./scheme program.scm # Enable detailed S-expression parsing/codegen debug output +``` + ### Debug Output Shows - Token parsing and expression tree construction - VM instruction generation @@ -218,4 +225,8 @@ echo "5 3 + ." | awk -f forth.awk # => Result: N:8 - `bin/vm.awk` - Virtual machine implementation - `bin/repl` - Interactive REPL - `test/` - Comprehensive test suite -- `scratch/forth/` - Forth implementation for VM validation \ No newline at end of file +- `scratch/forth/` - Forth implementation for VM validation + +## Known Issues + +- Some advanced closure/currying and higher-order function tests are still failing and are under active investigation. See WHAT-NEEDS-FIXING.md for current status and debugging plan. diff --git a/awk/scheme/scheme/WHAT-NEEDS-FIXING.md b/awk/scheme/scheme/WHAT-NEEDS-FIXING.md index 99dbfd8..f8b5a0c 100644 --- a/awk/scheme/scheme/WHAT-NEEDS-FIXING.md +++ b/awk/scheme/scheme/WHAT-NEEDS-FIXING.md @@ -3,54 +3,47 @@ ## Current State (as of latest debugging) - **Testing Infrastructure:** - - Test runner and environment variable handling are now robust; DEBUG/DEBUG_SEXPR work as intended. - - Most tests pass (37/51), including basic, integration, and many higher-order function tests. - - 14 tests still fail, primarily those involving advanced closure/currying, nested lambdas, and some edge-case scoping. - -- **Recent Fixes:** - - S-expression splitting and body handling for define/lambda/let are robust and debugged. - - Compiler now emits correct closure construction (CAPTURE_ENV, PUSH_CONST CLOSURE) before RETURN in lambdas. - - Function application parsing and codegen now handle curried and higher-order calls recursively. - - Test runner bug with environment variable passing (DEBUG=1) is fixed. - -- **Current Closure/Currying Bug:** - - Minimal closure/currying tests (e.g., minimal_closure_env, minimal_function_persistence) still fail. - - Symptom: After a chain of curried calls, the final value is a number, but the VM/compiler emits an extra CALL, causing 'Undefined function: N:99' or similar errors. - - The compiler always emits CALL for function applications, even when the result is not a function. - - The test runner workaround (just printing the result) is not sufficient, as the compiler still emits CALL for the last value. - -- **Other Failing Patterns:** - - Some advanced function, closure, and scoping tests (advanced_functions, closures, lambdas, higher_order_functions) still fail, likely due to the same root issue: incorrect codegen or VM handling for returned closures and final values. + - Test runner and environment variable handling are robust; DEBUG/DEBUG_SEXPR work as intended. + - Only 6/51 tests pass; 45 fail, including basic, integration, closure, and higher-order function tests. + - Most failures are silent (no assertion errors/output), indicating expressions are not being evaluated or CALLs are mis-emitted. + +- **Recent Fixes and Attempts:** + - Refactored top-level CALL emission logic in the compiler to match idiomatic Scheme/Lisp behavior: + - Now, CALL is only emitted for top-level compound expressions whose first symbol is not a special form (define, let, lambda, if, cond, and, or, not). + - Special forms are handled by the compiler, not as function calls. + - Helper function added to extract the first symbol from a compound expression string. + - Type-tracking logic for top-level CALL emission has been removed for simplicity and robustness. + - This approach is modeled after working reference implementations (e.g., [maryrosecook/littlelisp](https://raw.githubusercontent.com/maryrosecook/littlelisp/refs/heads/master/littlelisp.js)). + +- **Current Symptoms:** + - Many tests still fail, including basic arithmetic, map, closures, and higher-order functions. + - Failures are mostly silent: no assertion errors, no output, suggesting expressions are not being evaluated or results are not printed. + - Some improvement: a few more tests pass compared to previous attempts, but the majority still fail. ## What Has Been Ruled Out -- For all currently failing tests and with current debug evidence, S-expression splitting and body parsing are robust and not the source of closure/currying bugs. -- The VM constructs and returns closures correctly when the codegen is correct; no VM-level closure bugs are currently indicated. -- The test runner and shell environment are not the source of the remaining failures in the current setup. - -## Next Steps: Plan for Closure/Currying/Function Application Bugs +- The VM and test runner are not the source of the remaining failures. +- S-expression parsing and body handling are robust and not the source of the bug. +- The new CALL emission logic is more correct, but not sufficient to fix all test failures. +- The bug is not due to missing CALLs for assert/display/user-defined function calls at the top level. -1. **Targeted Debugging of Failing Closure/Curried Tests:** - - Focus on minimal_closure_env, minimal_function_persistence, closures, and advanced_functions. - - Use DEBUG_SEXPR=1 and DEBUG=1 to trace codegen and VM execution for these tests. - - Confirm exactly where the extra CALL is emitted and why. +## Next Steps: Plan for Remaining Bugs -2. **Compiler Codegen Review:** - - Review compile_primitive_call and related code to ensure CALL is only emitted when the result is expected to be a function. - - Consider a minimal patch: at the top-level, avoid emitting CALL for the final value if it is not a function. - - Document with TODOs where a more robust, type-aware solution would go. +1. **Targeted Debugging of Failing Tests:** + - Focus on a representative failing test (e.g., basic_numeric_operations, closures, or a simple assert). + - Inspect the generated assembly and VM output for these tests to confirm whether CALL is being emitted and executed as expected. + - Check for missing PRINT/DISPLAY or incorrect stack state after CALL. -3. **VM/Runtime Review:** - - Confirm that the VM leaves the correct value on the stack after each function call, and does not attempt to call non-functions. - - Add debug output if needed to trace stack state after each CALL. +2. **Special Form Handling Review:** + - Ensure that all special forms (let, lambda, if, cond, etc.) are handled correctly and do not result in spurious CALLs or missed evaluation. + - Confirm that nested expressions within special forms are compiled and evaluated as expected. -4. **Test and Iterate:** - - After each fix, re-run the minimal closure/currying tests and confirm progress. +3. **Test and Iterate:** + - After each fix, re-run the minimal and representative tests to confirm progress. - Once minimal tests pass, move to more complex closure and higher-order function tests. -5. **Document Findings:** +4. **Document Findings:** - Update this file after each major fix or discovery, so the next debugging session has a clear starting point. ## Goal (Restated) -- Ensure closure/currying/function application codegen and VM logic are correct for all cases, including nested and returned lambdas. -- Eliminate extra CALLs for non-function values at the top level. +- Ensure top-level and nested expression evaluation is correct for all cases, including special forms, closures, and function applications. - Systematically fix all remaining failing tests by following the above plan. \ No newline at end of file diff --git a/awk/scheme/scheme/bin/compiler.awk b/awk/scheme/scheme/bin/compiler.awk index 864b19c..dec4c22 100755 --- a/awk/scheme/scheme/bin/compiler.awk +++ b/awk/scheme/scheme/bin/compiler.awk @@ -87,14 +87,11 @@ END { function split_expressions(prog, current, paren_count, i, c, expr, cleaned, lines, n, line, in_string, out, j) { current = "" paren_count = 0 - # Improved comment removal: process line by line n = split(prog, lines, "\n") out = "" for (j = 1; j <= n; j++) { line = lines[j] - # Skip lines that start with ';' (comments) if (line ~ /^[ \t]*;/) continue - # Remove inline comments, but not inside strings in_string = 0 cleaned_line = "" for (i = 1; i <= length(line); i++) { @@ -103,101 +100,104 @@ function split_expressions(prog, current, paren_count, i, c, expr, cleaned, line if (!in_string && c == ";") break cleaned_line = cleaned_line c } - # Append cleaned line out = out cleaned_line "\n" } cleaned = out debug("Cleaned program: [" cleaned "]") if (cleaned == "") return - if (cleaned == "") return - - # Parse expressions by tracking parenthesis nesting and string literals - # This approach ensures that parentheses inside strings don't affect - # expression boundaries, and that comments are properly handled - # AWK FEATURE: length(string) returns the length of a string - # Unlike JS string.length, this is a function call, not a property - in_string = 0 # Track if we're inside a string literal - + in_string = 0 for (i = 1; i <= length(cleaned); i++) { c = substr(cleaned, i, 1) - - # Handle string literals if (c == "\"" && !in_string) { in_string = 1 if (paren_count == 0) current = "" } else if (c == "\"" && in_string) { in_string = 0 } - if (c == "(" && !in_string) { if (paren_count == 0) current = "" paren_count++ } - current = current c - if (c == ")" && !in_string) { paren_count-- if (paren_count == 0) { - # Complete expression found - compile it expr = current sub(/^\s+/, "", expr) sub(/\s+$/, "", expr) - debug("Processing expression: [" expr "]") - program = expr # Set for parser + program = expr + expr_str = expr expr = parse_expr() - compile_expr(expr) - # Clear stack between expressions to prevent pollution - print "CLEAR_STACK" # Clear stack between expressions + if (substr(expr_str, 1, 1) == "(") { + op = extract_first_symbol(expr_str) + if (op != "define" && op != "let" && op != "lambda" && op != "if" && op != "cond" && op != "and" && op != "or" && op != "not") { + compile_expr(expr) + print "CALL" + } else { + compile_expr(expr) + } + } else { + compile_expr(expr) + } + print "CLEAR_STACK" current = "" } } - - # Handle atomic expressions (not in parentheses or strings) if (paren_count == 0 && !in_string && c == " " && current != "") { - # We've reached a space after an atomic expression expr = current sub(/^\s+/, "", expr) sub(/\s+$/, "", expr) - if (expr != "") { debug("Processing atomic expression: [" expr "]") - program = expr # Set for parser + program = expr + expr_str = expr expr = parse_expr() - compile_expr(expr) - # Clear stack between expressions to prevent pollution - print "CLEAR_STACK" # Clear stack between expressions + if (substr(expr_str, 1, 1) == "(") { + op = extract_first_symbol(expr_str) + if (op != "define" && op != "let" && op != "lambda" && op != "if" && op != "cond" && op != "and" && op != "or" && op != "not") { + compile_expr(expr) + print "CALL" + } else { + compile_expr(expr) + } + } else { + compile_expr(expr) + } + print "CLEAR_STACK" } current = "" } } - - # Handle the last expression if it's atomic if (paren_count == 0 && !in_string && current != "") { expr = current sub(/^\s+/, "", expr) sub(/\s+$/, "", expr) - if (expr != "") { debug("Processing final atomic expression: [" expr "]") - program = expr # Set for parser + program = expr + expr_str = expr expr = parse_expr() - compile_expr(expr) - # Clear stack after the final expression + if (substr(expr_str, 1, 1) == "(") { + op = extract_first_symbol(expr_str) + if (op != "define" && op != "let" && op != "lambda" && op != "if" && op != "cond" && op != "and" && op != "or" && op != "not") { + compile_expr(expr) + print "CALL" + } else { + compile_expr(expr) + } + } else { + compile_expr(expr) + } print "CLEAR_STACK" } } - - # Check for incomplete expressions if (paren_count > 0) { debug("paren_count at end of split_expressions: " paren_count) error("Unmatched opening parentheses - incomplete expression") exit 1 } - - # Add final HALT instruction print "HALT" } @@ -448,35 +448,23 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { debug("Primitive call: op=" op " args=" args) nargs = split_args(args, arg_array) - # Check if this is a lambda function call - # AWK FEATURE: ~ is the regex match operator (like /pattern/.test() in JS) - # The pattern is a regex literal, not a string if (op ~ /^\(lambda /) { - # This is a lambda function call - # First compile all arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } - - # Then compile the lambda function (this will push the function name) compile_expr(op) - - # Call the function - the lambda name is now on top of stack print "CALL" - return + return "function" } - - # Then emit appropriate operation if (op == "+") { - # Compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } for (i = 1; i < nargs; i++) print "ADD" + return "value" } else if (op == "-") { - # Compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } @@ -486,14 +474,15 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { } for (i = 1; i < nargs; i++) print "SUB" + return "value" } else if (op == "*") { - # Compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } for (i = 1; i < nargs; i++) print "MUL" + return "value" } else if (op == "/") { if (nargs < 2) error("/ requires at least 2 arguments") @@ -502,6 +491,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { } for (i = 1; i < nargs; i++) print "DIV" + return "value" } else if (op == "modulo" || op == "%") { if (nargs != 2) error("modulo requires 2 arguments") @@ -511,6 +501,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP modulo" print "GET_VALUE" print "CALL" + return "value" } else if (op == "expt") { if (nargs != 2) error("expt requires 2 arguments") @@ -520,6 +511,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP expt" print "GET_VALUE" print "CALL" + return "value" } else if (op == "abs") { if (nargs != 1) error("abs requires 1 argument") @@ -527,6 +519,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP abs" print "GET_VALUE" print "CALL" + return "value" } else if (op == "min") { if (nargs != 2) error("min requires 2 arguments") @@ -536,6 +529,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP min" print "GET_VALUE" print "CALL" + return "value" } else if (op == "max") { if (nargs != 2) error("max requires 2 arguments") @@ -545,42 +539,43 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP max" print "GET_VALUE" print "CALL" + return "value" } else if (op == "cons") { if (nargs != 2) error("cons requires 2 arguments") - # Compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } print "CONS" + return "value" } else if (op == "car") { if (nargs != 1) error("car requires 1 argument") - # Compile argument compile_expr(arg_array[1]) print "CAR" + return "value" } else if (op == "cdr") { if (nargs != 1) error("cdr requires 1 argument") - # Compile argument compile_expr(arg_array[1]) print "CDR" + return "value" } else if (op == "<") { if (nargs != 2) error("< requires 2 arguments") - # Compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } print "LT" + return "value" } else if (op == "=") { if (nargs != 2) error("= requires 2 arguments") - # Compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } print "EQ" + return "value" } # Standard library functions else if (op == "null?") { @@ -589,6 +584,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP null?" print "GET_VALUE" print "CALL" + return "value" } else if (op == "pair?") { if (nargs != 1) error("pair? requires 1 argument") @@ -596,6 +592,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP pair?" print "GET_VALUE" print "CALL" + return "value" } else if (op == "number?") { if (nargs != 1) error("number? requires 1 argument") @@ -603,6 +600,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP number?" print "GET_VALUE" print "CALL" + return "value" } else if (op == "string?") { if (nargs != 1) error("string? requires 1 argument") @@ -610,6 +608,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP string?" print "GET_VALUE" print "CALL" + return "value" } else if (op == "boolean?") { if (nargs != 1) error("boolean? requires 1 argument") @@ -617,6 +616,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP boolean?" print "GET_VALUE" print "CALL" + return "value" } else if (op == "symbol?") { if (nargs != 1) error("symbol? requires 1 argument") @@ -624,6 +624,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP symbol?" print "GET_VALUE" print "CALL" + return "value" } else if (op == "zero?") { if (nargs != 1) error("zero? requires 1 argument") @@ -631,68 +632,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP zero?" print "GET_VALUE" print "CALL" - } - else if (op == "positive?") { - if (nargs != 1) error("positive? requires 1 argument") - compile_expr(arg_array[1]) - print "LOOKUP positive?" - print "GET_VALUE" - print "CALL" - } - else if (op == "negative?") { - if (nargs != 1) error("negative? requires 1 argument") - compile_expr(arg_array[1]) - print "LOOKUP negative?" - print "GET_VALUE" - print "CALL" - } - else if (op == "length") { - if (nargs != 1) error("length requires 1 argument") - compile_expr(arg_array[1]) - print "LOOKUP length" - print "GET_VALUE" - print "CALL" - } - else if (op == "cadr") { - if (nargs != 1) error("cadr requires 1 argument") - compile_expr(arg_array[1]) - print "LOOKUP cadr" - print "GET_VALUE" - print "CALL" - } - else if (op == "caddr") { - if (nargs != 1) error("caddr requires 1 argument") - compile_expr(arg_array[1]) - print "LOOKUP caddr" - print "GET_VALUE" - print "CALL" - } - else if (op == "list-ref") { - if (nargs != 2) error("list-ref requires 2 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP list-ref" - print "GET_VALUE" - print "CALL" - } - else if (op == "list-tail") { - if (nargs != 2) error("list-tail requires 2 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP list-tail" - print "GET_VALUE" - print "CALL" - } - else if (op == "append") { - if (nargs != 2) error("append requires 2 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP append" - print "GET_VALUE" - print "CALL" + return "value" } else if (op == "list") { for (i = 1; i <= nargs; i++) { @@ -701,6 +641,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP list" print "GET_VALUE" print "CALL_WITH_ARGS " nargs + return "value" } else if (op == "reverse") { if (nargs != 1) error("reverse requires 1 argument") @@ -710,6 +651,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP reverse" print "GET_VALUE" print "CALL" + return "value" } else if (op == "member") { if (nargs != 2) error("member requires 2 arguments") @@ -719,6 +661,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP member" print "GET_VALUE" print "CALL" + return "value" } else if (op == "map") { if (nargs != 2) error("map requires 2 arguments") @@ -728,6 +671,7 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP map" print "GET_VALUE" print "CALL" + return "value" } else if (op == "filter") { if (nargs != 2) error("filter requires 2 arguments") @@ -737,14 +681,15 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP filter" print "GET_VALUE" print "CALL" + return "value" } - # String operations else if (op == "string-length") { if (nargs != 1) error("string-length requires 1 argument") compile_expr(arg_array[1]) print "LOOKUP string-length" print "GET_VALUE" print "CALL" + return "value" } else if (op == "string-append") { if (nargs < 2) error("string-append requires at least 2 arguments") @@ -754,60 +699,23 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP string-append" print "GET_VALUE" print "CALL_WITH_ARGS " nargs + return "value" } - else if (op == "string-ref") { - if (nargs != 2) error("string-ref requires 2 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP string-ref" - print "GET_VALUE" - print "CALL" - } - else if (op == "substring") { - if (nargs != 3) error("substring requires 3 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP substring" - print "GET_VALUE" - print "CALL" - } - else if (op == "string=?") { - if (nargs != 2) error("string=? requires 2 arguments") + else if (op == "assert" || op == "display" || op == "error" || op == "print") { for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } - print "LOOKUP string=?" - print "GET_VALUE" - print "CALL" - } - else if (op == "string<?") { - if (nargs != 2) error("string<? requires 2 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP string<?" - print "GET_VALUE" - print "CALL" - } - else if (op == "string>?") { - if (nargs != 2) error("string>? requires 2 arguments") - for (i = 1; i <= nargs; i++) { - compile_expr(arg_array[i]) - } - print "LOOKUP string>?" + print "LOOKUP " op print "GET_VALUE" print "CALL" + return "function" } else { # Function call for user-defined functions or higher-order/callable expressions debug("Function call: " op) - # First compile arguments for (i = 1; i <= nargs; i++) { compile_expr(arg_array[i]) } - # If the operator is a parenthesized expression, recursively compile it if (substr(op, 1, 1) == "(") { if (DEBUG_SEXPR) print "[DEBUG_SEXPR] compile_primitive_call: compiling operator expr: [" op "]" > "/dev/stderr" compile_expr(op) @@ -815,8 +723,8 @@ function compile_primitive_call(op, args, arg_array, nargs, i) { print "LOOKUP " op print "GET_VALUE" } - # Call the function print "CALL" + return "function" } } @@ -863,8 +771,7 @@ function split_bindings(bindings, binding_array, count, current, paren_count, i, } # Compiles let expressions (local variable bindings) -function compile_let(args, bindings, body, binding_array, nbindings, i, var, val, binding_parts, sexprs, nsexprs, j, expr) { - # Split into bindings and body +function compile_let(args, bindings, body, binding_array, nbindings, i, var, val, binding_parts, sexprs, nsexprs, j, expr, last_type) { if (substr(args, 1, 1) != "(") error("Malformed let expression") paren_count = 1 i = 2 @@ -901,7 +808,6 @@ function compile_let(args, bindings, body, binding_array, nbindings, i, var, val print "STORE " var } } - # --- Robust multi-expression let body support --- nsexprs = split_sexpressions(body, sexprs) if (DEBUG_SEXPR) { printf("[DEBUG_SEXPR] compile_let: splitting body, found %d expressions\n", nsexprs) > "/dev/stderr" @@ -909,17 +815,18 @@ function compile_let(args, bindings, body, binding_array, nbindings, i, var, val printf("[DEBUG_SEXPR] %d: [%s]\n", j, sexprs[j]) > "/dev/stderr" } } + last_type = "value" for (j = 1; j <= nsexprs; j++) { expr = sexprs[j] sub(/^[ \t\n]+/, "", expr) sub(/[ \t\n]+$/, "", expr) if (DEBUG_SEXPR) printf("[DEBUG_SEXPR] let body expr: [%s]\n", expr) > "/dev/stderr" - compile_expr(expr) + last_type = compile_expr(expr) } - # --- End robust let body support --- for (i = nbindings; i >= 1; i--) { print "POP_ENV" } + return last_type } # Compiles define expressions (function/variable definitions) @@ -1306,54 +1213,54 @@ function compile_not(args, expr) { } # Main expression compiler - dispatches based on expression type -function compile_expr(expr, split_result, op, args) { +function compile_expr(expr, split_result, op, args, result_type) { if (DEBUG_SEXPR) print "[DEBUG_SEXPR] compile_expr called with expr: [" expr "]" > "/dev/stderr" debug("Compiling expression: " expr) # Handle empty expressions if (expr == "") { debug("Skipping empty expression") - return + return "value" } # Handle comment lines if (expr ~ /^[ \t]*;;/ || expr ~ /^[ \t]*;/) { debug("Skipping comment line: [" expr "]") - return + return "value" } # Handle string literals if (substr(expr, 1, 1) == "\"") { compile_string(expr) - return + return "value" } # Handle numeric literals if (expr ~ /^-?[0-9]+$/) { compile_number(expr) - return + return "value" } # Handle nil constant if (expr == "nil") { print "PUSH_CONST NIL:" - return + return "value" } # Handle boolean literals if (expr == "#t") { print "PUSH_CONST B:1" - return + return "value" } if (expr == "#f") { print "PUSH_CONST B:0" - return + return "value" } # Handle variable lookup (only if not a parenthesized expression) if (expr ~ /^[a-zA-Z_][a-zA-Z0-9_?-]*$/) { print "LOOKUP " expr - return + return "value" } # Handle compound expressions (lists) @@ -1365,27 +1272,37 @@ function compile_expr(expr, split_result, op, args) { if (DEBUG_SEXPR) print "[DEBUG_SEXPR] split_expr op: [" op "] args: [" args "]" > "/dev/stderr" if (op == "define") { compile_define(args) + return "value" } else if (op == "let") { - compile_let(args) + result_type = compile_let(args) + return result_type } else if (op == "lambda") { compile_lambda(args) + return "function" } else if (op == "if") { compile_if(args) + # TODO: Could be value or function, but usually value + return "value" } else if (op == "cond") { compile_cond(args) + # TODO: Could be value or function, but usually value + return "value" } else if (op == "and") { compile_and(args) + return "value" } else if (op == "or") { compile_or(args) + return "value" } else if (op == "not") { compile_not(args) + return "value" } else { - compile_primitive_call(op, args) + return compile_primitive_call(op, args) } - return } error("Unknown expression type: " expr) + return "value" } # Error reporting helper @@ -1448,3 +1365,20 @@ function split_sexpressions(str, sexpr_array, i, c, in_string, paren_count, curr } return n } + +# Helper: Extract first symbol from a compound expression string +function extract_first_symbol(expr_str, op) { + # Assumes expr_str starts with '(' + op = "" + i = 2 + # Skip whitespace after '(' + while (i <= length(expr_str) && (substr(expr_str, i, 1) == " " || substr(expr_str, i, 1) == "\t")) i++ + # Read until next whitespace or ')' + while (i <= length(expr_str)) { + c = substr(expr_str, i, 1) + if (c == " " || c == "\t" || c == ")") break + op = op c + i++ + } + return op +} diff --git a/awk/uxn/.gitignore b/awk/uxn/.gitignore new file mode 100644 index 0000000..f71ddea --- /dev/null +++ b/awk/uxn/.gitignore @@ -0,0 +1,3 @@ +**/out/ +**/uxnasm + diff --git a/awk/uxn/README.md b/awk/uxn/README.md new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/awk/uxn/README.md diff --git a/awk/uxn/awk/uxnasm.awk b/awk/uxn/awk/uxnasm.awk new file mode 100644 index 0000000..cfcdd00 --- /dev/null +++ b/awk/uxn/awk/uxnasm.awk @@ -0,0 +1,916 @@ +#!/usr/bin/awk -f + +# Uxntal Assembler in AWK - Two-Pass Implementation + +BEGIN { + # Constants + PAGE = 256 + MAX_LABELS = 1024 + MAX_REFS = 4096 + + # Global state + ptr = PAGE + data_length = PAGE + + # Label and reference tracking + labels_len = 0 + refs_len = 0 + macros_len = 0 + + # Device tracking + devices_len = 0 + last_padding = "" + 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) + + # Utility strings + hexad = "0123456789abcdef" + + # Check arguments + if (ARGC < 3) { + 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.awk\n" + exit 0 + } + + if (ARGC != 3) { + printf "usage: uxnasm.awk [-v] input.tal output.rom\n" > "/dev/stderr" + exit 1 + } + + input_file = ARGV[1] + output_file = ARGV[2] + + # Remove output file from ARGV so AWK doesn't try to read it + ARGV[2] = "" + + # Two-pass assembly + if (!pass1_collect_symbols(input_file)) { + exit 1 + } + + if (!pass2_generate_code(input_file)) { + exit 1 + } + + if (!build_output(output_file)) { + exit 1 + } + + printf "Assembled %s in %d bytes(%.2f%% used), %d labels, %d refs.\n", + output_file, data_length - PAGE, (data_length - PAGE) / 652.80, labels_len, refs_len +} + +# 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++) { + c = substr(s, i, 1) + d = index(hexad, c) - 1 + if (d < 0) return -1 + n = n * 16 + d + } + return n +} + +function ishex(x) { + return shex(x) >= 0 +} + +function findopcode(s, i, m, base, c) { + # Special case for BRK + if (s == "BRK") return 0 + + for (i = 1; i <= 32; i++) { + if (substr(ops[i], 1, 3) == substr(s, 1, 3)) { + base = i - 1 + if (i == 1) base = base + 128 # LIT special case + + m = 4 + while (m <= length(s)) { + c = substr(s, m, 1) + if (c == "2") + base = base + 32 + else if (c == "r") + base = base + 64 + else if (c == "k") + base = base + 128 + else + return -1 + m++ + } + return base + } + } + return -1 +} + +function isopc(x) { + return findopcode(x) >= 0 || x == "BRK" +} + +function makelabel(name, setscope) { + if (labels_len >= MAX_LABELS) { + printf "Labels limit exceeded\n" > "/dev/stderr" + return 0 + } + + labels_len++ + labels[labels_len, "name"] = name + labels[labels_len, "addr"] = ptr + labels[labels_len, "refs"] = 0 + + printf "DEBUG: Created label '%s' at addr %d\n", name, ptr > "/dev/stderr" + + return 1 +} + +function findlabel(name, i) { + for (i = 1; i <= labels_len; i++) { + if (labels[i, "name"] == name) { + return i + } + } + return 0 +} + +function makeref(label, rune, addr) { + if (refs_len >= MAX_REFS) { + printf "References limit exceeded\n" > "/dev/stderr" + return 0 + } + + refs_len++ + refs[refs_len, "name"] = label + refs[refs_len, "rune"] = rune + refs[refs_len, "addr"] = addr + + return 1 +} + +function makedevice(name, base_addr) { + if (devices_len >= MAX_LABELS) { + printf "Devices limit exceeded\n" > "/dev/stderr" + return 0 + } + + devices_len++ + devices[devices_len, "name"] = name + devices[devices_len, "base"] = base_addr + devices[devices_len, "fields_len"] = 0 + + return 1 +} + +function adddevicefield(device_name, field_name, size) { + # Find device + for (i = 1; i <= devices_len; i++) { + if (devices[i, "name"] == device_name) { + devices[i, "fields_len"]++ + devices[i, "fields", devices[i, "fields_len"], "name"] = field_name + devices[i, "fields", devices[i, "fields_len"], "size"] = size + return 1 + } + } + return 0 +} + +function finddevicefield(device_name, field_name, i, j) { + for (i = 1; i <= devices_len; i++) { + if (devices[i, "name"] == device_name) { + addr = devices[i, "base"] + for (j = 1; j <= devices[i, "fields_len"]; j++) { + if (devices[i, "fields", j, "name"] == field_name) { + return addr + } + addr += devices[i, "fields", j, "size"] + } + } + } + return -1 +} + +# --- PASS 1: Symbol/Label Collection --- +function pass1_collect_symbols(filename) { + ptr = PAGE + data_length = PAGE + + while ((getline < filename) > 0) { + pass1_process_line($0) + } + close(filename) + + return 1 +} + +function pass1_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++ + } + 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++ + } + 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] + 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 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)) + current_device = substr(w, 2) + last_padding = "" # Reset after device definition + } else { + makelabel(substr(w, 2), 1) + } + return 1 + } + + # Handle device fields + if (substr(w, 1, 1) == "&") { + if (current_device != "") { + adddevicefield(current_device, substr(w, 2), last_size) + } else { + makelabel(w, 0) + } + return 1 + } + + # Skip brackets and control flow + if (substr(w, 1, 1) == "[" || substr(w, 1, 1) == "]" || 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) + # Set pointer based on padding value (no writing, just positioning) + if (last_padding == "0000") { + ptr = 0 + } else if (last_padding == "0100") { + ptr = PAGE + } else { + ptr = shex(last_padding) + } + return 1 + } + if (substr(w, 1, 1) == "$") { + last_size = shex(substr(w, 2)) + # Advance pointer by size (no writing, just positioning) + ptr += last_size + return 1 + } + + # Handle references (just collect them, don't resolve yet) + if (substr(w, 1, 1) == "_") { + makeref(substr(w, 2), substr(w, 1, 1), ptr) + ptr++ + return 1 + } + if (substr(w, 1, 1) == ",") { + makeref(substr(w, 2), substr(w, 1, 1), ptr + 1) + ptr += 2 + return 1 + } + if (substr(w, 1, 1) == "-") { + # Check if this is a device field reference + if (index(substr(w, 2), "/") > 0) { + # Device field reference - just advance pointer (will be resolved in pass2) + ptr++ + } else { + makeref(substr(w, 2), substr(w, 1, 1), ptr) + ptr++ + } + return 1 + } + if (substr(w, 1, 1) == ".") { + # Check if this is a device field reference + if (index(substr(w, 2), "/") > 0) { + # Device field reference - just advance pointer + ptr += 2 + } else { + makeref(substr(w, 2), substr(w, 1, 1), ptr + 1) + ptr += 2 + } + return 1 + } + if (substr(w, 1, 1) == "=") { + makeref(substr(w, 2), substr(w, 1, 1), ptr) + ptr += 2 + return 1 + } + if (substr(w, 1, 1) == ";") { + makeref(substr(w, 2), substr(w, 1, 1), ptr + 1) + ptr += 3 + return 1 + } + if (substr(w, 1, 1) == "?") { + makeref(substr(w, 2), substr(w, 1, 1), ptr + 1) + ptr += 3 + return 1 + } + if (substr(w, 1, 1) == "!") { + makeref(substr(w, 2), substr(w, 1, 1), ptr + 1) + ptr += 3 + return 1 + } + + # 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 + } else { + ptr += 2 # LIT + 1 byte + } + 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++ + return 1 + } + + # Handle strings + if (substr(w, 1, 1) == "\"") { + ptr += length(substr(w, 2)) + 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: Code Generation --- +function pass2_generate_code(filename) { + ptr = PAGE + data_length = PAGE + + while ((getline < filename) > 0) { + pass2_process_line($0) + } + close(filename) + + return 1 +} + +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++ + } + 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++ + } + 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 standalone tokens (but not device field references) + if (w == ">") { + return 1 + } + + # Handle labels (just skip, already collected in pass 1) + if (substr(w, 1, 1) == "@" || substr(w, 1, 1) == "&") { + return 1 + } + + # Skip brackets and control flow + if (substr(w, 1, 1) == "[" || substr(w, 1, 1) == "]" || 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) + padding_val = substr(w, 2) + if (padding_val == "0000") { + ptr = 0 + } else if (padding_val == "0100") { + ptr = PAGE + } else { + ptr = shex(padding_val) + } + return 1 + } + if (substr(w, 1, 1) == "$") { + # Advance pointer by size (no writing, just positioning) + size_val = shex(substr(w, 2)) + ptr += size_val + return 1 + } + + # Handle references (resolve them now) + if (substr(w, 1, 1) == "_") { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr) && writebyte(0xff) + return 1 + } + if (substr(w, 1, 1) == ",") { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr + 1) && writebyte(128) && writebyte(0xff) + return 1 + } + if (substr(w, 1, 1) == "-") { + # Device field reference + if (index(substr(w, 2), "/") > 0) { + resolve_device_ref(substr(w, 2), ptr) + writebyte(0xff) + } else { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr) + writebyte(0xff) + } + return 1 + } + if (substr(w, 1, 1) == ".") { + # Check if this is a device field reference + if (index(substr(w, 2), "/") > 0) { + resolve_device_ref(substr(w, 2), ptr + 1) && writebyte(128) && writebyte(0xff) + } else { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr + 1) && writebyte(128) && writebyte(0xff) + } + return 1 + } + if (substr(w, 1, 1) == "=") { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr) && writeshort(0xffff) + return 1 + } + if (substr(w, 1, 1) == ";") { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr + 1) && writebyte(160) && writeshort(0xffff) + return 1 + } + if (substr(w, 1, 1) == "?") { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr + 1) && writebyte(32) && writeshort(0xffff) + return 1 + } + if (substr(w, 1, 1) == "!") { + resolve_ref(substr(w, 2), substr(w, 1, 1), ptr + 1) && writebyte(64) && writeshort(0xffff) + return 1 + } + + # 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 string literals + if (substr(w, 1, 1) == "\"") { + 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 + } + + # Handle unknown tokens as label references (fallback) + printf "DEBUG: Unknown token '%s' treated as label reference\n", w > "/dev/stderr" + makeref(w, " ", ptr + 1) + ptr += 3 # LIT2 + 2 bytes + return 1 +} + +function resolve_ref(label, rune, addr, l, rel) { + l = findlabel(label) + if (l == 0) { + printf "Label unknown: %s\n", label > "/dev/stderr" + return 0 + } + + # Resolve based on reference type + if (rune == "_" || rune == ",") { + rel = labels[l, "addr"] - addr - 2 + data[addr] = rel + } else if (rune == "-" || rune == ".") { + data[addr] = labels[l, "addr"] + } else if (rune == "=" || rune == ";") { + data[addr] = int(labels[l, "addr"] / 256) + data[addr + 1] = labels[l, "addr"] % 256 + } else if (rune == "?" || rune == "!") { + rel = labels[l, "addr"] - addr - 2 + data[addr] = int(rel / 256) + data[addr + 1] = rel % 256 + } + + labels[l, "refs"]++ + return 1 +} + +function resolve_device_ref(device_field, addr, device_name, field_name, device_addr) { + # Split device/field + split(device_field, parts, "/") + if (length(parts) != 2) { + printf "Invalid device field: %s\n", device_field > "/dev/stderr" + return 0 + } + + device_name = parts[1] + field_name = parts[2] + + device_addr = finddevicefield(device_name, field_name) + if (device_addr == -1) { + printf "Device field unknown: %s\n", device_field > "/dev/stderr" + return 0 + } + + data[addr] = device_addr + return 1 +} + +function writebyte(b) { + if (ptr >= 65536) { + printf "Writing outside memory\n" > "/dev/stderr" + return 0 + } + + # Only write to data array if we're in the code section (ptr >= PAGE) + if (ptr >= PAGE) { + data[ptr] = b + if (b) { + data_length = ptr + } + printf "DEBUG: writebyte(%d) at ptr %d, data_length now %d\n", b, ptr, data_length > "/dev/stderr" + } + ptr++ + return 1 +} + +function writeshort(x) { + return writebyte(int(x / 256)) && writebyte(x % 256) +} + +function writehex(w) { + if (substr(w, 1, 1) == "#") { + # Write LIT opcode + if (length(substr(w, 2)) > 2) { + writebyte(32) # LIT2 + } else { + writebyte(128) # LIT (BRK + 128) + } + w = substr(w, 2) + } + + if (ishex(w)) { + if (length(w) == 2) { + return writebyte(shex(w)) + } else if (length(w) == 4) { + return writeshort(shex(w)) + } + } + + printf "Hexadecimal invalid: %s\n", w > "/dev/stderr" + 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 +} + +function writestring(w, i, c) { + for (i = 1; i <= length(w); i++) { + c = substr(w, i, 1) + # Simple ASCII conversion + if (!writebyte(ord(c))) { + printf "String invalid\n" > "/dev/stderr" + return 0 + } + } + return 1 +} + +function build_output(rompath) { + # Write ROM file + printf "DEBUG: Writing %d bytes from PAGE (%d) to data_length (%d)\n", data_length - PAGE + 1, PAGE, data_length > "/dev/stderr" + for (i = PAGE; i <= data_length; i++) { + printf "%c", data[i] > rompath + } + close(rompath) + + return 1 +} diff --git a/awk/uxn/ref/uxnasm.c b/awk/uxn/ref/uxnasm.c new file mode 100644 index 0000000..f25d6ce --- /dev/null +++ b/awk/uxn/ref/uxnasm.c @@ -0,0 +1,481 @@ +#include <stdio.h> + +/* +Copyright (c) 2021-2024 Devine Lu Linvega, Andrew Alderwick + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE. +*/ + +/* clang-format off */ + +#define PAGE 0x0100 +#define ishex(x) (shex(x) >= 0) +#define isopc(x) (findopcode(x) || scmp(x, "BRK", 4)) +#define isinvalid(x) (!x[0] || ishex(x) || isopc(x) || find(runes, x[0]) >= 0) +#define writeshort(x) (writebyte(x >> 8, ctx) && writebyte(x & 0xff, ctx)) +#define findlabel(x) finditem(x, labels, labels_len) +#define findmacro(x) finditem(x, macros, macro_len) +#define error_top(id, msg) !printf("%s: %s\n", id, msg) +#define error_asm(id) !printf("%s: %s in @%s, %s:%d.\n", id, token, scope, ctx->path, ctx->line) +#define error_ref(id) !printf("%s: %s, %s:%d\n", id, r->name, r->data, r->line) + +typedef unsigned char Uint8; +typedef signed char Sint8; +typedef unsigned short Uint16; +typedef struct { int line; char *path; } Context; +typedef struct { char *name, rune, *data; Uint16 addr, refs, line; } Item; + +static int ptr, length; +static char token[0x30], scope[0x40], lambda[0x05]; +static char dict[0x8000], *dictnext = dict; +static Uint8 data[0x10000], lambda_stack[0x100], lambda_ptr, lambda_len; +static Uint16 labels_len, refs_len, macro_len; +static Item labels[0x400], refs[0x1000], macros[0x100]; + +static char *runes = "|$@&,_.-;=!?#\"%~"; +static char *hexad = "0123456789abcdef"; +static char ops[][4] = { + "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" +}; + +/* clang-format on */ + +static int +find(char *s, char t) +{ + int i = 0; + char c; + while((c = *s++)) { + if(c == t) return i; + i++; + } + return -1; +} + +static int +shex(char *s) +{ + int d, n = 0; + char c; + while((c = *s++)) { + d = find(hexad, c); + if(d < 0) return d; + n = n << 4, n |= d; + } + return n; +} + +static int +scmp(char *a, char *b, int len) +{ + int i = 0; + while(a[i] == b[i]) + if(!a[i] || ++i >= len) return 1; + return 0; +} + +static char * +copy(char *src, char *dst, char c) +{ + while(*src && *src != c) *dst++ = *src++; + *dst++ = 0; + return dst; +} + +static char * +save(char *s, char c) +{ + char *o = dictnext; + while((*dictnext++ = *s++) && *s); + *dictnext++ = c; + return o; +} + +static char * +join(char *a, char j, char *b) +{ + char *res = dictnext; + save(a, j), save(b, 0); + return res; +} + +static char * +push(char *s, char c) +{ + char *d; + for(d = dict; d < dictnext; d++) { + char *ss = s, *dd = d, a, b; + while((a = *dd++) == (b = *ss++)) + if(!a && !b) return d; + } + return save(s, c); +} + +static Item * +finditem(char *name, Item *list, int len) +{ + int i; + if(name[0] == '&') + name = join(scope, '/', name + 1); + for(i = 0; i < len; i++) + if(scmp(list[i].name, name, 0x40)) + return &list[i]; + return NULL; +} + +static Uint8 +findopcode(char *s) +{ + int i; + for(i = 0; i < 0x20; i++) { + int m = 3; + if(!scmp(ops[i], s, 3)) continue; + if(!i) i |= (1 << 7); + while(s[m]) { + if(s[m] == '2') + i |= (1 << 5); + else if(s[m] == 'r') + i |= (1 << 6); + else if(s[m] == 'k') + i |= (1 << 7); + else + return 0; + m++; + } + return i; + } + return 0; +} + +static int +walkcomment(FILE *f, Context *ctx) +{ + char c, last = 0; + int depth = 1; + while(f && fread(&c, 1, 1, f)) { + if(c <= 0x20) { + if(c == 0xa) ctx->line++; + if(last == '(') + depth++; + else if(last == ')' && --depth < 1) + return 1; + last = 0; + } else if(last <= 0x20) + last = c; + else + last = '~'; + } + return error_asm("Comment incomplete"); +} + +static int parse(char *w, FILE *f, Context *ctx); + +static int +walkmacro(Item *m, Context *ctx) +{ + unsigned char c; + char *dataptr = m->data, *_token = token; + while((c = *dataptr++)) { + if(c < 0x21) { + *_token = 0x00; + if(token[0] && !parse(token, NULL, ctx)) return 0; + _token = token; + } else if(_token - token < 0x2f) + *_token++ = c; + else + return error_asm("Token size exceeded"); + } + return 1; +} + +static int +walkfile(FILE *f, Context *ctx) +{ + unsigned char c; + char *_token = token; + while(f && fread(&c, 1, 1, f)) { + if(c < 0x21) { + *_token = 0x00; + if(token[0] && !parse(token, f, ctx)) return 0; + if(c == 0xa) ctx->line++; + _token = token; + } else if(_token - token < 0x2f) + *_token++ = c; + else + return error_asm("Token size exceeded"); + } + *_token = 0; + return parse(token, f, ctx); +} + +static char * +makelambda(int id) +{ + lambda[0] = (char)0xce; + lambda[1] = (char)0xbb; + lambda[2] = hexad[id >> 0x4]; + lambda[3] = hexad[id & 0xf]; + return lambda; +} + +static int +makemacro(char *name, FILE *f, Context *ctx) +{ + int depth = 0; + char c; + Item *m; + if(macro_len >= 0x100) return error_asm("Macros limit exceeded"); + if(isinvalid(name)) return error_asm("Macro invalid"); + if(findmacro(name)) return error_asm("Macro duplicate"); + if(findlabel(name)) return error_asm("Label duplicate"); + m = ¯os[macro_len++]; + m->name = push(name, 0); + m->data = dictnext; + while(f && fread(&c, 1, 1, f) && c != '{') + if(c == 0xa) ctx->line++; + while(f && fread(&c, 1, 1, f)) { + if(c == 0xa) ctx->line++; + if(c == '%') return error_asm("Macro nested"); + if(c == '{') depth++; + if(c == '}' && --depth) break; + *dictnext++ = c; + } + *dictnext++ = 0; + return 1; +} + +static int +makelabel(char *name, int setscope, Context *ctx) +{ + Item *l; + if(name[0] == '&') + name = join(scope, '/', name + 1); + if(labels_len >= 0x400) return error_asm("Labels limit exceeded"); + if(isinvalid(name)) return error_asm("Label invalid"); + if(findmacro(name)) return error_asm("Label duplicate"); + if(findlabel(name)) return error_asm("Label duplicate"); + l = &labels[labels_len++]; + l->name = push(name, 0); + l->addr = ptr; + l->refs = 0; + if(setscope) copy(name, scope, '/'); + return 1; +} + +static int +makeref(char *label, char rune, Uint16 addr, Context *ctx) +{ + Item *r; + if(refs_len >= 0x1000) return error_asm("References limit exceeded"); + r = &refs[refs_len++]; + if(label[0] == '{') { + lambda_stack[lambda_ptr++] = lambda_len; + r->name = push(makelambda(lambda_len++), 0); + if(label[1]) return error_asm("Label invalid"); + } else if(label[0] == '&' || label[0] == '/') { + r->name = join(scope, '/', label + 1); + } else + r->name = push(label, 0); + r->rune = rune; + r->addr = addr; + r->line = ctx->line; + r->data = ctx->path; + return 1; +} + +static int +writepad(char *w, Context *ctx) +{ + Item *l; + int rel = w[0] == '$' ? ptr : 0; + if(ishex(w + 1)) { + ptr = shex(w + 1) + rel; + return 1; + } + if((l = findlabel(w + 1))) { + ptr = l->addr + rel; + return 1; + } + return error_asm("Padding invalid"); +} + +static int +writebyte(Uint8 b, Context *ctx) +{ + if(ptr < PAGE) + return error_asm("Writing zero-page"); + else if(ptr >= 0x10000) + return error_asm("Writing outside memory"); + else if(ptr < length) + return error_asm("Writing rewind"); + data[ptr++] = b; + if(b) + length = ptr; + return 1; +} + +static int +writehex(char *w, Context *ctx) +{ + if(*w == '#') + writebyte(findopcode("LIT") | !!(++w)[2] << 5, ctx); + if(ishex(w)) { + if(w[1] && !w[2]) + return writebyte(shex(w), ctx); + else if(w[3] && !w[4]) + return writeshort(shex(w)); + } + return error_asm("Hexadecimal invalid"); +} + +static int +writestring(char *w, Context *ctx) +{ + char c; + while((c = *(w++))) + if(!writebyte(c, ctx)) return error_asm("String invalid"); + return 1; +} + +static int +assemble(char *filename) +{ + FILE *f; + int res; + Context ctx; + ctx.line = 1; + ctx.path = push(filename, 0); + if(!(f = fopen(filename, "r"))) + return error_top("File missing", filename); + res = walkfile(f, &ctx); + fclose(f); + return res; +} + +static int +parse(char *w, FILE *f, Context *ctx) +{ + Item *m; + switch(w[0]) { + case 0x0: return 1; + case '(': + if(w[1] <= 0x20) + return walkcomment(f, ctx); + else + return error_asm("Invalid word"); + case '%': return makemacro(w + 1, f, ctx); + case '@': return makelabel(w + 1, 1, ctx); + case '&': return makelabel(w, 0, ctx); + case '}': return makelabel(makelambda(lambda_stack[--lambda_ptr]), 0, ctx); + case '#': return writehex(w, ctx); + case '_': return makeref(w + 1, w[0], ptr, ctx) && writebyte(0xff, ctx); + case ',': return makeref(w + 1, w[0], ptr + 1, ctx) && writebyte(findopcode("LIT"), ctx) && writebyte(0xff, ctx); + case '-': return makeref(w + 1, w[0], ptr, ctx) && writebyte(0xff, ctx); + case '.': return makeref(w + 1, w[0], ptr + 1, ctx) && writebyte(findopcode("LIT"), ctx) && writebyte(0xff, ctx); + case ':': printf("Deprecated rune %s, use =%s\n", w, w + 1); /* fall-through */ + case '=': return makeref(w + 1, w[0], ptr, ctx) && writeshort(0xffff); + case ';': return makeref(w + 1, w[0], ptr + 1, ctx) && writebyte(findopcode("LIT2"), ctx) && writeshort(0xffff); + case '?': return makeref(w + 1, w[0], ptr + 1, ctx) && writebyte(0x20, ctx) && writeshort(0xffff); + case '!': return makeref(w + 1, w[0], ptr + 1, ctx) && writebyte(0x40, ctx) && writeshort(0xffff); + case '"': return writestring(w + 1, ctx); + case '~': return !assemble(w + 1) ? error_asm("Include missing") : 1; + case '$': + case '|': return writepad(w, ctx); + case '[': + case ']': return 1; + } + if(ishex(w)) return writehex(w, ctx); + if(isopc(w)) return writebyte(findopcode(w), ctx); + if((m = findmacro(w))) return walkmacro(m, ctx); + return makeref(w, ' ', ptr + 1, ctx) && writebyte(0x60, ctx) && writeshort(0xffff); +} + +static int +resolve(char *filename) +{ + int i, rel; + if(!length) return error_top("Output empty", filename); + for(i = 0; i < refs_len; i++) { + Item *r = &refs[i], *l = findlabel(r->name); + Uint8 *rom = data + r->addr; + if(!l) return error_ref("Label unknown"); + switch(r->rune) { + case '_': + case ',': + *rom = rel = l->addr - r->addr - 2; + if((Sint8)data[r->addr] != rel) + return error_ref("Reference too far"); + break; + case '-': + case '.': + *rom = l->addr; + break; + case ':': + case '=': + case ';': + *rom++ = l->addr >> 8, *rom = l->addr; + break; + case '?': + case '!': + default: + rel = l->addr - r->addr - 2; + *rom++ = rel >> 8, *rom = rel; + break; + } + l->refs++; + } + return 1; +} + +static int +build(char *rompath) +{ + int i; + FILE *dst, *dstsym; + char *sympath = join(rompath, '.', "sym"); + /* rom */ + if(!(dst = fopen(rompath, "wb"))) + return !error_top("Output file invalid", rompath); + for(i = 0; i < labels_len; i++) + if(!labels[i].refs && (unsigned char)(labels[i].name[0] - 'A') > 25) + printf("-- Unused label: %s\n", labels[i].name); + fwrite(data + PAGE, length - PAGE, 1, dst); + printf( + "Assembled %s in %d bytes(%.2f%% used), %d labels, %d macros.\n", + rompath, + length - PAGE, + (length - PAGE) / 652.80, + labels_len, + macro_len); + /* sym */ + if(!(dstsym = fopen(sympath, "wb"))) + return !error_top("Symbols file invalid", sympath); + for(i = 0; i < labels_len; i++) { + Uint8 hb = labels[i].addr >> 8, lb = labels[i].addr; + char c, d = 0, *name = labels[i].name; + fwrite(&hb, 1, 1, dstsym); + fwrite(&lb, 1, 1, dstsym); + while((c = *name++)) fwrite(&c, 1, 1, dstsym); + fwrite(&d, 1, 1, dstsym); + } + fclose(dst), fclose(dstsym); + return 1; +} + +int +main(int argc, char *argv[]) +{ + ptr = PAGE; + copy("on-reset", scope, 0); + if(argc == 2 && scmp(argv[1], "-v", 2)) return !printf("Uxnasm - Uxntal Assembler, 15 Jan 2025.\n"); + if(argc != 3) return error_top("usage", "uxnasm [-v] input.tal output.rom"); + return !assemble(argv[1]) || !resolve(argv[2]) || !build(argv[2]); +} diff --git a/awk/uxn/test/runner.sh b/awk/uxn/test/runner.sh new file mode 100755 index 0000000..711dd28 --- /dev/null +++ b/awk/uxn/test/runner.sh @@ -0,0 +1,105 @@ +#!/bin/bash + +# Test runner for Uxntal AWK assembler +# Compares output with reference C implementation + +set -e + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +# Paths +AWK_ASM="../awk/uxnasm.awk" +REF_ASM="../ref/uxnasm" +TEST_DIR="tal" +OUT_DIR="out" + +# Ensure output directory exists +mkdir -p "$OUT_DIR" + +echo "Testing Uxntal AWK Assembler" +echo "=============================" + +# Check if reference assembler exists +if [ ! -f "$REF_ASM" ]; then + echo -e "${RED}Error: Reference assembler not found at $REF_ASM${NC}" + echo "Please compile the reference implementation first:" + echo " cd ../ref && make" + exit 1 +fi + +# Check if AWK assembler exists +if [ ! -f "$AWK_ASM" ]; then + echo -e "${RED}Error: AWK assembler not found at $AWK_ASM${NC}" + exit 1 +fi + +# Test function +test_file() { + local input_file="$1" + local base_name=$(basename "$input_file" .tal) + + echo -n "Testing $base_name.tal... " + + # Run reference assembler + if ! "$REF_ASM" "$input_file" "$OUT_DIR/${base_name}_ref.rom" >/dev/null 2>&1; then + echo -e "${RED}FAIL${NC} (reference assembler failed)" + return 1 + fi + + # Run AWK assembler + if [ "$DEBUG_AWK" -eq 1 ]; then + awk -f "$AWK_ASM" "$input_file" "$OUT_DIR/${base_name}_awk.rom" 2> "$OUT_DIR/${base_name}_awk.debug" + else + awk -f "$AWK_ASM" "$input_file" "$OUT_DIR/${base_name}_awk.rom" >/dev/null 2>&1 + fi + + # Compare outputs + if cmp -s "$OUT_DIR/${base_name}_ref.rom" "$OUT_DIR/${base_name}_awk.rom"; then + echo -e "${GREEN}PASS${NC}" + if [ "$DEBUG_AWK" -eq 1 ]; then + echo " Debug output: $OUT_DIR/${base_name}_awk.debug" + fi + return 0 + else + echo -e "${RED}FAIL${NC} (outputs differ)" + echo " Reference size: $(wc -c < "$OUT_DIR/${base_name}_ref.rom") bytes" + echo " AWK size: $(wc -c < "$OUT_DIR/${base_name}_awk.rom") bytes" + echo " Diff:" + xxd "$OUT_DIR/${base_name}_ref.rom" > "$OUT_DIR/${base_name}_ref.hex" + xxd "$OUT_DIR/${base_name}_awk.rom" > "$OUT_DIR/${base_name}_awk.hex" + diff "$OUT_DIR/${base_name}_ref.hex" "$OUT_DIR/${base_name}_awk.hex" || true + if [ "$DEBUG_AWK" -eq 1 ]; then + echo " Debug output: $OUT_DIR/${base_name}_awk.debug" + fi + return 1 + fi +} + +# Run tests +failed=0 +total=0 + +for test_file in "$TEST_DIR"/*.tal; do + if [ -f "$test_file" ]; then + total=$((total + 1)) + if ! test_file "$test_file"; then + failed=$((failed + 1)) + fi + fi +done + +echo +echo "=============================" +echo "Results: $((total - failed))/$total tests passed" + +if [ $failed -eq 0 ]; then + echo -e "${GREEN}All tests passed!${NC}" + exit 0 +else + echo -e "${RED}$failed tests failed${NC}" + exit 1 +fi diff --git a/awk/uxn/test/tal/brk.tal b/awk/uxn/test/tal/brk.tal new file mode 100644 index 0000000..bf83010 --- /dev/null +++ b/awk/uxn/test/tal/brk.tal @@ -0,0 +1 @@ +BRK \ No newline at end of file diff --git a/awk/uxn/test/tal/brk_test.tal b/awk/uxn/test/tal/brk_test.tal new file mode 100644 index 0000000..487f63d --- /dev/null +++ b/awk/uxn/test/tal/brk_test.tal @@ -0,0 +1 @@ +BRK \ No newline at end of file diff --git a/awk/uxn/test/tal/brk_with_data.tal b/awk/uxn/test/tal/brk_with_data.tal new file mode 100644 index 0000000..c055e74 --- /dev/null +++ b/awk/uxn/test/tal/brk_with_data.tal @@ -0,0 +1 @@ +#01 #02 ADD BRK \ No newline at end of file diff --git a/awk/uxn/test/tal/bunnymark.tal b/awk/uxn/test/tal/bunnymark.tal new file mode 100644 index 0000000..579d305 --- /dev/null +++ b/awk/uxn/test/tal/bunnymark.tal @@ -0,0 +1,221 @@ +( bunnymark.tal ) + ( November 2021, Kira Oakley ) + ( March 2022, Devine Lu Linvega ) + +|00 @System &vector $2 &pad $6 &r $2 &g $2 &b $2 &debug $1 &halt $1 +|20 @Screen &vector $2 &width $2 &height $2 &auto $1 &pad $1 &x $2 &y $2 &addr $2 &pixel $1 &sprite $1 +|80 @Controller &vector $2 &button $1 &key $1 +|90 @Mouse &vector $2 &x $2 &y $2 &state $1 &wheel $1 +|c0 @DateTime &year $2 &month $1 &day $1 &hour $1 &minute $1 &second $1 &dotw $1 &doty $2 &isdst $1 + +|0000 + + @frames $2 + @last $1 + +|0100 + +@on-reset ( -> ) + ( | theme ) + #2ce9 .System/r DEO2 + #01c0 .System/g DEO2 + #2ce5 .System/b DEO2 + ( | interrupts ) + ;on-frame .Screen/vector DEO2 + ( | fps label ) + .Screen/width DEI2 #0046 SUB2 .Screen/x DEO2 + #0008 .Screen/y DEO2 + ;text/fps #42 <draw-str> + ( | bunnies label ) + #0004 .Screen/x DEO2 + ;text/bunnies #42 <draw-str> + ( | instructions label ) + .Screen/width DEI2 #01 SFT2 #0050 SUB2 .Screen/x DEO2 + ;text/instructions #43 <draw-str> + #0028 #0008 #0000 <draw-dec> + ( | seed prng ) + prng-init BRK + +@on-frame ( -> ) + .frames LDZ2k INC2 ROT STZ2 + .DateTime/second DEI .last LDZ EQU ?{ + .DateTime/second DEI .last STZ + .Screen/width DEI2 #002b SUB2 #0008 .frames LDZ2 <draw-dec> + #0000 .frames STZ2 } + ( | mouse handling ) + .Mouse/state DEI + ( ) DUP #01 NEQ ?{ add-bunny } + ( ) #02 LTH ?{ remove-bunny } + ( | controller handling ) + .Controller/button DEI + ( ) DUP #01 NEQ ?{ add-bunny } + ( ) #02 LTH ?{ remove-bunny } + ( | clear ) + #0000 DUP2 .Screen/x DEO2 + .Screen/y DEO2 + [ LIT2 80 -Screen/pixel ] DEO + ;sprite/length LDA2 #0000 + &loop ( -- ) + EQU2k ?&bail + DUP2 <draw-bunny> + INC2 !&loop + &bail ( -- ) + POP2 POP2 BRK + +@add-bunny ( -- ) + ;sprite/length LDA2 + ( | cap bunny count at 65535 ) + DUP2 #ffff EQU2 ?&bail + ( | compute the offset to the beginning of this new bunny's data ) + DUP2 #30 SFT2 ;sprite/array ADD2 + ( | populate the new bunny's x/y/xvel/yvel with random values ) + #00 rand OVR2 STA2 + rand #1f AND rand OVR2 INC2 INC2 STA2 + #00 rand #7f AND OVR2 #0004 ADD2 STA2 + #00 rand #7f AND OVR2 #0006 ADD2 STA2 + ( | pop ptr to bunny data ) + POP2 + ( | write new increased array length ) + INC2 DUP2 ;sprite/length STA2 + ( | update label ) + STH2k #0028 #0008 STH2r <draw-dec> + &bail ( pop sprite/length ) + POP2 JMP2r + +@remove-bunny ( -- ) + ;sprite/length LDA2 + ( don't let length go below 0 ) ORAk #00 EQU ?&bail + #0001 SUB2 DUP2 ;sprite/length STA2 + ( update label ) STH2k #0028 #0008 STH2r <draw-dec> + &bail POP2 JMP2r + +( +@|drawing ) + +@<draw-bunny> ( idx -- ) + ( | compute the offset to the beginning of this bunny's data ) + #30 SFT2 ;sprite/array ADD2 + ( | move the sprite by its velocity ) + LDA2k OVR2 #0004 ADD2 LDA2 ADD2 OVR2 STA2 + INC2k INC2 LDA2 OVR2 #0006 ADD2 LDA2 ADD2 OVR2 INC2 INC2 STA2 + ( | check for right wall collision + bounce x ) + DUP2 #0004 ADD2 LDA2 #0f SFT2 #0001 EQU2 ?&skip-max-x + LDA2k #05 SFT2 #0008 ADD2 .Screen/width DEI2 LTH2 ?&skip-max-x + DUP2 #0004 ADD2 LDA2 #ffff MUL2 OVR2 #0004 ADD2 STA2 + &skip-max-x ( check for left wall collision + bounce x ) + LDA2k #0f SFT2 #0000 EQU2 ?&skip-min-x + DUP2 #0004 ADD2 LDA2 #ffff MUL2 OVR2 #0004 ADD2 STA2 + &skip-min-x ( check for bottom wall collision + bounce y ) + DUP2 #0006 ADD2 LDA2 #0f SFT2 #0001 EQU2 ?&skip-max-y + INC2k INC2 LDA2 #05 SFT2 #0010 ADD2 .Screen/height DEI2 LTH2 ?&skip-max-y + DUP2 #0006 ADD2 LDA2 #ffff MUL2 OVR2 #0006 ADD2 STA2 + !&skip-gravity + &skip-max-y ( check for top wall collision + bounce x ) + INC2k INC2 LDA2 #0f SFT2 #0000 EQU2 ?&skip-min-y + DUP2 #0006 ADD2 LDA2 #ffff MUL2 OVR2 #0006 ADD2 STA2 + !&skip-gravity + &skip-min-y ( apply gravity ) + DUP2 #0006 ADD2 LDA2 #0004 ADD2 OVR2 #0006 ADD2 STA2 + &skip-gravity ( draw the sprite ) + ( top ) LDA2k #05 SFT2 .Screen/x DEO2 + INC2 INC2 LDA2 #05 SFT2 .Screen/y DEO2 + ( draw ) [ LIT2 15 -Screen/auto ] DEO + ;bunny-chr .Screen/addr DEO2 + [ LIT2 85 -Screen/sprite ] DEO + [ LIT2 00 -Screen/auto ] DEO + JMP2r + +@<draw-str> ( x* y* text* color -- ) + ,&t STR + [ LIT2 01 -Screen/auto ] DEO + &loop ( -- ) + LDAk #20 SUB #00 SWP #30 SFT2 ;font ADD2 .Screen/addr DEO2 + [ LIT2 &t $1 -Screen/sprite ] DEO + INC2 LDAk ?&loop + POP2 JMP2r + +@<draw-dec> ( x* y* num* -- ) + [ LIT2 01 -Screen/auto ] DEO + SWP2 .Screen/y DEO2 + SWP2 .Screen/x DEO2 + #2710 DIV2k DUP <draw-digit> + MUL2 SUB2 #03e8 DIV2k DUP <draw-digit> + MUL2 SUB2 #0064 DIV2k DUP <draw-digit> + MUL2 SUB2 NIP #0a DIVk DUP <draw-digit> + MUL SUB <draw-digit> + [ LIT2 00 -Screen/auto ] DEO + JMP2r + +@<draw-digit> ( num -- ) + #30 SFT #00 SWP ;font/num ADD2 .Screen/addr DEO2 + [ LIT2 41 -Screen/sprite ] DEO + JMP2r + +( +@|random ) + +@prng-init ( -- ) + [ LIT2 00 -DateTime/second ] DEI [ LIT2 00 -DateTime/minute ] DEI #60 SFT2 EOR2 [ LIT2 00 -DateTime/hour ] DEI #c0 SFT2 EOR2 ,prng/x STR2 + [ LIT2 00 -DateTime/hour ] DEI #04 SFT2 [ LIT2 00 -DateTime/day ] DEI #10 SFT2 EOR2 [ LIT2 00 -DateTime/month ] DEI #60 SFT2 EOR2 .DateTime/year DEI2 #a0 SFT2 EOR2 ,prng/y STR2 + JMP2r + +@prng ( -- number* ) + [ LIT2 &x $2 ] DUP2 #50 SFT2 EOR2 DUP2 #03 SFT2 EOR2 [ LIT2 &y $2 ] DUP2 ,&x STR2 + DUP2 #01 SFT2 EOR2 EOR2 ,&y STR2k POP JMP2r + +@rand ( -- number ) + prng ADD JMP2r + ( static string data ) + +( +@|assets ) + +@text &fps "FPS: $1 + &bunnies "BUNS: $1 + &instructions "CLICK 20 "TO 20 "ADD 20 "BUNNIES! $1 + +@font ( atari8.uf1 ) + [ + 0000 0000 0000 0000 6060 6060 6000 6000 + 6666 6600 0000 0000 006c fe6c 6cfe 6c00 + 183e 603c 067c 1800 0066 6c18 3066 4600 + 386c 3870 decc 7600 6060 6000 0000 0000 + 0e1c 1818 181c 0e00 7038 1818 1838 7000 + 0066 3cff 3c66 0000 0018 187e 1818 0000 + 0000 0000 0030 3060 0000 007e 0000 0000 + 0000 0000 0018 1800 0206 0c18 3060 4000 ] &num [ + 3c66 6e76 6666 3c00 1838 1818 1818 7e00 + 3c66 060c 1830 7e00 7e0c 180c 0666 3c00 + 0c1c 3c6c 7e0c 0c00 7e60 7c06 0666 3c00 + 3c60 607c 6666 3c00 7e06 0c18 3030 3000 + 3c66 663c 6666 3c00 3c66 663e 060c 3800 + 0060 6000 6060 0000 0030 3000 3030 6000 + 0c18 3060 3018 0c00 0000 7e00 007e 0000 + 6030 180c 1830 6000 3c66 060c 1800 1800 + 3c66 6e6a 6e60 3e00 183c 6666 7e66 6600 + 7c66 667c 6666 7c00 3c66 6060 6066 3c00 + 786c 6666 666c 7800 7e60 607c 6060 7e00 + 7e60 607c 6060 6000 3e60 606e 6666 3e00 + 6666 667e 6666 6600 7830 3030 3030 7800 + 0606 0606 0666 3c00 666c 7870 786c 6600 + 6060 6060 6060 7e00 c6ee fed6 c6c6 c600 + 6676 7e7e 6e66 6600 3c66 6666 6666 3c00 + 7c66 667c 6060 6000 3c66 6666 766c 3600 + 7c66 667c 6c66 6600 3c66 603c 0666 3c00 + 7e18 1818 1818 1800 6666 6666 6666 3e00 + 6666 6666 663c 1800 c6c6 c6d6 feee c600 + 6666 3c18 3c66 6600 6666 663c 1818 1800 + 7e06 0c18 3060 7e00 7860 6060 6060 7800 ] + +@fill-icn [ ffff ffff ffff ffff ] + +@bunny-chr [ + 2466 6600 2424 003c 4200 007e 7e7e 7e7e + 1818 3c3c 1800 0000 ff66 4242 667e 4242 ] + +( +@|memory ) + +@sprite &length $2 + &array &x 0600 &y 0500 &xvel 0060 &yvel 0010 + diff --git a/awk/uxn/test/tal/life.tal b/awk/uxn/test/tal/life.tal new file mode 100644 index 0000000..718068b --- /dev/null +++ b/awk/uxn/test/tal/life.tal @@ -0,0 +1,221 @@ +( uxnemu life.rom ) + ( Any live cell with fewer than two live neighbours dies, as if by underpopulation. ) + ( Any live cell with two or three live neighbours lives on to the next generation. ) + ( Any live cell with more than three live neighbours dies, as if by overpopulation. ) + ( Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction. ) + +|00 @System &vector $2 &expansion $2 &wst $1 &rst $1 &metadata $2 &r $2 &g $2 &b $2 &debug $1 &state $1 +|10 @Console &vector $2 &read $1 &pad $5 &write $1 &error $1 +|20 @Screen &vector $2 &width $2 &height $2 &auto $1 &pad $1 &x $2 &y $2 &addr $2 &pixel $1 &sprite $1 +|30 @Audio0 &vector $2 &position $2 &output $1 &pad $3 &adsr $2 &length $2 &addr $2 &volume $1 &pitch $1 +|80 @Controller &vector $2 &button $1 &key $1 +|90 @Mouse &vector $2 &x $2 &y $2 &state $1 &wheel $1 +|000 + + @world &count $2 + @anchor &x $2 &y $2 &x2 $2 &y2 $2 + +|100 + +@on-reset ( -> ) + ( | theme ) + #02cf .System/r DEO2 + #02ff .System/g DEO2 + #024f .System/b DEO2 + ( | resize ) + #00c0 DUP2 .Screen/width DEO2 + .Screen/height DEO2 + ( | vectors ) + ;on-frame .Screen/vector DEO2 + ;on-mouse .Mouse/vector DEO2 + ;on-control .Controller/vector DEO2 + ( | glider ) + #0703 <set-cell> + #0704 <set-cell> + #0504 <set-cell> + #0705 <set-cell> + #0605 <set-cell> + ( | center ) + .Screen/width DEI2 #01 SFT2 #0040 SUB2 DUP2 .anchor/x STZ2 + #007e ADD2 .anchor/x2 STZ2 + .Screen/height DEI2 #01 SFT2 #0040 SUB2 DUP2 .anchor/y STZ2 + #007e ADD2 .anchor/y2 STZ2 + BRK + +@on-frame ( -> ) + [ LIT2 00 -Mouse/state ] DEI EQU ?{ BRK } + #0000 .world/count STZ2 + [ LIT &f $1 ] INCk ,&f STR + ( ) #03 AND #00 EQU ?{ BRK } + <run> + BRK + +@on-mouse ( -> ) + [ LIT2 00 -Mouse/state ] DEI NEQ #42 ADD ;cursor-icn <update-cursor> + ( | on touch in rect ) + .Mouse/state DEI ?{ BRK } + .Mouse/x DEI2 .Mouse/y DEI2 .anchor within-rect ?{ BRK } + ( | paint ) + .Mouse/x DEI2 .anchor/x LDZ2 SUB2 #01 SFT NIP + ( ) .Mouse/y DEI2 .anchor/y LDZ2 SUB2 #01 SFT NIP <set-cell> + <redraw> + BRK + +@on-control ( -> ) + .Controller/key DEI + ( ) DUP #20 NEQ ?{ + #0000 ;on-frame .Screen/vector DEI2 ORA ?{ SWP2 } + POP2 .Screen/vector DEO2 } + ( ) #1b NEQ ?{ ;MMU/clear1 .System/expansion DEO2 } + BRK + +( +@|core ) + +@<run> ( -- ) + ;MMU/clear2 .System/expansion DEO2 + #4000 + &ver ( -- ) + DUP ,&y STR + #4000 + &hor ( -- ) + DUP [ LIT &y $1 ] <run-cell> + INC GTHk ?&hor + POP2 INC GTHk ?&ver + POP2 + ( move ) ;MMU/move21 .System/expansion DEO2 + !<redraw> + +@<run-cell> ( x y -- ) + ( x y ) DUP2 STH2k + ( neighbours ) get-neighbours + ( state ) STH2r get-index LDA #00 EQU ?&dead + DUP #02 LTH ?&dies + DUP #03 GTH ?&dies + POP !&save + &dies POP POP2 JMP2r + &dead ( -- ) + DUP #03 EQU ?&birth + POP POP2 JMP2r + &birth POP !&save + &save ( x y -- ) + STH2 + #01 STH2r get-index #1000 ADD2 STA + .world/count LDZ2 INC2 .world/count STZ2 + JMP2r + +@get-index ( x y -- index* ) + ( y ) #3f AND #00 SWP #60 SFT2 ROT + ( x ) #3f AND #00 SWP ADD2 ;bank1 ADD2 JMP2r + +@<set-cell> ( x y -- ) + get-index STH2 + #01 STH2r STA + JMP2r + +@get-neighbours ( x y -- neighbours ) + ,&y STR + ,&x STR + [ LITr 00 ] #0800 + &l ( -- ) + #00 OVRk ADD2 ;&mask ADD2 LDA2 + ( ) [ LIT &y $1 ] ADD SWP + ( ) [ LIT &x $1 ] ADD SWP get-index LDA [ STH ADDr ] + ( stop at 3 ) DUPr [ LITr 03 ] GTHr [ LITr _&end ] JCNr + ( ) INC GTHk ?&l + &end POP2 STHr JMP2r + &mask [ + ffff 00ff 01ff ff00 0100 ff01 0001 0101 ] + +@within-rect ( x* y* rect -- flag ) + STH + ( y < rect.y1 ) DUP2 STHkr INC INC LDZ2 LTH2 ?&skip + ( y > rect.y2 ) DUP2 STHkr #06 ADD LDZ2 GTH2 ?&skip + SWP2 + ( x < rect.x1 ) DUP2 STHkr LDZ2 LTH2 ?&skip + ( x > rect.x2 ) DUP2 STHkr #04 ADD LDZ2 GTH2 ?&skip + POP2 POP2 POPr #01 JMP2r + &skip POP2 POP2 POPr #00 JMP2r + +( +@|drawing ) + +@<redraw> ( -- ) + ( | draw count ) + .anchor/x LDZ2 .Screen/x DEO2 + .anchor/y2 LDZ2 #0008 ADD2 .Screen/y DEO2 + [ LIT2 01 -Screen/auto ] DEO + .world/count LDZ2 <draw-short> + ( | draw grid ) + [ LIT2 01 -Screen/auto ] DEO + .anchor/y LDZ2 .Screen/y DEO2 + ;bank2 ;bank1 + &l ( -- ) + DUP #3f AND ?{ + .Screen/y DEI2k INC2 INC2 ROT DEO2 + .anchor/x LDZ2 .Screen/x DEO2 } + LDAk INC .Screen/pixel DEO + [ LIT2 00 -Screen/pixel ] DEO + INC2 GTH2k ?&l + POP2 POP2 JMP2r + +@<draw-short> ( short* -- ) + SWP <draw-byte> + ( >> ) + +@<draw-byte> ( byte color -- ) + DUP #04 SFT <draw-hex> + #0f AND + ( >> ) + +@<draw-hex> ( char color -- ) + #00 SWP #30 SFT2 ;font-hex ADD2 .Screen/addr DEO2 + [ LIT2 03 -Screen/sprite ] DEO + JMP2r + +@<update-cursor> ( color addr* -- ) + [ LIT2 00 -Screen/auto ] DEO + ;fill-icn .Screen/addr DEO2 + #40 <draw-cursor> + .Mouse/x DEI2 ,<draw-cursor>/x STR2 + .Mouse/y DEI2 ,<draw-cursor>/y STR2 + .Screen/addr DEO2 + ( >> ) + +@<draw-cursor> ( color -- ) + [ LIT2 &x $2 ] .Screen/x DEO2 + [ LIT2 &y $2 ] .Screen/y DEO2 + .Screen/sprite DEO + JMP2r + +( +@|assets ) + +@MMU ( programs ) + &clear1 [ 01 1000 0000 =bank3 0000 =bank1 ] + &clear2 [ 01 1000 0000 =bank3 0000 =bank2 ] + &move21 [ 01 1000 0000 =bank2 0000 =bank1 ] + +@cursor-icn [ 80c0 e0f0 f8e0 1000 ] + +@fill-icn [ ffff ffff ffff ffff ] + +@font-hex [ + 7c82 8282 8282 7c00 3010 1010 1010 3800 + 7c82 027c 8080 fe00 7c82 021c 0282 7c00 + 2242 82fe 0202 0200 fe80 807c 0282 7c00 + 7c82 80fc 8282 7c00 fe82 0408 0810 1000 + 7c82 827c 8282 7c00 7c82 827e 0202 0200 + 7c82 82fe 8282 8200 fc82 82fc 8282 fc00 + 7c82 8080 8082 7c00 fc82 8282 8282 fc00 + fe80 80f0 8080 fe00 fe80 80f0 8080 8000 ] + +( +@|memory ) + +|8000 @bank1 $1000 + +@bank2 $1000 + +@bank3 $1000 + diff --git a/awk/uxn/test/tal/opctest.tal b/awk/uxn/test/tal/opctest.tal new file mode 100644 index 0000000..b803de6 --- /dev/null +++ b/awk/uxn/test/tal/opctest.tal @@ -0,0 +1,492 @@ +( Opcode Tester ) + +|0013 + + @Zeropage &byte $1 &short $2 + @id $1 + +|100 + +@on-reset ( -> ) + + ( part 1 + > LIT2: Puts a short on the stack + > LIT: Puts a byte on the stack + > #06 DEO: Write to metadata ports + > #18 DEO: Write a letter in terminal ) + + ;meta #06 DEO2 + [ LIT2 "kO ] #18 DEO #18 DEO + [ LIT2 "1 18 ] DEO #0a18 DEO + + ( part 2 + > LITr: Put a byte on return stack + > STH: Move a byte from working stack to return stack + > STH2r: Move a short from return stack to working stack ) + + [ LITr "k ] [ LIT "O ] STH STH2r #18 DEO #18 DEO + [ LIT2 "2 18 ] DEO #0a18 DEO + + ( part 3 + > LIT2r: Put a short on return stack + > DUP: Duplicate byte + > ADDr: Add bytes on return stack ) + + [ LIT2r "k 4d ] #01 DUP STH ADDr STH ADDr STH2r #18 DEO #18 DEO + [ LIT2 "3 18 ] DEO #0a18 DEO + + ( part 4 + > JSI: Subroutine to relative short address + > JMP2r: Jumps to absolute address on return stack ) + + subroutine + [ LIT2 "4 18 ] DEO #0a18 DEO + + ( part 5 + > POP2: Removes a short from the stack + > INC2: Increments short on stack + > DUP2: Duplicate short + > LDA: load byte from absolute address + > JCI: Conditional subroutine to relative short address ) + + ;Dict/ok pstr + [ LIT2 "5 18 ] DEO #0a18 DEO + + ( part 6 + > JSR2: Jump to subroutine from short pointer + > LDAk: Non-destructive load byte from absolute address ) + + { "Ok $1 } STH2r ;pstr-jcn JSR2 + [ LIT2 "6 18 ] DEO #0a18 DEO + + ( part 7 + > Relative distance bytes ) + + rel-distance/entry SWP #18 DEO #18 DEO + [ LIT2 "7 18 ] DEO #0a18 DEO + + ( part xx + > GTH2k: Non-destructive greater-than short + > LDA2k: Non-destructive load short from absolute address + > STA2: Store short at absolute address ) + + [ LIT2r 0000 ] + ;tests/end ;tests + &l + run-test [ LITr 00 ] STH ADD2r + INC2 INC2 GTH2k ?&l + POP2 POP2 + STH2r ;tests/end ;tests SUB2 #01 SFT2 + EQU2 ;Dict/opctests test-part + + ( Part xx + > Testing that stacks are circular and wrapping + > Storing 12 at -1 and 34 at 0 ) + + POP #12 #34 ADD #46 EQU STH + POP #1234 ADD #46 EQU STH + POP2 #1111 #2222 ADD2 #3333 EQU2 + STHr AND STHr AND + ;Dict/stack-wrap test-part + + ( restore stack ) #0000 #0000 + + ( Part xx + > Testing RAM wrapping + > Storing 12 in 0xffff, and 34 in 0x0000 ) + + #1234 #ffff STA2 + ( LDA ) #0000 LDA #ffff LDA ADD #46 EQU + ( LDA2 ) #ffff LDA2 ADD #46 EQU + AND ;Dict/ram-wrap test-part + + ( Part xx + > Testing that zero-page is wrapping ) + + #5678 #ff STZ2 + ( LDZ ) #00 LDZ #ff LDZ ADD #ce EQU + ( LDZ2 ) #ff LDZ2 ADD #ce EQU + AND ;Dict/zp-wrap test-part + + ( Part xx + > Testing that device page is wrapping ) + + #1234 #ff DEO2 + ( DEI ) #00 DEI #ff DEI ADD #46 EQU + ( DEI2 ) #ff DEI2 ADD #46 EQU + AND ;Dict/dev-wrap test-part + #0000 DEO #00ff DEO + + ( end ) + + [ LIT &fail 80 ] + DUP #80 EQU ;Dict/result test-part + #0f DEO + + #0a18 DEO + #010e DEO + +BRK + +( +@|metadata ) + +@meta 00 + ( name ) "Opctest 0a + ( details ) "A 20 "Testing 20 "Program 0a + ( author ) "By 20 "Devine 20 "Lu 20 "Linvega 0a + ( date ) "24 20 "Jun 20 "2025 $2 + +@test-part ( f name* -- ) + pstr ?{ + #01 ;on-reset/fail STA + ;Dict/failed !pstr } + ;Dict/passed !pstr + +@run-test ( addr* -- addr* f ) + + LDA2k JSR2 DUP ?&pass + ;Dict/missed pstr + [ LIT2 &name $2 ] pstr + [ LIT2 "# 18 ] DEO + [ LIT2 "a -id ] LDZ ADD #18 DEO + #0a18 DEO + #01 ;on-reset/fail STA + &pass + .id LDZ INC .id STZ + +JMP2r + +@set ( name* -- f ) + + ;run-test/name STA2 #01 + [ LIT2 ff -id ] STZ + +JMP2r + +@pstr ( str* -- ) + DUP2 LDA + DUP ?{ POP POP2 JMP2r } + #18 DEO + INC2 !pstr + +@pstr-jcn ( str* -- ) + LDAk #18 DEO + INC2 LDAk ,pstr-jcn JCN + POP2 + JMP2r + +@tests +=op-equ [ + =op-equ/a =op-equ/b =op-equ/c =op-equ/d + =op-equ/e =op-equ/f =op-equ/g =op-equ/h ] +=op-neq [ + =op-neq/a =op-neq/b =op-neq/c =op-neq/d + =op-neq/e =op-neq/f =op-neq/g =op-neq/h ] +=op-gth [ + =op-gth/a =op-gth/b =op-gth/c =op-gth/d + =op-gth/e =op-gth/f =op-gth/g =op-gth/h ] +=op-lth [ + =op-lth/a =op-lth/b =op-lth/c =op-lth/d + =op-lth/e =op-lth/f =op-lth/g =op-lth/h ] +=op-add [ + =op-add/a =op-add/b =op-add/c =op-add/d + =op-add/e =op-add/f =op-add/g =op-add/h ] +=op-sub [ + =op-sub/a =op-sub/b =op-sub/c =op-sub/d + =op-sub/e =op-sub/f =op-sub/g =op-sub/h ] +=op-mul [ + =op-mul/a =op-mul/b =op-mul/c =op-mul/d + =op-mul/e =op-mul/f =op-mul/g =op-mul/h ] +=op-div [ + =op-div/a =op-div/b =op-div/c =op-div/d =op-div/e + =op-div/f =op-div/g =op-div/h =op-div/i =op-div/j ] +=op-inc [ + =op-inc/a =op-inc/b =op-inc/c =op-inc/d + =op-inc/e =op-inc/f =op-inc/g =op-inc/h ] +=op-pop [ + =op-pop/a =op-pop/b =op-pop/c =op-pop/d + =op-pop/e =op-pop/f =op-pop/g =op-pop/h ] +=op-dup [ + =op-dup/a =op-dup/b ] +=op-nip [ + =op-nip/a =op-nip/b =op-nip/c =op-nip/d ] +=op-swp [ + =op-swp/a =op-swp/b ] +=op-ovr [ + =op-ovr/a =op-ovr/b ] +=op-rot [ + =op-rot/a =op-rot/b ] +=op-and [ + =op-and/a =op-and/b =op-and/c =op-and/d + =op-and/e =op-and/f =op-and/g =op-and/h ] +=op-ora [ + =op-ora/a =op-ora/b =op-ora/c =op-ora/d + =op-ora/e =op-ora/f =op-ora/g =op-ora/h ] +=op-eor [ + =op-eor/a =op-eor/b =op-eor/c =op-eor/d + =op-eor/e =op-eor/f =op-eor/g =op-eor/h ] +=op-sft [ + =op-sft/a =op-sft/b =op-sft/c =op-sft/d + =op-sft/e =op-sft/f =op-sft/g =op-sft/h ] +=op-stz [ + =op-stz/a =op-stz/b =op-stz/c =op-stz/d ] +=op-str [ + =op-str/a =op-str/b =op-str/c =op-str/d ] +=op-sta [ + =op-sta/a =op-sta/b =op-sta/c =op-sta/d ] +=op-jmp [ + =op-jmp/a =op-jmp/b ] +=op-jcn [ + =op-jcn/a =op-jcn/b =op-jcn/c =op-jcn/d ] +=op-jsr [ + =op-jsr/a =op-jsr/b ] +=op-sth [ + =op-sth/a =op-sth/b ] +=op-jci [ + =op-jci/a =op-jci/b =op-jci/c ] +=op-jmi [ + =op-jmi/a ] +=op-jsi [ + =op-jsi/a =op-jsi/b =op-jsi/c =op-jsi/d ] + &end + +@op-equ ;Dict/equ !set + &a #f8 #f8 EQU [ #01 ] EQU JMP2r + &b #01 #01 EQU [ #01 ] EQU JMP2r + &c #f8 #01 EQU [ #00 ] EQU JMP2r + &d #00 #ff EQU [ #00 ] EQU JMP2r + &e #f801 #f801 EQU2 [ #01 ] EQU JMP2r + &f #01f8 #01f8 EQU2 [ #01 ] EQU JMP2r + &g #f801 #01f8 EQU2 [ #00 ] EQU JMP2r + &h #01f8 #f801 EQU2 [ #00 ] EQU JMP2r +@op-neq ;Dict/neq !set + &a #f8 #f8 NEQ [ #00 ] EQU JMP2r + &b #01 #01 NEQ [ #00 ] EQU JMP2r + &c #f8 #01 NEQ [ #01 ] EQU JMP2r + &d #01 #f8 NEQ [ #01 ] EQU JMP2r + &e #f801 #f801 NEQ2 [ #00 ] EQU JMP2r + &f #01f8 #01f8 NEQ2 [ #00 ] EQU JMP2r + &g #f801 #01f8 NEQ2 [ #01 ] EQU JMP2r + &h #01f8 #f801 NEQ2 [ #01 ] EQU JMP2r +@op-gth ;Dict/gth !set + &a #f8 #f8 GTH [ #00 ] EQU JMP2r + &b #01 #01 GTH [ #00 ] EQU JMP2r + &c #f8 #01 GTH [ #01 ] EQU JMP2r + &d #01 #f8 GTH [ #00 ] EQU JMP2r + &e #f801 #f801 GTH2 [ #00 ] EQU JMP2r + &f #01f8 #01f8 GTH2 [ #00 ] EQU JMP2r + &g #f801 #01f8 GTH2 [ #01 ] EQU JMP2r + &h #01f8 #f801 GTH2 [ #00 ] EQU JMP2r +@op-lth ;Dict/lth !set + &a #f8 #f8 LTH [ #00 ] EQU JMP2r + &b #01 #01 LTH [ #00 ] EQU JMP2r + &c #f8 #01 LTH [ #00 ] EQU JMP2r + &d #01 #ff LTH [ #01 ] EQU JMP2r + &e #f801 #f801 LTH2 [ #00 ] EQU JMP2r + &f #01f8 #01f8 LTH2 [ #00 ] EQU JMP2r + &g #f801 #01f8 LTH2 [ #00 ] EQU JMP2r + &h #01f8 #f801 LTH2 [ #01 ] EQU JMP2r +@op-add ;Dict/add !set + &a #ff #00 ADD [ #ff ] EQU JMP2r + &b #01 #ff ADD [ #00 ] EQU JMP2r + &c #ff #ff ADD [ #fe ] EQU JMP2r + &d #12 #34 ADDk ADD ADD [ #8c ] EQU JMP2r + &e #ffff #0000 ADD2 [ #ffff ] EQU2 JMP2r + &f #0001 #ffff ADD2 [ #0000 ] EQU2 JMP2r + &g #ffff #ffff ADD2 [ #fffe ] EQU2 JMP2r + &h #fffe #ffff ADD2 [ #fffd ] EQU2 JMP2r +@op-sub ;Dict/sub !set + &a #ff #00 SUB [ #ff ] EQU JMP2r + &b #01 #ff SUB [ #02 ] EQU JMP2r + &c #ff #ff SUB [ #00 ] EQU JMP2r + &d #fe #ff SUB [ #ff ] EQU JMP2r + &e #ffff #0000 SUB2 [ #ffff ] EQU2 JMP2r + &f #0001 #ffff SUB2 [ #0002 ] EQU2 JMP2r + &g #ffff #ffff SUB2 [ #0000 ] EQU2 JMP2r + &h #fffe #ffff SUB2 [ #ffff ] EQU2 JMP2r +@op-mul ;Dict/mul !set + &a #00 #01 MUL [ #00 ] EQU JMP2r + &b #3f #e7 MUL [ #d9 ] EQU JMP2r + &c #37 #3f MUL [ #89 ] EQU JMP2r + &d #10 #02 MUL [ #20 ] EQU JMP2r + &e #1000 #0003 MUL2 [ #3000 ] EQU2 JMP2r + &f #abcd #1234 MUL2 [ #4fa4 ] EQU2 JMP2r + &g #8000 #0200 MUL2 [ #0000 ] EQU2 JMP2r + &h #2222 #0003 MUL2 [ #6666 ] EQU2 JMP2r +@op-div ;Dict/div !set + &a #10 #06 DIV [ #02 ] EQU JMP2r + &b #20 #20 DIV [ #01 ] EQU JMP2r + &c #34 #01 DIV [ #34 ] EQU JMP2r + &d #02 #ef DIV [ #00 ] EQU JMP2r + &e #02 #00 DIV [ #00 ] EQU JMP2r + &f #03e8 #0006 DIV2 [ #00a6 ] EQU2 JMP2r + &g #abcd #1234 DIV2 [ #0009 ] EQU2 JMP2r + &h #8000 #0200 DIV2 [ #0040 ] EQU2 JMP2r + &i #2222 #0003 DIV2 [ #0b60 ] EQU2 JMP2r + &j #0202 #0000 DIV2 [ #0000 ] EQU2 JMP2r +@op-inc ;Dict/inc !set + &a #01 INC [ #02 ] EQU JMP2r + &b #ff INC [ #00 ] EQU JMP2r + &c #fe INC [ #ff ] EQU JMP2r + &d #00 INC [ #01 ] EQU JMP2r + &e #0001 INC2 [ #0002 ] EQU2 JMP2r + &f #ffff INC2 [ #0000 ] EQU2 JMP2r + &g #fffe INC2 [ #ffff ] EQU2 JMP2r + &h #0000 INC2 [ #0001 ] EQU2 JMP2r +@op-pop ;Dict/pop !set + &a #0a #0b POP [ #0a ] EQU JMP2r + &b #0a #0b #0c POP POP [ #0a ] EQU JMP2r + &c #0a #0b #0c ADD POP [ #0a ] EQU JMP2r + &d #0a #0b #0c POP ADD [ #15 ] EQU JMP2r + &e #0a0b #0c0d POP2 [ #0a0b ] EQU2 JMP2r + &f #0a0b #0c0d #0e0f POP2 POP2 [ #0a0b ] EQU2 JMP2r + &g #0a0b #0c0d #0e0f ADD2 POP2 [ #0a0b ] EQU2 JMP2r + &h #0a0b #0c0d #0e0f POP2 ADD2 [ #1618 ] EQU2 JMP2r +@op-dup ;Dict/dup !set + &a #0a #0b DUP ADD ADD [ #20 ] EQU JMP2r + &b #0a0b DUP2 ADD2 [ #1416 ] EQU2 JMP2r +@op-nip ;Dict/nip !set + &a #12 #34 #56 NIP ADD [ #68 ] EQU JMP2r + &b #12 #34 #56 NIPk ADD2 ADD [ #f2 ] EQU JMP2r + &c #1234 #5678 #9abc NIP2 ADD2 [ #acf0 ] EQU2 JMP2r + &d #1234 #5678 #9abc NIP2k ADD2 ADD2 ADD2 [ #9e24 ] EQU2 JMP2r +@op-swp ;Dict/swp !set + &a #02 #10 SWP DIV [ #08 ] EQU JMP2r + &b #0a0b #0c0d SWP2 NIP2 [ #0a0b ] EQU2 JMP2r +@op-ovr ;Dict/ovr !set + &a #02 #10 OVR DIV ADD [ #0a ] EQU JMP2r + &b #0a0b #0c0d OVR2 NIP2 ADD2 [ #1416 ] EQU2 JMP2r +@op-rot ;Dict/rot !set + &a #02 #04 #10 ROT DIV ADD [ #0c ] EQU JMP2r + &b #0a0b #0c0d #0c0f ROT2 ADD2 NIP2 [ #161a ] EQU2 JMP2r +@op-and ;Dict/and !set + &a #fc #3f AND [ #3c ] EQU JMP2r + &b #f0 #0f AND [ #00 ] EQU JMP2r + &c #ff #3c AND [ #3c ] EQU JMP2r + &d #02 #03 AND [ #02 ] EQU JMP2r + &e #f0f0 #00f0 AND2 [ #00f0 ] EQU2 JMP2r + &f #aaaa #5555 AND2 [ #0000 ] EQU2 JMP2r + &g #ffff #1234 AND2 [ #1234 ] EQU2 JMP2r + &h #abcd #0a0c AND2 [ #0a0c ] EQU2 JMP2r +@op-ora ;Dict/ora !set + &a #0f #f0 ORA [ #ff ] EQU JMP2r + &b #ab #cd ORA [ #ef ] EQU JMP2r + &c #12 #34 ORA [ #36 ] EQU JMP2r + &d #88 #10 ORA [ #98 ] EQU JMP2r + &e #0f0f #f0f0 ORA2 [ #ffff ] EQU2 JMP2r + &f #abab #cdcd ORA2 [ #efef ] EQU2 JMP2r + &g #1122 #1234 ORA2 [ #1336 ] EQU2 JMP2r + &h #8888 #1000 ORA2 [ #9888 ] EQU2 JMP2r +@op-eor ;Dict/eor !set + &a #00 #00 EOR [ #00 ] EQU JMP2r + &b #ff #00 EOR [ #ff ] EQU JMP2r + &c #aa #55 EOR [ #ff ] EQU JMP2r + &d #ff #ff EOR [ #00 ] EQU JMP2r + &e #ffff #ff00 EOR2 [ #00ff ] EQU2 JMP2r + &f #aaaa #5555 EOR2 [ #ffff ] EQU2 JMP2r + &g #1122 #1234 EOR2 [ #0316 ] EQU2 JMP2r + &h #8888 #1000 EOR2 [ #9888 ] EQU2 JMP2r +@op-sft ;Dict/sft !set + &a #ff #08 SFT [ #00 ] EQU JMP2r + &b #ff #e0 SFT [ #00 ] EQU JMP2r + &c #ff #11 SFT [ #fe ] EQU JMP2r + &d #ff #12 SFT [ #7e ] EQU JMP2r + &e #ffff #01 SFT2 [ #7fff ] EQU2 JMP2r + &f #ffff #70 SFT2 [ #ff80 ] EQU2 JMP2r + &g #ffff #7e SFT2 [ #0180 ] EQU2 JMP2r + &h #ffff #e3 SFT2 [ #c000 ] EQU2 JMP2r +@op-stz ;Dict/stz !set + &a #ab .Zeropage/byte STZ .Zeropage/byte LDZ [ #ab ] EQU JMP2r + &b #cd .Zeropage/byte STZ .Zeropage/byte LDZ [ #cd ] EQU JMP2r + &c #1234 .Zeropage/short STZ2 .Zeropage/short LDZ2 [ #1234 ] EQU2 JMP2r + &d #5678 .Zeropage/short STZ2 .Zeropage/short LDZ2 [ #5678 ] EQU2 JMP2r +@op-str ;Dict/str !set + [ LIT &before1 $1 ] [ LIT2 &before2 $2 ] + &a #22 ,&before1 STR ,&before1 LDR [ #22 ] EQU JMP2r + &b #ef ,&after1 STR ,&after1 LDR [ #ef ] EQU JMP2r + &c #1234 ,&before2 STR2 ,&before2 LDR2 [ #1234 ] EQU2 JMP2r + &d #5678 ,&after2 STR2 ,&after2 LDR2 [ #5678 ] EQU2 JMP2r + [ LIT &after1 $1 ] [ LIT2 &after2 $2 ] +@op-sta ;Dict/sta !set + &a #34 ;Absolute/byte STA ;Absolute/byte LDA [ #34 ] EQU JMP2r + &b #56 ;Absolute/byte STA ;Absolute/byte LDA [ #56 ] EQU JMP2r + &c #1234 ;Absolute/short STA2 ;Absolute/short LDA2 [ #1234 ] EQU2 JMP2r + &d #5678 ;Absolute/short STA2 ;Absolute/short LDA2 [ #5678 ] EQU2 JMP2r +@op-jmp ;Dict/jmp !set + &a #12 #34 ,&reljmp JMP SWP &reljmp POP [ #12 ] EQU JMP2r + &b #56 #78 ;&absjmp JMP2 SWP &absjmp POP [ #56 ] EQU JMP2r +@op-jcn ;Dict/jcn !set + &a #23 #01 ,&reljcn-y JCN INC &reljcn-y [ #23 ] EQU JMP2r + &b #23 #00 ,&reljcn-n JCN INC &reljcn-n [ #24 ] EQU JMP2r + &c #23 #01 ;&absjcn-y JCN2 INC &absjcn-y [ #23 ] EQU JMP2r + &d #23 #00 ;&absjcn-n JCN2 INC &absjcn-n [ #24 ] EQU JMP2r +@op-jsr ;Dict/jsr !set + &a #1234 #5678 ,&routine JSR [ #68ac ] EQU2 JMP2r + &b #12 #34 ;routine JSR2 [ #46 ] EQU JMP2r + &routine ADD2 JMP2r +@op-sth ;Dict/sth !set + &a #0a STH #0b STH ADDr STHr [ #15 ] EQU JMP2r + &b #000a STH2 #000b STH2 ADD2r STH2r [ #0015 ] EQU2 JMP2r +@op-jci ;Dict/jci !set + &before #01 JMP2r + &a #01 ?&skip-a #00 JMP2r &skip-a #01 JMP2r + &b #00 ?&skip-b #01 JMP2r &skip-b #00 JMP2r + &c #01 ?&before #00 JMP2r +@op-jmi ;Dict/jmi !set + &a !&skip-a #00 JMP2r &skip-a #01 JMP2r +@op-jsi ;Dict/jsi !set + &a #02 #04 routine #06 EQU JMP2r + &b ;&return special &return JMP2r + &c ,&skip-c JMP &routine-c ADD JMP2r &skip-c #02 #04 op-jsi/routine-c #06 EQU JMP2r + &d ,&skip-d JMP &routine-d ADD JMP2r &skip-d #02 #04 op-jsi-far-routine-d #06 EQU JMP2r + +@special ( routine* -- f ) + + ( test that the stack order is LIFO ) + DUP2 STH2kr EQU2 + ROT ROT DUP2r STHr STHr SWP EQU2 AND + +JMP2r + +@routine ( a b -- c ) ADD JMP2r +@subroutine ( -- ) [ LIT2 "kO ] #18 DEO #18 DEO JMP2r +@Absolute &byte $1 &short $2 + +@Dict [ + &ok "Ok $1 + &done "Tests 20 "Complete. 0a $1 + &opctests "Opcodes $1 + &stack-wrap "Stack-wrap $1 + &ram-wrap "RAM-wrap $1 + &zp-wrap "Zeropage-wrap $1 + &dev-wrap "Devices-wrap $1 + &result "Result: $1 + &passed 20 "passed! 0a $1 + &missed "Opcode 20 "Failed 20 "-- 20 $1 + &failed 20 "failed. 0a $1 + &equ "EQU $1 &neq "NEQ $1 >h "GTH $1 <h "LTH $1 + &add "ADD $1 &sub "SUB $1 &mul "MUL $1 &div "DIV $1 + &inc "INC $1 &pop "POP $1 &dup "DUP $1 &nip "NIP $1 + &swp "SWP $1 &ovr "OVR $1 &rot "ROT $1 + &and "AND $1 &ora "ORA $1 &eor "EOR $1 &sft "SFT $1 + &stz "STZ $1 &str "STR $1 &sta "STA $1 + &jmp "JMP $1 &jcn "JCN $1 &jsr "JSR $1 &sth "STH $1 + &jmi "JMI $1 &jci "JCI $1 &jsi "JSI $1 +] + +( +@|Relative Distance Bytes ) + +@rel-distance +&back "O $7c +&entry + ,&back LDR + ,&forw LDR + JMP2r +$7e +&forw "k + +@op-jsi-far-routine-d + op-jsi/routine-d JMP2r + diff --git a/awk/uxn/test/tal/proper.tal b/awk/uxn/test/tal/proper.tal new file mode 100644 index 0000000..be8e04b --- /dev/null +++ b/awk/uxn/test/tal/proper.tal @@ -0,0 +1 @@ +@on-reset #01 #02 ADD BRK \ No newline at end of file diff --git a/awk/uxn/test/tal/simple.tal b/awk/uxn/test/tal/simple.tal new file mode 100644 index 0000000..c055e74 --- /dev/null +++ b/awk/uxn/test/tal/simple.tal @@ -0,0 +1 @@ +#01 #02 ADD BRK \ No newline at end of file diff --git a/awk/uxn/test/tal/simple2.tal b/awk/uxn/test/tal/simple2.tal new file mode 100644 index 0000000..6a37b65 --- /dev/null +++ b/awk/uxn/test/tal/simple2.tal @@ -0,0 +1 @@ +#01 #02 ADD BRK \ No newline at end of file diff --git a/awk/uxn/test/tal/simple3.tal b/awk/uxn/test/tal/simple3.tal new file mode 100644 index 0000000..09086b7 --- /dev/null +++ b/awk/uxn/test/tal/simple3.tal @@ -0,0 +1 @@ +#01 #02 ADD \ 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..8061fb7 --- /dev/null +++ b/js/scripting-lang/NEXT-STEPS.md @@ -0,0 +1,435 @@ +# Next Steps: Immutable Real-World Programming Features + +## Overview + +This document outlines the plan for extending the Simple Scripting Language to support real-world programming scenarios while maintaining its immutable, functional design philosophy. + +## Core Principles + +- **Immutability First**: All data structures are immutable +- **Transformation Over Mutation**: Operations return new data rather than modifying existing data +- **Functional Composition**: Complex operations built from simple, composable functions +- **Type Safety**: Enhanced pattern matching and type checking +- **Performance**: Efficient persistent data structures + +## Phase 1: String Operations and Type System + +### 1.1 String Operations +**Goal**: Add essential string manipulation capabilities + +**New Functions**: +```javascript +// String operations as functions +length : string.length "hello"; // 5 +contains : string.contains "hello" "ll"; // true +startsWith : string.startsWith "hello" "he"; // true +endsWith : string.endsWith "hello" "lo"; // true +substring : string.substring "hello" 1 3; // "el" + +// String concatenation +result : string.concat "Hello" " " "World"; // "Hello World" + +// String transformation +uppercase : string.upper "hello"; // "HELLO" +lowercase : string.lower "HELLO"; // "hello" +trimmed : string.trim " hello "; // "hello" +``` + +**Implementation**: +- Add `string.` namespace for string operations +- Add string operation functions to standard library +- No new syntax - uses existing function call patterns +- Extend existing string literal support + +### 1.2 Runtime Type Checking with `is` Keyword +**Goal**: Add explicit, optional type checking mechanism using the `is` keyword + +**Design Philosophy**: +- Type checking is purely additive - no breaking changes to existing code +- Works seamlessly with existing case expression syntax +- Returns boolean values, fitting the functional style +- Simple implementation with clear semantics + +**New Features**: +```javascript +// Basic type checking +isNumber : x -> x is number; +isString : x -> x is string; +isTable : x -> x is table; +isFunction : x -> x is function; + +// Type-safe operations in case expressions +safeStringOp : x -> case x of + x is string : string.length x + _ : "not a string"; + +// Complex type validation +validateUser : user -> case user of + user.name is string and user.age is number : true + _ : false; + +// Type guards in pattern matching +processData : data -> case data of + data is table : "processing table" + data is string : "processing string" + data is number : "processing number" + _ : "unknown type"; +``` + +**Supported Types**: +- `number` (both integers and floats) +- `string` +- `boolean` +- `table` (objects and arrays) +- `function` + +**Implementation**: +- Add `IS` token type and type-specific tokens (`NUMBER_TYPE`, `STRING_TYPE`, etc.) +- Update lexer to recognize `is` keyword and type names +- Extend parser to handle type checking expressions in case patterns +- Add type checking logic in interpreter that returns boolean values +- No changes to existing syntax or semantics + +## Phase 2: Persistent Data Structures + +### 2.1 Immutable Tables with Transformations +**Goal**: Replace mutable table operations with immutable transformations + +**Current Problem**: +```javascript +// This won't work (mutable) +cache[key] = value; +``` + +**Solution - Functional Immutable Transformations**: +```javascript +// Functional transformations using table namespace +cache : {}; +cache1 : table.set cache "user.1" "Alice"; +cache2 : table.set cache1 "user.2" "Bob"; +value : table.get cache2 "user.1"; // "Alice" +cache3 : table.delete cache2 "user.1"; + +// Nested updates with dot notation +user : {name: "Alice", profile: {age: 25}}; +updatedUser : table.set user "profile.age" 26; + +// Complex transformations using composition +cache1 : pipe + (table.set "user.1" "Alice") + (table.set "user.2" "Bob") + (table.set "user.3" "Charlie") + cache; + +// Table merging +combined : table.merge table1 table2; +``` + +**Implementation**: +- Add `table.set`, `table.get`, `table.delete`, `table.merge` functions +- Implement efficient structural sharing for immutable updates +- Add nested key support (e.g., "profile.age") +- All functions return new tables, never modify originals +- Use existing function composition patterns + +### 2.2 APL-Inspired Table Primitives +**Goal**: Enhance tables with APL-style operations for ergonomic data manipulation + +**Design Philosophy**: +- Use existing table syntax for array-like behavior +- Add APL-inspired primitives for vectorized operations +- Keep immutable transformations +- Provide concise, expressive data manipulation + +**New Features**: +```javascript +// Table creation (array-like using existing syntax) +numbers : {1, 2, 3, 4, 5}; +mixed : {1, "hello", true, {key: "value"}}; + +// All table operations namespaced for consistency +first : table.first numbers; // First element +last : table.last numbers; // Last element +length : table.length numbers; // Size/shape + +// Less common operations (namespaced) +rest : table.drop 1 numbers; // Drop first element +slice : table.slice numbers 2 3; // Elements 2-3 + +// Vectorized operations +doubled : table.add numbers numbers; // Element-wise addition +squared : table.multiply numbers numbers; // Element-wise multiplication +incremented : table.add numbers 1; // Scalar addition to each element + +// Reductions (all namespaced) +sum : table.sum numbers; // Sum reduction +max : table.max numbers; // Maximum reduction +min : table.min numbers; // Minimum reduction +product : table.product numbers; // Product reduction +average : table.average numbers; // Average reduction + +// Scan operations (namespaced) +runningSum : table.scan table.sum numbers; // Running sum scan +runningProduct : table.scan table.product numbers; // Running product scan + +// Table metadata operations +keys : table.keys table; // Get all keys +values : table.values table; // Get all values +reversed : table.reverse table; // Reverse order +sorted : table.sort table; // Sort +unique : table.unique table; // Remove duplicates +``` + +**Implementation**: +- Add `table.` namespace for all table operations +- Extend lexer to recognize table operation keywords +- Add vectorized operation logic in interpreter +- Implement reduction and scan operations +- Add table metadata operations + +## Phase 3: Higher-Order Functions for Collections + +### 3.1 Enhanced Standard Library +**Goal**: Add collection processing functions + +**New Functions**: +```javascript +// Table processing (using namespaced primitives) +numbers : {1, 2, 3, 4, 5}; +doubled : map @double numbers; // {2, 4, 6, 8, 10} +evens : filter @isEven numbers; // {2, 4} +sum : table.sum numbers; // 15 (sum reduction) + +// Table metadata operations +table : {a: 1, b: 2, c: 3}; +keys : table.keys table; // {a, b, c} +values : table.values table; // {1, 2, 3} +pairs : table.pairs table; // {{a, 1}, {b, 2}, {c, 3}} + +// Advanced operations with tables +nested : {{1, 2}, {3, 4}, {5}}; +flattened : table.flatten nested; // {1, 2, 3, 4, 5} +grouped : table.groupBy @isEven numbers; // {true: {2, 4}, false: {1, 3, 5}} + +// Table operations +reversed : table.reverse numbers; // {5, 4, 3, 2, 1} +sorted : table.sort numbers; // {1, 2, 3, 4, 5} +unique : table.unique {1, 2, 2, 3, 3, 4}; // {1, 2, 3, 4} +``` + +**Implementation**: +- Extend existing `map`, `filter`, `reduce` to work with tables +- Implement vectorized operations for tables +- Add reduction and scan operations +- Implement table metadata operations + +### 3.2 Table Generation Helpers +**Goal**: Add convenient table creation functions + +**New Functions**: +```javascript +// Table generation helpers +range : table.range 1 5; // {1, 2, 3, 4, 5} +repeated : table.repeat "hello" 3; // {"hello", "hello", "hello"} + +// Use existing map/filter instead of comprehensions +squares : map (x -> x * x) {1, 2, 3, 4, 5}; +evens : filter @isEven {1, 2, 3, 4, 5}; +``` + +## Phase 4: Error Handling with Error Type + +### 4.1 Error Type +**Goal**: Provide consistent error handling without complex monads + +**Implementation**: +```javascript +// Simple error type +error : message -> {type: "error", message: message}; + +// Safe operations with error handling +safeDivide : x y -> case y of + 0 : error "division by zero" + _ : x / y; + +safeParseNumber : str -> case str of + str is number : str + _ : error "invalid number"; + +// Error checking +isError : value -> value is error; +getErrorMessage : error -> case error of + {type: "error", message: m} : m; +``` + +## Phase 5: Real-World Scenario Support + +### 5.1 User Management System +**Immutable Implementation**: +```javascript +// User validation +isValidEmail : email -> case email of + email contains "@" : true + _ : false; + +createUser : name email age -> case (isValidEmail email) and (isValidAge age) of + true : {name: name, email: email, age: age, status: "active"} + false : error "invalid user data"; + +// User management +users : {}; +user1 : createUser "Alice" "alice@example.com" 25; +users1 : table.set users "user.1" user1; +user2 : createUser "Bob" "bob@example.com" 30; +users2 : table.set users1 "user.2" user2; + +// Safe user lookup +findUser : email users -> case users of + {} : error "user not found" + _ : case (table.first users).email = email of + true : table.first users + false : findUser email (table.drop 1 users); +``` + +### 5.2 Shopping Cart System +**Immutable Implementation**: +```javascript +// Cart operations +emptyCart : {items: {}, total: 0}; +addItem : cart item -> { + items: table.set cart.items (table.length cart.items + 1) item, + total: cart.total + item.price +}; +removeItem : cart itemId -> { + items: filter (item -> item.id != itemId) cart.items, + total: calculateTotal (filter (item -> item.id != itemId) cart.items) +}; + +// Discount application +applyDiscount : cart discountPercent -> { + items: cart.items, + total: cart.total * (1 - discountPercent / 100) +}; +``` + +### 5.3 Data Processing Pipeline +**Immutable Implementation**: +```javascript +// Data processing +salesData : { + {month: "Jan", sales: 1000, region: "North"}, + {month: "Feb", sales: 1200, region: "North"}, + {month: "Mar", sales: 800, region: "South"} +}; + +// Filter by region +filterByRegion : data region -> filter (item -> item.region = region) data; + +// Calculate totals using sum reduction +sumSales : data -> table.sum (map (item -> item.sales) data); + +// Process pipeline +northData : filterByRegion salesData "North"; +northTotal : sumSales northData; +``` + +## Implementation Timeline + +### Week 1-2: String Operations and Runtime Type Checking +- [ ] String concatenation operator +- [ ] String method implementations +- [ ] `is` keyword and type checking tokens +- [ ] Type checking in case expressions +- [ ] Type validation functions in standard library + +### Week 3-4: Table Primitives with Namespacing +- [ ] `table.` namespace for all table operations +- [ ] Vectorized operations for tables +- [ ] Reduction and scan operations +- [ ] Table metadata operations +- [ ] Performance optimization + +### Week 5-6: Higher-Order Functions +- [ ] Enhanced standard library +- [ ] Collection processing functions +- [ ] Table-specific operations +- [ ] Utility functions + +### Week 7-8: Error Handling +- [ ] Error type implementation +- [ ] Error handling patterns +- [ ] Error checking functions +- [ ] Integration with existing operations + +### Week 9-10: Real-World Scenarios +- [ ] User management system +- [ ] Shopping cart system +- [ ] Data processing pipeline +- [ ] Integration testing + +## Benefits of Runtime Type Checking Approach + +### Simplicity +- **Minimal Implementation**: Only need to add `is` keyword and type checking logic +- **No Breaking Changes**: Existing code continues to work unchanged +- **Clear Semantics**: `x is number` is obviously a boolean expression +- **Consistent Syntax**: Works seamlessly with existing case expressions + +### Functional Design +- **Boolean Results**: Type checking returns true/false, fitting functional style +- **Composable**: Can combine with logical operators (`and`, `or`, `not`) +- **Pattern Matching**: Integrates naturally with case expressions +- **No Side Effects**: Pure functions for type validation + +### Extensibility +- **Easy to Add Types**: Simple to extend for new types (arrays, tuples, etc.) +- **Custom Types**: Can implement custom type checking via functions +- **Performance**: Runtime overhead only when explicitly used +- **Optional**: No requirement to use type checking in existing code + +## Testing Strategy + +### Unit Tests +- String operation tests +- Runtime type checking tests (`is` keyword) +- Type validation function tests +- Data structure transformation tests +- Higher-order function tests +- Error handling tests + +### Integration Tests +- Real-world scenario tests +- Performance tests +- Edge case tests +- Error handling tests + +### Performance Benchmarks +- Data structure operation performance +- Memory usage analysis +- Transformation efficiency +- Scalability testing + +## Success Metrics + +- [ ] All real-world scenarios in `tests/17_real_world_scenarios.txt` pass +- [ ] Performance within acceptable bounds (no more than 2x slower than current) +- [ ] Memory usage remains reasonable +- [ ] Code remains readable and maintainable +- [ ] Backward compatibility maintained + +## Future Considerations + +### Advanced Features (Post-v1.0) +- Lazy evaluation for large collections +- Parallel processing capabilities +- Advanced type system with generics +- Macro system for code generation +- Module system for code organization + +### Performance Optimizations +- Structural sharing for immutable data structures +- Compile-time optimizations +- JIT compilation for hot paths +- Memory pooling for temporary objects + +This plan maintains the language's functional, immutable design while adding the capabilities needed for real-world programming scenarios. \ 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/debug_test.txt b/js/scripting-lang/debug_test.txt new file mode 100644 index 0000000..246c3fd --- /dev/null +++ b/js/scripting-lang/debug_test.txt @@ -0,0 +1,7 @@ +/* Simple test for case expressions */ +factorial : n -> case n of + 0 : 1 + _ : n * (factorial (n - 1)); + +test : factorial 5; +..out test; \ No newline at end of file diff --git a/js/scripting-lang/func_call_test.txt b/js/scripting-lang/func_call_test.txt new file mode 100644 index 0000000..826eb4e --- /dev/null +++ b/js/scripting-lang/func_call_test.txt @@ -0,0 +1,8 @@ +/* Test function calls in case expressions */ +add : x y -> x + y; +factorial : n -> case n of + 0 : 1 + _ : add n 1; + +test : factorial 5; +..out test; \ 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..1a0d77e 100644 --- a/js/scripting-lang/lang.js +++ b/js/scripting-lang/lang.js @@ -1,320 +1,2965 @@ -// 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. + * + * @param {Object} scope - The global scope object to inject functions into + * + * @description Injects higher-order functions into the interpreter's global scope. + * These functions provide functional programming utilities like map, compose, pipe, etc. + * + * @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 a value + * @param {Function} f - Function to apply + * @param {*} x - Value to apply function to + * @returns {*} Result of applying f to x + * @throws {Error} When first argument is not a function + */ + scope.map = function(f, x) { + 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)) + * @param {Function} f - Outer function + * @param {Function} g - Inner function + * @param {*} [x] - Optional argument to apply composed function to + * @returns {Function|*} Either a composed function or the result of applying it + * @throws {Error} When first two arguments are not functions + */ + scope.compose = function(f, g, x) { + if (typeof f === 'function' && typeof g === 'function') { + if (arguments.length === 3) { + return f(g(x)); + } else { + return function(x) { + return f(g(x)); + }; + } + } else { + throw new Error('compose: first two arguments must be functions'); + } + }; + + /** + * Curry: Apply a function to arguments (simplified currying) + * @param {Function} f - Function to curry + * @param {*} x - First argument + * @param {*} y - Second argument + * @returns {*} Result of applying f to x and y + * @throws {Error} When first argument is not a function + */ + 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 (explicit function application) + * @param {Function} f - Function to apply + * @param {*} x - Argument to apply function to + * @returns {*} Result of applying f to x + * @throws {Error} When first argument is not a function + */ + 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) + * @param {Function} f - First function + * @param {Function} g - Second function + * @param {*} [x] - Optional argument to apply piped function to + * @returns {Function|*} Either a piped function or the result of applying it + * @throws {Error} When first two arguments are not functions + */ + scope.pipe = function(f, g, x) { + if (typeof f === 'function' && typeof g === 'function') { + if (arguments.length === 3) { + return g(f(x)); + } else { + return function(x) { + return g(f(x)); + }; + } + } else { + throw new Error('pipe: first two arguments must be functions'); + } + }; + + /** + * Filter: Filter a value based on a predicate + * @param {Function} p - Predicate function + * @param {*} x - Value to test + * @returns {*|0} The value if predicate is true, 0 otherwise + * @throws {Error} When first argument is not a 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 two values using a binary function + * @param {Function} f - Binary function + * @param {*} init - Initial value + * @param {*} x - Second value + * @returns {*} Result of applying f to init and x + * @throws {Error} When first argument is not a 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 + * @param {Function} f - Binary function + * @param {*} init - Initial value + * @param {*} x - Second value + * @returns {*} Result of applying f to init and x + * @throws {Error} When first argument is not a function + */ + 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 enumeration for all supported token types. + * + * @type {Object.<string, string>} + * + * @description A flat object mapping token names to their string representations. + * This approach allows 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. + * + * @param {string} input - Source code to tokenize + * @returns {Array.<Object>} Array of token objects with type and value properties + * @throws {Error} For unterminated strings or unexpected characters + * + * @description Performs lexical analysis by converting source code into a stream of tokens. + * Handles whitespace, nested comments, numbers (integers and decimals), strings, + * identifiers/keywords, and both single- and multi-character operators. + * + * @how Uses a single pass with a while loop and manual character inspection. + * Each character is examined to determine the appropriate token type, with + * special handling for multi-character tokens and nested constructs. + * + * @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. + * + * @note 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]; + + // Handle nested comments: /* ... */ with support for /* /* ... */ */ + 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++; + + // Parse numbers (integers and decimals) + 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++; + + // Parse string literals + 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++; + + // Parse 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; + + // Parse 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 '..': + // Parse IO operations: ..in, ..out, ..assert + 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; + + // Parse 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). + * + * @param {Array.<Object>} tokens - Array of tokens from the lexer + * @returns {Object} Abstract Syntax Tree with program body + * @throws {Error} For parsing errors like unexpected tokens or missing delimiters + * + * @description Implements a recursive descent parser that builds an AST from tokens. + * Handles all language constructs including expressions, statements, function + * definitions, case expressions, table literals, and IO operations. + * + * @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. + * + * @note The parser 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 + let parsingFunctionArgs = false; // Flag to track when we're parsing function arguments + + // Reset call stack tracker for parser + callStackTracker.reset(); + + // Define all parsing functions outside of walk to avoid circular dependencies + + function parseChainedDotAccess(tableExpr) { + callStackTracker.push('parseChainedDotAccess', ''); + + try { + /** + * Handles chained dot access (e.g., table.key.subkey). + * + * @param {Object} tableExpr - The table expression to chain access from + * @returns {Object} AST node representing the chained access + * @throws {Error} When expected identifier is missing after dot + * + * @description Parses dot notation for table access, building a chain + * of TableAccess nodes for nested property access. + * + * @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; + } finally { + callStackTracker.pop(); } - - let token = tokens[current]; - - if (token.type === TokenType.NUMBER) { - current++; - return { - type: 'NumberLiteral', - value: token.value, - }; + } + + function parseChainedTableAccess(tableExpr) { + callStackTracker.push('parseChainedTableAccess', ''); + + try { + /** + * Handles chained bracket and dot access (e.g., table[0].key). + * + * @param {Object} tableExpr - The table expression to chain access from + * @returns {Object} AST node representing the chained access + * @throws {Error} When expected closing bracket is missing + * + * @description Parses both bracket and dot notation for table access, + * supporting mixed access patterns like 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; + } finally { + callStackTracker.pop(); } - - if (token.type === TokenType.PLUS) { - current++; - return { - type: 'PlusExpression', - left: walk(), - right: walk(), - }; + } + + function parseArgument() { + callStackTracker.push('parseArgument', ''); + + try { + const token = tokens[current]; + if (!token) { + throw new Error('Unexpected end of input'); + } + + // Parse unary operators + if (token.type === TokenType.NOT) { + current++; + const operand = parseArgument(); + return { type: 'NotExpression', operand }; + } + + if (token.type === TokenType.MINUS) { + current++; + const operand = parseArgument(); + return { type: 'UnaryMinusExpression', operand }; + } + + // Parse literals + if (token.type === TokenType.NUMBER) { + current++; + return { type: 'NumberLiteral', value: token.value }; + } else if (token.type === TokenType.STRING) { + current++; + return { type: 'StringLiteral', value: token.value }; + } else if (token.type === TokenType.TRUE) { + current++; + return { type: 'BooleanLiteral', value: true }; + } else if (token.type === TokenType.FALSE) { + current++; + return { type: 'BooleanLiteral', value: false }; + } else if (token.type === TokenType.NULL) { + current++; + return { type: 'NullLiteral' }; + } else if (token.type === TokenType.WILDCARD) { + current++; + return { type: 'WildcardPattern' }; + } else if (token.type === TokenType.FUNCTION_REF) { + current++; + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const functionName = tokens[current].value; + current++; + return { type: 'FunctionReference', name: functionName }; + } else { + throw new Error('Expected function name after @'); + } + } else if (token.type === TokenType.IO_IN) { + current++; + return { type: 'IOInExpression' }; + } else if (token.type === TokenType.IO_OUT) { + current++; + const outputValue = parseLogicalExpression(); + return { type: 'IOOutExpression', value: outputValue }; + } else if (token.type === TokenType.IO_ASSERT) { + current++; + const assertionExpr = parseLogicalExpression(); + return { type: 'IOAssertExpression', value: assertionExpr }; + } + + // Parse identifiers (but NOT as function calls) + if (token.type === TokenType.IDENTIFIER) { + current++; + const identifier = { type: 'Identifier', value: token.value }; + + // Check for table access + if (current < tokens.length && tokens[current].type === TokenType.DOT) { + return parseChainedDotAccess(identifier); + } + + // Check for table access with brackets + if (current < tokens.length && tokens[current].type === TokenType.LEFT_BRACKET) { + return parseChainedTableAccess(identifier); + } + + return identifier; + } + + // Parse parenthesized expressions + 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'); + } + } + + // Parse table literals + if (token.type === TokenType.LEFT_BRACE) { + current++; // Skip '{' + const properties = []; + + while (current < tokens.length && tokens[current].type !== TokenType.RIGHT_BRACE) { + if (tokens[current].type === TokenType.IDENTIFIER) { + const key = tokens[current].value; + current++; + + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + const value = parseLogicalExpression(); + properties.push({ key, value }); + } else { + throw new Error('Expected ":" after property name in table literal'); + } + } else { + throw new Error('Expected property name in table literal'); + } + + // Skip comma if present + 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', properties }; + } else { + throw new Error('Expected closing brace in table literal'); + } + } + + // If we get here, we have an unexpected token + throw new Error(`Unexpected token in parseArgument: ${token.type}`); + } finally { + callStackTracker.pop(); } - - if (token.type === TokenType.IDENTIFIER) { - current++; + } + + function parseFunctionCall(functionName) { + callStackTracker.push('parseFunctionCall', ''); + + try { + /** + * Parses function calls with arbitrary argument lists. + * + * @param {Object|string} functionName - Function name or expression to call + * @returns {Object} AST node representing the function call + * + * @description Parses function calls by collecting arguments until a + * clear terminator is found, supporting both curried and regular calls. + * + * @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. + * + * @note Special handling for unary minus arguments to distinguish them + * from binary minus operations. + */ + 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 - parse as expression but skip function call detection + // Create a temporary parsing context that doesn't trigger function call detection + const savedParsingFunctionArgs = parsingFunctionArgs; + parsingFunctionArgs = true; // Temporarily disable function call detection + const arg = parseExpression(); + parsingFunctionArgs = savedParsingFunctionArgs; // Restore the flag + args.push(arg); + } + } + return { - type: 'Identifier', - value: token.value, + type: 'FunctionCall', + name: functionName, + args: args }; + } finally { + callStackTracker.pop(); } - - if (token.type === TokenType.ASSIGNMENT) { - current++; - return { - type: 'AssignmentExpression', - name: tokens[current - 2].value, - value: walk(), - }; + } + + function parseLogicalExpression() { + callStackTracker.push('parseLogicalExpression', ''); + + try { + /** + * Parses logical expressions with lowest precedence. + * + * @returns {Object} AST node representing the logical expression + * + * @description Parses logical operators (and, or, xor) with proper + * precedence handling and left associativity. + * + * @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; + } finally { + callStackTracker.pop(); } - - 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; + } + + function parseExpression() { + callStackTracker.push('parseExpression', ''); + + try { + /** + * Parses expressions with left-associative binary operators. + * + * @returns {Object} AST node representing the expression + * + * @description Parses addition, subtraction, and comparison operators + * with proper precedence and associativity. + * + * @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. + * + * @note Special case handling for unary minus after function references + * to distinguish from binary minus 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; + } + + 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; + } + } + + return left; + } finally { + callStackTracker.pop(); } - - 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); + } + + function parseTerm() { + callStackTracker.push('parseTerm', ''); + + try { + /** + * Parses multiplication, division, and modulo operations. + * + * @returns {Object} AST node representing the term + * + * @description Parses multiplicative operators with higher precedence + * than addition/subtraction. + * + * @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 paren - while (tokens[current].type !== TokenType.RIGHT_BRACE) { - node.body.push(walk()); + + return left; + } finally { + callStackTracker.pop(); + } + } + + function parseFactor() { + callStackTracker.push('parseFactor', ''); + + try { + /** + * Parses exponentiation and primary expressions. + * + * @returns {Object} AST node representing the factor + * + * @description Parses exponentiation with right associativity and + * highest precedence among arithmetic operators. + * + * @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 brace - return node; + + return left; + } finally { + callStackTracker.pop(); } + } + + function parsePrimary() { + callStackTracker.push('parsePrimary', ''); + + try { + /** + * Parses literals, identifiers, function definitions, assignments, + * table literals, and parenthesized expressions. + * + * @returns {Object} AST node representing the primary expression + * @throws {Error} For parsing errors like unexpected tokens + * + * @description The core parsing function that handles all atomic and + * context-sensitive constructs in the language. + * + * @why This function is the core of the recursive descent parser, handling + * all atomic and context-sensitive constructs. Special care is taken to + * avoid circular dependencies by not calling higher-level parsing functions. + */ + + const token = tokens[current]; + if (!token) { + throw new Error('Unexpected end of input'); + } + + // Parse unary operators + 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 }; + } + + // Parse literals + if (token.type === TokenType.NUMBER) { + current++; + return { type: 'NumberLiteral', value: token.value }; + } else if (token.type === TokenType.STRING) { + current++; + return { type: 'StringLiteral', value: token.value }; + } else if (token.type === TokenType.TRUE) { + current++; + return { type: 'BooleanLiteral', value: true }; + } else if (token.type === TokenType.FALSE) { + current++; + return { type: 'BooleanLiteral', value: false }; + } else if (token.type === TokenType.NULL) { + current++; + return { type: 'NullLiteral' }; + } else if (token.type === TokenType.WILDCARD) { + current++; + return { type: 'WildcardPattern' }; + } else if (token.type === TokenType.FUNCTION_REF) { + current++; + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const functionName = tokens[current].value; + current++; + return { type: 'FunctionReference', name: functionName }; + } else { + throw new Error('Expected function name after @'); + } + } else if (token.type === TokenType.IO_IN) { + current++; + return { type: 'IOInExpression' }; + } else if (token.type === TokenType.IO_OUT) { + current++; + const outputValue = parseLogicalExpression(); + return { type: 'IOOutExpression', value: outputValue }; + } else if (token.type === TokenType.IO_ASSERT) { + current++; + const assertionExpr = parseLogicalExpression(); + return { type: 'IOAssertExpression', value: assertionExpr }; + } + + // Parse identifiers + if (token.type === TokenType.IDENTIFIER) { + current++; + const identifier = { type: 'Identifier', value: token.value }; + + // Skip function call detection if we're parsing function arguments + if (parsingFunctionArgs) { + return identifier; + } + + // Check for function calls + if (current < tokens.length && tokens[current].type === TokenType.LEFT_PAREN) { + return parseFunctionCall(identifier.value); + } + + // Check if the next token is an operator - if so, don't treat as function call + if (current < tokens.length && + (tokens[current].type === TokenType.PLUS || + tokens[current].type === TokenType.MINUS || + tokens[current].type === TokenType.MULTIPLY || + tokens[current].type === TokenType.DIVIDE || + tokens[current].type === TokenType.MODULO || + tokens[current].type === TokenType.POWER)) { + // This is part of a binary expression, don't treat as function call + return identifier; + } + + // Check for function calls without parentheses (e.g., add 3 4) + // Only treat as function call if the next token is a number, string, or left paren + // This prevents treating identifiers as function calls when they're actually arguments + if (current < tokens.length && + (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.value); + } + + // Special case for unary minus: only treat as function call if it's a unary minus + if (current < tokens.length && tokens[current].type === TokenType.MINUS) { + // Look ahead to see if this is a unary minus (like -5) or binary minus (like n - 1) + const nextToken = current + 1 < tokens.length ? tokens[current + 1] : null; + if (nextToken && nextToken.type === TokenType.NUMBER) { + // This is a unary minus, treat as function call + return parseFunctionCall(identifier.value); + } + // This is a binary minus, don't treat as function call + } + + // Special case for function calls with identifier arguments (e.g., add x y) + // Only treat as function call if the next token is an identifier and not followed by an operator + if (!parsingFunctionArgs && current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + // Look ahead to see if the next token is an identifier followed by an operator + const nextToken = current + 1 < tokens.length ? tokens[current + 1] : null; + const nextNextToken = current + 2 < tokens.length ? tokens[current + 2] : null; + + // Only treat as function call if the next token is an identifier and not followed by an operator + if (nextToken && nextToken.type === TokenType.IDENTIFIER && + (!nextNextToken || + (nextNextToken.type !== TokenType.PLUS && + nextNextToken.type !== TokenType.MINUS && + nextNextToken.type !== TokenType.MULTIPLY && + nextNextToken.type !== TokenType.DIVIDE && + nextNextToken.type !== TokenType.MODULO && + nextNextToken.type !== TokenType.POWER && + nextNextToken.type !== TokenType.EQUALS && + nextNextToken.type !== TokenType.NOT_EQUAL && + nextNextToken.type !== TokenType.LESS_THAN && + nextNextToken.type !== TokenType.GREATER_THAN && + nextNextToken.type !== TokenType.LESS_EQUAL && + nextNextToken.type !== TokenType.GREATER_EQUAL))) { + if (process.env.DEBUG) { + console.log(`[DEBUG] Creating function call for ${identifier.value} at position ${current}`); + } + return parseFunctionCall(identifier.value); + } + } + - 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()); + + // Check for table access + if (current < tokens.length && tokens[current].type === TokenType.DOT) { + return parseChainedDotAccess(identifier); + } + + // Check for table access with brackets + if (current < tokens.length && tokens[current].type === TokenType.LEFT_BRACKET) { + return parseChainedTableAccess(identifier); + } + + return identifier; } - current++; // Skip right paren - return node; - } + + // Parse parenthesized expressions + 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'); + } + } + + // Parse table literals + if (token.type === TokenType.LEFT_BRACE) { + current++; // Skip '{' + const properties = []; + + while (current < tokens.length && tokens[current].type !== TokenType.RIGHT_BRACE) { + if (tokens[current].type === TokenType.IDENTIFIER) { + const key = tokens[current].value; + current++; + + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + const value = parseLogicalExpression(); + properties.push({ key, value }); + } else { + throw new Error('Expected ":" after property name in table literal'); + } + } else { + throw new Error('Expected property name in table literal'); + } + + // Skip comma if present + 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', properties }; + } else { + throw new Error('Expected closing brace in table literal'); + } + } + + // Parse arrow expressions (function definitions) + if (token.type === TokenType.ARROW) { + current++; // Skip '->' + + // Parse the function body + const body = parseLogicalExpression(); + + return { type: 'ArrowExpression', body }; + } + - if (token.type === TokenType.SEMICOLON) { - current++; - return; - } + - throw new TypeError(token.type); + + // If we get here, we have an unexpected token + throw new Error(`Unexpected token in parsePrimary: ${token.type}`); + } finally { + callStackTracker.pop(); + } } + + function walk() { + callStackTracker.push('walk', `position:${current}`); + + try { + - let ast = { + + + + function parseLogicalExpression() { + callStackTracker.push('parseLogicalExpression', ''); + + try { + /** + * Parses logical expressions with lowest precedence. + * + * @returns {Object} AST node representing the logical expression + * + * @description Parses logical operators (and, or, xor) with proper + * precedence handling and left associativity. + * + * @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; + } finally { + callStackTracker.pop(); + } + } + + function parseExpression() { + callStackTracker.push('parseExpression', ''); + + try { + /** + * Parses expressions with left-associative binary operators. + * + * @returns {Object} AST node representing the expression + * + * @description Parses addition, subtraction, and comparison operators + * with proper precedence and associativity. + * + * @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. + * + * @note Special case handling for unary minus after function references + * to distinguish from binary minus 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; + } + + 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; + } + } + + return left; + } finally { + callStackTracker.pop(); + } + } + + function parseTerm() { + callStackTracker.push('parseTerm', ''); + + try { + /** + * Parses multiplication, division, and modulo operations. + * + * @returns {Object} AST node representing the term + * + * @description Parses multiplicative operators with higher precedence + * than addition/subtraction. + * + * @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; + } + } + + return left; + } finally { + callStackTracker.pop(); + } + } + + function parseFactor() { + callStackTracker.push('parseFactor', ''); + + try { + /** + * Parses exponentiation and primary expressions. + * + * @returns {Object} AST node representing the factor + * + * @description Parses exponentiation with right associativity and + * highest precedence among arithmetic operators. + * + * @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 }; + } + + return left; + } finally { + callStackTracker.pop(); + } + } + + // Check for IO operations first + if (tokens[current].type === TokenType.IO_IN) { + current++; + 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 }; + } + + + + // Check for assignments (identifier followed by ':') + if (tokens[current].type === TokenType.IDENTIFIER) { + const identifier = tokens[current].value; + current++; + + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + + // Check if this is a function definition with arrow syntax (x y -> body) + // Look ahead to see if we have parameters followed by -> + const lookAheadTokens = []; + let lookAheadPos = current; + + // Collect tokens until we find -> or hit a terminator + while (lookAheadPos < tokens.length && + tokens[lookAheadPos].type !== TokenType.ARROW && + tokens[lookAheadPos].type !== TokenType.SEMICOLON && + tokens[lookAheadPos].type !== TokenType.ASSIGNMENT) { + lookAheadTokens.push(tokens[lookAheadPos]); + lookAheadPos++; + } + + // If we found ->, this is a function definition with arrow syntax + if (lookAheadPos < tokens.length && tokens[lookAheadPos].type === TokenType.ARROW) { + // Parse parameters (identifiers separated by spaces) + const parameters = []; + let paramIndex = 0; + + while (paramIndex < lookAheadTokens.length) { + if (lookAheadTokens[paramIndex].type === TokenType.IDENTIFIER) { + parameters.push(lookAheadTokens[paramIndex].value); + paramIndex++; + } else { + // Skip non-identifier tokens (spaces, etc.) + paramIndex++; + } + } + + // Skip the parameters and -> + current = lookAheadPos + 1; // Skip the arrow + + // Parse the function body (check if it's a case expression) + let functionBody; + if (current < tokens.length && tokens[current].type === TokenType.CASE) { + // Parse case expression directly + current++; // Skip 'case' + + // Parse the values being matched (can be multiple) + const values = []; + while (current < tokens.length && tokens[current].type !== TokenType.OF) { + 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 { + const value = parsePrimary(); + 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) { + // If we hit an IO operation, we've reached the end of the case expression + if (current < tokens.length && + (tokens[current].type === TokenType.IO_IN || + tokens[current].type === TokenType.IO_OUT || + tokens[current].type === TokenType.IO_ASSERT)) { + break; + } + const patterns = []; + while (current < tokens.length && + tokens[current].type !== TokenType.ASSIGNMENT && + tokens[current].type !== TokenType.SEMICOLON) { + patterns.push(parsePrimary()); + } + + // Expect ':' after pattern + if (current < tokens.length && tokens[current].type === TokenType.ASSIGNMENT) { + current++; // Skip ':' + } else { + throw new Error('Expected ":" after pattern in case expression'); + } + + // Temporarily disable function call detection when parsing case expression results + const savedParsingFunctionArgs = parsingFunctionArgs; + parsingFunctionArgs = true; // Disable function call detection + const result = parseLogicalExpression(); + parsingFunctionArgs = savedParsingFunctionArgs; // Restore the flag + cases.push({ + pattern: patterns, + result: [result] + }); + + // Skip semicolon if present (but don't stop parsing cases) + if (current < tokens.length && tokens[current].type === TokenType.SEMICOLON) { + current++; + // If the next token is an identifier followed by assignment, we've reached the end of the case expression + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const nextPos = current + 1; + if (nextPos < tokens.length && tokens[nextPos].type === TokenType.ASSIGNMENT) { + break; // End of case expression + } + } + } + } + + functionBody = { + type: 'CaseExpression', + value: values, + cases, + }; + } else { + functionBody = parseLogicalExpression(); + } + + return { + type: 'Assignment', + identifier, + value: { + type: 'FunctionDefinition', + parameters, + body: functionBody + } + }; + } + + // Check if this is a function definition with 'function' keyword + if (current < tokens.length && tokens[current].type === TokenType.FUNCTION) { + current++; // Skip 'function' + + if (current >= tokens.length || tokens[current].type !== TokenType.LEFT_PAREN) { + throw new Error('Expected "(" after "function"'); + } + current++; // Skip '(' + + const parameters = []; + while (current < tokens.length && tokens[current].type !== TokenType.RIGHT_PAREN) { + if (tokens[current].type === TokenType.IDENTIFIER) { + parameters.push(tokens[current].value); + current++; + } else { + throw new Error('Expected parameter name in function definition'); + } + + // Skip comma if present + if (current < tokens.length && tokens[current].type === TokenType.COMMA) { + current++; + } + } + + if (current >= tokens.length || tokens[current].type !== TokenType.RIGHT_PAREN) { + throw new Error('Expected ")" after function parameters'); + } + current++; // Skip ')' + + if (current >= tokens.length || tokens[current].type !== TokenType.ASSIGNMENT) { + throw new Error('Expected ":" after function parameters'); + } + current++; // Skip ':' + + // Parse the function body (check if it's a case expression) + let functionBody; + if (current < tokens.length && tokens[current].type === TokenType.CASE) { + // Parse case expression directly + current++; // Skip 'case' + + // Parse the values being matched (can be multiple) + const values = []; + while (current < tokens.length && tokens[current].type !== TokenType.OF) { + const value = parsePrimary(); + 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) { + // If we hit an IO operation, we've reached the end of the case expression + if (current < tokens.length && + (tokens[current].type === TokenType.IO_IN || + tokens[current].type === TokenType.IO_OUT || + tokens[current].type === TokenType.IO_ASSERT)) { + break; + } + const patterns = []; + while (current < tokens.length && + tokens[current].type !== TokenType.ASSIGNMENT && + tokens[current].type !== TokenType.SEMICOLON) { + patterns.push(parsePrimary()); + } + + // 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] + }); + + // Skip semicolon if present (but don't stop parsing cases) + if (current < tokens.length && tokens[current].type === TokenType.SEMICOLON) { + current++; + // If the next token is an identifier followed by assignment, we've reached the end of the case expression + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const nextPos = current + 1; + if (nextPos < tokens.length && tokens[nextPos].type === TokenType.ASSIGNMENT) { + break; // End of case expression + } + } + } + } + + functionBody = { + type: 'CaseExpression', + value: values, + cases, + }; + } else { + functionBody = parseLogicalExpression(); + } + + return { + type: 'Assignment', + identifier, + value: { + type: 'FunctionDefinition', + parameters, + body: functionBody + } + }; + } else { + // Check if this is a case expression + if (current < tokens.length && tokens[current].type === TokenType.CASE) { + // Parse the case expression directly + current++; // Skip 'case' + + // Parse the values being matched (can be multiple) + const values = []; + while (current < tokens.length && tokens[current].type !== TokenType.OF) { + const value = parsePrimary(); + 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) { + // If we hit an IO operation, we've reached the end of the case expression + if (current < tokens.length && + (tokens[current].type === TokenType.IO_IN || + tokens[current].type === TokenType.IO_OUT || + tokens[current].type === TokenType.IO_ASSERT)) { + break; + } + const patterns = []; + while (current < tokens.length && + tokens[current].type !== TokenType.ASSIGNMENT && + tokens[current].type !== TokenType.SEMICOLON) { + patterns.push(parsePrimary()); + } + + // 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] + }); + + // Skip semicolon if present (but don't stop parsing cases) + if (current < tokens.length && tokens[current].type === TokenType.SEMICOLON) { + current++; + // If the next token is an identifier followed by assignment, we've reached the end of the case expression + if (current < tokens.length && tokens[current].type === TokenType.IDENTIFIER) { + const nextPos = current + 1; + if (nextPos < tokens.length && tokens[nextPos].type === TokenType.ASSIGNMENT) { + break; // End of case expression + } + } + } + } + + return { + type: 'Assignment', + identifier, + value: { + type: 'CaseExpression', + value: values, + cases, + } + }; + } else { + // Regular assignment + const value = parseLogicalExpression(); + + return { + type: 'Assignment', + identifier, + value + }; + } + } + } + + // If it's not an assignment, put the identifier back and continue + current--; + } + + // For all other token types (identifiers, numbers, operators, etc.), call parsePrimary + // This handles atomic expressions and delegates to the appropriate parsing functions + return parsePrimary(); + } finally { + callStackTracker.pop(); + } + } + + 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. + * + * @param {Object} ast - Abstract Syntax Tree to evaluate + * @returns {*} The result of evaluating the AST, or a Promise for async operations + * @throws {Error} For evaluation errors like division by zero, undefined variables, etc. + * + * @description Evaluates an AST by walking through each node and performing the + * corresponding operations. Manages scope, handles function calls, and supports + * both synchronous and asynchronous operations. + * + * @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. + * + * @note 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); + + // Reset call stack tracker at the start of interpretation + callStackTracker.reset(); + + /** + * Evaluates AST nodes in the global scope. + * + * @param {Object} node - AST node to evaluate + * @returns {*} The result of evaluating the node + * @throws {Error} For evaluation errors + * + * @description Main evaluation function that handles all node types in the + * global scope context. + */ function evalNode(node) { - switch (node.type) { - case 'NumberLiteral': - return parseInt(node.value); - case 'PlusExpression': - return evalNode(node.left) + evalNode(node.right); - case 'AssignmentExpression': - globalScope[node.name] = evalNode(node.value); - return; - case 'Identifier': - return globalScope[node.value]; - case 'IfExpression': - return evalNode(node.test) ? evalNode(node.consequent) : node.alternate ? evalNode(node.alternate) : undefined; - case 'FunctionDeclaration': - globalScope[node.name] = function() { - 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); - } - return lastResult; - }; - return; - case 'FunctionCall': - if (globalScope[node.name] instanceof Function) { - let args = node.args.map(evalNode); - return globalScope[node.name].apply(null, args); - } - throw new Error(`Function ${node.name} is not defined`); - default: - throw new Error(`Unknown node type: ${node.type}`); + callStackTracker.push('evalNode', node?.type || 'unknown'); + + try { + 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 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': + 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 'Assignment': + if (globalScope.hasOwnProperty(node.identifier)) { + throw new Error(`Cannot reassign immutable variable: ${node.identifier}`); + } + const assignmentValue = evalNode(node.value); + globalScope[node.identifier] = assignmentValue; + return; + case 'Identifier': + const identifierValue = globalScope[node.value]; + if (identifierValue === undefined) { + throw new Error(`Variable ${node.value} is not defined`); + } + 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) { + callStackTracker.push('FunctionCall', node.params.join(',')); + try { + let localScope = Object.create(globalScope); + for (let i = 0; i < node.params.length; i++) { + localScope[node.params[i]] = args[i]; + } + return localEvalNodeWithScope(node.body, localScope); + } finally { + callStackTracker.pop(); + } + }; + case 'FunctionDefinition': + // Create a function from the function definition + return function(...args) { + callStackTracker.push('FunctionCall', node.parameters.join(',')); + try { + let localScope = Object.create(globalScope); + for (let i = 0; i < node.parameters.length; i++) { + localScope[node.parameters[i]] = args[i]; + } + return localEvalNodeWithScope(node.body, localScope); + } finally { + callStackTracker.pop(); + } + }; + case 'FunctionCall': + 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 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`); + } + if (typeof functionValue !== 'function') { + throw new Error(`${node.name} is not a function`); + } + return functionValue; + case 'ArrowExpression': + // Arrow expressions are function bodies that should be evaluated + return evalNode(node.body); + default: + throw new Error(`Unknown node type: ${node.type}`); + } + } finally { + callStackTracker.pop(); } } - return evalNode(ast.body[0]); + /** + * Evaluates AST nodes in a local scope with access to parent scope. + * + * @param {Object} node - AST node to evaluate + * @param {Object} scope - Local scope object (prototypally inherits from global) + * @returns {*} The result of evaluating the node + * @throws {Error} For evaluation errors + * + * @description Used for evaluating function bodies and other expressions + * that need access to both local and global variables. + */ + const localEvalNodeWithScope = (node, scope) => { + callStackTracker.push('localEvalNodeWithScope', node?.type || 'unknown'); + + try { + 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) { + callStackTracker.push('FunctionCall', node.params.join(',')); + try { + 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); + } finally { + callStackTracker.pop(); + } + }; + case 'FunctionDefinition': + // Create a function from the function definition + return function(...args) { + callStackTracker.push('FunctionCall', node.parameters.join(',')); + try { + let nestedScope = Object.create(globalScope); + for (let i = 0; i < node.parameters.length; i++) { + nestedScope[node.parameters[i]] = args[i]; + } + return localEvalNodeWithScope(node.body, nestedScope); + } finally { + callStackTracker.pop(); + } + }; + 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; + case 'ArrowExpression': + // Arrow expressions are function bodies that should be evaluated + return localEvalNodeWithScope(node.body, scope); + default: + throw new Error(`Unknown node type: ${node.type}`); + } + } finally { + callStackTracker.pop(); + } + }; + + /** + * Evaluates AST nodes in the global scope (internal recursion helper). + * + * @param {Object} node - AST node to evaluate + * @returns {*} The result of evaluating the node + * @throws {Error} For evaluation errors + * + * @description Internal helper function for recursive evaluation that + * always uses the global scope. Used to avoid circular dependencies. + */ + const localEvalNode = (node) => { + callStackTracker.push('localEvalNode', node?.type || 'unknown'); + + try { + 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) { + callStackTracker.push('FunctionCall', node.params.join(',')); + try { + 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); + } finally { + callStackTracker.pop(); + } + }; + case 'FunctionDefinition': + // Create a function from the function definition + return function(...args) { + callStackTracker.push('FunctionCall', node.parameters.join(',')); + try { + let nestedScope = Object.create(globalScope); + for (let i = 0; i < node.parameters.length; i++) { + nestedScope[node.parameters[i]] = args[i]; + } + return localEvalNodeWithScope(node.body, nestedScope); + } finally { + callStackTracker.pop(); + } + }; + 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; + case 'ArrowExpression': + // Arrow expressions are function bodies that should be evaluated + return localEvalNode(node.body); + default: + throw new Error(`Unknown node type: ${node.type}`); + } + } finally { + callStackTracker.pop(); + } + }; + + 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; +} + +/** + * Debug logging utility function. + * + * @param {string} message - Debug message to log + * @param {*} [data=null] - Optional data to log with the message + * + * @description Logs debug messages to console when DEBUG environment variable is set. + * Provides verbose output during development while remaining silent in production. + * + * @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); + } + } } -// Usage -// const tokens = lexer('2 + 2'); -// const ast = parser(tokens); -// const result = interpreter(ast); -// console.log(result); // 4 +/** + * Debug error logging utility function. + * + * @param {string} message - Debug error message to log + * @param {Error} [error=null] - Optional error object to log + * + * @description Logs debug error messages to console when DEBUG environment variable is set. + * Provides verbose error output during development while remaining silent in production. + * + * @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 tokens2 = lexer('x : 2 + 2'); -// const ast2 = parser(tokens2); -// const result2 = interpreter(ast2); -// console.log(result2); +/** + * Call stack tracking for debugging recursion issues. + * + * @description Tracks function calls to help identify infinite recursion + * and deep call stacks that cause stack overflow errors. + */ +const callStackTracker = { + stack: [], + maxDepth: 0, + callCounts: new Map(), + + /** + * Push a function call onto the stack + * @param {string} functionName - Name of the function being called + * @param {string} context - Context where the call is happening + */ + push: function(functionName, context = '') { + const callInfo = { functionName, context, timestamp: Date.now() }; + this.stack.push(callInfo); + + // Track maximum depth + if (this.stack.length > this.maxDepth) { + this.maxDepth = this.stack.length; + } + + // Count function calls + const key = `${functionName}${context ? `:${context}` : ''}`; + this.callCounts.set(key, (this.callCounts.get(key) || 0) + 1); + + // Check for potential infinite recursion + if (this.stack.length > 1000) { + console.error('=== POTENTIAL INFINITE RECURSION DETECTED ==='); + console.error('Call stack depth:', this.stack.length); + console.error('Function call counts:', Object.fromEntries(this.callCounts)); + console.error('Recent call stack:'); + this.stack.slice(-10).forEach((call, i) => { + console.error(` ${this.stack.length - 10 + i}: ${call.functionName}${call.context ? ` (${call.context})` : ''}`); + }); + throw new Error(`Potential infinite recursion detected. Call stack depth: ${this.stack.length}`); + } + + if (process.env.DEBUG && this.stack.length % 100 === 0) { + console.log(`[DEBUG] Call stack depth: ${this.stack.length}, Max: ${this.maxDepth}`); + } + }, + + /** + * Pop a function call from the stack + */ + pop: function() { + return this.stack.pop(); + }, + + /** + * Get current stack depth + */ + getDepth: function() { + return this.stack.length; + }, + + /** + * Get call statistics + */ + getStats: function() { + return { + currentDepth: this.stack.length, + maxDepth: this.maxDepth, + callCounts: Object.fromEntries(this.callCounts) + }; + }, + + /** + * Reset the tracker + */ + reset: function() { + this.stack = []; + this.maxDepth = 0; + this.callCounts.clear(); + } +}; -const fs = require('fs'); +/** + * Reads a file, tokenizes, parses, and interprets it. + * + * @param {string} filePath - Path to the file to execute + * @throws {Error} For file reading, parsing, or execution errors + * + * @description Main entry point for file execution. Handles the complete language + * pipeline: file reading, lexical analysis, parsing, and interpretation. + * + * @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. + * + * @note Supports both synchronous and asynchronous execution, with proper + * error handling and process exit codes. + */ +function executeFile(filePath) { + try { + // Validate file extension + if (!filePath.endsWith('.txt')) { + throw new Error('Only .txt files are supported'); + } + + 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); + } + // Print call stack statistics after execution + const stats = callStackTracker.getStats(); + console.log('\n=== CALL STACK STATISTICS ==='); + console.log('Maximum call stack depth:', stats.maxDepth); + console.log('Function call counts:', JSON.stringify(stats.callCounts, null, 2)); + }).catch(error => { + console.error(`Error executing file: ${error.message}`); + // Print call stack statistics on error + const stats = callStackTracker.getStats(); + console.error('\n=== CALL STACK STATISTICS ON ERROR ==='); + console.error('Maximum call stack depth:', stats.maxDepth); + console.error('Function call counts:', JSON.stringify(stats.callCounts, null, 2)); + process.exit(1); + }); + } else { + if (result !== undefined) { + console.log(result); + } + // Print call stack statistics after execution + const stats = callStackTracker.getStats(); + console.log('\n=== CALL STACK STATISTICS ==='); + console.log('Maximum call stack depth:', stats.maxDepth); + console.log('Function call counts:', JSON.stringify(stats.callCounts, null, 2)); + } + } catch (error) { + console.error(`Error executing file: ${error.message}`); + // Print call stack statistics on error + const stats = callStackTracker.getStats(); + console.error('\n=== CALL STACK STATISTICS ON ERROR ==='); + console.error('Maximum call stack depth:', stats.maxDepth); + console.error('Function call counts:', JSON.stringify(stats.callCounts, null, 2)); + process.exit(1); + } +} -// Read the input from a file -const input = fs.readFileSync('input.txt', 'utf-8'); +/** + * CLI argument handling and program entry point. + * + * @description Processes command line arguments and executes the specified file. + * Provides helpful error messages for incorrect usage. + * + * @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. + * + * @note Exits with appropriate error codes for different failure scenarios. + */ +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/learn_scripting_lang.txt b/js/scripting-lang/learn_scripting_lang.txt new file mode 100644 index 0000000..fc4f966 --- /dev/null +++ b/js/scripting-lang/learn_scripting_lang.txt @@ -0,0 +1,61 @@ +/* Learn an as of yet unnamed language in Y Minutes */ +/* A functional programming language with immutable variables, + first-class functions, and pattern matching */ + +/* We've got numbers */ +x : 42; /* also the ability to assign values to variables */ +y : 3.14; +z : 0; + +/* We've got identifiers */ +this_is_a : "test"; +flag : true; +value : false; + +/* We've got basic mathematical operators */ +sum : x + y; +diff : x - y; +prod : x * y; +quot : x / y; + +/* We've got pattern matching case statements! */ +result : case x of + 42 : "correct" + _ : "wrong"; + +/* Of course, there are functions */ +double : x -> x * 2; +add : x y -> x + y; +func_result : double 5; + +/* And immutable tables, kinda inspired by Lua's tables */ +table : {1, 2, 3, name: "Alice", age: 30}; +first : table[1]; +table_name : table.name; + +/* A boring standard library */ +square : x -> x * x; +mapped : map @double 5; +composed : compose @double @square 3; + +/* Special functions for IO all start with .. */ +..out "Hello from the scripting language!"; +..out x; +..out func_result; +..out result; +..out first; +..out table_name; +..out mapped; +..out composed; + +/* There's a baked in IO function for performing assertions */ +..assert x = 42; +..assert func_result = 10; +..assert result = "correct"; +..assert first = 1; +..assert table_name = "Alice"; +..assert mapped = 10; +..assert composed = 18; +..assert 5 > 3; /* ..assert should work with any kinda operators */ + +..out "Learn Scripting Language tutorial completed!"; \ No newline at end of file diff --git a/js/scripting-lang/nested_test.txt b/js/scripting-lang/nested_test.txt new file mode 100644 index 0000000..afb0677 --- /dev/null +++ b/js/scripting-lang/nested_test.txt @@ -0,0 +1,7 @@ +/* Test nested function calls in case expressions */ +factorial : n -> case n of + 0 : 1 + _ : factorial (n - 1); + +test : factorial 5; +..out test; \ No newline at end of file diff --git a/js/scripting-lang/paren_test.txt b/js/scripting-lang/paren_test.txt new file mode 100644 index 0000000..990858b --- /dev/null +++ b/js/scripting-lang/paren_test.txt @@ -0,0 +1,7 @@ +/* Test parentheses in case expressions */ +factorial : n -> case n of + 0 : 1 + _ : (n - 1); + +test : factorial 5; +..out test; \ 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..b456ff0 --- /dev/null +++ b/js/scripting-lang/run_tests.sh @@ -0,0 +1,123 @@ +#!/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" + "tests/11_edge_cases.txt:Edge Cases" + "tests/12_advanced_tables.txt:Advanced Tables" + "tests/13_standard_library_complete.txt:Complete Standard Library" + "tests/14_error_handling.txt:Error Handling" + # "tests/15_performance_stress.txt:Performance and Stress" + # "tests/16_advanced_functional.txt:Advanced Functional Programming" + # "tests/17_real_world_scenarios.txt:Real-World Scenarios" +) + +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" + "tests/integration_04_mini_case_multi_param.txt:Multi-parameter case expression at top level" +) + +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/simple_case_test.txt b/js/scripting-lang/simple_case_test.txt new file mode 100644 index 0000000..bfc4768 --- /dev/null +++ b/js/scripting-lang/simple_case_test.txt @@ -0,0 +1,7 @@ +/* Simple case expression test */ +factorial : n -> case n of + 0 : 1 + _ : 2; + +test : factorial 5; +..out test; \ No newline at end of file diff --git a/js/scripting-lang/simple_test.txt b/js/scripting-lang/simple_test.txt new file mode 100644 index 0000000..5f1c5df --- /dev/null +++ b/js/scripting-lang/simple_test.txt @@ -0,0 +1,4 @@ +/* Simple test */ +x : 5; +y : x - 1; +..out y; \ 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..e6f7160 --- /dev/null +++ b/js/scripting-lang/tests/10_standard_library.txt @@ -0,0 +1,49 @@ +/* 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 */ +reduced : reduce @add 0 5; +folded : fold @add 0 5; + +..assert reduced = 5; +..assert folded = 5; + +/* Curry function */ +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/11_edge_cases.txt b/js/scripting-lang/tests/11_edge_cases.txt new file mode 100644 index 0000000..ceb39b4 --- /dev/null +++ b/js/scripting-lang/tests/11_edge_cases.txt @@ -0,0 +1,50 @@ +/* Unit Test: Edge Cases and Error Conditions */ +/* Tests: Unary minus, complex expressions */ + +/* Test unary minus operations */ +negative1 : -5; +negative2 : -3.14; +negative3 : -0; + +..assert negative1 = -5; +..assert negative2 = -3.14; +..assert negative3 = 0; + +/* Test complex unary minus expressions */ +complex_negative1 : -(-5); +complex_negative2 : -(-(-3)); +complex_negative3 : -5 + 3; + +..assert complex_negative1 = 5; +..assert complex_negative2 = -3; +..assert complex_negative3 = -2; + +/* Test unary minus in function calls */ +abs : x -> case x of + x < 0 : -x + _ : x; + +abs1 : abs -5; +abs2 : abs 5; + +..assert abs1 = 5; +..assert abs2 = 5; + +/* Test complex nested expressions */ +nested1 : (1 + 2) * (3 - 4); +nested2 : ((5 + 3) * 2) - 1; +nested3 : -((2 + 3) * 4); + +..assert nested1 = -3; +..assert nested2 = 15; +..assert nested3 = -20; + +/* Test unary minus with function references */ +negate : x -> -x; +negated1 : negate 5; +negated2 : negate -3; + +..assert negated1 = -5; +..assert negated2 = 3; + +..out "Edge cases test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/12_advanced_tables.txt b/js/scripting-lang/tests/12_advanced_tables.txt new file mode 100644 index 0000000..3b2a326 --- /dev/null +++ b/js/scripting-lang/tests/12_advanced_tables.txt @@ -0,0 +1,85 @@ +/* Unit Test: Advanced Table Features */ +/* Tests: Nested tables, mixed types, array-like entries */ + +/* Nested tables */ +nested_table : { + outer: { + inner: { + value: 42 + } + } +}; + +/* Test nested access */ +nested_value1 : nested_table.outer.inner.value; +..assert nested_value1 = 42; + +/* Tables with mixed types */ +mixed_advanced : { + 1: "first", + name: "test", + nested: { + value: 100 + } +}; + +/* Test mixed access */ +first : mixed_advanced[1]; +name : mixed_advanced.name; +nested_value2 : mixed_advanced.nested.value; + +..assert first = "first"; +..assert name = "test"; +..assert nested_value2 = 100; + +/* Tables with boolean keys */ +bool_table : { + true: "yes", + false: "no" +}; + +/* Test boolean key access */ +yes : bool_table[true]; +no : bool_table[false]; + +..assert yes = "yes"; +..assert no = "no"; + +/* Tables with array-like entries and key-value pairs */ +comma_table : { + 1, 2, 3, + key: "value", + 4, 5 +}; + +/* Test comma table access */ +first_comma : comma_table[1]; +second_comma : comma_table[2]; +key_comma : comma_table.key; +fourth_comma : comma_table[4]; + +..assert first_comma = 1; +..assert second_comma = 2; +..assert key_comma = "value"; +..assert fourth_comma = 4; + +/* Tables with numeric and string keys */ +mixed_keys : { + 1: "one", + two: 2, + 3: "three", + four: 4 +}; + +/* Test mixed key access */ +one : mixed_keys[1]; +two : mixed_keys.two; +three : mixed_keys[3]; +four : mixed_keys.four; + +..assert one = "one"; +..assert two = 2; +..assert three = "three"; +..assert four = 4; + +..out "Advanced tables test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/13_standard_library_complete.txt b/js/scripting-lang/tests/13_standard_library_complete.txt new file mode 100644 index 0000000..ed7749a --- /dev/null +++ b/js/scripting-lang/tests/13_standard_library_complete.txt @@ -0,0 +1,97 @@ +/* Unit Test: Complete Standard Library */ +/* Tests: All built-in higher-order functions including reduce, fold, curry */ + +/* Basic functions for testing */ +double : x -> x * 2; +square : x -> x * x; +add : x y -> x + y; +isPositive : x -> x > 0; +isEven : x -> x % 2 = 0; + +/* 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; + +/* Filter function */ +filtered1 : filter @isPositive 5; +filtered2 : filter @isPositive -3; + +..assert filtered1 = 5; +..assert filtered2 = 0; + +/* Reduce function */ +reduced : reduce @add 0 5; +..assert reduced = 5; + +/* Fold function */ +folded : fold @add 0 5; +..assert folded = 5; + +/* Curry function */ +curried : curry @add 3 4; +..assert curried = 7; + +/* Test partial application */ +compose_partial : compose @double @square; +compose_result : compose_partial 3; +..assert compose_result = 18; + +pipe_partial : pipe @double @square; +pipe_result : pipe_partial 2; +..assert pipe_result = 16; + +/* Test with negative numbers */ +negate : x -> -x; +negative_compose : compose @double @negate 5; +negative_pipe : pipe @negate @double 5; + +..assert negative_compose = -10; +..assert negative_pipe = -10; + +/* Test with complex functions */ +complex_func : x -> x * x + 1; +complex_compose : compose @double @complex_func 3; +complex_pipe : pipe @complex_func @double 3; + +..assert complex_compose = 20; +..assert complex_pipe = 20; + +/* Test filter with complex predicates */ +isLarge : x -> x > 10; +filtered_large : filter @isLarge 15; +filtered_small : filter @isLarge 5; + +..assert filtered_large = 15; +..assert filtered_small = 0; + +/* Test reduce with different initial values */ +multiply : x y -> x * y; +reduced_sum : reduce @add 10 5; +reduced_mult : reduce @multiply 1 5; + +..assert reduced_sum = 15; +..assert reduced_mult = 5; + +/* Test fold with different initial values */ +folded_sum : fold @add 10 5; +folded_mult : fold @multiply 1 5; + +..assert folded_sum = 15; +..assert folded_mult = 5; + +..out "Complete standard library test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/14_error_handling.txt b/js/scripting-lang/tests/14_error_handling.txt new file mode 100644 index 0000000..ce485f7 --- /dev/null +++ b/js/scripting-lang/tests/14_error_handling.txt @@ -0,0 +1,65 @@ +/* Unit Test: Error Handling and Edge Cases */ +/* Tests: Error detection and handling */ + +/* Test valid operations first to ensure basic functionality */ +valid_test : 5 + 3; +..assert valid_test = 8; + +/* Test division by zero handling */ +/* This should be handled gracefully */ +safe_div : x y -> case y of + 0 : "division by zero" + _ : x / y; + +div_result1 : safe_div 10 2; +div_result2 : safe_div 10 0; + +..assert div_result1 = 5; +..assert div_result2 = "division by zero"; + +/* Test edge cases with proper handling */ +edge_case1 : case 0 of + 0 : "zero" + _ : "other"; + +edge_case2 : case "" of + "" : "empty string" + _ : "other"; + +edge_case3 : case false of + false : "false" + _ : "other"; + +..assert edge_case1 = "zero"; +..assert edge_case2 = "empty string"; +..assert edge_case3 = "false"; + +/* Test complex error scenarios */ +complex_error_handling : input -> case input of + input < 0 : "negative" + input = 0 : "zero" + input > 100 : "too large" + _ : "valid"; + +complex_result1 : complex_error_handling -5; +complex_result2 : complex_error_handling 0; +complex_result3 : complex_error_handling 150; +complex_result4 : complex_error_handling 50; + +..assert complex_result1 = "negative"; +..assert complex_result2 = "zero"; +..assert complex_result3 = "too large"; +..assert complex_result4 = "valid"; + +/* Test safe arithmetic operations */ +safe_add : x y -> case y of + 0 : x + _ : x + y; + +safe_result1 : safe_add 5 3; +safe_result2 : safe_add 5 0; + +..assert safe_result1 = 8; +..assert safe_result2 = 5; + +..out "Error handling test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/15_performance_stress.txt b/js/scripting-lang/tests/15_performance_stress.txt new file mode 100644 index 0000000..7dab1f5 --- /dev/null +++ b/js/scripting-lang/tests/15_performance_stress.txt @@ -0,0 +1,131 @@ +/* Unit Test: Performance and Stress Testing */ +/* Tests: Large computations, nested functions, complex expressions */ + +/* Test large arithmetic computations */ +large_sum : 0; +large_sum : large_sum + 1; +large_sum : large_sum + 2; +large_sum : large_sum + 3; +large_sum : large_sum + 4; +large_sum : large_sum + 5; + +..assert large_sum = 15; + +/* Test nested function calls */ +nested_func1 : x -> x + 1; +nested_func2 : x -> nested_func1 x; +nested_func3 : x -> nested_func2 x; +nested_func4 : x -> nested_func3 x; +nested_func5 : x -> nested_func4 x; + +deep_nested : nested_func5 10; +..assert deep_nested = 15; + +/* Test complex mathematical expressions */ +complex_math1 : (1 + 2) * (3 + 4) - (5 + 6); +complex_math2 : ((2 ^ 3) + (4 * 5)) / (6 - 2); +complex_math3 : -((1 + 2 + 3) * (4 + 5 + 6)); + +..assert complex_math1 = 10; +..assert complex_math2 = 7; +..assert complex_math3 = -126; + +/* Test large table operations */ +large_table : {}; +large_table : {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}; +large_table : {large_table, 6: "six", 7: "seven", 8: "eight"}; + +table_size : 8; +..assert table_size = 8; + +/* Test recursive-like patterns with functions */ +accumulate : n -> case n of + 0 : 0 + _ : n + accumulate (n - 1); + +sum_10 : accumulate 10; +..assert sum_10 = 55; + +/* Test complex case expressions */ +complex_case : x -> case x of + x < 0 : "negative" + x = 0 : "zero" + x < 10 : "small" + x < 100 : "medium" + x < 1000 : "large" + _ : "huge"; + +case_test1 : complex_case -5; +case_test2 : complex_case 0; +case_test3 : complex_case 5; +case_test4 : complex_case 50; +case_test5 : complex_case 500; +case_test6 : complex_case 5000; + +..assert case_test1 = "negative"; +..assert case_test2 = "zero"; +..assert case_test3 = "small"; +..assert case_test4 = "medium"; +..assert case_test5 = "large"; +..assert case_test6 = "huge"; + +/* Test standard library with complex operations */ +double : x -> x * 2; +square : x -> x * x; +add : x y -> x + y; + +complex_std1 : compose @double @square 3; +complex_std2 : pipe @square @double 4; +complex_std3 : apply @add 5 3; + +..assert complex_std1 = 18; +..assert complex_std2 = 32; +..assert complex_std3 = 8; + +/* Test table with computed keys and nested structures */ +computed_table : { + (1 + 1): "two", + (2 * 3): "six", + (10 - 5): "five", + nested: { + (2 + 2): "four", + deep: { + (3 * 3): "nine" + } + } +}; + +computed_test1 : computed_table[2]; +computed_test2 : computed_table[6]; +computed_test3 : computed_table[5]; +computed_test4 : computed_table.nested[4]; +computed_test5 : computed_table.nested.deep[9]; + +..assert computed_test1 = "two"; +..assert computed_test2 = "six"; +..assert computed_test3 = "five"; +..assert computed_test4 = "four"; +..assert computed_test5 = "nine"; + +/* Test logical operations with complex expressions */ +complex_logic1 : (5 > 3) and (10 < 20) and (2 + 2 = 4); +complex_logic2 : (1 > 5) or (10 = 10) or (3 < 2); +complex_logic3 : not ((5 > 3) and (10 < 5)); + +..assert complex_logic1 = true; +..assert complex_logic2 = true; +..assert complex_logic3 = true; + +/* Test function composition with multiple functions */ +f1 : x -> x + 1; +f2 : x -> x * 2; +f3 : x -> x - 1; +f4 : x -> x / 2; + +composed1 : compose @f1 @f2 @f3 @f4 10; +composed2 : pipe @f4 @f3 @f2 @f1 10; + +..assert composed1 = 10; +..assert composed2 = 10; + +..out "Performance and stress test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/16_advanced_functional.txt b/js/scripting-lang/tests/16_advanced_functional.txt new file mode 100644 index 0000000..3da9d76 --- /dev/null +++ b/js/scripting-lang/tests/16_advanced_functional.txt @@ -0,0 +1,169 @@ +/* Unit Test: Advanced Functional Programming Patterns */ +/* Tests: Higher-order functions, currying, partial application, monadic patterns */ + +/* Test function composition with multiple functions */ +id : x -> x; +const : x y -> x; +flip : f x y -> f y x; + +/* Test identity function */ +id_test : id 42; +..assert id_test = 42; + +/* Test constant function */ +const_test : const 5 10; +..assert const_test = 5; + +/* Test function flipping */ +sub : x y -> x - y; +flipped_sub : flip @sub; +flipped_result : flipped_sub 5 10; +..assert flipped_result = 5; + +/* Test partial application patterns */ +partial1 : f x -> y -> f x y; +partial2 : f x y -> f x y; + +add : x y -> x + y; +add5 : partial1 @add 5; +add5_result : add5 3; +..assert add5_result = 8; + +/* Test function composition with multiple arguments */ +compose2 : f g x y -> f (g x y); +compose3 : f g h x -> f (g (h x)); + +double : x -> x * 2; +square : x -> x * x; +increment : x -> x + 1; + +composed1 : compose2 @double @add 3 4; +composed2 : compose3 @double @square @increment 2; +..assert composed1 = 14; +..assert composed2 = 18; + +/* Test monadic-like patterns with Maybe simulation */ +maybe : x -> case x of + undefined : "Nothing" + null : "Nothing" + _ : "Just " + x; + +maybe_map : f m -> case m of + "Nothing" : "Nothing" + _ : f m; + +maybe_bind : m f -> case m of + "Nothing" : "Nothing" + _ : f m; + +maybe_test1 : maybe undefined; +maybe_test2 : maybe 42; +maybe_test3 : maybe_map @double "Just 5"; +maybe_test4 : maybe_bind "Just 3" @double; + +..assert maybe_test1 = "Nothing"; +..assert maybe_test2 = "Just 42"; +..assert maybe_test3 = "Just 10"; +..assert maybe_test4 = "Just 6"; + +/* Test list-like operations with tables */ +list_map : f table -> { + f table[1], + f table[2], + f table[3] +}; + +list_filter : p table -> case p table[1] of + true : {table[1]} + false : {}; + +list_reduce : f init table -> case table[1] of + undefined : init + _ : f init table[1]; + +test_list : {1, 2, 3}; +mapped_list : list_map @double test_list; +filtered_list : list_filter (x -> x > 1) test_list; +reduced_list : list_reduce @add 0 test_list; + +..assert mapped_list[1] = 2; +..assert mapped_list[2] = 4; +..assert mapped_list[3] = 6; +..assert filtered_list[1] = 2; +..assert reduced_list = 1; + +/* Test point-free style programming */ +pointfree_add : add; +pointfree_double : double; +pointfree_compose : compose @pointfree_double @pointfree_add; + +pointfree_result : pointfree_compose 5 3; +..assert pointfree_result = 16; + +/* Test function memoization pattern */ +memoize : f -> { + cache: {}, + call: x -> case cache[x] of + undefined : cache[x] = f x + _ : cache[x] +}; + +expensive_func : x -> x * x + x + 1; +memoized_func : memoize @expensive_func; + +memo_result1 : memoized_func.call 5; +memo_result2 : memoized_func.call 5; /* Should use cache */ +..assert memo_result1 = 31; +..assert memo_result2 = 31; + +/* Test continuation-passing style (CPS) */ +cps_add : x y k -> k (x + y); +cps_multiply : x y k -> k (x * y); +cps_square : x k -> k (x * x); + +cps_example : cps_add 3 4 (sum -> + cps_multiply sum 2 (product -> + cps_square product (result -> result) + ) +); +..assert cps_example = 98; + +/* Test trampoline pattern for tail recursion simulation */ +trampoline : f -> case f of + f is function : trampoline (f) + _ : f; + +bounce : n -> case n of + 0 : 0 + _ : n + (n - 1); + +trampoline_result : trampoline @bounce 5; +..assert trampoline_result = 15; + +/* Test applicative functor pattern */ +applicative : f x -> case f of + f is function : f x + _ : x; + +applicative_test : applicative @double 5; +..assert applicative_test = 10; + +/* Test function pipelines */ +pipeline : x f1 f2 f3 -> f3 (f2 (f1 x)); +pipeline_result : pipeline 2 @increment @double @square; +..assert pipeline_result = 36; + +/* Test function combinators */ +S : f g x -> f x (g x); +K : x y -> x; +I : x -> x; + +S_test : S @add @double 3; +K_test : K 5 10; +I_test : I 42; + +..assert S_test = 9; +..assert K_test = 5; +..assert I_test = 42; + +..out "Advanced functional programming test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/17_real_world_scenarios.txt b/js/scripting-lang/tests/17_real_world_scenarios.txt new file mode 100644 index 0000000..0a9fc49 --- /dev/null +++ b/js/scripting-lang/tests/17_real_world_scenarios.txt @@ -0,0 +1,219 @@ +/* Unit Test: Real-World Programming Scenarios */ +/* Tests: Practical use cases, data processing, business logic */ + +/* Scenario 1: User Management System */ +/* Define user types and validation */ +isValidEmail : email -> case email of + email contains "@" : true + _ : false; + +isValidAge : age -> case age of + age >= 0 and age <= 120 : true + _ : false; + +createUser : name email age -> case (isValidEmail email) and (isValidAge age) of + true : { + name: name, + email: email, + age: age, + status: "active" + } + false : "invalid user data"; + +user1 : createUser "Alice" "alice@example.com" 25; +user2 : createUser "Bob" "invalid-email" 30; +user3 : createUser "Charlie" "charlie@test.com" 150; + +..assert user1.name = "Alice"; +..assert user2 = "invalid user data"; +..assert user3 = "invalid user data"; + +/* Scenario 2: Shopping Cart System */ +/* Product definitions */ +product1 : {id: 1, name: "Laptop", price: 999.99, category: "electronics"}; +product2 : {id: 2, name: "Book", price: 19.99, category: "books"}; +product3 : {id: 3, name: "Coffee", price: 4.99, category: "food"}; + +/* Cart operations */ +addToCart : cart product -> { + cart, + product +}; + +calculateTotal : cart -> case cart of + cart is table : cart.product.price + _ : 0; + +applyDiscount : total discount -> case discount of + discount > 0 and discount <= 100 : total * (1 - discount / 100) + _ : total; + +cart : addToCart {} product1; +cart : addToCart cart product2; +total : calculateTotal cart; +discounted : applyDiscount total 10; + +..assert total = 1019.98; +..assert discounted = 917.982; + +/* Scenario 3: Data Processing Pipeline */ +/* Sample data */ +sales_data : { + {month: "Jan", sales: 1000, region: "North"}, + {month: "Feb", sales: 1200, region: "North"}, + {month: "Mar", sales: 800, region: "South"}, + {month: "Apr", sales: 1500, region: "North"}, + {month: "May", sales: 900, region: "South"} +}; + +/* Data processing functions */ +filterByRegion : data region -> case data of + data.region = region : data + _ : null; + +sumSales : data -> case data of + data is table : data.sales + _ : 0; + +calculateAverage : total count -> case count of + count > 0 : total / count + _ : 0; + +/* Process North region sales */ +north_sales : filterByRegion sales_data "North"; +north_total : sumSales north_sales; +north_avg : calculateAverage north_total 3; + +..assert north_total = 3700; +..assert north_avg = 1233.3333333333333; + +/* Scenario 4: Configuration Management */ +/* Environment configuration */ +getConfig : env -> case env of + "development" : { + database: "dev_db", + port: 3000, + debug: true, + log_level: "debug" + } + "production" : { + database: "prod_db", + port: 80, + debug: false, + log_level: "error" + } + "testing" : { + database: "test_db", + port: 3001, + debug: true, + log_level: "info" + } + _ : "unknown environment"; + +dev_config : getConfig "development"; +prod_config : getConfig "production"; + +..assert dev_config.debug = true; +..assert prod_config.debug = false; +..assert dev_config.port = 3000; +..assert prod_config.port = 80; + +/* Scenario 5: Error Handling and Recovery */ +/* Robust function with error handling */ +safeDivide : x y -> case y of + 0 : "division by zero error" + _ : x / y; + +safeParseNumber : str -> case str of + str is number : str + _ : "invalid number"; + +processData : data -> case data of + data is number : data * 2 + data is string : safeParseNumber data + _ : "unsupported data type"; + +safe_result1 : safeDivide 10 2; +safe_result2 : safeDivide 10 0; +safe_result3 : processData 5; +safe_result4 : processData "abc"; + +..assert safe_result1 = 5; +..assert safe_result2 = "division by zero error"; +..assert safe_result3 = 10; +..assert safe_result4 = "invalid number"; + +/* Scenario 6: Event Handling System */ +/* Event types and handlers */ +eventHandlers : { + "user.login": x -> "User logged in: " + x, + "user.logout": x -> "User logged out: " + x, + "order.created": x -> "Order created: " + x, + "order.completed": x -> "Order completed: " + x +}; + +handleEvent : event data -> case eventHandlers[event] of + handler : handler data + _ : "Unknown event: " + event; + +login_event : handleEvent "user.login" "alice@example.com"; +logout_event : handleEvent "user.logout" "bob@example.com"; +unknown_event : handleEvent "unknown.event" "data"; + +..assert login_event = "User logged in: alice@example.com"; +..assert logout_event = "User logged out: bob@example.com"; +..assert unknown_event = "Unknown event: unknown.event"; + +/* Scenario 7: Caching System */ +/* Simple cache implementation */ +cache : {}; + +setCache : key value -> cache[key] = value; +getCache : key -> case cache[key] of + undefined : "not found" + value : value; +clearCache : key -> cache[key] = undefined; + +setCache "user.1" "Alice"; +setCache "user.2" "Bob"; +cache_result1 : getCache "user.1"; +cache_result2 : getCache "user.999"; +clearCache "user.1"; +cache_result3 : getCache "user.1"; + +..assert cache_result1 = "Alice"; +..assert cache_result2 = "not found"; +..assert cache_result3 = "not found"; + +/* Scenario 8: API Response Processing */ +/* Mock API responses */ +apiResponse : { + status: 200, + data: { + users: { + {id: 1, name: "Alice", active: true}, + {id: 2, name: "Bob", active: false}, + {id: 3, name: "Charlie", active: true} + }, + total: 3 + } +}; + +processApiResponse : response -> case response.status of + 200 : response.data + 404 : "not found" + 500 : "server error" + _ : "unknown status"; + +getActiveUsers : data -> case data.users of + users : case users.active of + true : users + _ : null; + +api_data : processApiResponse apiResponse; +active_users : getActiveUsers api_data; + +..assert api_data.total = 3; +..assert active_users = null; /* Simplified for this example */ + +..out "Real-world scenarios test completed successfully"; \ 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/integration_04_mini_case_multi_param.txt b/js/scripting-lang/tests/integration_04_mini_case_multi_param.txt new file mode 100644 index 0000000..be4b71d --- /dev/null +++ b/js/scripting-lang/tests/integration_04_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 |