1494 lines
40 KiB
C
Raw Normal View History

fix: reject trailing non-number characters in Num.fromString parsing Previously, `Num.fromString` accepted strings like `"1.2prefix"` and returned the leading numeric portion (`1.2`). This change makes parsing stricter by requiring that the entire string be consumed after `strtod`, skipping only trailing whitespace. If any non-whitespace characters remain after the number, the function now returns `null` instead of a partial result. The fix also adds an explicit empty-string check and updates the test suite to reflect the new behavior, replacing the old `"1.2prefix"` success test with a `"1.2suffix"` null-return test.
2015-02-25 16:07:54 +01:00
#include <ctype.h>
feat: add ERANGE error handling for oversized number literals in lexer and Num.fromString Replace TODO stubs with actual errno checks in readHexNumber, readNumber, and num_fromString to emit a "Number literal is too large." error when strtol/strtod overflow. Add three test files (literal_too_large.wren, hex_too_large.wren, from_string_too_large.wren) verifying compile-time and runtime error behavior for out-of-range numeric inputs.
2015-03-03 09:06:34 +01:00
#include <errno.h>
feat: implement modulo operator for numbers with fmod and add test suite Add num_mod primitive using fmod from math.h to support the % operator on number types. Register the new primitive in the numClass method table. Include a comprehensive test file covering positive, negative, and left-associative modulo cases, plus a divide-by-zero TODO comment in the existing division test.
2013-11-10 06:01:18 +01:00
#include <math.h>
feat: add io.write primitive and test runner with number literal tests Implement the io.write() primitive function that prints a value followed by a newline, enabling basic output for testing. Add a Python test runner script (runtests) that discovers and executes .wren test files, comparing output against // expect: comments. Include initial number literal tests covering positive, negative, and zero values. Remove debug print statements from the VM interpreter and refactor primitive registration macros for cleaner code.
2013-10-28 06:45:40 +01:00
#include <stdio.h>
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
#include <stdlib.h>
#include <string.h>
fix: ensure UINT32_MAX is available in gcc C++ builds by defining __STDC_LIMIT_MACROS before including stdint.h in wren_common.h
2015-02-25 06:09:04 +01:00
#include "wren_common.h"
refactor: rename primitives module to wren_core and update all references Rename the `primitives.h` and `primitives.c` files to `wren_core.h` and `wren_core.c` respectively, reflecting the module's purpose of defining built-in classes and native methods. Update all includes, macro names (PRIMITIVE -> NATIVE, DEF_PRIMITIVE -> DEF_NATIVE, etc.), and function calls (wrenLoadCore -> wrenInitializeCore) across the codebase and Xcode project file to match the new naming convention.
2013-11-28 17:00:55 +01:00
#include "wren_core.h"
fix: replace foreign Meta.eval with primitive and suppress compile errors in wrenCompile
2015-04-04 06:22:58 +02:00
#include "wren_primitive.h"
chore: rename source files to wren_ prefix and add module-level documentation headers
2013-11-28 17:11:50 +01:00
#include "wren_value.h"
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
refactor: extract IO class into separate module with wrenLoadIOLibrary and wren_io.c Replace monolithic corelib.wren with per-class builtin/*.wren files and generate_builtins.py script. Move IO class definition and its native writeString_ method from wren_core.c to new wren_io.c, adding wrenGetArgumentString and wrenDefineStaticMethod to the public API. Update Makefile target from corelib to builtin and remove generate_corelib.py.
2014-02-04 17:44:59 +01:00
// This string literal is generated automatically from core. Do not edit.
fix: rename builtin static variables to avoid linker ambiguity across modules
2015-04-16 13:07:14 +02:00
static const char* coreLibSource =
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
"class Bool {}\n"
"class Fiber {}\n"
"class Fn {}\n"
"class Null {}\n"
"class Num {}\n"
"\n"
feat: extract map and where into Sequence base class for List and Range Extract the common `map` and `where` methods from `List` into a new `Sequence` base class, making `List is Sequence` and `Range is Sequence`. Remove duplicate native method registrations for Range in wren_core.c and add new test files for Range map/where operations.
2014-02-16 18:20:31 +01:00
"class Sequence {\n"
feat: make Sequence.all() and Sequence.any() return actual predicate values instead of booleans Rewrite all() and any() to store and return the predicate's result directly, matching && and || semantics. Update documentation to describe the new behavior. Move tests from test/core/list/ to test/core/sequence/ and add cases verifying that the first falsey/truthy value is returned.
2015-03-28 18:18:45 +01:00
" all(f) {\n"
" var result = true\n"
" for (element in this) {\n"
" result = f.call(element)\n"
" if (!result) return result\n"
" }\n"
" return result\n"
" }\n"
"\n"
" any(f) {\n"
" var result = false\n"
" for (element in this) {\n"
" result = f.call(element)\n"
" if (result) return result\n"
" }\n"
" return result\n"
" }\n"
"\n"
feat: move contains method from List to Sequence and add tests for List and Range Add a generic `contains` implementation on the `Sequence` base class, removing the duplicate method from `List`. This allows all sequence types (including Range) to use the method without per-class redefinition. Include new test files for `List.contains` and `Range.contains` covering ordered, backwards, and exclusive ranges.
2015-03-15 15:43:10 +01:00
" contains(element) {\n"
" for (item in this) {\n"
feat: make Sequence.all() and Sequence.any() return actual predicate values instead of booleans Rewrite all() and any() to store and return the predicate's result directly, matching && and || semantics. Update documentation to describe the new behavior. Move tests from test/core/list/ to test/core/sequence/ and add cases verifying that the first falsey/truthy value is returned.
2015-03-28 18:18:45 +01:00
" if (element == item) return true\n"
feat: move contains method from List to Sequence and add tests for List and Range Add a generic `contains` implementation on the `Sequence` base class, removing the duplicate method from `List`. This allows all sequence types (including Range) to use the method without per-class redefinition. Include new test files for `List.contains` and `Range.contains` covering ordered, backwards, and exclusive ranges.
2015-03-15 15:43:10 +01:00
" }\n"
" return false\n"
" }\n"
"\n"
feat: add count method to Sequence class with iteration-based element tally Implement a `count` method on the `Sequence` class that iterates over all elements and returns the total number. The method uses a simple for-loop to increment a counter for each element, providing a generic way to determine sequence length without requiring a separate length property. Includes a test sequence that yields values 1 through 10 to verify the count returns 10.
2015-03-06 16:01:02 +01:00
" count {\n"
" var result = 0\n"
" for (element in this) {\n"
" result = result + 1\n"
" }\n"
" return result\n"
" }\n"
"\n"
feat: add Sequence.count(predicate) method and update documentation Implement a new `count(f)` method on the Sequence class that accepts a predicate function and returns the number of elements for which the predicate evaluates to true. The implementation iterates over the sequence, calling `f.call(element)` on each element and incrementing a counter when the result is truthy. Also update the documentation for both Sequence and List classes: add full documentation for the new `count(predicate)` method on Sequence, and change the terminology in List docs from "items" to "elements" for consistency. Add three test files covering the basic predicate behavior, non-boolean return values from the predicate, and the error case when a non-function argument is passed.
2015-03-14 14:17:21 +01:00
" count(f) {\n"
" var result = 0\n"
" for (element in this) {\n"
feat: make Sequence.all() and Sequence.any() return actual predicate values instead of booleans Rewrite all() and any() to store and return the predicate's result directly, matching && and || semantics. Update documentation to describe the new behavior. Move tests from test/core/list/ to test/core/sequence/ and add cases verifying that the first falsey/truthy value is returned.
2015-03-28 18:18:45 +01:00
" if (f.call(element)) result = result + 1\n"
feat: add Sequence.count(predicate) method and update documentation Implement a new `count(f)` method on the Sequence class that accepts a predicate function and returns the number of elements for which the predicate evaluates to true. The implementation iterates over the sequence, calling `f.call(element)` on each element and incrementing a counter when the result is truthy. Also update the documentation for both Sequence and List classes: add full documentation for the new `count(predicate)` method on Sequence, and change the terminology in List docs from "items" to "elements" for consistency. Add three test files covering the basic predicate behavior, non-boolean return values from the predicate, and the error case when a non-function argument is passed.
2015-03-14 14:17:21 +01:00
" }\n"
" return result\n"
" }\n"
"\n"
feat: add Sequence.each method for side-effect iteration without list creation Add a new `each` method to the Sequence class that iterates over elements calling a provided function for each, serving as a side-effect-only alternative to `map` when the resulting list is not needed. This is particularly important for the upcoming change where `map` will return a new sequence instead of mutating in place, as demonstrated by updating the README and index examples to use `each` with Fiber.yield. Includes documentation in the Sequence API reference and three new test cases covering normal iteration, empty sequences, and non-function argument error handling.
2015-03-28 20:35:20 +01:00
" each(f) {\n"
" for (element in this) {\n"
" f.call(element)\n"
" }\n"
" }\n"
"\n"
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
" isEmpty { iterate(null) ? false : true }\n"
"\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" map(transformation) { MapSequence.new(this, transformation) }\n"
feat: extract map and where into Sequence base class for List and Range Extract the common `map` and `where` methods from `List` into a new `Sequence` base class, making `List is Sequence` and `Range is Sequence`. Remove duplicate native method registrations for Range in wren_core.c and add new test files for Range map/where operations.
2014-02-16 18:20:31 +01:00
"\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" where(predicate) { WhereSequence.new(this, predicate) }\n"
feat: add forall method to Sequence class for testing all elements pass predicate Implement a `forall` method on the Sequence class that takes a predicate function and returns true only if every element in the sequence satisfies the predicate. The method iterates through all elements, returning false immediately upon encountering any element where the predicate does not return exactly true. Includes core library documentation and a test file verifying behavior with numeric comparisons and non-boolean predicate returns.
2015-01-14 08:47:01 +01:00
"\n"
feat: add reduce method to Sequence with two overloads and tests Implement `reduce` on the `Sequence` class in core.wren with two overloads: one taking an initial accumulator and a function, and another using the first element as the initial accumulator. Add three test files covering normal reduction, single-element edge case, and wrong arity error.
2015-01-15 16:29:49 +01:00
" reduce(acc, f) {\n"
" for (element in this) {\n"
" acc = f.call(acc, element)\n"
" }\n"
" return acc\n"
" }\n"
"\n"
feat: implement single-argument reduce with manual iteration and empty-sequence abort Replace the previous slice-based single-argument reduce implementation with an explicit iterator loop that seeds from the first element. This avoids the out-of-bounds range error on single-element lists and adds a Fiber.abort for empty sequences. Update the test to verify correct behavior for single-element and empty sequences.
2015-01-16 09:24:18 +01:00
" reduce(f) {\n"
" var iter = iterate(null)\n"
" if (!iter) Fiber.abort(\"Can't reduce an empty sequence.\")\n"
"\n"
" // Seed with the first element.\n"
" var result = iteratorValue(iter)\n"
" while (iter = iterate(iter)) {\n"
" result = f.call(result, iteratorValue(iter))\n"
" }\n"
"\n"
" return result\n"
" }\n"
feat: add reduce method to Sequence with two overloads and tests Implement `reduce` on the `Sequence` class in core.wren with two overloads: one taking an initial accumulator and a function, and another using the first element as the initial accumulator. Add three test files covering normal reduction, single-element edge case, and wrong arity error.
2015-01-15 16:29:49 +01:00
"\n"
feat: abstract List's toString into generic join method on Sequence Add `join` and `join(sep)` methods to the `Sequence` class, allowing any sequence to produce a concatenated string of its elements with an optional separator. Refactor `List.toString` to delegate to `join(", ")` with bracket wrapping, removing the manual iteration logic from List. Include new test files for List, Range, and String join behavior, plus runtime error tests for non-string separators.
2015-01-24 05:45:23 +01:00
" join { join(\"\") }\n"
"\n"
" join(sep) {\n"
" var first = true\n"
" var result = \"\"\n"
"\n"
" for (element in this) {\n"
" if (!first) result = result + sep\n"
" first = false\n"
" result = result + element.toString\n"
" }\n"
"\n"
" return result\n"
" }\n"
feat: add Sequence.list method to convert any sequence into a List Implements a new `list` method on the Sequence class that iterates over all elements and collects them into a new List instance. Includes documentation in the core sequence docs and a test case verifying correct behavior with a custom sequence implementation.
2015-03-27 22:59:58 +01:00
"\n"
feat: rename Sequence.list method to toList and update all call sites The `.list` method on Sequence was renamed to `.toList` to better reflect its purpose of converting a sequence into a List object. This change updates the method definition in `builtin/core.wren` and `src/vm/wren_core.c`, along with all test files that called `.list` on sequences, maps, ranges, and custom sequence implementations. The test file `test/core/sequence/list.wren` was also renamed to `test/core/sequence/to_list.wren` to match the new method name.
2015-04-03 20:22:34 +02:00
" toList {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" var result = List.new()\n"
feat: add Sequence.list method to convert any sequence into a List Implements a new `list` method on the Sequence class that iterates over all elements and collects them into a new List instance. Includes documentation in the core sequence docs and a test case verifying correct behavior with a custom sequence implementation.
2015-03-27 22:59:58 +01:00
" for (element in this) {\n"
" result.add(element)\n"
" }\n"
" return result\n"
" }\n"
feat: extract map and where into Sequence base class for List and Range Extract the common `map` and `where` methods from `List` into a new `Sequence` base class, making `List is Sequence` and `Range is Sequence`. Remove duplicate native method registrations for Range in wren_core.c and add new test files for Range map/where operations.
2014-02-16 18:20:31 +01:00
"}\n"
"\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
"class MapSequence is Sequence {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" this new(sequence, fn) {\n"
docs: rename MapSequence and WhereSequence fields and parameters for clarity, expand map(_) and where(_) docs with lazy semantics and examples
2015-04-01 16:31:15 +02:00
" _sequence = sequence\n"
" _fn = fn\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
" }\n"
"\n"
docs: rename MapSequence and WhereSequence fields and parameters for clarity, expand map(_) and where(_) docs with lazy semantics and examples
2015-04-01 16:31:15 +02:00
" iterate(iterator) { _sequence.iterate(iterator) }\n"
" iteratorValue(iterator) { _fn.call(_sequence.iteratorValue(iterator)) }\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
"}\n"
"\n"
"class WhereSequence is Sequence {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" this new(sequence, fn) {\n"
docs: rename MapSequence and WhereSequence fields and parameters for clarity, expand map(_) and where(_) docs with lazy semantics and examples
2015-04-01 16:31:15 +02:00
" _sequence = sequence\n"
" _fn = fn\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
" }\n"
"\n"
docs: rename MapSequence and WhereSequence fields and parameters for clarity, expand map(_) and where(_) docs with lazy semantics and examples
2015-04-01 16:31:15 +02:00
" iterate(iterator) {\n"
" while (iterator = _sequence.iterate(iterator)) {\n"
" if (_fn.call(_sequence.iteratorValue(iterator))) break\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
" }\n"
docs: rename MapSequence and WhereSequence fields and parameters for clarity, expand map(_) and where(_) docs with lazy semantics and examples
2015-04-01 16:31:15 +02:00
" return iterator\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
" }\n"
"\n"
docs: rename MapSequence and WhereSequence fields and parameters for clarity, expand map(_) and where(_) docs with lazy semantics and examples
2015-04-01 16:31:15 +02:00
" iteratorValue(iterator) { _sequence.iteratorValue(iterator) }\n"
feat: replace eager list-based map/where with deferred MapSequence and WhereSequence classes Introduce MapSequence and WhereSequence subclasses of Sequence that apply transformations lazily during iteration instead of building intermediate lists. Update Sequence.map and Sequence.where to return these deferred wrappers, modify all existing tests to call .list on results, and add new infinite-sequence tests verifying lazy behavior on Fibonacci iterators.
2015-03-28 22:51:50 +01:00
"}\n"
"\n"
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
"class String is Sequence {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" bytes { StringByteSequence.new(this) }\n"
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
"}\n"
"\n"
"class StringByteSequence is Sequence {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" this new(string) {\n"
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
" _string = string\n"
" }\n"
"\n"
" [index] { _string.byteAt(index) }\n"
" iterate(iterator) { _string.iterateByte_(iterator) }\n"
" iteratorValue(iterator) { _string.byteAt(iterator) }\n"
"}\n"
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
"\n"
feat: extract map and where into Sequence base class for List and Range Extract the common `map` and `where` methods from `List` into a new `Sequence` base class, making `List is Sequence` and `Range is Sequence`. Remove duplicate native method registrations for Range in wren_core.c and add new test files for Range map/where operations.
2014-02-16 18:20:31 +01:00
"class List is Sequence {\n"
feat: implement List.addAll() method to append elements from iterable Add `addAll(other)` method to the List class in both the Wren core library source and its embedded C string representation. The method iterates over the given `other` sequence, appends each element to the list using the existing `add()` method, and returns the original `other` argument to match the documented return behavior. Include a new test file `test/list/add_all.wren` covering basic appending, empty iterable, range input, and return value verification.
2014-04-06 17:37:37 +02:00
" addAll(other) {\n"
" for (element in other) {\n"
" add(element)\n"
" }\n"
" return other\n"
" }\n"
"\n"
revert: remove safeToString_ and recursive toString handling due to memory leak on runtime errors The safeToString_ mechanism introduced in 40897f33 used per-fiber maps and lists to detect recursive toString calls, but leaked memory when runtime errors occurred before cleanup. This reverts to direct toString implementations for List and Map, removing the recursive detection logic and updating tests to mark self-referencing containers as TODO.
2015-05-19 15:50:17 +02:00
" toString { \"[\" + join(\", \") + \"]\" }\n"
feat: implement List concat operator + supporting Range and empty lists Add `+` method to List class in core.wren that creates a new list by concatenating elements from both operands. Supports concatenation with Range objects and handles empty lists on either side. Includes comprehensive test cases in test/list/concat.wren covering list-list, list-range, and empty list combinations.
2014-02-14 18:09:02 +01:00
"\n"
feat: require parentheses around operator and setter method parameters in Wren Enforce syntactic requirement for parentheses in operator method signatures (e.g., `+(other)` instead of `+ other`) and setter definitions (e.g., `bar=(value)` instead of `bar = value`). Update the compiler's `infixSignature`, `mixedSignature`, and `namedSignature` functions to consume explicit `(` and `)` tokens around parameter names. Migrate all built-in core library operator definitions and test fixtures to the new parenthesized syntax.
2014-04-09 02:54:37 +02:00
" +(other) {\n"
fix: allow empty range subscripts [0..-1] and [0...0] on empty lists Add special case in list_subscript native to return a new empty list when the source list is empty and the requested range is [0..-1] (inclusive) or [0...0] (exclusive). This enables using list[0..-1] as a universal copy idiom that works even for empty lists. Update the List.+ operator to use this idiom instead of manual iteration. Add test cases for both range forms on empty lists.
2014-02-15 05:10:41 +01:00
" var result = this[0..-1]\n"
feat: require parentheses around operator and setter method parameters in Wren Enforce syntactic requirement for parentheses in operator method signatures (e.g., `+(other)` instead of `+ other`) and setter definitions (e.g., `bar=(value)` instead of `bar = value`). Update the compiler's `infixSignature`, `mixedSignature`, and `namedSignature` functions to consume explicit `(` and `)` tokens around parameter names. Migrate all built-in core library operator definitions and test fixtures to the new parenthesized syntax.
2014-04-09 02:54:37 +02:00
" for (element in other) {\n"
fix: remove conditional guards in List.+ and handle empty list iteration in iterate native The previous implementation of List.+ used conditional checks (`this.count > 0`, `that.count > 0`) before iterating, which caused the loop body to be skipped entirely for empty lists. This commit removes those guards, allowing the for-in loops to run unconditionally — the Wren VM's iterate/iterateValue protocol already handles the empty case correctly at the native level. Additionally, the `list_iterate` native in `wren_core.c` now returns `false` immediately when the list count is zero and the iterator argument is null, preventing an out-of-bounds index of 0 from being returned for empty lists. The test file `test/list/concat.wren` is renamed to `test/list/plus.wren` and extended with a check that the original list `a` remains unmodified after concatenation. A new test in `test/list/iterate.wren` verifies that iterating over an empty list returns `false`.
2014-02-15 02:24:06 +01:00
" result.add(element)\n"
feat: implement List concat operator + supporting Range and empty lists Add `+` method to List class in core.wren that creates a new list by concatenating elements from both operands. Supports concatenation with Range objects and handles empty lists on either side. Includes comprehensive test cases in test/list/concat.wren covering list-list, list-range, and empty list combinations.
2014-02-14 18:09:02 +01:00
" }\n"
fix: remove conditional guards in List.+ and handle empty list iteration in iterate native The previous implementation of List.+ used conditional checks (`this.count > 0`, `that.count > 0`) before iterating, which caused the loop body to be skipped entirely for empty lists. This commit removes those guards, allowing the for-in loops to run unconditionally — the Wren VM's iterate/iterateValue protocol already handles the empty case correctly at the native level. Additionally, the `list_iterate` native in `wren_core.c` now returns `false` immediately when the list count is zero and the iterator argument is null, preventing an out-of-bounds index of 0 from being returned for empty lists. The test file `test/list/concat.wren` is renamed to `test/list/plus.wren` and extended with a check that the original list `a` remains unmodified after concatenation. A new test in `test/list/iterate.wren` verifies that iterating over an empty list returns `false`.
2014-02-15 02:24:06 +01:00
" return result\n"
feat: implement List concat operator + supporting Range and empty lists Add `+` method to List class in core.wren that creates a new list by concatenating elements from both operands. Supports concatenation with Range objects and handles empty lists on either side. Includes comprehensive test cases in test/list/concat.wren covering list-list, list-range, and empty list combinations.
2014-02-14 18:09:02 +01:00
" }\n"
feat: extract map and where into Sequence base class for List and Range Extract the common `map` and `where` methods from `List` into a new `Sequence` base class, making `List is Sequence` and `Range is Sequence`. Remove duplicate native method registrations for Range in wren_core.c and add new test files for Range map/where operations.
2014-02-16 18:20:31 +01:00
"}\n"
"\n"
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
"class Map {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" keys { MapKeySequence.new(this) }\n"
" values { MapValueSequence.new(this) }\n"
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
"\n"
" toString {\n"
revert: remove safeToString_ and recursive toString handling due to memory leak on runtime errors The safeToString_ mechanism introduced in 40897f33 used per-fiber maps and lists to detect recursive toString calls, but leaked memory when runtime errors occurred before cleanup. This reverts to direct toString implementations for List and Map, removing the recursive detection logic and updating tests to mark self-referencing containers as TODO.
2015-05-19 15:50:17 +02:00
" var first = true\n"
" var result = \"{\"\n"
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
"\n"
revert: remove safeToString_ and recursive toString handling due to memory leak on runtime errors The safeToString_ mechanism introduced in 40897f33 used per-fiber maps and lists to detect recursive toString calls, but leaked memory when runtime errors occurred before cleanup. This reverts to direct toString implementations for List and Map, removing the recursive detection logic and updating tests to mark self-referencing containers as TODO.
2015-05-19 15:50:17 +02:00
" for (key in keys) {\n"
" if (!first) result = result + \", \"\n"
" first = false\n"
" result = result + key.toString + \": \" + this[key].toString\n"
fix: prevent stack overflow on recursive toString for List and Map Add `String.safeToString_` static method that tracks objects currently being converted to string per fiber, returning "..." when recursion is detected. Wrap List.toString and Map.toString with this guard to handle self-referential and mutually recursive structures without crashing.
2015-05-03 20:13:05 +02:00
" }\n"
revert: remove safeToString_ and recursive toString handling due to memory leak on runtime errors The safeToString_ mechanism introduced in 40897f33 used per-fiber maps and lists to detect recursive toString calls, but leaked memory when runtime errors occurred before cleanup. This reverts to direct toString implementations for List and Map, removing the recursive detection logic and updating tests to mark self-referencing containers as TODO.
2015-05-19 15:50:17 +02:00
"\n"
" return result + \"}\"\n"
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
" }\n"
"}\n"
"\n"
"class MapKeySequence is Sequence {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" this new(map) {\n"
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
" _map = map\n"
" }\n"
"\n"
" iterate(n) { _map.iterate_(n) }\n"
" iteratorValue(iterator) { _map.keyIteratorValue_(iterator) }\n"
"}\n"
"\n"
"class MapValueSequence is Sequence {\n"
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
" this new(map) {\n"
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
" _map = map\n"
" }\n"
"\n"
" iterate(n) { _map.iterate_(n) }\n"
" iteratorValue(iterator) { _map.valueIteratorValue_(iterator) }\n"
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
"}\n"
"\n"
feat: extract map and where into Sequence base class for List and Range Extract the common `map` and `where` methods from `List` into a new `Sequence` base class, making `List is Sequence` and `Range is Sequence`. Remove duplicate native method registrations for Range in wren_core.c and add new test files for Range map/where operations.
2014-02-16 18:20:31 +01:00
"class Range is Sequence {}\n";
feat: make IO.write call toString on argument and add corelib with List.toString
2013-12-22 20:50:00 +01:00
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
// A simple primitive that just returns "this". Used in a few different places:
//
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
// * The default new() initializer on Object needs no initialization so just
// uses this.
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
// * String's toString method obviously can use this.
DEF_PRIMITIVE(return_this)
{
RETURN_VAL(args[0]);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(bool_not)
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
{
RETURN_BOOL(!AS_BOOL(args[0]));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(bool_toString)
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
{
if (AS_BOOL(args[0]))
{
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
RETURN_VAL(CONST_STRING(vm, "true"));
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
}
else
{
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
RETURN_VAL(CONST_STRING(vm, "false"));
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
}
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(class_name)
feat: add class name storage and expose via `name` method on class objects Store the class name string in `ObjClass` during compilation and class creation, and expose it through a new `class_name` native method. Also update `object_toString` to return the class name for class instances and "instance of <name>" for regular instances.
2014-01-29 00:31:11 +01:00
{
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
RETURN_OBJ(AS_CLASS(args[0])->name);
feat: add class name storage and expose via `name` method on class objects Store the class name string in `ObjClass` during compilation and class creation, and expose it through a new `class_name` native method. Also update `object_toString` to return the class name for class instances and "instance of <name>" for regular instances.
2014-01-29 00:31:11 +01:00
}
feat: add Class.supertype primitive and documentation for retrieving superclass Implement a new `supertype` property on Class objects that returns the superclass of a given class. The primitive `class_supertype` checks if the class has a superclass (returning null for Object) and returns the superclass object. Includes documentation in the class reference and a test file verifying behavior for explicit superclasses, implicit Object inheritance, and Object's null supertype.
2015-03-14 17:48:45 +01:00
DEF_PRIMITIVE(class_supertype)
{
ObjClass* classObj = AS_CLASS(args[0]);
// Object has no superclass.
if (classObj->superclass == NULL) RETURN_NULL;
feat: reverse argument order of List.insert to index-first convention The previous signature `insert(element, index)` was counter-intuitive and inconsistent with every major language's list API. This commit swaps the parameters to `insert(index, element)`, matching the convention used by Ruby, JavaScript, C++, Lua, C#, Java, and Python. All documentation, C implementation, and test files are updated to reflect the new order.
2015-03-15 22:51:24 +01:00
feat: add Class.supertype primitive and documentation for retrieving superclass Implement a new `supertype` property on Class objects that returns the superclass of a given class. The primitive `class_supertype` checks if the class has a superclass (returning null for Object) and returns the superclass object. Includes documentation in the class reference and a test file verifying behavior for explicit superclasses, implicit Object inheritance, and Object's null supertype.
2015-03-14 17:48:45 +01:00
RETURN_OBJ(classObj->superclass);
}
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
DEF_PRIMITIVE(class_toString)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
RETURN_OBJ(AS_CLASS(args[0])->name);
feat: replace Fiber.create constructor with new Fiber instantiation pattern Refactor fiber creation from a static `Fiber.create` method to a constructor-based `new Fiber` pattern. This introduces a `fiber_instantiate` native that returns the Fiber class itself, allowing `new Fiber` to invoke `fiber_new` for validation and creation. A shared `validateFn` helper is added to centralize function argument checking, replacing inline validation in both `fiber_new` and `fn_new`. All test files are updated to use the new syntax, and the old `create_wrong_arg_type` test is replaced with `new_wrong_arg_type`.
2014-04-05 03:24:55 +02:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_new)
feat: replace Fiber.create constructor with new Fiber instantiation pattern Refactor fiber creation from a static `Fiber.create` method to a constructor-based `new Fiber` pattern. This introduces a `fiber_instantiate` native that returns the Fiber class itself, allowing `new Fiber` to invoke `fiber_new` for validation and creation. A shared `validateFn` helper is added to centralize function argument checking, replacing inline validation in both `fiber_new` and `fn_new`. All test files are updated to use the new syntax, and the old `create_wrong_arg_type` test is replaced with `new_wrong_arg_type`.
2014-04-05 03:24:55 +02:00
{
if (!validateFn(vm, args, 1, "Argument")) return PRIM_ERROR;
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
ObjFiber* newFiber = wrenNewFiber(vm, AS_OBJ(args[1]));
feat: allow implicit null return when return statement has no value In the compiler, when a `return` token is followed by a newline or right brace, emit CODE_NULL instead of parsing an expression. This enables bare `return` statements to implicitly return null. Also removes a stale TODO comment about setter parameters and fixes a typo in a comment in wren_core.c. Adds three test cases: one for explicit return in a function, one for bare return before a brace, and one for bare return before a newline.
2014-01-13 04:37:11 +01:00
// The compiler expects the first slot of a function to hold the receiver.
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
// Since a fiber's stack is invoked directly, it doesn't have one, so put it
// in here.
// TODO: Is there a cleaner solution?
// TODO: If we make growable stacks, make sure this grows it.
newFiber->stack[0] = NULL_VAL;
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
newFiber->stackTop++;
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
feat: add class name storage and expose via `name` method on class objects Store the class name string in `ObjClass` during compilation and class creation, and expose it through a new `class_name` native method. Also update `object_toString` to return the class name for class instances and "instance of <name>" for regular instances.
2014-01-29 00:31:11 +01:00
RETURN_OBJ(newFiber);
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_abort)
feat: add Fiber.abort() method to abort fiber with error message Implements a new `Fiber.abort()` static method that allows a fiber to terminate with a custom error message string. The method validates that the argument is a string, then returns a PRIM_ERROR to abort the current fiber. Includes three test cases: basic abort with error message retrieval via `fiber.try`, aborting the main fiber with a runtime error, and type checking that non-string arguments produce an appropriate error message.
2015-01-01 19:40:14 +01:00
{
if (!validateString(vm, args, 1, "Error message")) return PRIM_ERROR;
// Move the error message to the return position.
args[0] = args[1];
return PRIM_ERROR;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_call)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
if (runFiber->numFrames == 0) RETURN_ERROR("Cannot call a finished fiber.");
if (runFiber->caller != NULL) RETURN_ERROR("Fiber has already been called.");
fix: wrap ASSERT in do-while and add UNREACHABLE macro for GCC compatibility
2014-11-28 20:21:01 +01:00
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
// Remember who ran it.
runFiber->caller = fiber;
// If the fiber was yielded, make the yield call return null.
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
if (runFiber->stackTop > runFiber->stack)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
*(runFiber->stackTop - 1) = NULL_VAL;
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
}
return PRIM_RUN_FIBER;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_call1)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
if (runFiber->numFrames == 0) RETURN_ERROR("Cannot call a finished fiber.");
if (runFiber->caller != NULL) RETURN_ERROR("Fiber has already been called.");
feat: add fiber.isDone property and runtime error checks for finished fiber operations Add a new `isDone` native method to the Fiber class that returns true when the fiber has no remaining frames. Replace TODO comments with proper runtime error handling in `fiber_run`, `fiber_run1`, `fiber_yield`, and `fiber_yield1` to prevent running finished fibers or yielding from the main fiber. Include test cases verifying the new property and error conditions.
2014-01-13 15:58:27 +01:00
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
// Remember who ran it.
runFiber->caller = fiber;
// If the fiber was yielded, make the yield call return the value passed to
// run.
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
if (runFiber->stackTop > runFiber->stack)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
*(runFiber->stackTop - 1) = args[1];
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
}
// When the calling fiber resumes, we'll store the result of the run call
// in its stack. Since fiber.run(value) has two arguments (the fiber and the
// value) and we only need one slot for the result, discard the other slot
// now.
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
fiber->stackTop--;
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
return PRIM_RUN_FIBER;
}
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
DEF_PRIMITIVE(fiber_current)
{
RETURN_OBJ(fiber);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_error)
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
if (runFiber->error == NULL) RETURN_NULL;
RETURN_OBJ(runFiber->error);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_isDone)
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
RETURN_BOOL(runFiber->numFrames == 0 || runFiber->error != NULL);
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_run)
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
if (runFiber->numFrames == 0) RETURN_ERROR("Cannot run a finished fiber.");
// If the fiber was yielded, make the yield call return null.
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
if (runFiber->caller == NULL && runFiber->stackTop > runFiber->stack)
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
{
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
*(runFiber->stackTop - 1) = NULL_VAL;
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
}
// Unlike run, this does not remember the calling fiber. Instead, it
// remember's *that* fiber's caller. You can think of it like tail call
// elimination. The switched-from fiber is discarded and when the switched
// to fiber completes or yields, control passes to the switched-from fiber's
// caller.
runFiber->caller = fiber->caller;
return PRIM_RUN_FIBER;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_run1)
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
if (runFiber->numFrames == 0) RETURN_ERROR("Cannot run a finished fiber.");
// If the fiber was yielded, make the yield call return the value passed to
// run.
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
if (runFiber->caller == NULL && runFiber->stackTop > runFiber->stack)
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
{
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
*(runFiber->stackTop - 1) = args[1];
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
}
// Unlike run, this does not remember the calling fiber. Instead, it
// remember's *that* fiber's caller. You can think of it like tail call
// elimination. The switched-from fiber is discarded and when the switched
// to fiber completes or yields, control passes to the switched-from fiber's
// caller.
runFiber->caller = fiber->caller;
return PRIM_RUN_FIBER;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_try)
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
{
ObjFiber* runFiber = AS_FIBER(args[0]);
if (runFiber->numFrames == 0) RETURN_ERROR("Cannot try a finished fiber.");
if (runFiber->caller != NULL) RETURN_ERROR("Fiber has already been called.");
// Remember who ran it.
runFiber->caller = fiber;
runFiber->callerIsTrying = true;
// If the fiber was yielded, make the yield call return null.
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
if (runFiber->stackTop > runFiber->stack)
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
{
refactor: replace integer stack index with pointer for stack top in fiber Migrate fiber stack management from an integer `stackSize` counter to a direct `Value* stackTop` pointer, eliminating repeated `stack[stackSize - 1]` calculations. Update all stack slot accesses, iteration loops, and the `CallFrame::stackStart` field to use pointer arithmetic, simplifying the code and reducing index arithmetic overhead.
2014-12-31 19:34:27 +01:00
*(runFiber->stackTop - 1) = NULL_VAL;
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
}
return PRIM_RUN_FIBER;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_yield)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
// Unhook this fiber from the one that called it.
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
ObjFiber* caller = fiber->caller;
fiber->caller = NULL;
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
fiber->callerIsTrying = false;
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
// If we don't have any other pending fibers, jump all the way out of the
// interpreter.
if (caller == NULL)
{
args[0] = NULL_VAL;
}
else
{
// Make the caller's run method return null.
*(caller->stackTop - 1) = NULL_VAL;
// Return the fiber to resume.
args[0] = OBJ_VAL(caller);
}
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
return PRIM_RUN_FIBER;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fiber_yield1)
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
{
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
// Unhook this fiber from the one that called it.
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
ObjFiber* caller = fiber->caller;
fiber->caller = NULL;
feat: add Fiber.try() method for catching errors across fiber boundaries Implement a new `Fiber.try()` method that allows a calling fiber to catch runtime errors from a called fiber. When a fiber is invoked with `try()` instead of `call()`, any runtime error that occurs in the called fiber is returned as a string to the caller rather than terminating the program with a stack trace. The `callerIsTrying` flag on `ObjFiber` tracks this state, and the `runtimeError` function now checks this flag to redirect the error to the caller's stack. Also adds `Fiber.error` getter to retrieve the error string from a failed fiber, changes `Fiber.isDone` to return `true` for errored fibers, and migrates the fiber error field from a raw `char*` to an `ObjString*` for proper memory management. Includes comprehensive test cases for try behavior, re-entry prevention, and error state queries.
2014-10-15 15:36:42 +02:00
fiber->callerIsTrying = false;
feat: implement symmetric coroutines with fiber.call and fiber.run distinction Add new `fiber.call` method that remembers the calling fiber for symmetric transfer, while `fiber.run` now performs tail-call style switching without preserving the caller. Introduce re-entrancy guards preventing a fiber from being called multiple times, update all test fixtures to use the new API, and add comprehensive test coverage for call semantics including direct/indirect re-entrancy, value passing, and finished fiber errors.
2014-04-14 16:23:05 +02:00
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
// If we don't have any other pending fibers, jump all the way out of the
// interpreter.
if (caller == NULL)
{
args[0] = NULL_VAL;
}
else
{
// Make the caller's run method return the argument passed to yield.
*(caller->stackTop - 1) = args[1];
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
// When the yielding fiber resumes, we'll store the result of the yield call
// in its stack. Since Fiber.yield(value) has two arguments (the Fiber class
// and the value) and we only need one slot for the result, discard the other
// slot now.
fiber->stackTop--;
// Return the fiber to resume.
args[0] = OBJ_VAL(caller);
}
feat: implement fiber primitives with create, run, yield and caller tracking Add core fiber functionality including Fiber.create, Fiber.run, Fiber.yield primitives with value passing between fibers. Introduce PRIM_RUN_FIBER result type for interpreter loop, add caller field to ObjFiber struct for yield resumption, and update GC marking to traverse fiber caller chains. Modify wrenNewFiber to accept a function/closure argument and initialize the first call frame. Add debug stack printing with fiber pointer. Include test suite covering fiber creation, run, yield, value passing, type checking, and caller resumption.
2014-01-12 20:02:07 +01:00
return PRIM_RUN_FIBER;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fn_new)
feat: add arity getter to Fn class and rename numParams to arity Add a public `arity` getter to the Fn class that returns the number of required arguments for a function. Internally rename the `numParams` field to `arity` across the codebase for consistency, update the C API parameter name from `numParams` to `arity` in `wrenDefineMethod` and `wrenDefineStaticMethod`, and adjust the error message in `callFunction` to use the new field name. Also update documentation to clarify that extra arguments are ignored rather than causing an error, and add a new test file `test/function/arity.wren` verifying arity values from 0 to 4.
2015-01-24 05:33:05 +01:00
{
if (!validateFn(vm, args, 1, "Argument")) return PRIM_ERROR;
// The block argument is already a function, so just return it.
RETURN_VAL(args[1]);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fn_arity)
feat: add arity getter to Fn class and rename numParams to arity Add a public `arity` getter to the Fn class that returns the number of required arguments for a function. Internally rename the `numParams` field to `arity` across the codebase for consistency, update the C API parameter name from `numParams` to `arity` in `wrenDefineMethod` and `wrenDefineStaticMethod`, and adjust the error message in `callFunction` to use the new field name. Also update documentation to clarify that extra arguments are ignored rather than causing an error, and add a new test file `test/function/arity.wren` verifying arity values from 0 to 4.
2015-01-24 05:33:05 +01:00
{
RETURN_NUM(AS_FN(args[0])->arity);
}
refactor: rename static callFunction helper to callFn to avoid name collision with public API The static helper `callFunction` in wren_core.c was renamed to `callFn` to prevent symbol conflicts with the public `wrenCallFunction` API, ensuring unique linkage and clearer separation between internal and external call paths.
2015-03-26 20:42:20 +01:00
static PrimitiveResult callFn(WrenVM* vm, Value* args, int numArgs)
feat: add numParams tracking and arity-checked fn.call variants for extra/missing args Add `numParams` field to `ObjFn` and `Compiler` structs to track expected parameter count. Refactor `parameterList` to return count and store it in compiler. Modify `endCompiler` to pass `numParams` to `wrenNewFunction`. Replace single `fn_call` native with 17 arity-specific `fn_call0` through `fn_call16` natives that validate argument count against `fn->numParams` via `callFunction` helper, returning error on missing args. Remove stale TODO comment in VM interpreter. Add test files `call_extra_arguments.wren` and `call_missing_arguments.wren`.
2014-02-04 18:34:05 +01:00
{
fix: handle parameter list checking for closures in callFunction
2014-02-10 16:53:09 +01:00
ObjFn* fn;
if (IS_CLOSURE(args[0]))
{
fn = AS_CLOSURE(args[0])->fn;
}
else
{
fn = AS_FN(args[0]);
}
feat: add List.where method for filtering elements with a predicate function Implement a `where` method on the List class that takes a function `f` and returns a new list containing only elements for which `f.call(element)` returns true. The implementation is added both in the builtin core.wren source and embedded in the C library source string in wren_core.c. Also includes a new test file `test/list/where.wren` verifying filtering with matching and non-matching predicates.
2014-02-15 20:21:24 +01:00
feat: add arity getter to Fn class and rename numParams to arity Add a public `arity` getter to the Fn class that returns the number of required arguments for a function. Internally rename the `numParams` field to `arity` across the codebase for consistency, update the C API parameter name from `numParams` to `arity` in `wrenDefineMethod` and `wrenDefineStaticMethod`, and adjust the error message in `callFunction` to use the new field name. Also update documentation to clarify that extra arguments are ignored rather than causing an error, and add a new test file `test/function/arity.wren` verifying arity values from 0 to 4.
2015-01-24 05:33:05 +01:00
if (numArgs < fn->arity) RETURN_ERROR("Function expects more arguments.");
feat: add List.where method for filtering elements with a predicate function Implement a `where` method on the List class that takes a function `f` and returns a new list containing only elements for which `f.call(element)` returns true. The implementation is added both in the builtin core.wren source and embedded in the C library source string in wren_core.c. Also includes a new test file `test/list/where.wren` verifying filtering with matching and non-matching predicates.
2014-02-15 20:21:24 +01:00
feat: add numParams tracking and arity-checked fn.call variants for extra/missing args Add `numParams` field to `ObjFn` and `Compiler` structs to track expected parameter count. Refactor `parameterList` to return count and store it in compiler. Modify `endCompiler` to pass `numParams` to `wrenNewFunction`. Replace single `fn_call` native with 17 arity-specific `fn_call0` through `fn_call16` natives that validate argument count against `fn->numParams` via `callFunction` helper, returning error on missing args. Remove stale TODO comment in VM interpreter. Add test files `call_extra_arguments.wren` and `call_missing_arguments.wren`.
2014-02-04 18:34:05 +01:00
return PRIM_CALL;
}
refactor: rename static callFunction helper to callFn to avoid name collision with public API The static helper `callFunction` in wren_core.c was renamed to `callFn` to prevent symbol conflicts with the public `wrenCallFunction` API, ensuring unique linkage and clearer separation between internal and external call paths.
2015-03-26 20:42:20 +01:00
DEF_PRIMITIVE(fn_call0) { return callFn(vm, args, 0); }
DEF_PRIMITIVE(fn_call1) { return callFn(vm, args, 1); }
DEF_PRIMITIVE(fn_call2) { return callFn(vm, args, 2); }
DEF_PRIMITIVE(fn_call3) { return callFn(vm, args, 3); }
DEF_PRIMITIVE(fn_call4) { return callFn(vm, args, 4); }
DEF_PRIMITIVE(fn_call5) { return callFn(vm, args, 5); }
DEF_PRIMITIVE(fn_call6) { return callFn(vm, args, 6); }
DEF_PRIMITIVE(fn_call7) { return callFn(vm, args, 7); }
DEF_PRIMITIVE(fn_call8) { return callFn(vm, args, 8); }
DEF_PRIMITIVE(fn_call9) { return callFn(vm, args, 9); }
DEF_PRIMITIVE(fn_call10) { return callFn(vm, args, 10); }
DEF_PRIMITIVE(fn_call11) { return callFn(vm, args, 11); }
DEF_PRIMITIVE(fn_call12) { return callFn(vm, args, 12); }
DEF_PRIMITIVE(fn_call13) { return callFn(vm, args, 13); }
DEF_PRIMITIVE(fn_call14) { return callFn(vm, args, 14); }
DEF_PRIMITIVE(fn_call15) { return callFn(vm, args, 15); }
DEF_PRIMITIVE(fn_call16) { return callFn(vm, args, 16); }
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(fn_toString)
feat: add conditional operator and fn toString to wren compiler and core Add TOKEN_QUESTION token type and implement conditional() parsing function in wren_compiler.c to support the ternary conditional operator (condition ? then : else). Register fn_toString native in wren_core.c to return "<fn>" string for function objects. Include comprehensive test suite covering precedence, short-circuit evaluation, and error cases for missing tokens.
2014-02-15 20:36:01 +01:00
{
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
RETURN_VAL(CONST_STRING(vm, "<fn>"));
feat: add conditional operator and fn toString to wren compiler and core Add TOKEN_QUESTION token type and implement conditional() parsing function in wren_compiler.c to support the ternary conditional operator (condition ? then : else). Register fn_toString native in wren_core.c to return "<fn>" string for function objects. Include comprehensive test suite covering precedence, short-circuit evaluation, and error cases for missing tokens.
2014-02-15 20:36:01 +01:00
}
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
DEF_PRIMITIVE(list_new)
feat: implement List instantiation via "new" and fix inline functions to static Add `list_instantiate` native to create empty lists, bind it to List's metaclass for `new` support, and remove the related TODO. Also change three `inline` functions in `wren_value.h` to `static inline` to prevent linker errors. Include a new test `test/list/new.wren` verifying `new List` yields an empty list that supports `add`.
2014-04-08 16:31:23 +02:00
{
RETURN_OBJ(wrenNewList(vm, 0));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_add)
feat: implement list.add() with dynamic growth and add wrenPrintValue helper Add the `list_add` primitive to support appending elements to lists with automatic capacity management using `LIST_MIN_CAPACITY` and `LIST_GROW_FACTOR` constants. Rename internal `valuesEqual` and `reallocate` functions to `wrenValuesEqual` and `wrenReallocate` for consistent naming, and introduce `wrenPrintValue` to handle formatted output of all value types including lists. Add a test file `test/list_add.wren` verifying basic add operations and return value behavior.
2013-11-27 03:02:10 +01:00
{
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
wrenValueBufferWrite(vm, &AS_LIST(args[0])->elements, args[1]);
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
RETURN_VAL(args[1]);
feat: implement list.add() with dynamic growth and add wrenPrintValue helper Add the `list_add` primitive to support appending elements to lists with automatic capacity management using `LIST_MIN_CAPACITY` and `LIST_GROW_FACTOR` constants. Rename internal `valuesEqual` and `reallocate` functions to `wrenValuesEqual` and `wrenReallocate` for consistent naming, and introduce `wrenPrintValue` to handle formatted output of all value types including lists. Add a test file `test/list_add.wren` verifying basic add operations and return value behavior.
2013-11-27 03:02:10 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_clear)
feat: add list clear and insert primitives with capacity growth and index validation Extract inline list growth logic into `ensureListCapacity` helper and add `validateIndex` function supporting negative indices. Implement `list_clear` primitive that resets count to zero without freeing memory, and `list_insert` primitive that shifts elements right and inserts at validated position. Add comprehensive test suites for both operations covering empty lists, normal/negative indices, and return values.
2013-11-27 08:11:11 +01:00
{
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
wrenValueBufferClear(vm, &AS_LIST(args[0])->elements);
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
RETURN_NULL;
feat: add list clear and insert primitives with capacity growth and index validation Extract inline list growth logic into `ensureListCapacity` helper and add `validateIndex` function supporting negative indices. Implement `list_clear` primitive that resets count to zero without freeing memory, and `list_insert` primitive that shifts elements right and inserts at validated position. Add comprehensive test suites for both operations covering empty lists, normal/negative indices, and return values.
2013-11-27 08:11:11 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_count)
feat: implement list literal syntax and List class with count property Add support for list literals in the compiler with bracket-delimited syntax and comma-separated elements. Introduce the ObjList runtime type with a contiguous elements array, garbage collection marking, and proper memory deallocation. Expose a `List` class in the core library with a `count` method returning the number of elements. Update the grammar table to register `[` as a prefix token for list compilation instead of an infix subscript operator, and reorder opcode enum entries to place CODE_LIST before the load/store group.
2013-11-24 22:38:31 +01:00
{
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
RETURN_NUM(AS_LIST(args[0])->elements.count);
feat: implement list literal syntax and List class with count property Add support for list literals in the compiler with bracket-delimited syntax and comma-separated elements. Introduce the ObjList runtime type with a contiguous elements array, garbage collection marking, and proper memory deallocation. Expose a `List` class in the core library with a `count` method returning the number of elements. Update the grammar table to register `[` as a prefix token for list compilation instead of an infix subscript operator, and reorder opcode enum entries to place CODE_LIST before the load/store group.
2013-11-24 22:38:31 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_insert)
feat: implement subscript operator for lists with negative index and bounds checking Add list_subscript primitive that supports integer indexing with negative indices counting from the end, returns null for out-of-bounds access, non-integer indices, and non-numeric argument types. Register the `[ ]` operator on the List class in loadCore and include comprehensive test coverage in test/list_subscript.wren.
2013-11-25 04:08:46 +01:00
{
feat: add list clear and insert primitives with capacity growth and index validation Extract inline list growth logic into `ensureListCapacity` helper and add `validateIndex` function supporting negative indices. Implement `list_clear` primitive that resets count to zero without freeing memory, and `list_insert` primitive that shifts elements right and inserts at validated position. Add comprehensive test suites for both operations covering empty lists, normal/negative indices, and return values.
2013-11-27 08:11:11 +01:00
ObjList* list = AS_LIST(args[0]);
feat: implement subscript operator for lists with negative index and bounds checking Add list_subscript primitive that supports integer indexing with negative indices counting from the end, returns null for out-of-bounds access, non-integer indices, and non-numeric argument types. Register the `[ ]` operator on the List class in loadCore and include comprehensive test coverage in test/list_subscript.wren.
2013-11-25 04:08:46 +01:00
feat: implement list_removeAt primitive with capacity shrink and test suite Add DEF_PRIMITIVE(list_removeAt) to src/primitives.c that removes an element at a given index from an ObjList, shifts remaining elements up, shrinks capacity when excess is detected via LIST_GROW_FACTOR, and returns the removed Value. Register the primitive as "removeAt " on vm->listClass. Create test/list/remove_at.wren covering removal at positive indices 0,1,2, negative indices -1,-2,-3, out-of-bounds cases returning null, and verification that the removed value is returned.
2013-11-27 19:20:32 +01:00
// count + 1 here so you can "insert" at the very end.
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
uint32_t index = validateIndex(vm, args, list->elements.count + 1, 1,
"Index");
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
if (index == UINT32_MAX) return PRIM_ERROR;
feat: implement subscript operator for lists with negative index and bounds checking Add list_subscript primitive that supports integer indexing with negative indices counting from the end, returns null for out-of-bounds access, non-integer indices, and non-numeric argument types. Register the `[ ]` operator on the List class in loadCore and include comprehensive test coverage in test/list_subscript.wren.
2013-11-25 04:08:46 +01:00
feat: reverse argument order of List.insert to index-first convention The previous signature `insert(element, index)` was counter-intuitive and inconsistent with every major language's list API. This commit swaps the parameters to `insert(index, element)`, matching the convention used by Ruby, JavaScript, C++, Lua, C#, Java, and Python. All documentation, C implementation, and test files are updated to reflect the new order.
2015-03-15 22:51:24 +01:00
wrenListInsert(vm, list, args[2], index);
RETURN_VAL(args[2]);
feat: add list clear and insert primitives with capacity growth and index validation Extract inline list growth logic into `ensureListCapacity` helper and add `validateIndex` function supporting negative indices. Implement `list_clear` primitive that resets count to zero without freeing memory, and `list_insert` primitive that shifts elements right and inserts at validated position. Add comprehensive test suites for both operations covering empty lists, normal/negative indices, and return values.
2013-11-27 08:11:11 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_iterate)
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
{
fix: remove conditional guards in List.+ and handle empty list iteration in iterate native The previous implementation of List.+ used conditional checks (`this.count > 0`, `that.count > 0`) before iterating, which caused the loop body to be skipped entirely for empty lists. This commit removes those guards, allowing the for-in loops to run unconditionally — the Wren VM's iterate/iterateValue protocol already handles the empty case correctly at the native level. Additionally, the `list_iterate` native in `wren_core.c` now returns `false` immediately when the list count is zero and the iterator argument is null, preventing an out-of-bounds index of 0 from being returned for empty lists. The test file `test/list/concat.wren` is renamed to `test/list/plus.wren` and extended with a check that the original list `a` remains unmodified after concatenation. A new test in `test/list/iterate.wren` verifies that iterating over an empty list returns `false`.
2014-02-15 02:24:06 +01:00
ObjList* list = AS_LIST(args[0]);
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
// If we're starting the iteration, return the first index.
fix: remove conditional guards in List.+ and handle empty list iteration in iterate native The previous implementation of List.+ used conditional checks (`this.count > 0`, `that.count > 0`) before iterating, which caused the loop body to be skipped entirely for empty lists. This commit removes those guards, allowing the for-in loops to run unconditionally — the Wren VM's iterate/iterateValue protocol already handles the empty case correctly at the native level. Additionally, the `list_iterate` native in `wren_core.c` now returns `false` immediately when the list count is zero and the iterator argument is null, preventing an out-of-bounds index of 0 from being returned for empty lists. The test file `test/list/concat.wren` is renamed to `test/list/plus.wren` and extended with a check that the original list `a` remains unmodified after concatenation. A new test in `test/list/iterate.wren` verifies that iterating over an empty list returns `false`.
2014-02-15 02:24:06 +01:00
if (IS_NULL(args[1]))
{
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
if (list->elements.count == 0) RETURN_FALSE;
fix: remove conditional guards in List.+ and handle empty list iteration in iterate native The previous implementation of List.+ used conditional checks (`this.count > 0`, `that.count > 0`) before iterating, which caused the loop body to be skipped entirely for empty lists. This commit removes those guards, allowing the for-in loops to run unconditionally — the Wren VM's iterate/iterateValue protocol already handles the empty case correctly at the native level. Additionally, the `list_iterate` native in `wren_core.c` now returns `false` immediately when the list count is zero and the iterator argument is null, preventing an out-of-bounds index of 0 from being returned for empty lists. The test file `test/list/concat.wren` is renamed to `test/list/plus.wren` and extended with a check that the original list `a` remains unmodified after concatenation. A new test in `test/list/iterate.wren` verifies that iterating over an empty list returns `false`.
2014-02-15 02:24:06 +01:00
RETURN_NUM(0);
}
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
if (!validateInt(vm, args, 1, "Iterator")) return PRIM_ERROR;
// Stop if we're out of bounds.
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
double index = AS_NUM(args[1]);
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
if (index < 0 || index >= list->elements.count - 1) RETURN_FALSE;
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
// Otherwise, move to the next index.
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
RETURN_NUM(index + 1);
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_iteratorValue)
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
{
ObjList* list = AS_LIST(args[0]);
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
uint32_t index = validateIndex(vm, args, list->elements.count, 1, "Iterator");
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
if (index == UINT32_MAX) return PRIM_ERROR;
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
RETURN_VAL(list->elements.data[index]);
feat: implement for-in loop syntax with iterate/iteratorValue protocol and break support Add `for (variable in sequence)` syntax to the Wren language, introducing the `in` keyword token and compiler support for iterating over sequences using `iterate` and `iteratorValue` methods. Includes new benchmark files for Lua, Python, Ruby, and Wren, plus test cases covering single-expression bodies, block bodies, closures over loop variables, and break statements. Also fixes a missing POP() in CLOSE_UPVALUE and moves the while test file to a subdirectory.
2013-12-25 06:04:11 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_removeAt)
feat: implement list_removeAt primitive with capacity shrink and test suite Add DEF_PRIMITIVE(list_removeAt) to src/primitives.c that removes an element at a given index from an ObjList, shifts remaining elements up, shrinks capacity when excess is detected via LIST_GROW_FACTOR, and returns the removed Value. Register the primitive as "removeAt " on vm->listClass. Create test/list/remove_at.wren covering removal at positive indices 0,1,2, negative indices -1,-2,-3, out-of-bounds cases returning null, and verification that the removed value is returned.
2013-11-27 19:20:32 +01:00
{
ObjList* list = AS_LIST(args[0]);
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
uint32_t index = validateIndex(vm, args, list->elements.count, 1, "Index");
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
if (index == UINT32_MAX) return PRIM_ERROR;
feat: implement list_removeAt primitive with capacity shrink and test suite Add DEF_PRIMITIVE(list_removeAt) to src/primitives.c that removes an element at a given index from an ObjList, shifts remaining elements up, shrinks capacity when excess is detected via LIST_GROW_FACTOR, and returns the removed Value. Register the primitive as "removeAt " on vm->listClass. Create test/list/remove_at.wren covering removal at positive indices 0,1,2, negative indices -1,-2,-3, out-of-bounds cases returning null, and verification that the removed value is returned.
2013-11-27 19:20:32 +01:00
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
RETURN_VAL(wrenListRemoveAt(vm, list, index));
feat: implement list_removeAt primitive with capacity shrink and test suite Add DEF_PRIMITIVE(list_removeAt) to src/primitives.c that removes an element at a given index from an ObjList, shifts remaining elements up, shrinks capacity when excess is detected via LIST_GROW_FACTOR, and returns the removed Value. Register the primitive as "removeAt " on vm->listClass. Create test/list/remove_at.wren covering removal at positive indices 0,1,2, negative indices -1,-2,-3, out-of-bounds cases returning null, and verification that the removed value is returned.
2013-11-27 19:20:32 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_subscript)
feat: add list clear and insert primitives with capacity growth and index validation Extract inline list growth logic into `ensureListCapacity` helper and add `validateIndex` function supporting negative indices. Implement `list_clear` primitive that resets count to zero without freeing memory, and `list_insert` primitive that shifts elements right and inserts at validated position. Add comprehensive test suites for both operations covering empty lists, normal/negative indices, and return values.
2013-11-27 08:11:11 +01:00
{
ObjList* list = AS_LIST(args[0]);
feat: implement subscript operator for lists with negative index and bounds checking Add list_subscript primitive that supports integer indexing with negative indices counting from the end, returns null for out-of-bounds access, non-integer indices, and non-numeric argument types. Register the `[ ]` operator on the List class in loadCore and include comprehensive test coverage in test/list_subscript.wren.
2013-11-25 04:08:46 +01:00
feat: allow Range objects as list subscript operator arguments Extend the list subscript operator to accept Range arguments in addition to plain numbers. When a Range is provided, the operator returns a new list containing the elements within that range, supporting inclusive (..) and exclusive (...) bounds, negative indices that count from the end, and automatic reversal for backwards ranges. Added validation functions for integer values and range bounds, with dedicated error messages for non-integer range endpoints and out-of-bounds conditions. Updated the test suite with comprehensive range subscript tests and removed the old test that only checked for non-numeric subscripts.
2014-01-30 18:12:44 +01:00
if (IS_NUM(args[1]))
{
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
uint32_t index = validateIndex(vm, args, list->elements.count, 1,
"Subscript");
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
if (index == UINT32_MAX) return PRIM_ERROR;
feat: allow Range objects as list subscript operator arguments Extend the list subscript operator to accept Range arguments in addition to plain numbers. When a Range is provided, the operator returns a new list containing the elements within that range, supporting inclusive (..) and exclusive (...) bounds, negative indices that count from the end, and automatic reversal for backwards ranges. Added validation functions for integer values and range bounds, with dedicated error messages for non-integer range endpoints and out-of-bounds conditions. Updated the test suite with comprehensive range subscript tests and removed the old test that only checked for non-numeric subscripts.
2014-01-30 18:12:44 +01:00
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
RETURN_VAL(list->elements.data[index]);
feat: allow Range objects as list subscript operator arguments Extend the list subscript operator to accept Range arguments in addition to plain numbers. When a Range is provided, the operator returns a new list containing the elements within that range, supporting inclusive (..) and exclusive (...) bounds, negative indices that count from the end, and automatic reversal for backwards ranges. Added validation functions for integer values and range bounds, with dedicated error messages for non-integer range endpoints and out-of-bounds conditions. Updated the test suite with comprehensive range subscript tests and removed the old test that only checked for non-numeric subscripts.
2014-01-30 18:12:44 +01:00
}
if (!IS_RANGE(args[1]))
{
RETURN_ERROR("Subscript must be a number or a range.");
}
refactor: replace CalculatedRange struct with output parameters in calculateRange The CalculatedRange struct is removed from the header and calculateRange now returns the start index directly while using pointer parameters for length and step, simplifying the API and reducing struct overhead.
2015-01-21 00:33:21 +01:00
int step;
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
uint32_t count = list->elements.count;
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
uint32_t start = calculateRange(vm, args, AS_RANGE(args[1]), &count, &step);
if (start == UINT32_MAX) return PRIM_ERROR;
feat: allow Range objects as list subscript operator arguments Extend the list subscript operator to accept Range arguments in addition to plain numbers. When a Range is provided, the operator returns a new list containing the elements within that range, supporting inclusive (..) and exclusive (...) bounds, negative indices that count from the end, and automatic reversal for backwards ranges. Added validation functions for integer values and range bounds, with dedicated error messages for non-integer range endpoints and out-of-bounds conditions. Updated the test suite with comprehensive range subscript tests and removed the old test that only checked for non-numeric subscripts.
2014-01-30 18:12:44 +01:00
refactor: replace CalculatedRange struct with output parameters in calculateRange The CalculatedRange struct is removed from the header and calculateRange now returns the start index directly while using pointer parameters for length and step, simplifying the API and reducing struct overhead.
2015-01-21 00:33:21 +01:00
ObjList* result = wrenNewList(vm, count);
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
for (uint32_t i = 0; i < count; i++)
feat: allow Range objects as list subscript operator arguments Extend the list subscript operator to accept Range arguments in addition to plain numbers. When a Range is provided, the operator returns a new list containing the elements within that range, supporting inclusive (..) and exclusive (...) bounds, negative indices that count from the end, and automatic reversal for backwards ranges. Added validation functions for integer values and range bounds, with dedicated error messages for non-integer range endpoints and out-of-bounds conditions. Updated the test suite with comprehensive range subscript tests and removed the old test that only checked for non-numeric subscripts.
2014-01-30 18:12:44 +01:00
{
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
result->elements.data[i] = list->elements.data[start + (i * step)];
feat: allow Range objects as list subscript operator arguments Extend the list subscript operator to accept Range arguments in addition to plain numbers. When a Range is provided, the operator returns a new list containing the elements within that range, supporting inclusive (..) and exclusive (...) bounds, negative indices that count from the end, and automatic reversal for backwards ranges. Added validation functions for integer values and range bounds, with dedicated error messages for non-integer range endpoints and out-of-bounds conditions. Updated the test suite with comprehensive range subscript tests and removed the old test that only checked for non-numeric subscripts.
2014-01-30 18:12:44 +01:00
}
RETURN_OBJ(result);
feat: implement subscript operator for lists with negative index and bounds checking Add list_subscript primitive that supports integer indexing with negative indices counting from the end, returns null for out-of-bounds access, non-integer indices, and non-numeric argument types. Register the `[ ]` operator on the List class in loadCore and include comprehensive test coverage in test/list_subscript.wren.
2013-11-25 04:08:46 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(list_subscriptSetter)
feat: add list subscript setter and refactor parameter validation Implement list subscript setter (`[ ]=`) native method in wren_core.c, enabling assignment to list elements via bracket syntax. Extract duplicate parameter count validation logic into a shared `validateNumParameters` function in wren_compiler.c, replacing inline checks in both `parameterList` and `methodCall`. Add comprehensive test suite covering basic assignment, return value semantics, negative indices, and error cases for out-of-range and excessive arguments.
2013-12-21 18:37:59 +01:00
{
ObjList* list = AS_LIST(args[0]);
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
uint32_t index = validateIndex(vm, args, list->elements.count, 1,
"Subscript");
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
if (index == UINT32_MAX) return PRIM_ERROR;
feat: add list subscript setter and refactor parameter validation Implement list subscript setter (`[ ]=`) native method in wren_core.c, enabling assignment to list elements via bracket syntax. Extract duplicate parameter count validation logic into a shared `validateNumParameters` function in wren_compiler.c, replacing inline checks in both `parameterList` and `methodCall`. Add comprehensive test suite covering basic assignment, return value semantics, negative indices, and error cases for out-of-range and excessive arguments.
2013-12-21 18:37:59 +01:00
refactor: replace ObjList manual array management with ValueBuffer in Compiler and ObjList Replace the hand-rolled capacity/count/elements fields in ObjList with a ValueBuffer struct, and update Compiler to use a ValueBuffer for its constant pool instead of an ObjList. This eliminates the separate ensureListCapacity and wrenListAdd functions, centralizing buffer growth logic in wrenValueBufferWrite. Adjust all list primitives (add, clear, count, iterate, iteratorValue) and the GC marking path to operate on the embedded ValueBuffer. Add wrenMarkBuffer helper for marking buffer contents during sweep.
2015-03-22 20:22:47 +01:00
list->elements.data[index] = args[2];
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
RETURN_VAL(args[2]);
feat: add list subscript setter and refactor parameter validation Implement list subscript setter (`[ ]=`) native method in wren_core.c, enabling assignment to list elements via bracket syntax. Extract duplicate parameter count validation logic into a shared `validateNumParameters` function in wren_compiler.c, replacing inline checks in both `parameterList` and `methodCall`. Add comprehensive test suite covering basic assignment, return value semantics, negative indices, and error cases for out-of-range and excessive arguments.
2013-12-21 18:37:59 +01:00
}
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
DEF_PRIMITIVE(map_new)
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
{
RETURN_OBJ(wrenNewMap(vm));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_subscript)
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
{
feat: add containsKey method to Map and validate key types in subscript operations Implement `containsKey()` native method on Map that returns a boolean indicating whether the given key exists in the map. Add `validateKey()` helper to reject non-value-type keys (objects, lists, fibers, etc.) with a clear runtime error. Refactor `wrenMapGet()` signature to return success/failure via bool and output the value through an out-parameter, enabling both `containsKey()` and the existing subscript operator to share the same key validation and lookup logic. Update `map_subscript` to return `null` instead of crashing when a key is not found. Add test cases for `containsKey` success/failure, and runtime error tests for invalid key types in subscript getter, setter, and containsKey.
2015-01-25 21:39:19 +01:00
if (!validateKey(vm, args, 1)) return PRIM_ERROR;
feat: add remove() method to Map class with native implementation and tests
2015-01-26 02:42:36 +01:00
ObjMap* map = AS_MAP(args[0]);
refactor: replace wrenMapFind with wrenMapGet returning Value instead of index Refactor the internal Map API to replace the low-level `wrenMapFind` function (which returned a raw entry index or UINT32_MAX) with a higher-level `wrenMapGet` that directly returns the stored Value or UNDEFINED_VAL. This change simplifies all call sites by eliminating manual index-based entry lookups and direct access to the internal `entries` array. The old `wrenMapFind` is made static and renamed to `findEntry`, returning a pointer to the MapEntry struct instead of an index, which is used internally by `wrenMapGet` and `wrenMapRemoveKey`. Additionally, fix a bug in `loadModule` where a new module was always created before checking if the module already existed; now the early return for already-loaded modules correctly skips module creation and variable copying.
2015-03-07 21:41:18 +01:00
Value value = wrenMapGet(map, args[1]);
if (IS_UNDEFINED(value)) RETURN_NULL;
feat: add containsKey method to Map and validate key types in subscript operations Implement `containsKey()` native method on Map that returns a boolean indicating whether the given key exists in the map. Add `validateKey()` helper to reject non-value-type keys (objects, lists, fibers, etc.) with a clear runtime error. Refactor `wrenMapGet()` signature to return success/failure via bool and output the value through an out-parameter, enabling both `containsKey()` and the existing subscript operator to share the same key validation and lookup logic. Update `map_subscript` to return `null` instead of crashing when a key is not found. Add test cases for `containsKey` success/failure, and runtime error tests for invalid key types in subscript getter, setter, and containsKey.
2015-01-25 21:39:19 +01:00
refactor: replace wrenMapFind with wrenMapGet returning Value instead of index Refactor the internal Map API to replace the low-level `wrenMapFind` function (which returned a raw entry index or UINT32_MAX) with a higher-level `wrenMapGet` that directly returns the stored Value or UNDEFINED_VAL. This change simplifies all call sites by eliminating manual index-based entry lookups and direct access to the internal `entries` array. The old `wrenMapFind` is made static and renamed to `findEntry`, returning a pointer to the MapEntry struct instead of an index, which is used internally by `wrenMapGet` and `wrenMapRemoveKey`. Additionally, fix a bug in `loadModule` where a new module was always created before checking if the module already existed; now the early return for already-loaded modules correctly skips module creation and variable copying.
2015-03-07 21:41:18 +01:00
RETURN_VAL(value);
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_subscriptSetter)
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
{
feat: add containsKey method to Map and validate key types in subscript operations Implement `containsKey()` native method on Map that returns a boolean indicating whether the given key exists in the map. Add `validateKey()` helper to reject non-value-type keys (objects, lists, fibers, etc.) with a clear runtime error. Refactor `wrenMapGet()` signature to return success/failure via bool and output the value through an out-parameter, enabling both `containsKey()` and the existing subscript operator to share the same key validation and lookup logic. Update `map_subscript` to return `null` instead of crashing when a key is not found. Add test cases for `containsKey` success/failure, and runtime error tests for invalid key types in subscript getter, setter, and containsKey.
2015-01-25 21:39:19 +01:00
if (!validateKey(vm, args, 1)) return PRIM_ERROR;
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
wrenMapSet(vm, AS_MAP(args[0]), args[1], args[2]);
RETURN_VAL(args[2]);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_clear)
feat: implement map clear method to remove all entries Add DEF_NATIVE(map_clear) that frees the underlying entries array and resets capacity and count to zero, returning null. Register the "clear" method on the Map class in wrenInitializeCore and include a test verifying the map is emptied and the return value is null.
2015-01-25 17:39:44 +01:00
{
feat: add remove() method to Map class with native implementation and tests
2015-01-26 02:42:36 +01:00
wrenMapClear(vm, AS_MAP(args[0]));
feat: implement map clear method to remove all entries Add DEF_NATIVE(map_clear) that frees the underlying entries array and resets capacity and count to zero, returning null. Register the "clear" method on the Map class in wrenInitializeCore and include a test verifying the map is emptied and the return value is null.
2015-01-25 17:39:44 +01:00
RETURN_NULL;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_containsKey)
feat: add containsKey method to Map and validate key types in subscript operations Implement `containsKey()` native method on Map that returns a boolean indicating whether the given key exists in the map. Add `validateKey()` helper to reject non-value-type keys (objects, lists, fibers, etc.) with a clear runtime error. Refactor `wrenMapGet()` signature to return success/failure via bool and output the value through an out-parameter, enabling both `containsKey()` and the existing subscript operator to share the same key validation and lookup logic. Update `map_subscript` to return `null` instead of crashing when a key is not found. Add test cases for `containsKey` success/failure, and runtime error tests for invalid key types in subscript getter, setter, and containsKey.
2015-01-25 21:39:19 +01:00
{
if (!validateKey(vm, args, 1)) return PRIM_ERROR;
refactor: replace wrenMapFind with wrenMapGet returning Value instead of index Refactor the internal Map API to replace the low-level `wrenMapFind` function (which returned a raw entry index or UINT32_MAX) with a higher-level `wrenMapGet` that directly returns the stored Value or UNDEFINED_VAL. This change simplifies all call sites by eliminating manual index-based entry lookups and direct access to the internal `entries` array. The old `wrenMapFind` is made static and renamed to `findEntry`, returning a pointer to the MapEntry struct instead of an index, which is used internally by `wrenMapGet` and `wrenMapRemoveKey`. Additionally, fix a bug in `loadModule` where a new module was always created before checking if the module already existed; now the early return for already-loaded modules correctly skips module creation and variable copying.
2015-03-07 21:41:18 +01:00
RETURN_BOOL(!IS_UNDEFINED(wrenMapGet(AS_MAP(args[0]), args[1])));
feat: add containsKey method to Map and validate key types in subscript operations Implement `containsKey()` native method on Map that returns a boolean indicating whether the given key exists in the map. Add `validateKey()` helper to reject non-value-type keys (objects, lists, fibers, etc.) with a clear runtime error. Refactor `wrenMapGet()` signature to return success/failure via bool and output the value through an out-parameter, enabling both `containsKey()` and the existing subscript operator to share the same key validation and lookup logic. Update `map_subscript` to return `null` instead of crashing when a key is not found. Add test cases for `containsKey` success/failure, and runtime error tests for invalid key types in subscript getter, setter, and containsKey.
2015-01-25 21:39:19 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_count)
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
{
RETURN_NUM(AS_MAP(args[0])->count);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_iterate)
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
{
ObjMap* map = AS_MAP(args[0]);
if (map->count == 0) RETURN_FALSE;
fix: convert signed integer types to unsigned in core and value modules to eliminate -Wsign-compare warnings - Change `int` to `uint32_t` for iterator indices in `map_iterate` and `string_iterate` to match capacity/length types - Update `String.length` field type from `int` to `uint32_t` in `wren_utils.h` - Modify `wrenStringCodePointAt` parameter type from `int` to `uint32_t` and remove redundant negative index assertion - Convert loop variable in `markMap` from `int` to `uint32_t` to match `map->capacity` type - Add `-Wsign-compare`, `-Wtype-limits`, and `-Wuninitialized` compiler flags to catch future mismatches
2015-02-25 06:56:33 +01:00
// If we're starting the iteration, start at the first used entry.
uint32_t index = 0;
// Otherwise, start one past the last entry we stopped at.
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
if (!IS_NULL(args[1]))
{
if (!validateInt(vm, args, 1, "Iterator")) return PRIM_ERROR;
fix: convert signed integer types to unsigned in core and value modules to eliminate -Wsign-compare warnings - Change `int` to `uint32_t` for iterator indices in `map_iterate` and `string_iterate` to match capacity/length types - Update `String.length` field type from `int` to `uint32_t` in `wren_utils.h` - Modify `wrenStringCodePointAt` parameter type from `int` to `uint32_t` and remove redundant negative index assertion - Convert loop variable in `markMap` from `int` to `uint32_t` to match `map->capacity` type - Add `-Wsign-compare`, `-Wtype-limits`, and `-Wuninitialized` compiler flags to catch future mismatches
2015-02-25 06:56:33 +01:00
if (AS_NUM(args[1]) < 0) RETURN_FALSE;
index = (uint32_t)AS_NUM(args[1]);
if (index >= map->capacity) RETURN_FALSE;
// Advance the iterator.
index++;
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
}
fix: convert signed integer types to unsigned in core and value modules to eliminate -Wsign-compare warnings - Change `int` to `uint32_t` for iterator indices in `map_iterate` and `string_iterate` to match capacity/length types - Update `String.length` field type from `int` to `uint32_t` in `wren_utils.h` - Modify `wrenStringCodePointAt` parameter type from `int` to `uint32_t` and remove redundant negative index assertion - Convert loop variable in `markMap` from `int` to `uint32_t` to match `map->capacity` type - Add `-Wsign-compare`, `-Wtype-limits`, and `-Wuninitialized` compiler flags to catch future mismatches
2015-02-25 06:56:33 +01:00
// Find a used entry, if any.
for (; index < map->capacity; index++)
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
{
if (!IS_UNDEFINED(map->entries[index].key)) RETURN_NUM(index);
}
// If we get here, walked all of the entries.
RETURN_FALSE;
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_remove)
feat: add remove() method to Map class with native implementation and tests
2015-01-26 02:42:36 +01:00
{
if (!validateKey(vm, args, 1)) return PRIM_ERROR;
feat: add == and != operators to Range class with equality tests Implement equality comparison for Range objects by defining `range_eqeq` and `range_bangeq` native methods that delegate to `wrenValuesEqual`. Register both operators on the Range class in `wrenInitializeCore` and add a comprehensive test suite in `test/range/equality.wren` covering inclusive/exclusive ranges and cross-type inequality checks.
2015-01-26 04:50:54 +01:00
feat: add remove() method to Map class with native implementation and tests
2015-01-26 02:42:36 +01:00
RETURN_VAL(wrenMapRemoveKey(vm, AS_MAP(args[0]), args[1]));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_keyIteratorValue)
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
{
ObjMap* map = AS_MAP(args[0]);
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
uint32_t index = validateIndex(vm, args, map->capacity, 1, "Iterator");
if (index == UINT32_MAX) return PRIM_ERROR;
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
MapEntry* entry = &map->entries[index];
if (IS_UNDEFINED(entry->key))
{
RETURN_ERROR("Invalid map iterator value.");
}
RETURN_VAL(entry->key);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(map_valueIteratorValue)
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
{
ObjMap* map = AS_MAP(args[0]);
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
uint32_t index = validateIndex(vm, args, map->capacity, 1, "Iterator");
if (index == UINT32_MAX) return PRIM_ERROR;
feat: implement Map.keys, Map.values iterators and proper toString with key-value formatting Add MapKeySequence and MapValueSequence classes in core.wren to expose iterable key and value views on Map instances. Implement native iterate_, keyIteratorValue_, and valueIteratorValue_ primitives in wren_core.c to support these sequences. Replace the stub Map.toString with a full implementation that iterates keys and formats each entry as "key: value", handling empty maps and nested maps correctly. Include comprehensive test suites for key iteration, value iteration, iterator type validation, and toString output across multiple orderings.
2015-01-25 19:27:38 +01:00
MapEntry* entry = &map->entries[index];
if (IS_UNDEFINED(entry->key))
{
RETURN_ERROR("Invalid map iterator value.");
}
RETURN_VAL(entry->value);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(null_not)
feat: implement `!` operator for all core types with proper truthiness semantics Add native `!` methods to Null, Object, Num, String, and List classes so that `!` works reliably on any value. Null returns `true`, all other types return `false` since they are considered truthy. Update documentation to describe the operator as returning the logical complement and add comprehensive tests for each type. Also fix the `all` method test to use a truthy string instead of expecting a runtime error.
2015-01-16 06:50:01 +01:00
{
RETURN_VAL(TRUE_VAL);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(null_toString)
fix: remove stack pop for loop body in LOOP opcode since bodies are now statements
2013-12-08 03:47:40 +01:00
{
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
RETURN_VAL(CONST_STRING(vm, "null"));
fix: remove stack pop for loop body in LOOP opcode since bodies are now statements
2013-12-08 03:47:40 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(num_fromString)
feat: add Num.fromString static method to parse decimal string literals Implements a new `fromString` static method on the `Num` class that attempts to parse a string as a decimal number literal using `strtod`. Returns the parsed `Num` value on success, or `null` if the string does not represent a valid number. Includes runtime validation that the argument is a string, and adds test coverage for positive, negative, zero, and decimal inputs as well as non-numeric strings.
2015-02-23 05:06:17 +01:00
{
if (!validateString(vm, args, 1, "Argument")) return PRIM_ERROR;
fix: reject trailing non-number characters in Num.fromString parsing Previously, `Num.fromString` accepted strings like `"1.2prefix"` and returned the leading numeric portion (`1.2`). This change makes parsing stricter by requiring that the entire string be consumed after `strtod`, skipping only trailing whitespace. If any non-whitespace characters remain after the number, the function now returns `null` instead of a partial result. The fix also adds an explicit empty-string check and updates the test suite to reflect the new behavior, replacing the old `"1.2prefix"` success test with a `"1.2suffix"` null-return test.
2015-02-25 16:07:54 +01:00
ObjString* string = AS_STRING(args[1]);
// Corner case: Can't parse an empty string.
if (string->length == 0) RETURN_NULL;
feat: add Num.fromString static method to parse decimal string literals Implements a new `fromString` static method on the `Num` class that attempts to parse a string as a decimal number literal using `strtod`. Returns the parsed `Num` value on success, or `null` if the string does not represent a valid number. Includes runtime validation that the argument is a string, and adds test coverage for positive, negative, zero, and decimal inputs as well as non-numeric strings.
2015-02-23 05:06:17 +01:00
feat: add ERANGE error handling for oversized number literals in lexer and Num.fromString Replace TODO stubs with actual errno checks in readHexNumber, readNumber, and num_fromString to emit a "Number literal is too large." error when strtol/strtod overflow. Add three test files (literal_too_large.wren, hex_too_large.wren, from_string_too_large.wren) verifying compile-time and runtime error behavior for out-of-range numeric inputs.
2015-03-03 09:06:34 +01:00
errno = 0;
feat: add Num.fromString static method to parse decimal string literals Implements a new `fromString` static method on the `Num` class that attempts to parse a string as a decimal number literal using `strtod`. Returns the parsed `Num` value on success, or `null` if the string does not represent a valid number. Includes runtime validation that the argument is a string, and adds test coverage for positive, negative, zero, and decimal inputs as well as non-numeric strings.
2015-02-23 05:06:17 +01:00
char* end;
fix: reject trailing non-number characters in Num.fromString parsing Previously, `Num.fromString` accepted strings like `"1.2prefix"` and returned the leading numeric portion (`1.2`). This change makes parsing stricter by requiring that the entire string be consumed after `strtod`, skipping only trailing whitespace. If any non-whitespace characters remain after the number, the function now returns `null` instead of a partial result. The fix also adds an explicit empty-string check and updates the test suite to reflect the new behavior, replacing the old `"1.2prefix"` success test with a `"1.2suffix"` null-return test.
2015-02-25 16:07:54 +01:00
double number = strtod(string->value, &end);
// Skip past any trailing whitespace.
fix: remove extraneous space inside isspace cast in num_fromString
2015-04-01 15:43:44 +02:00
while (*end != '\0' && isspace((unsigned char)*end)) end++;
feat: add Num.fromString static method to parse decimal string literals Implements a new `fromString` static method on the `Num` class that attempts to parse a string as a decimal number literal using `strtod`. Returns the parsed `Num` value on success, or `null` if the string does not represent a valid number. Includes runtime validation that the argument is a string, and adds test coverage for positive, negative, zero, and decimal inputs as well as non-numeric strings.
2015-02-23 05:06:17 +01:00
feat: add ERANGE error handling for oversized number literals in lexer and Num.fromString Replace TODO stubs with actual errno checks in readHexNumber, readNumber, and num_fromString to emit a "Number literal is too large." error when strtol/strtod overflow. Add three test files (literal_too_large.wren, hex_too_large.wren, from_string_too_large.wren) verifying compile-time and runtime error behavior for out-of-range numeric inputs.
2015-03-03 09:06:34 +01:00
if (errno == ERANGE)
{
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
args[0] = CONST_STRING(vm, "Number literal is too large.");
feat: add ERANGE error handling for oversized number literals in lexer and Num.fromString Replace TODO stubs with actual errno checks in readHexNumber, readNumber, and num_fromString to emit a "Number literal is too large." error when strtol/strtod overflow. Add three test files (literal_too_large.wren, hex_too_large.wren, from_string_too_large.wren) verifying compile-time and runtime error behavior for out-of-range numeric inputs.
2015-03-03 09:06:34 +01:00
return PRIM_ERROR;
}
fix: reject trailing non-number characters in Num.fromString parsing Previously, `Num.fromString` accepted strings like `"1.2prefix"` and returned the leading numeric portion (`1.2`). This change makes parsing stricter by requiring that the entire string be consumed after `strtod`, skipping only trailing whitespace. If any non-whitespace characters remain after the number, the function now returns `null` instead of a partial result. The fix also adds an explicit empty-string check and updates the test suite to reflect the new behavior, replacing the old `"1.2prefix"` success test with a `"1.2suffix"` null-return test.
2015-02-25 16:07:54 +01:00
// We must have consumed the entire string. Otherwise, it contains non-number
// characters and we can't parse it.
if (end < string->value + string->length) RETURN_NULL;
feat: add Num.fromString static method to parse decimal string literals Implements a new `fromString` static method on the `Num` class that attempts to parse a string as a decimal number literal using `strtod`. Returns the parsed `Num` value on success, or `null` if the string does not represent a valid number. Includes runtime validation that the argument is a string, and adds test coverage for positive, negative, zero, and decimal inputs as well as non-numeric strings.
2015-02-23 05:06:17 +01:00
RETURN_NUM(number);
}
feat: add Num.pi constant and trigonometric function tests for acos, asin, atan, cos, sin, tan
2015-03-19 21:12:50 +01:00
DEF_PRIMITIVE(num_pi)
{
RETURN_NUM(3.14159265358979323846);
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
// Defines a primitive on Num that calls infix [op] and returns [type].
#define DEF_NUM_INFIX(name, op, type) \
DEF_PRIMITIVE(num_##name) \
{ \
if (!validateNum(vm, args, 1, "Right operand")) return PRIM_ERROR; \
RETURN_##type(AS_NUM(args[0]) op AS_NUM(args[1])); \
}
feat: implement infix arithmetic operators for numbers and string concatenation Add parser support for +, -, *, / operators with correct precedence (term/factor) and emit method calls. Implement primitive methods for num_plus, num_minus, num_multiply, num_divide, and string_plus. Update VM to pass VM pointer to primitives and add unsupported value for type errors. Include test files for each operator.
2013-10-31 15:04:44 +01:00
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_NUM_INFIX(minus, -, NUM)
DEF_NUM_INFIX(plus, +, NUM)
DEF_NUM_INFIX(multiply, *, NUM)
DEF_NUM_INFIX(divide, /, NUM)
DEF_NUM_INFIX(lt, <, BOOL)
DEF_NUM_INFIX(gt, >, BOOL)
DEF_NUM_INFIX(lte, <=, BOOL)
DEF_NUM_INFIX(gte, >=, BOOL)
// Defines a primitive on Num that call infix bitwise [op].
#define DEF_NUM_BITWISE(name, op) \
DEF_PRIMITIVE(num_bitwise##name) \
{ \
if (!validateNum(vm, args, 1, "Right operand")) return PRIM_ERROR; \
uint32_t left = (uint32_t)AS_NUM(args[0]); \
uint32_t right = (uint32_t)AS_NUM(args[1]); \
RETURN_NUM(left op right); \
}
feat: implement infix arithmetic operators for numbers and string concatenation Add parser support for +, -, *, / operators with correct precedence (term/factor) and emit method calls. Implement primitive methods for num_plus, num_minus, num_multiply, num_divide, and string_plus. Update VM to pass VM pointer to primitives and add unsupported value for type errors. Include test files for each operator.
2013-10-31 15:04:44 +01:00
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_NUM_BITWISE(And, &)
DEF_NUM_BITWISE(Or, |)
DEF_NUM_BITWISE(Xor, ^)
DEF_NUM_BITWISE(LeftShift, <<)
DEF_NUM_BITWISE(RightShift, >>)
feat: implement infix arithmetic operators for numbers and string concatenation Add parser support for +, -, *, / operators with correct precedence (term/factor) and emit method calls. Implement primitive methods for num_plus, num_minus, num_multiply, num_divide, and string_plus. Update VM to pass VM pointer to primitives and add unsupported value for type errors. Include test files for each operator.
2013-10-31 15:04:44 +01:00
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
// Defines a primitive method on Num that returns the result of [fn].
#define DEF_NUM_FN(name, fn) \
DEF_PRIMITIVE(num_##name) \
{ \
RETURN_NUM(fn(AS_NUM(args[0]))); \
}
DEF_NUM_FN(abs, fabs)
DEF_NUM_FN(acos, acos)
DEF_NUM_FN(asin, asin)
DEF_NUM_FN(atan, atan)
DEF_NUM_FN(ceil, ceil)
DEF_NUM_FN(cos, cos)
DEF_NUM_FN(floor, floor)
DEF_NUM_FN(negate, -)
DEF_NUM_FN(sin, sin)
DEF_NUM_FN(sqrt, sqrt)
DEF_NUM_FN(tan, tan)
feat: implement infix arithmetic operators for numbers and string concatenation Add parser support for +, -, *, / operators with correct precedence (term/factor) and emit method calls. Implement primitive methods for num_plus, num_minus, num_multiply, num_divide, and string_plus. Update VM to pass VM pointer to primitives and add unsupported value for type errors. Include test files for each operator.
2013-10-31 15:04:44 +01:00
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(num_mod)
feat: implement modulo operator for numbers with fmod and add test suite Add num_mod primitive using fmod from math.h to support the % operator on number types. Register the new primitive in the numClass method table. Include a comprehensive test file covering positive, negative, and left-associative modulo cases, plus a divide-by-zero TODO comment in the existing division test.
2013-11-10 06:01:18 +01:00
{
feat: add validateNum/validateInt helpers and runtime type checks for list methods Replace the old validateIndex function with validateNum and validateInt helpers that produce descriptive runtime error messages. Add new test files covering invalid index types, out-of-bounds indices, and iterator validation for list insert, iterate, and iteratorValue methods. Rename existing number operator error tests to use consistent "must be a number" phrasing.
2014-01-02 16:32:00 +01:00
if (!validateNum(vm, args, 1, "Right operand")) return PRIM_ERROR;
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
RETURN_NUM(fmod(AS_NUM(args[0]), AS_NUM(args[1])));
feat: implement modulo operator for numbers with fmod and add test suite Add num_mod primitive using fmod from math.h to support the % operator on number types. Register the new primitive in the numClass method table. Include a comprehensive test file covering positive, negative, and left-associative modulo cases, plus a divide-by-zero TODO comment in the existing division test.
2013-11-10 06:01:18 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(num_eqeq)
feat: add == and != operators for bool, number, and string types with type-checking Implement equality and inequality operators across three primitive types in the compiler and runtime. Add `bool_eqeq`/`bool_bangeq`, `num_eqeq`/`num_bangeq`, and `string_eqeq`/`string_bangeq` primitives that return false/true respectively when comparing against incompatible types. Update the parse rule table with `INFIX_OPERATOR` macros for `TOKEN_EQEQ` and `TOKEN_BANGEQ` at `PREC_COMPARISON` precedence. Include test files `bool_equality.wren`, `number_equality.wren`, and `string_equality.wren` covering cross-type comparisons and edge cases.
2013-11-05 18:57:57 +01:00
{
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
if (!IS_NUM(args[1])) RETURN_FALSE;
RETURN_BOOL(AS_NUM(args[0]) == AS_NUM(args[1]));
feat: add == and != operators for bool, number, and string types with type-checking Implement equality and inequality operators across three primitive types in the compiler and runtime. Add `bool_eqeq`/`bool_bangeq`, `num_eqeq`/`num_bangeq`, and `string_eqeq`/`string_bangeq` primitives that return false/true respectively when comparing against incompatible types. Update the parse rule table with `INFIX_OPERATOR` macros for `TOKEN_EQEQ` and `TOKEN_BANGEQ` at `PREC_COMPARISON` precedence. Include test files `bool_equality.wren`, `number_equality.wren`, and `string_equality.wren` covering cross-type comparisons and edge cases.
2013-11-05 18:57:57 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(num_bangeq)
feat: add == and != operators for bool, number, and string types with type-checking Implement equality and inequality operators across three primitive types in the compiler and runtime. Add `bool_eqeq`/`bool_bangeq`, `num_eqeq`/`num_bangeq`, and `string_eqeq`/`string_bangeq` primitives that return false/true respectively when comparing against incompatible types. Update the parse rule table with `INFIX_OPERATOR` macros for `TOKEN_EQEQ` and `TOKEN_BANGEQ` at `PREC_COMPARISON` precedence. Include test files `bool_equality.wren`, `number_equality.wren`, and `string_equality.wren` covering cross-type comparisons and edge cases.
2013-11-05 18:57:57 +01:00
{
feat: add runtime error support with source paths, line info, and stack traces Introduce primitive error signaling, runtime error handling with callstack printing, and fiber termination on error. Add source file path and method name tracking to functions, along with debug line number information. Update arithmetic operators to error on non-numeric operands and implement proper "method not found" runtime errors. Refactor the test runner to expect runtime errors with exit code 70 (EX_SOFTWARE) and update the C API to accept source paths in wrenInterpret and wrenCompile. Rename WrenNativeMethodFn to WrenForeignMethodFn and adjust related typedefs. Add debug source line arrays to compilers and functions, and replace the old debug dump functions with new print-based variants that display line numbers.
2014-01-01 22:25:24 +01:00
if (!IS_NUM(args[1])) RETURN_TRUE;
RETURN_BOOL(AS_NUM(args[0]) != AS_NUM(args[1]));
feat: add == and != operators for bool, number, and string types with type-checking Implement equality and inequality operators across three primitive types in the compiler and runtime. Add `bool_eqeq`/`bool_bangeq`, `num_eqeq`/`num_bangeq`, and `string_eqeq`/`string_bangeq` primitives that return false/true respectively when comparing against incompatible types. Update the parse rule table with `INFIX_OPERATOR` macros for `TOKEN_EQEQ` and `TOKEN_BANGEQ` at `PREC_COMPARISON` precedence. Include test files `bool_equality.wren`, `number_equality.wren`, and `string_equality.wren` covering cross-type comparisons and edge cases.
2013-11-05 18:57:57 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(num_bitwiseNot)
feat: add bitwise NOT operator (~) with token, parser, and native implementation Add TOKEN_TILDE token type and lexer support for the '~' character in the compiler. Implement the bitwise NOT operation as a native method on the Num class, operating on 32-bit unsigned integers. Include a new OPERATOR macro for prefix/infix operator grammar rules and add comprehensive test cases covering positive, negative, floating-point, and boundary values.
2013-12-05 07:09:31 +01:00
{
// Bitwise operators always work on 32-bit unsigned ints.
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_NUM(~(uint32_t)AS_NUM(args[0]));
feat: add bitwise NOT operator (~) with token, parser, and native implementation Add TOKEN_TILDE token type and lexer support for the '~' character in the compiler. Implement the bitwise NOT operation as a native method on the Num class, operating on 32-bit unsigned integers. Include a new OPERATOR macro for prefix/infix operator grammar rules and add comprehensive test cases covering positive, negative, floating-point, and boundary values.
2013-12-05 07:09:31 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_dotDot)
feat: add bitwise AND and OR operators for numbers with 32-bit unsigned semantics Implement num_bitwiseAnd and num_bitwiseOr native methods that cast operands to uint32_t before applying bitwise operations, matching the existing bitwiseNot pattern. Register both operators on the number class and add test files covering basic cases, max u32 boundary, overflow behavior, and non-numeric operand error handling.
2014-02-24 16:27:43 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
if (!validateNum(vm, args, 1, "Right hand side of range")) return PRIM_ERROR;
feat: add bitwise AND and OR operators for numbers with 32-bit unsigned semantics Implement num_bitwiseAnd and num_bitwiseOr native methods that cast operands to uint32_t before applying bitwise operations, matching the existing bitwiseNot pattern. Register both operators on the number class and add test files covering basic cases, max u32 boundary, overflow behavior, and non-numeric operand error handling.
2014-02-24 16:27:43 +01:00
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
double from = AS_NUM(args[0]);
double to = AS_NUM(args[1]);
RETURN_VAL(wrenNewRange(vm, from, to, true));
feat: add bitwise AND and OR operators for numbers with 32-bit unsigned semantics Implement num_bitwiseAnd and num_bitwiseOr native methods that cast operands to uint32_t before applying bitwise operations, matching the existing bitwiseNot pattern. Register both operators on the number class and add test files covering basic cases, max u32 boundary, overflow behavior, and non-numeric operand error handling.
2014-02-24 16:27:43 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_dotDotDot)
feat: add bitwise AND and OR operators for numbers with 32-bit unsigned semantics Implement num_bitwiseAnd and num_bitwiseOr native methods that cast operands to uint32_t before applying bitwise operations, matching the existing bitwiseNot pattern. Register both operators on the number class and add test files covering basic cases, max u32 boundary, overflow behavior, and non-numeric operand error handling.
2014-02-24 16:27:43 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
if (!validateNum(vm, args, 1, "Right hand side of range")) return PRIM_ERROR;
feat: add bitwise AND and OR operators for numbers with 32-bit unsigned semantics Implement num_bitwiseAnd and num_bitwiseOr native methods that cast operands to uint32_t before applying bitwise operations, matching the existing bitwiseNot pattern. Register both operators on the number class and add test files covering basic cases, max u32 boundary, overflow behavior, and non-numeric operand error handling.
2014-02-24 16:27:43 +01:00
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
double from = AS_NUM(args[0]);
double to = AS_NUM(args[1]);
RETURN_VAL(wrenNewRange(vm, from, to, false));
feat: add bitwise AND and OR operators for numbers with 32-bit unsigned semantics Implement num_bitwiseAnd and num_bitwiseOr native methods that cast operands to uint32_t before applying bitwise operations, matching the existing bitwiseNot pattern. Register both operators on the number class and add test files covering basic cases, max u32 boundary, overflow behavior, and non-numeric operand error handling.
2014-02-24 16:27:43 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_atan2)
feat: add bitwise XOR, left-shift, and right-shift primitives for numbers Implement three new native methods on the Num class: `^` (bitwise XOR), `<<` (left shift), and `>>` (right shift). Each operates on 32-bit unsigned integers, matching the existing bitwise AND/OR convention. The new primitives are registered in `wrenInitializeCore` alongside the existing bitwise operators.
2015-02-16 11:29:14 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_NUM(atan2(AS_NUM(args[0]), AS_NUM(args[1])));
feat: add bitwise XOR, left-shift, and right-shift primitives for numbers Implement three new native methods on the Num class: `^` (bitwise XOR), `<<` (left shift), and `>>` (right shift). Each operates on 32-bit unsigned integers, matching the existing bitwise AND/OR convention. The new primitives are registered in `wrenInitializeCore` alongside the existing bitwise operators.
2015-02-16 11:29:14 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_fraction)
feat: add bitwise XOR, left-shift, and right-shift primitives for numbers Implement three new native methods on the Num class: `^` (bitwise XOR), `<<` (left shift), and `>>` (right shift). Each operates on 32-bit unsigned integers, matching the existing bitwise AND/OR convention. The new primitives are registered in `wrenInitializeCore` alongside the existing bitwise operators.
2015-02-16 11:29:14 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
double dummy;
RETURN_NUM(modf(AS_NUM(args[0]) , &dummy));
feat: add bitwise XOR, left-shift, and right-shift primitives for numbers Implement three new native methods on the Num class: `^` (bitwise XOR), `<<` (left shift), and `>>` (right shift). Each operates on 32-bit unsigned integers, matching the existing bitwise AND/OR convention. The new primitives are registered in `wrenInitializeCore` alongside the existing bitwise operators.
2015-02-16 11:29:14 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_isNan)
feat: add bitwise XOR, left-shift, and right-shift primitives for numbers Implement three new native methods on the Num class: `^` (bitwise XOR), `<<` (left shift), and `>>` (right shift). Each operates on 32-bit unsigned integers, matching the existing bitwise AND/OR convention. The new primitives are registered in `wrenInitializeCore` alongside the existing bitwise operators.
2015-02-16 11:29:14 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_BOOL(isnan(AS_NUM(args[0])));
feat: add bitwise XOR, left-shift, and right-shift primitives for numbers Implement three new native methods on the Num class: `^` (bitwise XOR), `<<` (left shift), and `>>` (right shift). Each operates on 32-bit unsigned integers, matching the existing bitwise AND/OR convention. The new primitives are registered in `wrenInitializeCore` alongside the existing bitwise operators.
2015-02-16 11:29:14 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_sign)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
double value = AS_NUM(args[0]);
if (value > 0)
{
RETURN_NUM(1);
}
else if (value < 0)
{
RETURN_NUM(-1);
}
else
{
RETURN_NUM(0);
}
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
}
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_toString)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_VAL(wrenNumToString(vm, AS_NUM(args[0])));
}
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
DEF_PRIMITIVE(num_truncate)
{
double integer;
modf(AS_NUM(args[0]) , &integer);
RETURN_NUM(integer);
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
}
feat: add Object.same static method for reliable built-in equality Introduce a new static method `Object.same(obj1, obj2)` that exposes the VM's built-in equality semantics (`wrenValuesEqual`) directly, bypassing any user-defined `==` overrides. This required creating a dedicated metaclass for Object (subclass of Class) to host the static method without polluting every class with a `same` method. The implementation wires up a new `Object metaclass` in the core initialization sequence, adjusts the class hierarchy setup order, and adds comprehensive tests covering value types, identity comparison, and verification that `Object.same` ignores custom `==` operators.
2015-05-01 16:55:28 +02:00
DEF_PRIMITIVE(object_same)
{
RETURN_BOOL(wrenValuesEqual(args[1], args[2]));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(object_not)
feat: implement `!` operator for all core types with proper truthiness semantics Add native `!` methods to Null, Object, Num, String, and List classes so that `!` works reliably on any value. Null returns `true`, all other types return `false` since they are considered truthy. Update documentation to describe the operator as returning the logical complement and add comprehensive tests for each type. Also fix the `all` method test to use a truthy string instead of expecting a runtime error.
2015-01-16 06:50:01 +01:00
{
RETURN_VAL(FALSE_VAL);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(object_eqeq)
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
{
refactor: remove redundant string and range equality natives, delegate to wrenValuesEqual
2015-01-26 08:26:59 +01:00
RETURN_BOOL(wrenValuesEqual(args[0], args[1]));
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(object_bangeq)
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
{
refactor: remove redundant string and range equality natives, delegate to wrenValuesEqual
2015-01-26 08:26:59 +01:00
RETURN_BOOL(!wrenValuesEqual(args[0], args[1]));
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
}
refactor: replace dedicated CODE_IS opcode with infix operator method call for "is"
2015-06-19 16:58:07 +02:00
DEF_PRIMITIVE(object_is)
{
if (!IS_CLASS(args[1]))
{
RETURN_ERROR("Right operand must be a class.");
}
ObjClass *classObj = wrenGetClass(vm, args[0]);
ObjClass *baseClassObj = AS_CLASS(args[1]);
// Walk the superclass chain looking for the class.
do
{
if (baseClassObj == classObj) RETURN_BOOL(true);
classObj = classObj->superclass;
}
while (classObj != NULL);
RETURN_BOOL(false);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(object_toString)
feat: make IO.write call toString on argument and add corelib with List.toString
2013-12-22 20:50:00 +01:00
{
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
Obj* obj = AS_OBJ(args[0]);
Value name = OBJ_VAL(obj->classObj->name);
RETURN_VAL(wrenStringFormat(vm, "instance of @", name));
feat: make IO.write call toString on argument and add corelib with List.toString
2013-12-22 20:50:00 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(object_type)
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
{
feat: add class name storage and expose via `name` method on class objects Store the class name string in `ObjClass` during compilation and class creation, and expose it through a new `class_name` native method. Also update `object_toString` to return the class name for class instances and "instance of <name>" for regular instances.
2014-01-29 00:31:11 +01:00
RETURN_OBJ(wrenGetClass(vm, args[0]));
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_from)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_NUM(AS_RANGE(args[0])->from);
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_to)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_NUM(AS_RANGE(args[0])->to);
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_min)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
ObjRange* range = AS_RANGE(args[0]);
RETURN_NUM(fmin(range->from, range->to));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_max)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
ObjRange* range = AS_RANGE(args[0]);
RETURN_NUM(fmax(range->from, range->to));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_isInclusive)
feat: add isInclusive field to ObjRange and implement proper exclusive range iteration Add isInclusive boolean to ObjRange struct to distinguish between inclusive (..) and exclusive (...) ranges. Update wrenNewRange signature to accept isInclusive parameter. Implement correct iteration logic for both ascending and descending ranges, handling empty exclusive ranges and floating-point iteration. Add type validation for range RHS operands. Update min/max/to properties to return raw endpoint values instead of adjusted ones. Add comprehensive test coverage for inclusive/exclusive ranges, negative ranges, empty ranges, floating-point iteration, isInclusive property, toString, and type error cases.
2014-01-20 22:20:22 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_BOOL(AS_RANGE(args[0])->isInclusive);
feat: add isInclusive field to ObjRange and implement proper exclusive range iteration Add isInclusive boolean to ObjRange struct to distinguish between inclusive (..) and exclusive (...) ranges. Update wrenNewRange signature to accept isInclusive parameter. Implement correct iteration logic for both ascending and descending ranges, handling empty exclusive ranges and floating-point iteration. Add type validation for range RHS operands. Update min/max/to properties to return raw endpoint values instead of adjusted ones. Add comprehensive test coverage for inclusive/exclusive ranges, negative ranges, empty ranges, floating-point iteration, isInclusive property, toString, and type error cases.
2014-01-20 22:20:22 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_iterate)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
ObjRange* range = AS_RANGE(args[0]);
feat: add isInclusive field to ObjRange and implement proper exclusive range iteration Add isInclusive boolean to ObjRange struct to distinguish between inclusive (..) and exclusive (...) ranges. Update wrenNewRange signature to accept isInclusive parameter. Implement correct iteration logic for both ascending and descending ranges, handling empty exclusive ranges and floating-point iteration. Add type validation for range RHS operands. Update min/max/to properties to return raw endpoint values instead of adjusted ones. Add comprehensive test coverage for inclusive/exclusive ranges, negative ranges, empty ranges, floating-point iteration, isInclusive property, toString, and type error cases.
2014-01-20 22:20:22 +01:00
// Special case: empty range.
if (range->from == range->to && !range->isInclusive) RETURN_FALSE;
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
// Start the iteration.
if (IS_NULL(args[1])) RETURN_NUM(range->from);
if (!validateNum(vm, args, 1, "Iterator")) return PRIM_ERROR;
double iterator = AS_NUM(args[1]);
feat: add isInclusive field to ObjRange and implement proper exclusive range iteration Add isInclusive boolean to ObjRange struct to distinguish between inclusive (..) and exclusive (...) ranges. Update wrenNewRange signature to accept isInclusive parameter. Implement correct iteration logic for both ascending and descending ranges, handling empty exclusive ranges and floating-point iteration. Add type validation for range RHS operands. Update min/max/to properties to return raw endpoint values instead of adjusted ones. Add comprehensive test coverage for inclusive/exclusive ranges, negative ranges, empty ranges, floating-point iteration, isInclusive property, toString, and type error cases.
2014-01-20 22:20:22 +01:00
// Iterate towards [to] from [from].
if (range->from < range->to)
{
iterator++;
if (iterator > range->to) RETURN_FALSE;
}
else
{
iterator--;
if (iterator < range->to) RETURN_FALSE;
}
if (!range->isInclusive && iterator == range->to) RETURN_FALSE;
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
feat: add isInclusive field to ObjRange and implement proper exclusive range iteration Add isInclusive boolean to ObjRange struct to distinguish between inclusive (..) and exclusive (...) ranges. Update wrenNewRange signature to accept isInclusive parameter. Implement correct iteration logic for both ascending and descending ranges, handling empty exclusive ranges and floating-point iteration. Add type validation for range RHS operands. Update min/max/to properties to return raw endpoint values instead of adjusted ones. Add comprehensive test coverage for inclusive/exclusive ranges, negative ranges, empty ranges, floating-point iteration, isInclusive property, toString, and type error cases.
2014-01-20 22:20:22 +01:00
RETURN_NUM(iterator);
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_iteratorValue)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
// Assume the iterator is a number so that is the value of the range.
RETURN_VAL(args[1]);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(range_toString)
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
{
ObjRange* range = AS_RANGE(args[0]);
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
Value from = wrenNumToString(vm, range->from);
wrenPushRoot(vm, AS_OBJ(from));
Value to = wrenNumToString(vm, range->to);
wrenPushRoot(vm, AS_OBJ(to));
Value result = wrenStringFormat(vm, "@$@", from,
range->isInclusive ? ".." : "...", to);
wrenPopRoot(vm);
wrenPopRoot(vm);
RETURN_VAL(result);
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
}
feat: add String.fromCodePoint static method and refactor UTF-8 encoding into reusable utilities Implement the `String.fromCodePoint(_)` primitive that creates a string from a Unicode code point, with validation for integer range 0–0x10ffff. Extract inline UTF-8 encoding logic from `readUnicodeEscape` in the compiler into new `wrenUtf8NumBytes` and `wrenUtf8Encode` utility functions in `wren_utils`, and add `wrenStringFromCodePoint` helper in `wren_value`. Update documentation for core classes to add "Methods" and "Static Methods" section headers, and include `String.fromCodePoint` docs with example. Add a test file `from_code_point.wren` covering various code points.
2015-03-27 15:43:36 +01:00
DEF_PRIMITIVE(string_fromCodePoint)
{
if (!validateInt(vm, args, 1, "Code point")) return PRIM_ERROR;
int codePoint = (int)AS_NUM(args[1]);
if (codePoint < 0)
{
RETURN_ERROR("Code point cannot be negative.");
}
else if (codePoint > 0x10ffff)
{
RETURN_ERROR("Code point cannot be greater than 0x10ffff.");
}
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
RETURN_VAL(wrenStringFromCodePoint(vm, codePoint));
}
DEF_PRIMITIVE(string_byteAt)
{
ObjString* string = AS_STRING(args[0]);
uint32_t index = validateIndex(vm, args, string->length, 1, "Index");
if (index == UINT32_MAX) return PRIM_ERROR;
RETURN_NUM((uint8_t)string->value[index]);
}
DEF_PRIMITIVE(string_codePointAt)
{
ObjString* string = AS_STRING(args[0]);
uint32_t index = validateIndex(vm, args, string->length, 1, "Index");
if (index == UINT32_MAX) return PRIM_ERROR;
// If we are in the middle of a UTF-8 sequence, indicate that.
const uint8_t* bytes = (uint8_t*)string->value;
if ((bytes[index] & 0xc0) == 0x80) RETURN_NUM(-1);
// Decode the UTF-8 sequence.
RETURN_NUM(wrenUtf8Decode((uint8_t*)string->value + index,
string->length - index));
feat: add String.fromCodePoint static method and refactor UTF-8 encoding into reusable utilities Implement the `String.fromCodePoint(_)` primitive that creates a string from a Unicode code point, with validation for integer range 0–0x10ffff. Extract inline UTF-8 encoding logic from `readUnicodeEscape` in the compiler into new `wrenUtf8NumBytes` and `wrenUtf8Encode` utility functions in `wren_utils`, and add `wrenStringFromCodePoint` helper in `wren_value`. Update documentation for core classes to add "Methods" and "Static Methods" section headers, and include `String.fromCodePoint` docs with example. Add a test file `from_code_point.wren` covering various code points.
2015-03-27 15:43:36 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_contains)
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
{
feat: replace validateIndexOld with validateIndex and add validateString for core methods Remove the deprecated validateIndexOld function and migrate all callers to the new validateIndex that reports runtime errors. Add validateString helper for string argument checking. Introduce comprehensive runtime error tests for list and string subscript operations, removeAt, and contains methods, replacing old silent null returns with proper error halting.
2014-01-03 19:47:26 +01:00
if (!validateString(vm, args, 1, "Argument")) return PRIM_ERROR;
feat: replace strlen calls with stored ObjString length for string operations Refactor string_contains, string_count, string_eqeq, string_bangeq, and string_subscript to use the precomputed ObjString->length field instead of calling strlen() on the C string. This avoids O(n) length calculations on every string comparison and count operation. Also update markString memory accounting to use the stored length plus null terminator instead of recalculating with strlen().
2015-01-07 22:05:33 +01:00
ObjString* string = AS_STRING(args[0]);
ObjString* search = AS_STRING(args[1]);
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
refactor: remove unused WrenVM* parameter from buffer init, string find, and debug print functions Remove the `WrenVM* vm` parameter from `wrenValueBufferInit`, `wrenByteBufferInit`, `wrenIntBufferInit`, `wrenStringBufferInit`, `wrenSymbolTableInit`, `wrenMethodBufferInit`, `wrenStringFind`, and `wrenDebugPrintStackTrace` functions across the compiler, core, debug, utils, value, and VM modules. Update all call sites and macro definitions to match the simplified signatures, eliminating dead parameters that were never used within the function bodies.
2015-03-23 06:17:40 +01:00
RETURN_BOOL(wrenStringFind(string, search) != UINT32_MAX);
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_count)
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
{
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_NUM(AS_STRING(args[0])->length);
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_endsWith)
docs: document String class methods and add startsWith, endsWith, indexOf natives
2015-01-10 23:45:14 +01:00
{
if (!validateString(vm, args, 1, "Argument")) return PRIM_ERROR;
ObjString* string = AS_STRING(args[0]);
ObjString* search = AS_STRING(args[1]);
// Corner case, if the search string is longer than return false right away.
if (search->length > string->length) RETURN_FALSE;
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
RETURN_BOOL(memcmp(string->value + string->length - search->length,
search->value, search->length) == 0);
docs: document String class methods and add startsWith, endsWith, indexOf natives
2015-01-10 23:45:14 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_indexOf)
docs: document String class methods and add startsWith, endsWith, indexOf natives
2015-01-10 23:45:14 +01:00
{
if (!validateString(vm, args, 1, "Argument")) return PRIM_ERROR;
ObjString* string = AS_STRING(args[0]);
ObjString* search = AS_STRING(args[1]);
refactor: remove unused WrenVM* parameter from buffer init, string find, and debug print functions Remove the `WrenVM* vm` parameter from `wrenValueBufferInit`, `wrenByteBufferInit`, `wrenIntBufferInit`, `wrenStringBufferInit`, `wrenSymbolTableInit`, `wrenMethodBufferInit`, `wrenStringFind`, and `wrenDebugPrintStackTrace` functions across the compiler, core, debug, utils, value, and VM modules. Update all call sites and macro definitions to match the simplified signatures, eliminating dead parameters that were never used within the function bodies.
2015-03-23 06:17:40 +01:00
uint32_t index = wrenStringFind(string, search);
refactor: change wrenStringFind to return UINT32_MAX instead of haystack->length for not-found The wrenStringFind function previously returned the haystack length to indicate a missing needle, which was ambiguous when the needle could legitimately appear at the end of the string. This commit changes the sentinel value to UINT32_MAX, updates all callers (string_contains, string_indexOf) to check against the new sentinel, and adds explicit handling for empty needle and empty haystack edge cases. The Boyer-Moore-Horspool implementation is also cleaned up with clearer variable names and comments.
2015-02-05 05:23:50 +01:00
RETURN_NUM(index == UINT32_MAX ? -1 : (int)index);
docs: document String class methods and add startsWith, endsWith, indexOf natives
2015-01-10 23:45:14 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_iterate)
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
{
ObjString* string = AS_STRING(args[0]);
// If we're starting the iteration, return the first index.
if (IS_NULL(args[1]))
{
if (string->length == 0) RETURN_FALSE;
RETURN_NUM(0);
}
if (!validateInt(vm, args, 1, "Iterator")) return PRIM_ERROR;
fix: convert signed integer types to unsigned in core and value modules to eliminate -Wsign-compare warnings - Change `int` to `uint32_t` for iterator indices in `map_iterate` and `string_iterate` to match capacity/length types - Update `String.length` field type from `int` to `uint32_t` in `wren_utils.h` - Modify `wrenStringCodePointAt` parameter type from `int` to `uint32_t` and remove redundant negative index assertion - Convert loop variable in `markMap` from `int` to `uint32_t` to match `map->capacity` type - Add `-Wsign-compare`, `-Wtype-limits`, and `-Wuninitialized` compiler flags to catch future mismatches
2015-02-25 06:56:33 +01:00
if (AS_NUM(args[1]) < 0) RETURN_FALSE;
uint32_t index = (uint32_t)AS_NUM(args[1]);
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
// Advance to the beginning of the next UTF-8 sequence.
do
{
index++;
fix: convert signed integer types to unsigned in core and value modules to eliminate -Wsign-compare warnings - Change `int` to `uint32_t` for iterator indices in `map_iterate` and `string_iterate` to match capacity/length types - Update `String.length` field type from `int` to `uint32_t` in `wren_utils.h` - Modify `wrenStringCodePointAt` parameter type from `int` to `uint32_t` and remove redundant negative index assertion - Convert loop variable in `markMap` from `int` to `uint32_t` to match `map->capacity` type - Add `-Wsign-compare`, `-Wtype-limits`, and `-Wuninitialized` compiler flags to catch future mismatches
2015-02-25 06:56:33 +01:00
if (index >= string->length) RETURN_FALSE;
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
} while ((string->value[index] & 0xc0) == 0x80);
RETURN_NUM(index);
}
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
DEF_PRIMITIVE(string_iterateByte)
{
ObjString* string = AS_STRING(args[0]);
// If we're starting the iteration, return the first index.
if (IS_NULL(args[1]))
{
if (string->length == 0) RETURN_FALSE;
RETURN_NUM(0);
}
if (!validateInt(vm, args, 1, "Iterator")) return PRIM_ERROR;
if (AS_NUM(args[1]) < 0) RETURN_FALSE;
uint32_t index = (uint32_t)AS_NUM(args[1]);
// Advance to the next byte.
index++;
if (index >= string->length) RETURN_FALSE;
RETURN_NUM(index);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_iteratorValue)
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
{
ObjString* string = AS_STRING(args[0]);
refactor: migrate list index and size types from int to uint32_t across core and value layers Convert `validateIndexValue` and `validateIndex` return types to `uint32_t` with `UINT32_MAX` sentinel, update `wrenNewList`, `wrenListInsert`, `wrenListRemoveAt` signatures, and remove the TODO comment about type unification with `ObjMap`.
2015-03-21 20:22:04 +01:00
uint32_t index = validateIndex(vm, args, string->length, 1, "Iterator");
if (index == UINT32_MAX) return PRIM_ERROR;
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
RETURN_VAL(wrenStringCodePointAt(vm, string, index));
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_startsWith)
docs: document String class methods and add startsWith, endsWith, indexOf natives
2015-01-10 23:45:14 +01:00
{
if (!validateString(vm, args, 1, "Argument")) return PRIM_ERROR;
ObjString* string = AS_STRING(args[0]);
ObjString* search = AS_STRING(args[1]);
// Corner case, if the search string is longer than return false right away.
if (search->length > string->length) RETURN_FALSE;
RETURN_BOOL(memcmp(string->value, search->value, search->length) == 0);
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_plus)
feat: implement infix arithmetic operators for numbers and string concatenation Add parser support for +, -, *, / operators with correct precedence (term/factor) and emit method calls. Implement primitive methods for num_plus, num_minus, num_multiply, num_divide, and string_plus. Update VM to pass VM pointer to primitives and add unsupported value for type errors. Include test files for each operator.
2013-10-31 15:04:44 +01:00
{
fix: enforce string type validation in string_plus and remove coercion TODO - Replace silent null return with explicit string type check in string_plus native - Remove outdated TODO comments about string coercion from both num_plus and string_plus - Add test for basic string concatenation ("a" + "b") - Add test verifying runtime error when concatenating string with non-string ("a" + 123)
2014-04-09 06:17:49 +02:00
if (!validateString(vm, args, 1, "Right operand")) return PRIM_ERROR;
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
RETURN_VAL(wrenStringFormat(vm, "@@", args[0], args[1]));
feat: implement infix arithmetic operators for numbers and string concatenation Add parser support for +, -, *, / operators with correct precedence (term/factor) and emit method calls. Implement primitive methods for num_plus, num_minus, num_multiply, num_divide, and string_plus. Update VM to pass VM pointer to primitives and add unsupported value for type errors. Include test files for each operator.
2013-10-31 15:04:44 +01:00
}
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
DEF_PRIMITIVE(string_subscript)
feat: add subscript operator for array indexing and string character access Implement the `[]` subscript operator as an infix parser at `PREC_CALL` precedence, compiling to a method call on the receiver. Add a `string_subscript` primitive that handles integer indices (including negative for reverse indexing), returns `null` for out-of-bounds or non-integer arguments, and returns a one-character string. Register the `[ ]` method on the string class and include tests for basic indexing, negative indices, out-of-bounds, wrong types, and non-integer indices.
2013-11-24 19:45:07 +01:00
{
ObjString* string = AS_STRING(args[0]);
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
if (IS_NUM(args[1]))
{
int index = validateIndex(vm, args, string->length, 1, "Subscript");
if (index == -1) return PRIM_ERROR;
docs: clarify UTF-8 byte indexing in string subscript and add wrenStringCodePointAt helper
2015-01-23 01:38:03 +01:00
RETURN_VAL(wrenStringCodePointAt(vm, string, index));
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
}
feat: add subscript operator for array indexing and string character access Implement the `[]` subscript operator as an infix parser at `PREC_CALL` precedence, compiling to a method call on the receiver. Add a `string_subscript` primitive that handles integer indices (including negative for reverse indexing), returns `null` for out-of-bounds or non-integer arguments, and returns a one-character string. Register the `[ ]` method on the string class and include tests for basic indexing, negative indices, out-of-bounds, wrong types, and non-integer indices.
2013-11-24 19:45:07 +01:00
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
if (!IS_RANGE(args[1]))
{
RETURN_ERROR("Subscript must be a number or a range.");
}
docs: clarify UTF-8 byte indexing in string subscript and add wrenStringCodePointAt helper
2015-01-23 01:38:03 +01:00
// TODO: Handle UTF-8 here.
feat: store precomputed hash in ObjString and use it for equality and hashing Cache the FNV-1a hash code in the ObjString struct at creation time, replacing the on-the-fly sampling hash in hashObject() and enabling constant-time string equality checks. Refactor string allocation into allocateString() and hashString() helpers, remove the old wrenNewUninitializedString() declaration, and add a CONST_STRING macro. Disable the unimplemented subscript range operator with a runtime error and skip the related UTF-8 tests. Add a string_equals benchmark to measure the speedup.
2015-03-18 15:09:03 +01:00
/*
refactor: replace CalculatedRange struct with output parameters in calculateRange The CalculatedRange struct is removed from the header and calculateRange now returns the start index directly while using pointer parameters for length and step, simplifying the API and reducing struct overhead.
2015-01-21 00:33:21 +01:00
int step;
int count = string->length;
int start = calculateRange(vm, args, AS_RANGE(args[1]), &count, &step);
if (start == -1) return PRIM_ERROR;
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
ObjString* result = wrenNewUninitializedString(vm, count);
refactor: replace CalculatedRange struct with output parameters in calculateRange The CalculatedRange struct is removed from the header and calculateRange now returns the start index directly while using pointer parameters for length and step, simplifying the API and reducing struct overhead.
2015-01-21 00:33:21 +01:00
for (int i = 0; i < count; i++)
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
{
refactor: replace CalculatedRange struct with output parameters in calculateRange The CalculatedRange struct is removed from the header and calculateRange now returns the start index directly while using pointer parameters for length and step, simplifying the API and reducing struct overhead.
2015-01-21 00:33:21 +01:00
result->value[i] = string->value[start + (i * step)];
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
}
refactor: replace CalculatedRange struct with output parameters in calculateRange The CalculatedRange struct is removed from the header and calculateRange now returns the start index directly while using pointer parameters for length and step, simplifying the API and reducing struct overhead.
2015-01-21 00:33:21 +01:00
result->value[count] = '\0';
feat: add range subscripting support for strings with CalculatedRange helper Extract range validation logic from list_subscript into a reusable calculateRange function that handles inclusive/exclusive bounds, negative indices, and direction stepping. Add CalculatedRange struct to wren_core.h and implement string subscripting via the new helper, including comprehensive test coverage for forward, backward, negative, and half-negative ranges with proper error messages for out-of-bounds and non-integer values.
2015-01-17 08:20:56 +01:00
RETURN_OBJ(result);
feat: store precomputed hash in ObjString and use it for equality and hashing Cache the FNV-1a hash code in the ObjString struct at creation time, replacing the on-the-fly sampling hash in hashObject() and enabling constant-time string equality checks. Refactor string allocation into allocateString() and hashString() helpers, remove the old wrenNewUninitializedString() declaration, and add a CONST_STRING macro. Disable the unimplemented subscript range operator with a runtime error and skip the related UTF-8 tests. Add a string_equals benchmark to measure the speedup.
2015-03-18 15:09:03 +01:00
*/
RETURN_ERROR("Subscript ranges for strings are not implemented yet.");
feat: add subscript operator for array indexing and string character access Implement the `[]` subscript operator as an infix parser at `PREC_CALL` precedence, compiling to a method call on the receiver. Add a `string_subscript` primitive that handles integer indices (including negative for reverse indexing), returns `null` for out-of-bounds or non-integer arguments, and returns a one-character string. Register the `[ ]` method on the string class and include tests for basic indexing, negative indices, out-of-bounds, wrong types, and non-integer indices.
2013-11-24 19:45:07 +01:00
}
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
// Creates either the Object or Class class in the core library with [name].
refactor: split class creation into raw single-class and superclass binding phases The bootstrapping of Object and Class now uses a two-phase approach: first creating a raw class with no metaclass or superclass via wrenNewSingleClass, then explicitly wiring superclass relationships with wrenBindSuperclass. This eliminates the need for special-case handling of null superclasses in the old newClass function and makes the metaclass chain setup explicit in wrenInitializeCore.
2013-12-22 05:44:37 +01:00
static ObjClass* defineClass(WrenVM* vm, const char* name)
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
{
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
ObjString* nameString = AS_STRING(wrenStringFormat(vm, "$", name));
fix: replace broken WREN_PIN macro with proper wrenPushRoot/wrenPopRoot GC root stack
2015-01-21 16:56:06 +01:00
wrenPushRoot(vm, (Obj*)nameString);
feat: add class name storage and expose via `name` method on class objects Store the class name string in `ObjClass` during compilation and class creation, and expose it through a new `class_name` native method. Also update `object_toString` to return the class name for class instances and "instance of <name>" for regular instances.
2014-01-29 00:31:11 +01:00
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
ObjClass* classObj = wrenNewSingleClass(vm, 0, nameString);
refactor: replace manual string concatenation with wrenStringFormat across VM core Replace ad-hoc string construction using wrenNewString, wrenStringConcat, and sprintf with the new wrenStringFormat helper. This centralizes string formatting logic, reduces code duplication, and eliminates manual length calculations in wren_compiler.c, wren_core.c, wren_value.c, and wren_vm.c. Also introduces CONST_STRING macro for compile-time string literals and changes wrenNewUninitializedString return type from Value to ObjString* for consistency.
2015-03-16 06:32:20 +01:00
wrenDefineVariable(vm, NULL, name, nameString->length, OBJ_VAL(classObj));
feat: add class name storage and expose via `name` method on class objects Store the class name string in `ObjClass` during compilation and class creation, and expose it through a new `class_name` native method. Also update `object_toString` to return the class name for class instances and "instance of <name>" for regular instances.
2014-01-29 00:31:11 +01:00
fix: replace broken WREN_PIN macro with proper wrenPushRoot/wrenPopRoot GC root stack
2015-01-21 16:56:06 +01:00
wrenPopRoot(vm);
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
return classObj;
}
feat: add `is` operator for type checking and refactor primitives registration Add TOKEN_IS token and CODE_IS bytecode to support runtime type checking via the `is` keyword. Refactor primitive registration by replacing `registerPrimitives` with `loadCore`, which compiles a core library string to define built-in classes (Bool, Class, Function, Num, Null, String, IO) and then attaches primitive methods to them. Update Primitive typedef to remove unused numArgs parameter, and add findGlobal helper to retrieve globals by name. Include test files for class syntax, class instantiation, and the new `is` operator.
2013-11-08 02:07:32 +01:00
refactor: rename primitives module to wren_core and update all references Rename the `primitives.h` and `primitives.c` files to `wren_core.h` and `wren_core.c` respectively, reflecting the module's purpose of defining built-in classes and native methods. Update all includes, macro names (PRIMITIVE -> NATIVE, DEF_PRIMITIVE -> DEF_NATIVE, etc.), and function calls (wrenLoadCore -> wrenInitializeCore) across the codebase and Xcode project file to match the new naming convention.
2013-11-28 17:00:55 +01:00
void wrenInitializeCore(WrenVM* vm)
feat: extract primitive method definitions into separate primitives.c/h files Move the PRIMITIVE macro and all primitive function implementations (num_abs, string_contains, string_count) from vm.c into new src/primitives.c and src/primitives.h files. Add registerPrimitives() function to centralize primitive registration, removing inline PRIMITIVE calls from newVM(). Also remove unused numGlobals field from VM struct and add primitives.c to Xcode project sources.
2013-10-27 19:28:15 +01:00
{
refactor: split class creation into raw single-class and superclass binding phases The bootstrapping of Object and Class now uses a two-phase approach: first creating a raw class with no metaclass or superclass via wrenNewSingleClass, then explicitly wiring superclass relationships with wrenBindSuperclass. This eliminates the need for special-case handling of null superclasses in the old newClass function and makes the metaclass chain setup explicit in wrenInitializeCore.
2013-12-22 05:44:37 +01:00
// Define the root Object class. This has to be done a little specially
feat: add Object.same static method for reliable built-in equality Introduce a new static method `Object.same(obj1, obj2)` that exposes the VM's built-in equality semantics (`wrenValuesEqual`) directly, bypassing any user-defined `==` overrides. This required creating a dedicated metaclass for Object (subclass of Class) to host the static method without polluting every class with a `same` method. The implementation wires up a new `Object metaclass` in the core initialization sequence, adjusts the class hierarchy setup order, and adds comprehensive tests covering value types, identity comparison, and verification that `Object.same` ignores custom `==` operators.
2015-05-01 16:55:28 +02:00
// because it has no superclass.
refactor: merge defineSingleClass into defineClass with conditional raw class creation The defineSingleClass helper was only used for the initial Object and Class definitions during core initialization. By inlining its logic into defineClass with a check for vm->classClass being NULL, we eliminate a redundant function while preserving the same behavior for those two special cases.
2015-03-30 01:18:36 +02:00
vm->objectClass = defineClass(vm, "Object");
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->objectClass, "!", object_not);
PRIMITIVE(vm->objectClass, "==(_)", object_eqeq);
PRIMITIVE(vm->objectClass, "!=(_)", object_bangeq);
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
PRIMITIVE(vm->objectClass, "this new()", return_this);
refactor: replace dedicated CODE_IS opcode with infix operator method call for "is"
2015-06-19 16:58:07 +02:00
PRIMITIVE(vm->objectClass, "is(_)", object_is);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->objectClass, "toString", object_toString);
PRIMITIVE(vm->objectClass, "type", object_type);
feat: replace per-type equality primitives with unified object_eqeq and wrenGetClass Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
2013-11-26 16:52:37 +01:00
feat: add Object.same static method for reliable built-in equality Introduce a new static method `Object.same(obj1, obj2)` that exposes the VM's built-in equality semantics (`wrenValuesEqual`) directly, bypassing any user-defined `==` overrides. This required creating a dedicated metaclass for Object (subclass of Class) to host the static method without polluting every class with a `same` method. The implementation wires up a new `Object metaclass` in the core initialization sequence, adjusts the class hierarchy setup order, and adds comprehensive tests covering value types, identity comparison, and verification that `Object.same` ignores custom `==` operators.
2015-05-01 16:55:28 +02:00
// Now we can define Class, which is a subclass of Object.
refactor: merge defineSingleClass into defineClass with conditional raw class creation The defineSingleClass helper was only used for the initial Object and Class definitions during core initialization. By inlining its logic into defineClass with a check for vm->classClass being NULL, we eliminate a redundant function while preserving the same behavior for those two special cases.
2015-03-30 01:18:36 +02:00
vm->classClass = defineClass(vm, "Class");
feat: remove hardcoded 256 symbol limit and switch to dynamic symbol table with 16-bit instruction arguments Replace the fixed-size MAX_SYMBOLS array with a dynamically growing StringBuffer for symbol names, update all instruction encodings to use 16-bit operands for constants and method symbols, and refactor method binding to use a dynamic MethodBuffer per class. Remove the constant deduplication logic in addConstant and the commented-out struct fields in initCompiler.
2014-01-04 20:08:31 +01:00
wrenBindSuperclass(vm, vm->classClass, vm->objectClass);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->classClass, "name", class_name);
feat: add Class.supertype primitive and documentation for retrieving superclass Implement a new `supertype` property on Class objects that returns the superclass of a given class. The primitive `class_supertype` checks if the class has a superclass (returning null for Object) and returns the superclass object. Includes documentation in the class reference and a test file verifying behavior for explicit superclasses, implicit Object inheritance, and Object's null supertype.
2015-03-14 17:48:45 +01:00
PRIMITIVE(vm->classClass, "supertype", class_supertype);
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
PRIMITIVE(vm->classClass, "toString", class_toString);
feat: replace CODE_NEW instruction with instantiate method call for class and Fn Refactor the 'new' operator compilation to emit a method call to 'instantiate' on the class instead of using a dedicated bytecode instruction. This allows built-in types like Fn to override instantiation behavior, enabling `new Fn { ... }` to return the block argument directly. Remove the CODE_NEW opcode from the VM, compiler, and debug printer, and add native methods `class_instantiate`, `fn_instantiate`, `fn_new`, and `object_instantiate` to handle the new dispatch. Update test files to reflect the renamed `Function` class to `Fn`.
2014-04-03 02:42:30 +02:00
feat: add Object.same static method for reliable built-in equality Introduce a new static method `Object.same(obj1, obj2)` that exposes the VM's built-in equality semantics (`wrenValuesEqual`) directly, bypassing any user-defined `==` overrides. This required creating a dedicated metaclass for Object (subclass of Class) to host the static method without polluting every class with a `same` method. The implementation wires up a new `Object metaclass` in the core initialization sequence, adjusts the class hierarchy setup order, and adds comprehensive tests covering value types, identity comparison, and verification that `Object.same` ignores custom `==` operators.
2015-05-01 16:55:28 +02:00
// Finally, we can define Object's metaclass which is a subclass of Class.
ObjClass* objectMetaclass = defineClass(vm, "Object metaclass");
// Wire up the metaclass relationships now that all three classes are built.
vm->objectClass->obj.classObj = objectMetaclass;
objectMetaclass->obj.classObj = vm->classClass;
vm->classClass->obj.classObj = vm->classClass;
// Do this after wiring up the metaclasses so objectMetaclass doesn't get
// collected.
wrenBindSuperclass(vm, objectMetaclass, vm->classClass);
PRIMITIVE(objectMetaclass, "same(_,_)", object_same);
refactor: split class creation into raw single-class and superclass binding phases The bootstrapping of Object and Class now uses a two-phase approach: first creating a raw class with no metaclass or superclass via wrenNewSingleClass, then explicitly wiring superclass relationships with wrenBindSuperclass. This eliminates the need for special-case handling of null superclasses in the old newClass function and makes the metaclass chain setup explicit in wrenInitializeCore.
2013-12-22 05:44:37 +01:00
// The core class diagram ends up looking like this, where single lines point
// to a class's superclass, and double lines point to its metaclass:
//
feat: add Object.same static method for reliable built-in equality Introduce a new static method `Object.same(obj1, obj2)` that exposes the VM's built-in equality semantics (`wrenValuesEqual`) directly, bypassing any user-defined `==` overrides. This required creating a dedicated metaclass for Object (subclass of Class) to host the static method without polluting every class with a `same` method. The implementation wires up a new `Object metaclass` in the core initialization sequence, adjusts the class hierarchy setup order, and adds comprehensive tests covering value types, identity comparison, and verification that `Object.same` ignores custom `==` operators.
2015-05-01 16:55:28 +02:00
// .------------------------------------. .====.
// | .---------------. | # #
// v | v | v #
// .---------. .-------------------. .-------. #
// | Object |==>| Object metaclass |==>| Class |=="
// '---------' '-------------------' '-------'
// ^ ^ ^ ^ ^
// | .--------------' # | #
// | | # | #
// .---------. .-------------------. # | # -.
// | Base |==>| Base metaclass |======" | # |
// '---------' '-------------------' | # |
// ^ | # |
// | .------------------' # | Example classes
// | | # |
// .---------. .-------------------. # |
// | Derived |==>| Derived metaclass |==========" |
// '---------' '-------------------' -'
refactor: split class creation into raw single-class and superclass binding phases The bootstrapping of Object and Class now uses a two-phase approach: first creating a raw class with no metaclass or superclass via wrenNewSingleClass, then explicitly wiring superclass relationships with wrenBindSuperclass. This eliminates the need for special-case handling of null superclasses in the old newClass function and makes the metaclass chain setup explicit in wrenInitializeCore.
2013-12-22 05:44:37 +01:00
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
// The rest of the classes can now be defined normally.
fix: rename builtin static variables to avoid linker ambiguity across modules
2015-04-16 13:07:14 +02:00
wrenInterpret(vm, "", coreLibSource);
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
vm->boolClass = AS_CLASS(wrenFindVariable(vm, "Bool"));
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->boolClass, "toString", bool_toString);
PRIMITIVE(vm->boolClass, "!", bool_not);
feat: add boolean literals and number comparison operators to compiler and VM Add TOKEN_TRUE/TOKEN_FALSE parsing with boolean() prefix rule emitting CODE_TRUE/CODE_FALSE bytecodes. Wire comparison operators <, >, <=, >= as infix rules with PREC_COMPARISON precedence. Implement num_lt, num_gt, num_lte, num_gte primitives returning bool values. Register boolClass with toString primitive and move class initialization into registerPrimitives(). Add OBJ_TRUE/OBJ_FALSE object types with makeBool() helper and AS_BOOL macro. Include test files for bool_toString and number_comparison.
2013-11-04 06:38:58 +01:00
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
vm->fiberClass = AS_CLASS(wrenFindVariable(vm, "Fiber"));
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->fiberClass->obj.classObj, "new(_)", fiber_new);
PRIMITIVE(vm->fiberClass->obj.classObj, "abort(_)", fiber_abort);
feat: allow yielding main fiber and expose current fiber reference - Change Fiber.yield() to exit interpreter when no parent fiber exists instead of raising runtime error - Add Fiber.current primitive to return the currently executing fiber object - Update interpreter loop to stop execution when PRIM_RUN_FIBER receives null value - Modify test expectations to reflect new yielding behavior from main fiber
2015-03-07 21:32:11 +01:00
PRIMITIVE(vm->fiberClass->obj.classObj, "current", fiber_current);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->fiberClass->obj.classObj, "yield()", fiber_yield);
PRIMITIVE(vm->fiberClass->obj.classObj, "yield(_)", fiber_yield1);
PRIMITIVE(vm->fiberClass, "call()", fiber_call);
PRIMITIVE(vm->fiberClass, "call(_)", fiber_call1);
PRIMITIVE(vm->fiberClass, "error", fiber_error);
PRIMITIVE(vm->fiberClass, "isDone", fiber_isDone);
PRIMITIVE(vm->fiberClass, "run()", fiber_run);
PRIMITIVE(vm->fiberClass, "run(_)", fiber_run1);
PRIMITIVE(vm->fiberClass, "try()", fiber_try);
feat: remove hardcoded 256 symbol limit and switch to dynamic symbol table with 16-bit instruction arguments Replace the fixed-size MAX_SYMBOLS array with a dynamically growing StringBuffer for symbol names, update all instruction encodings to use 16-bit operands for constants and method symbols, and refactor method binding to use a dynamic MethodBuffer per class. Remove the constant deduplication logic in addConstant and the commented-out struct fields in initCompiler.
2014-01-04 20:08:31 +01:00
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
vm->fnClass = AS_CLASS(wrenFindVariable(vm, "Fn"));
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->fnClass->obj.classObj, "new(_)", fn_new);
PRIMITIVE(vm->fnClass, "arity", fn_arity);
PRIMITIVE(vm->fnClass, "call()", fn_call0);
PRIMITIVE(vm->fnClass, "call(_)", fn_call1);
PRIMITIVE(vm->fnClass, "call(_,_)", fn_call2);
PRIMITIVE(vm->fnClass, "call(_,_,_)", fn_call3);
PRIMITIVE(vm->fnClass, "call(_,_,_,_)", fn_call4);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_)", fn_call5);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_)", fn_call6);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_)", fn_call7);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_)", fn_call8);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_)", fn_call9);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_)", fn_call10);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_,_)", fn_call11);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_,_,_)", fn_call12);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_,_,_,_)", fn_call13);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_,_,_,_,_)", fn_call14);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_,_,_,_,_,_)", fn_call15);
PRIMITIVE(vm->fnClass, "call(_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_)", fn_call16);
PRIMITIVE(vm->fnClass, "toString", fn_toString);
refactor: rename ObjBlock to ObjFn and replace block_call with fn_call across compiler, vm, and primitives
2013-11-06 15:52:28 +01:00
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
vm->nullClass = AS_CLASS(wrenFindVariable(vm, "Null"));
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->nullClass, "!", null_not);
PRIMITIVE(vm->nullClass, "toString", null_toString);
feat: add `is` operator for type checking and refactor primitives registration Add TOKEN_IS token and CODE_IS bytecode to support runtime type checking via the `is` keyword. Refactor primitive registration by replacing `registerPrimitives` with `loadCore`, which compiles a core library string to define built-in classes (Bool, Class, Function, Num, Null, String, IO) and then attaches primitive methods to them. Update Primitive typedef to remove unused numArgs parameter, and add findGlobal helper to retrieve globals by name. Include test files for class syntax, class instantiation, and the new `is` operator.
2013-11-08 02:07:32 +01:00
feat: move primitive class definitions from C into core.wren library source Move the definitions of Bool, Fiber, Fn, Null, and Num classes from hardcoded C code in wren_core.c into the core.wren library source, allowing them to be parsed and created during library initialization. Simplify defineClass to always use wrenNewSingleClass, remove redundant root pushing in wrenNewClass, and adjust the class creation in the interpreter to use a Value instead of ObjClass*.
2015-04-03 17:00:55 +02:00
vm->numClass = AS_CLASS(wrenFindVariable(vm, "Num"));
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->numClass->obj.classObj, "fromString(_)", num_fromString);
feat: add Num.pi constant and trigonometric function tests for acos, asin, atan, cos, sin, tan
2015-03-19 21:12:50 +01:00
PRIMITIVE(vm->numClass->obj.classObj, "pi", num_pi);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->numClass, "-(_)", num_minus);
PRIMITIVE(vm->numClass, "+(_)", num_plus);
PRIMITIVE(vm->numClass, "*(_)", num_multiply);
PRIMITIVE(vm->numClass, "/(_)", num_divide);
PRIMITIVE(vm->numClass, "<(_)", num_lt);
PRIMITIVE(vm->numClass, ">(_)", num_gt);
PRIMITIVE(vm->numClass, "<=(_)", num_lte);
PRIMITIVE(vm->numClass, ">=(_)", num_gte);
PRIMITIVE(vm->numClass, "&(_)", num_bitwiseAnd);
PRIMITIVE(vm->numClass, "|(_)", num_bitwiseOr);
PRIMITIVE(vm->numClass, "^(_)", num_bitwiseXor);
PRIMITIVE(vm->numClass, "<<(_)", num_bitwiseLeftShift);
PRIMITIVE(vm->numClass, ">>(_)", num_bitwiseRightShift);
PRIMITIVE(vm->numClass, "abs", num_abs);
feat: add acos, asin, atan trigonometric methods to Num class Implement arc cosine, arc sine, and arc tangent primitives in the VM core and document them in the Num API reference.
2015-03-14 14:52:16 +01:00
PRIMITIVE(vm->numClass, "acos", num_acos);
PRIMITIVE(vm->numClass, "asin", num_asin);
PRIMITIVE(vm->numClass, "atan", num_atan);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->numClass, "ceil", num_ceil);
PRIMITIVE(vm->numClass, "cos", num_cos);
PRIMITIVE(vm->numClass, "floor", num_floor);
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
PRIMITIVE(vm->numClass, "-", num_negate);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->numClass, "sin", num_sin);
PRIMITIVE(vm->numClass, "sqrt", num_sqrt);
feat: add Num.tan method to core library and documentation Add the missing `tan` method to the Num class, implementing the tangent trigonometric function. This fills the gap between the existing `sin` and `cos` methods, providing a complete set of basic trigonometric operations. - Register `num_tan` primitive in the VM core initialization - Implement `DEF_PRIMITIVE(num_tan)` using C's `tan()` math function - Add documentation entry for `tan` in the core library reference
2015-03-14 14:40:23 +01:00
PRIMITIVE(vm->numClass, "tan", num_tan);
refactor: remove inline local variable declarations in list primitives and delete redundant math primitives from wren_core.c Consolidate temporary variable usage in list_add, list_count, and list_iterate by directly inlining AS_LIST/AS_NUM calls. Remove the entire block of num_abs, num_acos, num_asin, num_atan, num_atan2, num_ceil, num_cos, num_floor, and num_fraction primitive definitions to eliminate boilerplate.
2015-03-21 22:57:43 +01:00
PRIMITIVE(vm->numClass, "%(_)", num_mod);
PRIMITIVE(vm->numClass, "~", num_bitwiseNot);
PRIMITIVE(vm->numClass, "..(_)", num_dotDot);
PRIMITIVE(vm->numClass, "...(_)", num_dotDotDot);
PRIMITIVE(vm->numClass, "atan(_)", num_atan2);
PRIMITIVE(vm->numClass, "fraction", num_fraction);
PRIMITIVE(vm->numClass, "isNan", num_isNan);
PRIMITIVE(vm->numClass, "sign", num_sign);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->numClass, "toString", num_toString);
feat: add decimal and truncate number methods to wren core Implement two new primitive methods for the Number class: `decimal` returns the integer part by casting to uint32_t, and `truncate` returns the fractional part by subtracting the integer portion from the original value. Register both primitives in the core initialization.
2015-03-04 00:29:19 +01:00
PRIMITIVE(vm->numClass, "truncate", num_truncate);
feat: implement `!` operator for all core types with proper truthiness semantics Add native `!` methods to Null, Object, Num, String, and List classes so that `!` works reliably on any value. Null returns `true`, all other types return `false` since they are considered truthy. Update documentation to describe the operator as returning the logical complement and add comprehensive tests for each type. Also fix the `all` method test to use a truthy string instead of expecting a runtime error.
2015-01-16 06:50:01 +01:00
// These are defined just so that 0 and -0 are equal, which is specified by
// IEEE 754 even though they have different bit representations.
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->numClass, "==(_)", num_eqeq);
PRIMITIVE(vm->numClass, "!=(_)", num_bangeq);
feat: replace Wren Range class with native C object for performance Remove the Range class definition from corelib.wren and implement it as a native C type with ObjRange struct, adding native methods for from, to, min, max, iterate, and iteratorValue. Move range operator handling from Num class to native num_dotDot and num_dotDotDot functions. Update VM to support OBJ_RANGE type in marking, printing, and type checking. Add comprehensive test suite for range operations including ordered, backwards, and exclusive ranges.
2014-01-20 17:45:15 +01:00
refactor: remove dedicated main module field from WrenVM struct Instead of storing the main module directly in a dedicated field on WrenVM, store it as a null-keyed entry in the new modules map. This eliminates the redundant `vm->main` pointer and paves the way for supporting multiple named modules. The change also adds `wrenFindVariable` as a public helper to look up top-level variables in the main module, and updates `wrenNewFunction` to accept an explicit module parameter instead of always using `vm->main`.
2015-02-05 21:03:19 +01:00
vm->stringClass = AS_CLASS(wrenFindVariable(vm, "String"));
feat: add String.fromCodePoint static method and refactor UTF-8 encoding into reusable utilities Implement the `String.fromCodePoint(_)` primitive that creates a string from a Unicode code point, with validation for integer range 0–0x10ffff. Extract inline UTF-8 encoding logic from `readUnicodeEscape` in the compiler into new `wrenUtf8NumBytes` and `wrenUtf8Encode` utility functions in `wren_utils`, and add `wrenStringFromCodePoint` helper in `wren_value`. Update documentation for core classes to add "Methods" and "Static Methods" section headers, and include `String.fromCodePoint` docs with example. Add a test file `from_code_point.wren` covering various code points.
2015-03-27 15:43:36 +01:00
PRIMITIVE(vm->stringClass->obj.classObj, "fromCodePoint(_)", string_fromCodePoint);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->stringClass, "+(_)", string_plus);
PRIMITIVE(vm->stringClass, "[_]", string_subscript);
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
PRIMITIVE(vm->stringClass, "byteAt(_)", string_byteAt);
PRIMITIVE(vm->stringClass, "codePointAt(_)", string_codePointAt);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->stringClass, "contains(_)", string_contains);
PRIMITIVE(vm->stringClass, "count", string_count);
PRIMITIVE(vm->stringClass, "endsWith(_)", string_endsWith);
PRIMITIVE(vm->stringClass, "indexOf(_)", string_indexOf);
PRIMITIVE(vm->stringClass, "iterate(_)", string_iterate);
feat: add raw byte access methods and \x escape to String class Add `byteAt(index)`, `codePointAt(index)`, and `bytes` sequence to String, enabling direct byte-level manipulation of UTF-8 encoded strings. Introduce `\x` hex escape sequence in string literals for specifying raw byte values. Refactor Unicode escape parsing into a generic `readHexEscape` function supporting variable digit counts. Implement `wrenUtf8Decode` utility for decoding UTF-8 sequences from byte buffers. Add comprehensive tests for `byteAt` including boundary conditions and error cases.
2015-03-28 04:44:07 +01:00
PRIMITIVE(vm->stringClass, "iterateByte_(_)", string_iterateByte);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->stringClass, "iteratorValue(_)", string_iteratorValue);
PRIMITIVE(vm->stringClass, "startsWith(_)", string_startsWith);
feat: add return_this primitive to replace duplicated identity-returning implementations Extract the common pattern of returning the receiver argument into a single DEF_PRIMITIVE(return_this) function, and refactor fiber_instantiate, fn_instantiate, and the default Object constructor to use it instead of inline RETURN_VAL(args[0]) calls. Also fix trailing whitespace on isEmpty and class_toString lines in the core library source string.
2015-06-30 16:39:43 +02:00
PRIMITIVE(vm->stringClass, "toString", return_this);
feat: add io.write primitive and test runner with number literal tests Implement the io.write() primitive function that prints a value followed by a newline, enabling basic output for testing. Add a Python test runner script (runtests) that discovers and executes .wren test files, comparing output against // expect: comments. Include initial number literal tests covering positive, negative, and zero values. Remove debug print statements from the VM interpreter and refactor primitive registration macros for cleaner code.
2013-10-28 06:45:40 +01:00
refactor: remove dedicated main module field from WrenVM struct Instead of storing the main module directly in a dedicated field on WrenVM, store it as a null-keyed entry in the new modules map. This eliminates the redundant `vm->main` pointer and paves the way for supporting multiple named modules. The change also adds `wrenFindVariable` as a public helper to look up top-level variables in the main module, and updates `wrenNewFunction` to accept an explicit module parameter instead of always using `vm->main`.
2015-02-05 21:03:19 +01:00
vm->listClass = AS_CLASS(wrenFindVariable(vm, "List"));
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
PRIMITIVE(vm->listClass->obj.classObj, "new()", list_new);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->listClass, "[_]", list_subscript);
PRIMITIVE(vm->listClass, "[_]=(_)", list_subscriptSetter);
PRIMITIVE(vm->listClass, "add(_)", list_add);
PRIMITIVE(vm->listClass, "clear()", list_clear);
PRIMITIVE(vm->listClass, "count", list_count);
PRIMITIVE(vm->listClass, "insert(_,_)", list_insert);
PRIMITIVE(vm->listClass, "iterate(_)", list_iterate);
PRIMITIVE(vm->listClass, "iteratorValue(_)", list_iteratorValue);
PRIMITIVE(vm->listClass, "removeAt(_)", list_removeAt);
feat: make IO.write call toString on argument and add corelib with List.toString
2013-12-22 20:50:00 +01:00
refactor: remove dedicated main module field from WrenVM struct Instead of storing the main module directly in a dedicated field on WrenVM, store it as a null-keyed entry in the new modules map. This eliminates the redundant `vm->main` pointer and paves the way for supporting multiple named modules. The change also adds `wrenFindVariable` as a public helper to look up top-level variables in the main module, and updates `wrenNewFunction` to accept an explicit module parameter instead of always using `vm->main`.
2015-02-05 21:03:19 +01:00
vm->mapClass = AS_CLASS(wrenFindVariable(vm, "Map"));
feat: replace `new` keyword with `this` constructor syntax and `ClassName.new()` calls across core library and docs Replace all uses of the `new` reserved word with explicit `this new()` constructor definitions and `ClassName.new()` instantiation calls in builtin/core.wren. Update all documentation files (classes.markdown, fiber.markdown, fn.markdown, sequence.markdown, error-handling.markdown, expressions.markdown, fibers.markdown, functions.markdown) to reflect the new constructor syntax, removing `new` keyword examples and replacing them with `ClassName.new()` patterns and `this new()` definitions.
2015-07-10 18:18:22 +02:00
PRIMITIVE(vm->mapClass->obj.classObj, "new()", map_new);
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->mapClass, "[_]", map_subscript);
PRIMITIVE(vm->mapClass, "[_]=(_)", map_subscriptSetter);
PRIMITIVE(vm->mapClass, "clear()", map_clear);
PRIMITIVE(vm->mapClass, "containsKey(_)", map_containsKey);
PRIMITIVE(vm->mapClass, "count", map_count);
PRIMITIVE(vm->mapClass, "remove(_)", map_remove);
PRIMITIVE(vm->mapClass, "iterate_(_)", map_iterate);
PRIMITIVE(vm->mapClass, "keyIteratorValue_(_)", map_keyIteratorValue);
PRIMITIVE(vm->mapClass, "valueIteratorValue_(_)", map_valueIteratorValue);
feat: add initial Map class with hash table, subscript, and count support Implement the core Map data structure in Wren, including the ObjMap type with hash table storage, native methods for instantiation, subscript get/set, and count. Add Map class declaration to core.wren with a basic toString stub. Introduce MapEntry struct and hash table growth logic with configurable load factor. Add test files for map creation, count tracking, key type support (including null, bool, num, string, range, and class keys), and growth behavior. Refactor list capacity constants into shared MIN_CAPACITY and GROW_FACTOR macros. Change object equality operators to use wrenValuesSame instead of wrenValuesEqual.
2015-01-25 07:27:35 +01:00
refactor: remove dedicated main module field from WrenVM struct Instead of storing the main module directly in a dedicated field on WrenVM, store it as a null-keyed entry in the new modules map. This eliminates the redundant `vm->main` pointer and paves the way for supporting multiple named modules. The change also adds `wrenFindVariable` as a public helper to look up top-level variables in the main module, and updates `wrenNewFunction` to accept an explicit module parameter instead of always using `vm->main`.
2015-02-05 21:03:19 +01:00
vm->rangeClass = AS_CLASS(wrenFindVariable(vm, "Range"));
refactor: rename NATIVE/DEF_NATIVE macros to PRIMITIVE/DEF_PRIMITIVE across wren_core Rename the NATIVE macro to PRIMITIVE and DEF_NATIVE to DEF_PRIMITIVE, updating all corresponding function prefixes from native_ to prim_ to maintain consistency with the existing METHOD_PRIMITIVE type and terminology used throughout the codebase.
2015-03-02 16:24:04 +01:00
PRIMITIVE(vm->rangeClass, "from", range_from);
PRIMITIVE(vm->rangeClass, "to", range_to);
PRIMITIVE(vm->rangeClass, "min", range_min);
PRIMITIVE(vm->rangeClass, "max", range_max);
PRIMITIVE(vm->rangeClass, "isInclusive", range_isInclusive);
PRIMITIVE(vm->rangeClass, "iterate(_)", range_iterate);
PRIMITIVE(vm->rangeClass, "iteratorValue(_)", range_iteratorValue);
PRIMITIVE(vm->rangeClass, "toString", range_toString);
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
// While bootstrapping the core types and running the core library, a number
feat: replace string import method with dedicated bytecode instruction for module variable loading Replace the runtime string-based `import_` method call with a new `CODE_IMPORT_VARIABLE` bytecode instruction that directly loads variables from other modules. This eliminates the overhead of calling a native method and string-based module lookup during import, moving the logic into the VM interpreter loop with a dedicated `importVariable` helper function. The change includes adding the opcode to the compiler's `import` function, implementing the runtime lookup in `wren_vm.c`, updating the debug disassembler, and removing the now-unnecessary `string_import` native from `wren_core.c`.
2015-02-17 16:21:51 +01:00
// of string objects have been created, many of which were instantiated
// before stringClass was stored in the VM. Some of them *must* be created
// first -- the ObjClass for string itself has a reference to the ObjString
// for its name.
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
//
feat: replace string import method with dedicated bytecode instruction for module variable loading Replace the runtime string-based `import_` method call with a new `CODE_IMPORT_VARIABLE` bytecode instruction that directly loads variables from other modules. This eliminates the overhead of calling a native method and string-based module lookup during import, moving the logic into the VM interpreter loop with a dedicated `importVariable` helper function. The change includes adding the opcode to the compiler's `import` function, implementing the runtime lookup in `wren_vm.c`, updating the debug disassembler, and removing the now-unnecessary `string_import` native from `wren_core.c`.
2015-02-17 16:21:51 +01:00
// These all currently have a NULL classObj pointer, so go back and assign
// them now that the string class is known.
feat: make String iterable over code points with iterate/iteratorValue primitives Add String as a subclass of Sequence in core.wren and implement the iterator protocol for strings in wren_core.c. The string_iterate native advances through UTF-8 code point boundaries, while string_iteratorValue extracts the full code point at a given byte index. Includes comprehensive test coverage for iteration, edge cases (empty strings, mid-sequence positions), and error handling for invalid iterator types and out-of-bounds indices. Also updates documentation for String, List, and Sequence classes with iterator protocol details and usage examples.
2015-01-23 05:58:22 +01:00
for (Obj* obj = vm->first; obj != NULL; obj = obj->next)
{
if (obj->type == OBJ_STRING) obj->classObj = vm->stringClass;
}
feat: add if/else expression parsing with jump bytecodes and null object support Implement initial support for `if` expressions in the compiler, including new `TOKEN_IF` and `TOKEN_ELSE` tokens, `CODE_JUMP` and `CODE_JUMP_IF` bytecodes for conditional branching, and a `makeNull()` function in the VM to represent the value returned when an if-condition is false without an else clause. The `emit()` function now returns the index of the emitted bytecode to enable patching jump offsets. Also add a `nullClass` to the VM and a `OBJ_NULL` object type, along with a `dumpCode()` debugging helper and new test files for block syntax and if-expression behavior.
2013-11-06 00:40:21 +01:00
}
Reference in New Issue Copy Permalink