mirrors/janet
1
0
Fork 0
mirror of https://github.com/janet-lang/janet synced 2024-11-29 03:19:54 +00:00
Code Issues 1 Releases Wiki Activity
cff718f37d
janet/src/core/vm.c

1609 lines
50 KiB
C
Raw Normal View History

Add license header to all source files.
2017-04-18 02:40:39 +00:00
/*
Address #926 - enter the event loop from janet_dobytes or janet_dostring.
2022-03-21 22:47:37 +00:00
* Copyright (c) 2022 Calvin Rose
Whitespace
2017-07-02 01:51:16 +00:00
*
Add license header to all source files.
2017-04-18 02:40:39 +00:00
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
Whitespace
2017-07-02 01:51:16 +00:00
*
Add license header to all source files.
2017-04-18 02:40:39 +00:00
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
Whitespace
2017-07-02 01:51:16 +00:00
*
Add license header to all source files.
2017-04-18 02:40:39 +00:00
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
Add source amalgamation The amalgamated source concatenates all sources to a file janet.c which can be used for embedding janet, much in the same way as sqlite or mongoose.
2019-01-24 05:15:58 +00:00
#ifndef JANET_AMALG
Add features.h for feature test macros. Because we use an amalgated build, feature test macros should be set in a single file that is included before any other headers, and is placed at the top of the amalgamated build.
2019-12-31 00:06:15 +00:00
#include "features.h"
Rename the header <janet/janet.h> to <janet.h> Makes it easier to use and remember, and makes the variable `module/*headerpath*` make more sense.
2019-02-19 01:13:35 +00:00
#include <janet.h>
Shrink the public interface by hiding internal state.
2018-03-31 20:40:36 +00:00
#include "state.h"
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
#include "fiber.h"
Add utf-8 compatibility in parser. Symbols can be valid utf-8 strings
2017-12-21 04:03:34 +00:00
#include "gc.h"
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
#include "symcache.h"
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
#include "util.h"
Add source amalgamation The amalgamated source concatenates all sources to a file janet.c which can be used for embedding janet, much in the same way as sqlite or mongoose.
2019-01-24 05:15:58 +00:00
#endif
First commit.
2017-02-09 20:02:59 +00:00
Remove warning about math.h on aarch64 ubuntu gcc.
2020-03-07 20:05:28 +00:00
#include <math.h>
Update copyright date, fix types, remove trailing whitespace.
2019-01-06 08:23:03 +00:00
/* Virtual registers
*
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
* One instruction word
* CC | BB | AA | OP
* DD | DD | DD | OP
* EE | EE | AA | OP
*/
#define A ((*pc >> 8) & 0xFF)
#define B ((*pc >> 16) & 0xFF)
#define C (*pc >> 24)
#define D (*pc >> 8)
#define E (*pc >> 16)
/* Signed interpretations of registers */
#define CS (*((int32_t *)pc) >> 24)
#define DS (*((int32_t *)pc) >> 8)
#define ES (*((int32_t *)pc) >> 16)
/* How we dispatch instructions. By default, we use
* a switch inside an infinite loop. For GCC/clang, we use
* computed gotos. */
More "correct" emscripten support.
2019-07-14 21:11:00 +00:00
#if defined(__GNUC__) && !defined(__EMSCRIPTEN__)
GCC seemed to not fill array of computed gotos. This is expected as per the C standard, but segfaulted unless all 255 labels were added.
2019-09-22 22:50:31 +00:00
#define JANET_USE_COMPUTED_GOTOS
Small changes to help with latest emscripten.
2019-07-14 14:58:11 +00:00
#endif
#ifdef JANET_USE_COMPUTED_GOTOS
Make source mapping use byte offset instead of line and col for better debugging support in repl. Add debug module for better debugging support.
2018-12-13 23:46:53 +00:00
#define VM_START() { goto *op_lookup[first_opcode];
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
#define VM_END() }
#define VM_OP(op) label_##op :
#define VM_DEFAULT() label_unknown_op:
Restore old status logic - (status checks in run_vm should be using the previous status, not the current which is always JANET_STATUS_ALIVE)
2019-01-08 18:42:29 +00:00
#define vm_next() goto *op_lookup[*pc & 0xFF]
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
#define opcode (*pc & 0xFF)
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
#else
Make source mapping use byte offset instead of line and col for better debugging support in repl. Add debug module for better debugging support.
2018-12-13 23:46:53 +00:00
#define VM_START() uint8_t opcode = first_opcode; for (;;) {switch(opcode) {
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
#define VM_END() }}
#define VM_OP(op) case op :
#define VM_DEFAULT() default:
Make source mapping use byte offset instead of line and col for better debugging support in repl. Add debug module for better debugging support.
2018-12-13 23:46:53 +00:00
#define vm_next() opcode = *pc & 0xFF; continue
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
#endif
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
/* Commit and restore VM state before possible longjmp */
#define vm_commit() do { janet_stack_frame(stack)->pc = pc; } while (0)
#define vm_restore() do { \
stack = fiber->data + fiber->frame; \
pc = janet_stack_frame(stack)->pc; \
func = janet_stack_frame(stack)->func; \
} while (0)
WIP panic functionality.
2019-01-05 04:20:34 +00:00
#define vm_return(sig, val) do { \
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.return_reg[0] = (val); \
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
vm_commit(); \
WIP panic functionality.
2019-01-05 04:20:34 +00:00
return (sig); \
} while (0)
Address #466? Do not restore pc when returning from top most fiber frame. Also add JANET_DEBUG config define for various debugging related configurations. In fiber.c, when debug is enabled we reallocate the entire stack everytime we push a frame to help uncover use after free errors.
2020-08-17 12:01:58 +00:00
#define vm_return_no_restore(sig, val) do { \
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.return_reg[0] = (val); \
Address #466? Do not restore pc when returning from top most fiber frame. Also add JANET_DEBUG config define for various debugging related configurations. In fiber.c, when debug is enabled we reallocate the entire stack everytime we push a frame to help uncover use after free errors.
2020-08-17 12:01:58 +00:00
return (sig); \
} while (0)
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
/* Next instruction variations */
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
#define maybe_collect() do {\
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (janet_vm.next_collection >= janet_vm.gc_interval) janet_collect(); } while (0)
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
#define vm_checkgc_next() maybe_collect(); vm_next()
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
#define vm_pcnext() pc++; vm_next()
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
#define vm_checkgc_pcnext() maybe_collect(); vm_pcnext()
New custom strtod implementation.
2017-12-08 20:57:02 +00:00
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
/* Handle certain errors in main vm loop */
WIP panic functionality.
2019-01-05 04:20:34 +00:00
#define vm_throw(e) do { vm_commit(); janet_panic(e); } while (0)
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
#define vm_assert(cond, e) do {if (!(cond)) vm_throw((e)); } while (0)
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
#define vm_assert_type(X, T) do { \
Rename to janet
2018-09-06 02:18:42 +00:00
if (!(janet_checktype((X), (T)))) { \
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_commit(); \
Add edefer. Also improve error messages from vm internal errors. (Show bad value, not its type).
2020-04-14 01:24:11 +00:00
janet_panicf("expected %T, got %v", (1 << (T)), (X)); \
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
} \
} while (0)
#define vm_assert_types(X, TS) do { \
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
if (!(janet_checktypes((X), (TS)))) { \
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_commit(); \
Add edefer. Also improve error messages from vm internal errors. (Show bad value, not its type).
2020-04-14 01:24:11 +00:00
janet_panicf("expected %T, got %v", (TS), (X)); \
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
} \
} while (0)
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
#ifdef JANET_NO_INTERPRETER_INTERRUPT
#define vm_maybe_auto_suspend(COND)
#else
#define vm_maybe_auto_suspend(COND) do { \
if ((COND) && janet_vm.auto_suspend) { \
janet_vm.auto_suspend = 0; \
fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \
Add utitities for interrupting the event loop. janet_loop1_interrupt makes the event loop compatible with safe interruptions for custom scheduling. Does this by exposing custom events on the event loop. A custom event schedules a function pointer to run in a way that can interrupt epoll_wait/poll/GetQueuedCompletionStatus.
2021-07-25 01:30:36 +00:00
vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
} \
} while (0)
#endif
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
/* Templates for certain patterns in opcodes */
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
#define vm_binop_immediate(op)\
{\
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet op1 = stack[B];\
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
if (!janet_checktype(op1, JANET_NUMBER)) {\
vm_commit();\
Janet _argv[2] = { op1, janet_wrap_number(CS) };\
stack[A] = janet_mcall(#op, 2, _argv);\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
vm_checkgc_pcnext();\
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
} else {\
double x1 = janet_unwrap_number(op1);\
stack[A] = janet_wrap_number(x1 op CS);\
vm_pcnext();\
}\
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
}
#define _vm_bitop_immediate(op, type1)\
{\
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet op1 = stack[B];\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
if (!janet_checktype(op1, JANET_NUMBER)) {\
vm_commit();\
Janet _argv[2] = { op1, janet_wrap_number(CS) };\
stack[A] = janet_mcall(#op, 2, _argv);\
vm_checkgc_pcnext();\
} else {\
type1 x1 = (type1) janet_unwrap_integer(op1);\
stack[A] = janet_wrap_integer(x1 op CS);\
vm_pcnext();\
}\
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
}
#define vm_bitop_immediate(op) _vm_bitop_immediate(op, int32_t);
#define vm_bitopu_immediate(op) _vm_bitop_immediate(op, uint32_t);
#define _vm_binop(op, wrap)\
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
{\
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet op1 = stack[B];\
Janet op2 = stack[C];\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
double x1 = janet_unwrap_number(op1);\
double x2 = janet_unwrap_number(op2);\
stack[A] = wrap(x1 op x2);\
vm_pcnext();\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
} else {\
vm_commit();\
stack[A] = janet_binop_call(#op, "r" #op, op1, op2);\
vm_checkgc_pcnext();\
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
}\
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
}
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
#define vm_binop(op) _vm_binop(op, janet_wrap_number)
#define _vm_bitop(op, type1)\
Inlining for all built in comparators.
2018-07-10 01:24:22 +00:00
{\
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet op1 = stack[B];\
Janet op2 = stack[C];\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\
type1 x1 = (type1) janet_unwrap_integer(op1);\
int32_t x2 = janet_unwrap_integer(op2);\
stack[A] = janet_wrap_integer(x1 op x2);\
vm_pcnext();\
} else {\
vm_commit();\
stack[A] = janet_binop_call(#op, "r" #op, op1, op2);\
vm_checkgc_pcnext();\
}\
Inlining for all built in comparators.
2018-07-10 01:24:22 +00:00
}
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
#define vm_bitop(op) _vm_bitop(op, int32_t)
#define vm_bitopu(op) _vm_bitop(op, uint32_t)
Remove ==, not==, and order[<,<=,>,>=]. This unifies equality and comparison checking. Before, we had separate functions and vm opcodes for comparing general values vs. for comparing numbers, where the numberic functions were polymorphic and had special cases for handling NaNs. By unfiying them, abstract types can now better integrate with other number types and behave as keys. For now, the old functions are aliased but will eventually be removed.
2019-12-28 20:57:36 +00:00
#define vm_compop(op) \
{\
Janet op1 = stack[B];\
Janet op2 = stack[C];\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {\
Remove ==, not==, and order[<,<=,>,>=]. This unifies equality and comparison checking. Before, we had separate functions and vm opcodes for comparing general values vs. for comparing numbers, where the numberic functions were polymorphic and had special cases for handling NaNs. By unfiying them, abstract types can now better integrate with other number types and behave as keys. For now, the old functions are aliased but will eventually be removed.
2019-12-28 20:57:36 +00:00
double x1 = janet_unwrap_number(op1);\
double x2 = janet_unwrap_number(op2);\
stack[A] = janet_wrap_boolean(x1 op x2);\
vm_pcnext();\
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
} else {\
vm_commit();\
stack[A] = janet_wrap_boolean(janet_compare(op1, op2) op 0);\
vm_checkgc_pcnext();\
Remove ==, not==, and order[<,<=,>,>=]. This unifies equality and comparison checking. Before, we had separate functions and vm opcodes for comparing general values vs. for comparing numbers, where the numberic functions were polymorphic and had special cases for handling NaNs. By unfiying them, abstract types can now better integrate with other number types and behave as keys. For now, the old functions are aliased but will eventually be removed.
2019-12-28 20:57:36 +00:00
}\
}
Immediate instuctions will now call :compare method.
2021-02-08 17:53:25 +00:00
#define vm_compop_imm(op) \
{\
Janet op1 = stack[B];\
if (janet_checktype(op1, JANET_NUMBER)) {\
double x1 = janet_unwrap_number(op1);\
double x2 = (double) CS; \
stack[A] = janet_wrap_boolean(x1 op x2);\
vm_pcnext();\
} else {\
vm_commit();\
stack[A] = janet_wrap_boolean(janet_compare(op1, janet_wrap_integer(CS)) op 0);\
vm_checkgc_pcnext();\
}\
}
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
Add simple tracing functionality to VM. Also disable debugger for normal errors.
2019-05-04 19:03:41 +00:00
/* Trace a function call */
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
static void vm_do_trace(JanetFunction *func, int32_t argc, const Janet *argv) {
Revert issue with removing buffer self print check.
2020-01-24 05:39:49 +00:00
if (func->def->name) {
Add simple tracing functionality to VM. Also disable debugger for normal errors.
2019-05-04 19:03:41 +00:00
janet_printf("trace (%S", func->def->name);
} else {
janet_printf("trace (%p", janet_wrap_function(func));
}
for (int32_t i = 0; i < argc; i++) {
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
janet_printf(" %p", argv[i]);
Add simple tracing functionality to VM. Also disable debugger for normal errors.
2019-05-04 19:03:41 +00:00
}
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
janet_printf(")\n");
Add simple tracing functionality to VM. Also disable debugger for normal errors.
2019-05-04 19:03:41 +00:00
}
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
/* Invoke a method once we have looked it up */
static Janet janet_method_invoke(Janet method, int32_t argc, Janet *argv) {
switch (janet_type(method)) {
case JANET_CFUNCTION:
return (janet_unwrap_cfunction(method))(argc, argv);
case JANET_FUNCTION: {
JanetFunction *fun = janet_unwrap_function(method);
return janet_call(fun, argc, argv);
}
case JANET_ABSTRACT: {
JanetAbstract abst = janet_unwrap_abstract(method);
const JanetAbstractType *at = janet_abstract_type(abst);
if (NULL != at->call) {
return at->call(abst, argc, argv);
}
}
/* fallthrough */
case JANET_STRING:
case JANET_BUFFER:
case JANET_TABLE:
case JANET_STRUCT:
case JANET_ARRAY:
case JANET_TUPLE: {
if (argc != 1) {
janet_panicf("%v called with %d arguments, possibly expected 1", method, argc);
}
return janet_in(method, argv[0]);
}
default: {
if (argc != 1) {
janet_panicf("%v called with %d arguments, possibly expected 1", method, argc);
}
return janet_in(argv[0], method);
Add call function pointer to abstract types. This will allow better JITs, FFIs, DSLs, etc.
2020-01-22 00:22:24 +00:00
}
}
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
}
/* Call a non function type from a JOP_CALL or JOP_TAILCALL instruction.
* Assumes that the arguments are on the fiber stack. */
static Janet call_nonfn(JanetFiber *fiber, Janet callee) {
int32_t argc = fiber->stacktop - fiber->stackstart;
WIP panic functionality.
2019-01-05 04:20:34 +00:00
fiber->stacktop = fiber->stackstart;
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
return janet_method_invoke(callee, argc, fiber->data + fiber->stacktop);
WIP panic functionality.
2019-01-05 04:20:34 +00:00
}
Update printing when entering debugger.
2021-03-19 20:38:46 +00:00
/* Method lookup could potentially handle tables specially... */
Change inheritance rule.
2021-03-19 20:18:19 +00:00
static Janet method_to_fun(Janet method, Janet obj) {
Update printing when entering debugger.
2021-03-19 20:38:46 +00:00
return janet_get(obj, method);
Change inheritance rule.
2021-03-19 20:18:19 +00:00
}
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
/* Get a callable from a keyword method name and ensure that it is valid. */
Improve error message on bad method calls.
2019-08-06 00:06:58 +00:00
static Janet resolve_method(Janet name, JanetFiber *fiber) {
int32_t argc = fiber->stacktop - fiber->stackstart;
Add some color to stacktraces in repl.
2019-08-13 00:20:01 +00:00
if (argc < 1) janet_panicf("method call (%v) takes at least 1 argument, got 0", name);
Change inheritance rule.
2021-03-19 20:18:19 +00:00
Janet callee = method_to_fun(name, fiber->data[fiber->stackstart]);
Improve error message on bad method calls.
2019-08-06 00:06:58 +00:00
if (janet_checktype(callee, JANET_NIL))
janet_panicf("unknown method %v invoked on %v", name, fiber->data[fiber->stackstart]);
return callee;
}
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
/* Lookup method on value x */
static Janet janet_method_lookup(Janet x, const char *name) {
Change inheritance rule.
2021-03-19 20:18:19 +00:00
return method_to_fun(janet_ckeywordv(name), x);
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
}
/* Call a method first on the righthand side, and then on the left hand side with a prefix */
static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lhs, Janet rhs) {
Janet lm = janet_method_lookup(lhs, lmethod);
if (janet_checktype(lm, JANET_NIL)) {
/* Invert order for rmethod */
Janet lr = janet_method_lookup(rhs, rmethod);
Janet argv[2] = { rhs, lhs };
if (janet_checktype(lr, JANET_NIL)) {
janet_panicf("could not find method :%s for %v, or :%s for %v",
lmethod, lhs,
rmethod, rhs);
}
return janet_method_invoke(lr, 2, argv);
} else {
Janet argv[2] = { lhs, rhs };
return janet_method_invoke(lm, 2, argv);
}
}
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
/* Forward declaration */
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out, int is_cancel);
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
/* Interpreter main loop */
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
/* opcode -> label lookup if using clang/GCC */
Small changes to help with latest emscripten.
2019-07-14 14:58:11 +00:00
#ifdef JANET_USE_COMPUTED_GOTOS
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
static void *op_lookup[255] = {
&&label_JOP_NOOP,
&&label_JOP_ERROR,
&&label_JOP_TYPECHECK,
&&label_JOP_RETURN,
&&label_JOP_RETURN_NIL,
&&label_JOP_ADD_IMMEDIATE,
&&label_JOP_ADD,
&&label_JOP_SUBTRACT,
&&label_JOP_MULTIPLY_IMMEDIATE,
&&label_JOP_MULTIPLY,
&&label_JOP_DIVIDE_IMMEDIATE,
&&label_JOP_DIVIDE,
Add mod function to core. The `mod` function is a pair function with `%`, or te remainder function and is distinct from it. This is taken from common lisp.
2020-01-24 00:54:30 +00:00
&&label_JOP_MODULO,
&&label_JOP_REMAINDER,
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
&&label_JOP_BAND,
&&label_JOP_BOR,
&&label_JOP_BXOR,
&&label_JOP_BNOT,
&&label_JOP_SHIFT_LEFT,
&&label_JOP_SHIFT_LEFT_IMMEDIATE,
&&label_JOP_SHIFT_RIGHT,
&&label_JOP_SHIFT_RIGHT_IMMEDIATE,
&&label_JOP_SHIFT_RIGHT_UNSIGNED,
&&label_JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE,
&&label_JOP_MOVE_FAR,
&&label_JOP_MOVE_NEAR,
&&label_JOP_JUMP,
&&label_JOP_JUMP_IF,
&&label_JOP_JUMP_IF_NOT,
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
&&label_JOP_JUMP_IF_NIL,
&&label_JOP_JUMP_IF_NOT_NIL,
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
&&label_JOP_GREATER_THAN,
&&label_JOP_GREATER_THAN_IMMEDIATE,
&&label_JOP_LESS_THAN,
&&label_JOP_LESS_THAN_IMMEDIATE,
&&label_JOP_EQUALS,
&&label_JOP_EQUALS_IMMEDIATE,
&&label_JOP_COMPARE,
&&label_JOP_LOAD_NIL,
&&label_JOP_LOAD_TRUE,
&&label_JOP_LOAD_FALSE,
&&label_JOP_LOAD_INTEGER,
&&label_JOP_LOAD_CONSTANT,
&&label_JOP_LOAD_UPVALUE,
&&label_JOP_LOAD_SELF,
&&label_JOP_SET_UPVALUE,
&&label_JOP_CLOSURE,
&&label_JOP_PUSH,
&&label_JOP_PUSH_2,
&&label_JOP_PUSH_3,
&&label_JOP_PUSH_ARRAY,
&&label_JOP_CALL,
&&label_JOP_TAILCALL,
&&label_JOP_RESUME,
&&label_JOP_SIGNAL,
Add propagate function and opcode This allows better stacktraces when manually intercepting signals to clean up resources. Also allows functionality from Common Lisp's unwind-protect, such as calling cleanup code while unwindinding the stack, restarting on certain signals, and just in general having more control over signal and signal propagation. Also fix a bug encountered while implementing with-resource in the compiler. Desturcturing arguments that were not the last argument would often result in bad code generation, as slots used to destructure the earlier arguments would invalidate the later parameters. This is fixed by allocating all named parameters before doing any destructuring.
2019-06-24 16:44:13 +00:00
&&label_JOP_PROPAGATE,
Rename 'get' opcode to 'in', add new 'get' opcode. This makes the names of the opcodes match their implied functionality. We also rename the C functions to match the opcodes and source level functionality.
2019-12-03 03:15:08 +00:00
&&label_JOP_IN,
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
&&label_JOP_GET,
&&label_JOP_PUT,
&&label_JOP_GET_INDEX,
&&label_JOP_PUT_INDEX,
&&label_JOP_LENGTH,
&&label_JOP_MAKE_ARRAY,
&&label_JOP_MAKE_BUFFER,
&&label_JOP_MAKE_STRING,
&&label_JOP_MAKE_STRUCT,
&&label_JOP_MAKE_TABLE,
&&label_JOP_MAKE_TUPLE,
&&label_JOP_MAKE_BRACKET_TUPLE,
Remove ==, not==, and order[<,<=,>,>=]. This unifies equality and comparison checking. Before, we had separate functions and vm opcodes for comparing general values vs. for comparing numbers, where the numberic functions were polymorphic and had special cases for handling NaNs. By unfiying them, abstract types can now better integrate with other number types and behave as keys. For now, the old functions are aliased but will eventually be removed.
2019-12-28 20:57:36 +00:00
&&label_JOP_GREATER_THAN_EQUAL,
&&label_JOP_LESS_THAN_EQUAL,
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
&&label_JOP_NEXT,
And lots of optimization functionality.
2020-06-28 23:16:57 +00:00
&&label_JOP_NOT_EQUALS,
&&label_JOP_NOT_EQUALS_IMMEDIATE,
Add cancel function. This should allow better stack unwinding on a fiber that no longer needs to complete.
2020-08-22 20:35:37 +00:00
&&label_JOP_CANCEL,
GCC seemed to not fill array of computed gotos. This is expected as per the C standard, but segfaulted unless all 255 labels were added.
2019-09-22 22:50:31 +00:00
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
&&label_unknown_op,
Reenable computed gotos - they were disabled.
2019-05-24 17:54:23 +00:00
&&label_unknown_op
};
#endif
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
/* Interpreter state */
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
register Janet *stack;
register uint32_t *pc;
register JanetFunction *func;
Start working on throwing errors from async functions.
2020-08-11 12:19:34 +00:00
if (fiber->flags & JANET_FIBER_RESUME_SIGNAL) {
JanetSignal sig = (fiber->gc.flags & JANET_FIBER_STATUS_MASK) >> JANET_FIBER_STATUS_OFFSET;
fiber->gc.flags &= ~JANET_FIBER_STATUS_MASK;
fiber->flags &= ~(JANET_FIBER_RESUME_SIGNAL | JANET_FIBER_FLAG_MASK);
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.return_reg[0] = in;
Start working on throwing errors from async functions.
2020-08-11 12:19:34 +00:00
return sig;
}
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
vm_restore();
Update copyright date, fix types, remove trailing whitespace.
2019-01-06 08:23:03 +00:00
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
if (fiber->flags & JANET_FIBER_DID_LONGJUMP) {
if (janet_fiber_frame(fiber)->func == NULL) {
/* Inside a c function */
janet_fiber_popframe(fiber);
vm_restore();
}
/* Check if we were at a tail call instruction. If so, do implicit return */
if ((*pc & 0xFF) == JOP_TAILCALL) {
/* Tail call resume */
int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE;
janet_fiber_popframe(fiber);
if (entrance_frame) {
fiber->flags &= ~JANET_FIBER_FLAG_MASK;
vm_return(JANET_SIGNAL_OK, in);
}
vm_restore();
}
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
}
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
if (!(fiber->flags & JANET_FIBER_RESUME_NO_USEVAL)) stack[A] = in;
if (!(fiber->flags & JANET_FIBER_RESUME_NO_SKIP)) pc++;
uint8_t first_opcode = *pc & ((fiber->flags & JANET_FIBER_BREAKPOINT) ? 0x7F : 0xFF);
fiber->flags &= ~JANET_FIBER_FLAG_MASK;
Add some more fiber functions. Add fiber.current and fiber.lineage
2018-05-11 00:25:49 +00:00
/* Main interpreter loop. Semantically is a switch on
Update copyright date, fix types, remove trailing whitespace.
2019-01-06 08:23:03 +00:00
* (*pc & 0xFF) inside of an infinite loop. */
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
VM_START();
First commit.
2017-02-09 20:02:59 +00:00
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
VM_DEFAULT();
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
fiber->flags |= JANET_FIBER_BREAKPOINT | JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
WIP panic functionality.
2019-01-05 04:20:34 +00:00
vm_return(JANET_SIGNAL_DEBUG, janet_wrap_nil());
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_NOOP)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_pcnext();
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_ERROR)
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_return(JANET_SIGNAL_ERROR, stack[A]);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_TYPECHECK)
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_assert_types(stack[A], E);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_pcnext();
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_RETURN) {
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
Janet retval = stack[D];
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
janet_fiber_popframe(fiber);
Address #466? Do not restore pc when returning from top most fiber frame. Also add JANET_DEBUG config define for various debugging related configurations. In fiber.c, when debug is enabled we reallocate the entire stack everytime we push a frame to help uncover use after free errors.
2020-08-17 12:01:58 +00:00
if (entrance_frame) vm_return_no_restore(JANET_SIGNAL_OK, retval);
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_restore();
stack[A] = retval;
vm_checkgc_pcnext();
}
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_RETURN_NIL) {
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
Janet retval = janet_wrap_nil();
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
janet_fiber_popframe(fiber);
Address #466? Do not restore pc when returning from top most fiber frame. Also add JANET_DEBUG config define for various debugging related configurations. In fiber.c, when debug is enabled we reallocate the entire stack everytime we push a frame to help uncover use after free errors.
2020-08-17 12:01:58 +00:00
if (entrance_frame) vm_return_no_restore(JANET_SIGNAL_OK, retval);
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_restore();
stack[A] = retval;
vm_checkgc_pcnext();
}
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_ADD_IMMEDIATE)
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
vm_binop_immediate(+);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_ADD)
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
vm_binop(+);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SUBTRACT)
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
vm_binop(-);
Strip trailing whitespace from many files. Add native modules to import with module.native-path.
2018-05-20 01:16:00 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_MULTIPLY_IMMEDIATE)
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
vm_binop_immediate(*);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_MULTIPLY)
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
vm_binop(*);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_DIVIDE_IMMEDIATE)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_binop_immediate( /);
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_DIVIDE)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_binop( /);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Revert issue with removing buffer self print check.
2020-01-24 05:39:49 +00:00
VM_OP(JOP_MODULO) {
Add mod function to core. The `mod` function is a pair function with `%`, or te remainder function and is distinct from it. This is taken from common lisp.
2020-01-24 00:54:30 +00:00
Janet op1 = stack[B];
Janet op2 = stack[C];
if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {
double x1 = janet_unwrap_number(op1);
double x2 = janet_unwrap_number(op2);
double intres = x2 * floor(x1 / x2);
stack[A] = janet_wrap_number(x1 - intres);
vm_pcnext();
} else {
vm_commit();
stack[A] = janet_binop_call("mod", "rmod", op1, op2);
vm_checkgc_pcnext();
}
}
Revert issue with removing buffer self print check.
2020-01-24 05:39:49 +00:00
VM_OP(JOP_REMAINDER) {
Add mod function to core. The `mod` function is a pair function with `%`, or te remainder function and is distinct from it. This is taken from common lisp.
2020-01-24 00:54:30 +00:00
Janet op1 = stack[B];
Janet op2 = stack[C];
if (janet_checktype(op1, JANET_NUMBER) && janet_checktype(op2, JANET_NUMBER)) {
double x1 = janet_unwrap_number(op1);
double x2 = janet_unwrap_number(op2);
stack[A] = janet_wrap_number(fmod(x1, x2));
vm_pcnext();
} else {
vm_commit();
stack[A] = janet_binop_call("%", "r%", op1, op2);
vm_checkgc_pcnext();
}
}
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_BAND)
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
vm_bitop(&);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_BOR)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitop( |);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_BXOR)
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
vm_bitop(^);
Remove ValuePrint. Improve ValueToString for reference types.
2017-02-13 05:11:30 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_BNOT) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet op = stack[E];
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
vm_assert_type(op, JANET_NUMBER);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = janet_wrap_integer(~janet_unwrap_integer(op));
vm_pcnext();
First commit removing the integer number type. This should remove some complexity and unexpected behavior around numbers in general as all numbers are the same number type, IEEE 754 double precision numbers. Also update examples and tests, some of which were out of date. Some more testing may be needed for new changes to numbers.
2018-12-27 18:05:29 +00:00
}
Strip trailing whitespace from many files. Add native modules to import with module.native-path.
2018-05-20 01:16:00 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SHIFT_RIGHT_UNSIGNED)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitopu( >>);
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitopu_immediate( >>);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SHIFT_RIGHT)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitop( >>);
Compiler is coming along. Work on Slot system and general compiler strategy.
2017-12-16 06:17:53 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SHIFT_RIGHT_IMMEDIATE)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitop_immediate( >>);
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SHIFT_LEFT)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitop( <<);
First commit.
2017-02-09 20:02:59 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_SHIFT_LEFT_IMMEDIATE)
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
vm_bitop_immediate( <<);
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_MOVE_NEAR)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = stack[E];
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_MOVE_FAR)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[E] = stack[A];
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_JUMP)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
pc += DS;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(DS < 0);
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
vm_next();
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_JUMP_IF)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
if (janet_truthy(stack[A])) {
pc += ES;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(ES < 0);
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
} else {
Add test nanbox implementation. Works for 32 bit and 64 bit x86
2017-11-27 00:31:40 +00:00
pc++;
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
vm_next();
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_JUMP_IF_NOT)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
if (janet_truthy(stack[A])) {
Add test nanbox implementation. Works for 32 bit and 64 bit x86
2017-11-27 00:31:40 +00:00
pc++;
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
} else {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
pc += ES;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(ES < 0);
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
vm_next();
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
VM_OP(JOP_JUMP_IF_NIL)
if (janet_checktype(stack[A], JANET_NIL)) {
pc += ES;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(ES < 0);
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
} else {
pc++;
}
vm_next();
VM_OP(JOP_JUMP_IF_NOT_NIL)
if (janet_checktype(stack[A], JANET_NIL)) {
pc++;
} else {
pc += ES;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(ES < 0);
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
}
vm_next();
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LESS_THAN)
Remove ==, not==, and order[<,<=,>,>=]. This unifies equality and comparison checking. Before, we had separate functions and vm opcodes for comparing general values vs. for comparing numbers, where the numberic functions were polymorphic and had special cases for handling NaNs. By unfiying them, abstract types can now better integrate with other number types and behave as keys. For now, the old functions are aliased but will eventually be removed.
2019-12-28 20:57:36 +00:00
vm_compop( <);
VM_OP(JOP_LESS_THAN_EQUAL)
vm_compop( <=);
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LESS_THAN_IMMEDIATE)
Immediate instuctions will now call :compare method.
2021-02-08 17:53:25 +00:00
vm_compop_imm( <);
Add some more opcodes for comparison with numeric types.
2018-05-07 16:34:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_GREATER_THAN)
Remove ==, not==, and order[<,<=,>,>=]. This unifies equality and comparison checking. Before, we had separate functions and vm opcodes for comparing general values vs. for comparing numbers, where the numberic functions were polymorphic and had special cases for handling NaNs. By unfiying them, abstract types can now better integrate with other number types and behave as keys. For now, the old functions are aliased but will eventually be removed.
2019-12-28 20:57:36 +00:00
vm_compop( >);
VM_OP(JOP_GREATER_THAN_EQUAL)
vm_compop( >=);
First commit.
2017-02-09 20:02:59 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_GREATER_THAN_IMMEDIATE)
Immediate instuctions will now call :compare method.
2021-02-08 17:53:25 +00:00
vm_compop_imm( >);
Add some more opcodes for comparison with numeric types.
2018-05-07 16:34:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_EQUALS)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = janet_wrap_boolean(janet_equals(stack[B], stack[C]));
vm_pcnext();
First commit.
2017-02-09 20:02:59 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_EQUALS_IMMEDIATE)
Define immediate comparison instructions for non-integers. Previous, the instructions were defined only for values that fit into 32 bit integers for legacy reasons.
2021-02-08 17:41:48 +00:00
stack[A] = janet_wrap_boolean(janet_unwrap_number(stack[B]) == (double) CS);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_pcnext();
Add some more opcodes for comparison with numeric types.
2018-05-07 16:34:04 +00:00
And lots of optimization functionality.
2020-06-28 23:16:57 +00:00
VM_OP(JOP_NOT_EQUALS)
stack[A] = janet_wrap_boolean(!janet_equals(stack[B], stack[C]));
vm_pcnext();
VM_OP(JOP_NOT_EQUALS_IMMEDIATE)
Define immediate comparison instructions for non-integers. Previous, the instructions were defined only for values that fit into 32 bit integers for legacy reasons.
2021-02-08 17:41:48 +00:00
stack[A] = janet_wrap_boolean(janet_unwrap_number(stack[B]) != (double) CS);
And lots of optimization functionality.
2020-06-28 23:16:57 +00:00
vm_pcnext();
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_COMPARE)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = janet_wrap_integer(janet_compare(stack[B], stack[C]));
vm_pcnext();
First commit.
2017-02-09 20:02:59 +00:00
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
VM_OP(JOP_NEXT)
Add a vm_commit before JOP_NEXT.
2020-08-14 03:28:50 +00:00
vm_commit();
Allow iterating over fibers with each and similar.
2021-01-03 22:17:36 +00:00
{
Janet temp = janet_next_impl(stack[B], stack[C], 1);
vm_restore();
stack[A] = temp;
}
Extend power of the each form This changes the implementation of the `next` function which is now used to implement each. This let's us iterate over more types, not just tables and structs.
2020-01-18 23:55:07 +00:00
vm_pcnext();
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LOAD_NIL)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_nil();
vm_pcnext();
Compiler is coming along. Work on Slot system and general compiler strategy.
2017-12-16 06:17:53 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LOAD_TRUE)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_true();
vm_pcnext();
Add 64 bit signed integers as a basic type. Will enable more native bitwise operations and c integration at the expense of complicating arithmetic.
2017-04-24 20:02:54 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LOAD_FALSE)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_false();
vm_pcnext();
Remove ValuePrint. Improve ValueToString for reference types.
2017-02-13 05:11:30 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LOAD_INTEGER)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = janet_wrap_integer(ES);
vm_pcnext();
Remove ValuePrint. Improve ValueToString for reference types.
2017-02-13 05:11:30 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_LOAD_CONSTANT) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
int32_t cindex = (int32_t)E;
vm_assert(cindex < func->def->constants_length, "invalid constant");
stack[A] = func->def->constants[cindex];
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
Compiler is coming along. Work on Slot system and general compiler strategy.
2017-12-16 06:17:53 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LOAD_SELF)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_function(func);
vm_pcnext();
Redo function call bytecode interface to be simpler and allow for an apply like structure in the language
2017-04-19 13:02:12 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_LOAD_UPVALUE) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
int32_t eindex = B;
int32_t vindex = C;
Rename to janet
2018-09-06 02:18:42 +00:00
JanetFuncEnv *env;
Change fiber signal model to add user signals. This should allow easier implementations of eventloops, threadpools, or custom data flows with fibers.
2018-05-17 02:09:36 +00:00
vm_assert(func->def->environments_length > eindex, "invalid upvalue environment");
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
env = func->envs[eindex];
Change fiber signal model to add user signals. This should allow easier implementations of eventloops, threadpools, or custom data flows with fibers.
2018-05-17 02:09:36 +00:00
vm_assert(env->length > vindex, "invalid upvalue index");
Move funcenv verification to runtime. Lazy verification makes it easier to not leave funcenvs in an invalid state, as well as be more precise with the validation. We needed to verify the FuncEnvs actually pointed to a stack frame if they were of the "on-stack" variant. There was some minor checking before, but it was not enough to prevent func envs from pointing to memory that was off of the fiber stack, overlapping stack frames, etc.
2020-04-06 15:58:47 +00:00
vm_assert(janet_env_valid(env), "invalid upvalue environment");
if (env->offset > 0) {
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
/* On stack */
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = env->as.fiber->data[env->offset + vindex];
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
} else {
/* Off stack */
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = env->as.values[vindex];
Add test nanbox implementation. Works for 32 bit and 64 bit x86
2017-11-27 00:31:40 +00:00
}
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
Redo function call bytecode interface to be simpler and allow for an apply like structure in the language
2017-04-19 13:02:12 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_SET_UPVALUE) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
int32_t eindex = B;
int32_t vindex = C;
Rename to janet
2018-09-06 02:18:42 +00:00
JanetFuncEnv *env;
Change fiber signal model to add user signals. This should allow easier implementations of eventloops, threadpools, or custom data flows with fibers.
2018-05-17 02:09:36 +00:00
vm_assert(func->def->environments_length > eindex, "invalid upvalue environment");
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
env = func->envs[eindex];
Change fiber signal model to add user signals. This should allow easier implementations of eventloops, threadpools, or custom data flows with fibers.
2018-05-17 02:09:36 +00:00
vm_assert(env->length > vindex, "invalid upvalue index");
Move funcenv verification to runtime. Lazy verification makes it easier to not leave funcenvs in an invalid state, as well as be more precise with the validation. We needed to verify the FuncEnvs actually pointed to a stack frame if they were of the "on-stack" variant. There was some minor checking before, but it was not enough to prevent func envs from pointing to memory that was off of the fiber stack, overlapping stack frames, etc.
2020-04-06 15:58:47 +00:00
vm_assert(janet_env_valid(env), "invalid upvalue environment");
if (env->offset > 0) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
env->as.fiber->data[env->offset + vindex] = stack[A];
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
} else {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
env->as.values[vindex] = stack[A];
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_CLOSURE) {
Rename to janet
2018-09-06 02:18:42 +00:00
JanetFuncDef *fd;
JanetFunction *fn;
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
int32_t elen;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
int32_t defindex = (int32_t)E;
vm_assert(defindex < func->def->defs_length, "invalid funcdef");
fd = func->def->defs[defindex];
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
elen = fd->environments_length;
Try to remove potential overflow bugs. Also make integer to size_t casts explicit rather than relying on int32_t * sizeof(x) = size_t. This is kind of a personal preference for this problem.
2020-01-03 04:02:57 +00:00
fn = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction) + ((size_t) elen * sizeof(JanetFuncEnv *)));
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
fn->def = fd;
Update func env representation to not store envs in function objects.
2018-02-12 21:43:59 +00:00
{
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
int32_t i;
for (i = 0; i < elen; ++i) {
int32_t inherit = fd->environments[i];
if (inherit == -1) {
Rename to janet
2018-09-06 02:18:42 +00:00
JanetStackFrame *frame = janet_stack_frame(stack);
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
if (!frame->env) {
/* Lazy capture of current stack frame */
Rename to janet
2018-09-06 02:18:42 +00:00
JanetFuncEnv *env = janet_gcalloc(JANET_MEMORY_FUNCENV, sizeof(JanetFuncEnv));
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
env->offset = fiber->frame;
env->as.fiber = fiber;
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
env->length = func->def->slotcount;
frame->env = env;
Update func env representation to not store envs in function objects.
2018-02-12 21:43:59 +00:00
}
Use flatter representation for function and environments.
2018-02-13 21:14:55 +00:00
fn->envs[i] = frame->env;
} else {
fn->envs[i] = func->envs[inherit];
Update func env representation to not store envs in function objects.
2018-02-12 21:43:59 +00:00
}
}
}
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[A] = janet_wrap_function(fn);
vm_checkgc_pcnext();
Strip trailing whitespace from many files. Add native modules to import with module.native-path.
2018-05-20 01:16:00 +00:00
}
Redo function call bytecode interface to be simpler and allow for an apply like structure in the language
2017-04-19 13:02:12 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_PUSH)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
janet_fiber_push(fiber, stack[D]);
stack = fiber->data + fiber->frame;
vm_checkgc_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_PUSH_2)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
janet_fiber_push2(fiber, stack[A], stack[E]);
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
stack = fiber->data + fiber->frame;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_PUSH_3)
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
janet_fiber_push3(fiber, stack[A], stack[B], stack[C]);
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
stack = fiber->data + fiber->frame;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_PUSH_ARRAY) {
Rename to janet
2018-09-06 02:18:42 +00:00
const Janet *vals;
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
int32_t len;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
if (janet_indexed_view(stack[D], &vals, &len)) {
Rename to janet
2018-09-06 02:18:42 +00:00
janet_fiber_pushn(fiber, vals, len);
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
} else {
Add edefer. Also improve error messages from vm internal errors. (Show bad value, not its type).
2020-04-14 01:24:11 +00:00
janet_panicf("expected %T, got %v", JANET_TFLAG_INDEXED, stack[D]);
Fix some vararg behavior in tail calls.
2018-01-12 18:54:37 +00:00
}
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
stack = fiber->data + fiber->frame;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_CALL) {
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(1);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet callee = stack[E];
WIP panic functionality.
2019-01-05 04:20:34 +00:00
if (fiber->stacktop > fiber->maxstack) {
Add configurable stack overflow to prevent infinite recursion without waiting for out of memory.
2018-02-12 16:49:10 +00:00
vm_throw("stack overflow");
}
Update examples, add method like semantics to calling keywords.
2019-01-07 19:47:47 +00:00
if (janet_checktype(callee, JANET_KEYWORD)) {
vm_commit();
Improve error message on bad method calls.
2019-08-06 00:06:58 +00:00
callee = resolve_method(callee, fiber);
Update examples, add method like semantics to calling keywords.
2019-01-07 19:47:47 +00:00
}
Rename to janet
2018-09-06 02:18:42 +00:00
if (janet_checktype(callee, JANET_FUNCTION)) {
func = janet_unwrap_function(callee);
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
if (func->gc.flags & JANET_FUNCFLAG_TRACE) {
Fix broken trace functionality. This was an older regression that caused trace to emit garbage output in most cases.
2020-06-14 16:58:20 +00:00
vm_do_trace(func, fiber->stacktop - fiber->stackstart, fiber->data + fiber->stackstart);
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
}
Rename to janet
2018-09-06 02:18:42 +00:00
janet_stack_frame(stack)->pc = pc;
WIP panic functionality.
2019-01-05 04:20:34 +00:00
if (janet_fiber_funcframe(fiber, func)) {
int32_t n = fiber->stacktop - fiber->stackstart;
janet_panicf("%v called with %d argument%s, expected %d",
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
callee, n, n == 1 ? "" : "s", func->def->arity);
WIP panic functionality.
2019-01-05 04:20:34 +00:00
}
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
stack = fiber->data + fiber->frame;
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
pc = func->def->bytecode;
vm_checkgc_next();
Rename to janet
2018-09-06 02:18:42 +00:00
} else if (janet_checktype(callee, JANET_CFUNCTION)) {
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_commit();
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
int32_t argc = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
janet_fiber_cframe(fiber, janet_unwrap_cfunction(callee));
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
Janet ret = janet_unwrap_cfunction(callee)(argc, fiber->data + fiber->frame);
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
janet_fiber_popframe(fiber);
stack = fiber->data + fiber->frame;
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
stack[A] = ret;
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
vm_checkgc_pcnext();
Allow calling keywords and symbols as functions to look themselves up in a data structure. Allow calling a data structure to look up the argument.
2019-01-04 03:46:25 +00:00
} else {
WIP panic functionality.
2019-01-05 04:20:34 +00:00
vm_commit();
stack[A] = call_nonfn(fiber, callee);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_pcnext();
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
}
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_TAILCALL) {
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(1);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Janet callee = stack[D];
Fix some stack overflow bugs.
2019-08-19 05:19:51 +00:00
if (fiber->stacktop > fiber->maxstack) {
vm_throw("stack overflow");
}
Update examples, add method like semantics to calling keywords.
2019-01-07 19:47:47 +00:00
if (janet_checktype(callee, JANET_KEYWORD)) {
vm_commit();
Improve error message on bad method calls.
2019-08-06 00:06:58 +00:00
callee = resolve_method(callee, fiber);
Update examples, add method like semantics to calling keywords.
2019-01-07 19:47:47 +00:00
}
Rename to janet
2018-09-06 02:18:42 +00:00
if (janet_checktype(callee, JANET_FUNCTION)) {
func = janet_unwrap_function(callee);
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
if (func->gc.flags & JANET_FUNCFLAG_TRACE) {
Fix broken trace functionality. This was an older regression that caused trace to emit garbage output in most cases.
2020-06-14 16:58:20 +00:00
vm_do_trace(func, fiber->stacktop - fiber->stackstart, fiber->data + fiber->stackstart);
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
}
WIP panic functionality.
2019-01-05 04:20:34 +00:00
if (janet_fiber_funcframe_tail(fiber, func)) {
Remove check for function calls to enable all types, even nil. Now any value can be called as a function, usually looking itself up in an associative data structure.
2019-01-06 16:56:40 +00:00
janet_stack_frame(fiber->data + fiber->frame)->pc = pc;
WIP panic functionality.
2019-01-05 04:20:34 +00:00
int32_t n = fiber->stacktop - fiber->stackstart;
janet_panicf("%v called with %d argument%s, expected %d",
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
callee, n, n == 1 ? "" : "s", func->def->arity);
WIP panic functionality.
2019-01-05 04:20:34 +00:00
}
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
stack = fiber->data + fiber->frame;
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
pc = func->def->bytecode;
vm_checkgc_next();
Allow calling keywords and symbols as functions to look themselves up in a data structure. Allow calling a data structure to look up the argument.
2019-01-04 03:46:25 +00:00
} else {
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
Janet retreg;
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
int entrance_frame = janet_stack_frame(stack)->flags & JANET_STACKFRAME_ENTRANCE;
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
vm_commit();
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
if (janet_checktype(callee, JANET_CFUNCTION)) {
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
int32_t argc = fiber->stacktop - fiber->stackstart;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
janet_fiber_cframe(fiber, janet_unwrap_cfunction(callee));
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
retreg = janet_unwrap_cfunction(callee)(argc, fiber->data + fiber->frame);
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
janet_fiber_popframe(fiber);
} else {
retreg = call_nonfn(fiber, callee);
}
janet_fiber_popframe(fiber);
Address #466? Do not restore pc when returning from top most fiber frame. Also add JANET_DEBUG config define for various debugging related configurations. In fiber.c, when debug is enabled we reallocate the entire stack everytime we push a frame to help uncover use after free errors.
2020-08-17 12:01:58 +00:00
if (entrance_frame) {
vm_return_no_restore(JANET_SIGNAL_OK, retreg);
}
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_restore();
stack[A] = retreg;
vm_checkgc_pcnext();
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
}
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
Use fewer special forms in c compiler. This should make the self hosted compiler easier to make. The C version of the compiler does not need to be efficient.
2017-04-12 14:31:50 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_RESUME) {
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
Janet retreg;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
vm_maybe_auto_suspend(1);
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
vm_assert_type(stack[B], JANET_FIBER);
JanetFiber *child = janet_unwrap_fiber(stack[B]);
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
if (janet_check_can_resume(child, &retreg, 0)) {
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
vm_commit();
janet_panicv(retreg);
}
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
fiber->child = child;
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
JanetSignal sig = janet_continue_no_check(child, stack[C], &retreg);
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) {
WIP panic functionality.
2019-01-05 04:20:34 +00:00
vm_return(sig, retreg);
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
}
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
fiber->child = NULL;
Fix undefined behavior bug with errors. janet_vm_return_reg should only be set when janet_continue is called. Otherwise, a panic may dump it's error message in the wrong place, resulting in undefined behavior (often showing the last return value or worse, segfaulting).
2019-04-11 03:29:40 +00:00
stack = fiber->data + fiber->frame;
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
stack[A] = retreg;
vm_checkgc_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
}
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_SIGNAL) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
int32_t s = C;
Rename to janet
2018-09-06 02:18:42 +00:00
if (s > JANET_SIGNAL_USER9) s = JANET_SIGNAL_USER9;
Change fiber signal model to add user signals. This should allow easier implementations of eventloops, threadpools, or custom data flows with fibers.
2018-05-17 02:09:36 +00:00
if (s < 0) s = 0;
WIP panic functionality.
2019-01-05 04:20:34 +00:00
vm_return(s, stack[B]);
Switch to assymetric coroutines instead of symmetric.
2018-03-11 19:35:23 +00:00
}
Add propagate function and opcode This allows better stacktraces when manually intercepting signals to clean up resources. Also allows functionality from Common Lisp's unwind-protect, such as calling cleanup code while unwindinding the stack, restarting on certain signals, and just in general having more control over signal and signal propagation. Also fix a bug encountered while implementing with-resource in the compiler. Desturcturing arguments that were not the last argument would often result in bad code generation, as slots used to destructure the earlier arguments would invalidate the later parameters. This is fixed by allocating all named parameters before doing any destructuring.
2019-06-24 16:44:13 +00:00
VM_OP(JOP_PROPAGATE) {
Janet fv = stack[C];
vm_assert_type(fv, JANET_FIBER);
JanetFiber *f = janet_unwrap_fiber(fv);
Address some issues found in lgtm Caught a few potentially issues with overflows, as well as use of unsafe function localtime.
2019-10-11 03:59:43 +00:00
JanetFiberStatus sub_status = janet_fiber_status(f);
if (sub_status > JANET_STATUS_USER9) {
Lots of work on improving debugging. doc macro can take no arguments and print out all bindings. Fix an issues with the vm skipping over a breakpoint in some situations. Add examples/debugger.janet for proof of concept debugger.
2019-11-24 23:45:53 +00:00
vm_commit();
janet_panicf("cannot propagate from fiber with status :%s",
janet_status_names[sub_status]);
Add propagate function and opcode This allows better stacktraces when manually intercepting signals to clean up resources. Also allows functionality from Common Lisp's unwind-protect, such as calling cleanup code while unwindinding the stack, restarting on certain signals, and just in general having more control over signal and signal propagation. Also fix a bug encountered while implementing with-resource in the compiler. Desturcturing arguments that were not the last argument would often result in bad code generation, as slots used to destructure the earlier arguments would invalidate the later parameters. This is fixed by allocating all named parameters before doing any destructuring.
2019-06-24 16:44:13 +00:00
}
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
fiber->child = f;
Revert change to propagate op code.
2021-01-17 21:33:42 +00:00
vm_return((int) sub_status, stack[B]);
Add propagate function and opcode This allows better stacktraces when manually intercepting signals to clean up resources. Also allows functionality from Common Lisp's unwind-protect, such as calling cleanup code while unwindinding the stack, restarting on certain signals, and just in general having more control over signal and signal propagation. Also fix a bug encountered while implementing with-resource in the compiler. Desturcturing arguments that were not the last argument would often result in bad code generation, as slots used to destructure the earlier arguments would invalidate the later parameters. This is fixed by allocating all named parameters before doing any destructuring.
2019-06-24 16:44:13 +00:00
}
Add cancel function. This should allow better stack unwinding on a fiber that no longer needs to complete.
2020-08-22 20:35:37 +00:00
VM_OP(JOP_CANCEL) {
Janet retreg;
vm_assert_type(stack[B], JANET_FIBER);
JanetFiber *child = janet_unwrap_fiber(stack[B]);
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
if (janet_check_can_resume(child, &retreg, 1)) {
Add cancel function. This should allow better stack unwinding on a fiber that no longer needs to complete.
2020-08-22 20:35:37 +00:00
vm_commit();
janet_panicv(retreg);
}
fiber->child = child;
JanetSignal sig = janet_continue_signal(child, stack[C], &retreg, JANET_SIGNAL_ERROR);
if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) {
vm_return(sig, retreg);
}
fiber->child = NULL;
stack = fiber->data + fiber->frame;
stack[A] = retreg;
vm_checkgc_pcnext();
}
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_PUT)
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
vm_commit();
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
janet_put(stack[A], stack[B], stack[C]);
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_checkgc_pcnext();
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_PUT_INDEX)
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
vm_commit();
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
janet_putindex(stack[A], C, stack[B]);
Add ability to Janet signal from C functions. While C functions are not re-entrant, signaling from a C function can be used to implement async returns. When resuming a fiber that signalled from within a C function, the fiber is started after the instruction that emitted the signal. The resume argument is used as the return result from the c function.
2020-01-10 23:25:10 +00:00
fiber->flags &= ~JANET_FIBER_RESUME_NO_USEVAL;
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_checkgc_pcnext();
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Rename 'get' opcode to 'in', add new 'get' opcode. This makes the names of the opcodes match their implied functionality. We also rename the C functions to match the opcodes and source level functionality.
2019-12-03 03:15:08 +00:00
VM_OP(JOP_IN)
vm_commit();
stack[A] = janet_in(stack[B], stack[C]);
vm_pcnext();
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_GET)
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
vm_commit();
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
stack[A] = janet_get(stack[B], stack[C]);
vm_pcnext();
Work on interpreter. adding more opcodes and syscalls.
2017-11-25 04:17:04 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_GET_INDEX)
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
vm_commit();
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
stack[A] = janet_getindex(stack[B], C);
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Rename to janet
2018-09-06 02:18:42 +00:00
VM_OP(JOP_LENGTH)
Update C API to use friendlier functions rather than macros. Error handling is implemented with setjmp/longjmp so code can be more concise. This required a very large but straight forward refactor for all of the libraries.
2019-01-06 01:09:03 +00:00
vm_commit();
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
stack[A] = janet_lengthv(stack[E]);
Better working panic implementation and more cleanup in main vm loop.
2019-01-05 05:33:20 +00:00
vm_pcnext();
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_MAKE_ARRAY) {
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
int32_t count = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
Janet *mem = fiber->data + fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_array(janet_array_n(mem, count));
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
fiber->stacktop = fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
}
Quasiquoting bracketed tuples.
2019-03-31 18:14:25 +00:00
VM_OP(JOP_MAKE_TUPLE)
/* fallthrough */
VM_OP(JOP_MAKE_BRACKET_TUPLE) {
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
int32_t count = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
Janet *mem = fiber->data + fiber->stackstart;
Quasiquoting bracketed tuples.
2019-03-31 18:14:25 +00:00
const Janet *tup = janet_tuple_n(mem, count);
if (opcode == JOP_MAKE_BRACKET_TUPLE)
janet_tuple_flag(tup) |= JANET_TUPLE_FLAG_BRACKETCTOR;
stack[D] = janet_wrap_tuple(tup);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
fiber->stacktop = fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
}
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_MAKE_TABLE) {
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
int32_t count = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
Janet *mem = fiber->data + fiber->stackstart;
Lots of work on improving debugging. doc macro can take no arguments and print out all bindings. Fix an issues with the vm skipping over a breakpoint in some situations. Add examples/debugger.janet for proof of concept debugger.
2019-11-24 23:45:53 +00:00
if (count & 1) {
vm_commit();
janet_panicf("expected even number of arguments to table constructor, got %d", count);
}
Rename to janet
2018-09-06 02:18:42 +00:00
JanetTable *table = janet_table(count / 2);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
for (int32_t i = 0; i < count; i += 2)
Rename to janet
2018-09-06 02:18:42 +00:00
janet_table_put(table, mem[i], mem[i + 1]);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_table(table);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
fiber->stacktop = fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
}
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_MAKE_STRUCT) {
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
int32_t count = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
Janet *mem = fiber->data + fiber->stackstart;
Lots of work on improving debugging. doc macro can take no arguments and print out all bindings. Fix an issues with the vm skipping over a breakpoint in some situations. Add examples/debugger.janet for proof of concept debugger.
2019-11-24 23:45:53 +00:00
if (count & 1) {
vm_commit();
janet_panicf("expected even number of arguments to struct constructor, got %d", count);
}
Rename to janet
2018-09-06 02:18:42 +00:00
JanetKV *st = janet_struct_begin(count / 2);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
for (int32_t i = 0; i < count; i += 2)
Rename to janet
2018-09-06 02:18:42 +00:00
janet_struct_put(st, mem[i], mem[i + 1]);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_struct(janet_struct_end(st));
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
fiber->stacktop = fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
}
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_MAKE_STRING) {
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
int32_t count = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
Janet *mem = fiber->data + fiber->stackstart;
JanetBuffer buffer;
janet_buffer_init(&buffer, 10 * count);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
for (int32_t i = 0; i < count; i++)
Rename to janet
2018-09-06 02:18:42 +00:00
janet_to_string_b(&buffer, mem[i]);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_stringv(buffer.data, buffer.count);
Rename to janet
2018-09-06 02:18:42 +00:00
janet_buffer_deinit(&buffer);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
fiber->stacktop = fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
}
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
VM_OP(JOP_MAKE_BUFFER) {
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
int32_t count = fiber->stacktop - fiber->stackstart;
Rename to janet
2018-09-06 02:18:42 +00:00
Janet *mem = fiber->data + fiber->stackstart;
JanetBuffer *buffer = janet_buffer(10 * count);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
for (int32_t i = 0; i < count; i++)
Rename to janet
2018-09-06 02:18:42 +00:00
janet_to_string_b(buffer, mem[i]);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
stack[D] = janet_wrap_buffer(buffer);
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
fiber->stacktop = fiber->stackstart;
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
vm_checkgc_pcnext();
Major refactor. Move files around, merge compiler into core and other changes, work on inlining many c functions.
2018-07-04 03:07:35 +00:00
}
Use computed goto in vm for GCC
2018-02-01 02:40:19 +00:00
VM_END()
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
}
Add debug/step to single step a fiber. Very useful for implementing debuggers.
2019-11-26 00:14:34 +00:00
/*
* Execute a single instruction in the fiber. Does this by inspecting
* the fiber, setting a breakpoint at the next instruction, executing, and
* reseting breakpoints to how they were prior. Yes, it's a bit hacky.
*/
JanetSignal janet_step(JanetFiber *fiber, Janet in, Janet *out) {
Fix up debug/step and janet_step. Also allow debugging on all signals, including errors. This is gated behind (setdyn :debug true) in the repl.
2019-11-26 02:00:13 +00:00
/* No finished or currently alive fibers. */
JanetFiberStatus status = janet_fiber_status(fiber);
if (status == JANET_STATUS_ALIVE ||
status == JANET_STATUS_DEAD ||
status == JANET_STATUS_ERROR) {
janet_panicf("cannot step fiber with status :%s", janet_status_names[status]);
}
/* Get PC for setting breakpoints */
uint32_t *pc = janet_stack_frame(fiber->data + fiber->frame)->pc;
Add debug/step to single step a fiber. Very useful for implementing debuggers.
2019-11-26 00:14:34 +00:00
/* Check current opcode (sans debug flag). This tells us where the next or next two candidate
* instructions will be. Usually it's the next instruction in memory,
* but for branching instructions it is also the target of the branch. */
Fix some example issue and warnings under -Os.
2019-12-08 18:39:37 +00:00
uint32_t *nexta = NULL, *nextb = NULL, olda = 0, oldb = 0;
Add debug/step to single step a fiber. Very useful for implementing debuggers.
2019-11-26 00:14:34 +00:00
/* Set temporary breakpoints */
switch (*pc & 0x7F) {
default:
nexta = pc + 1;
break;
/* These we just ignore for now. Supporting them means
* we could step into and out of functions (including JOP_CALL). */
case JOP_RETURN_NIL:
case JOP_RETURN:
case JOP_ERROR:
case JOP_TAILCALL:
break;
case JOP_JUMP:
nexta = pc + DS;
break;
case JOP_JUMP_IF:
case JOP_JUMP_IF_NOT:
nexta = pc + 1;
nextb = pc + ES;
break;
}
if (nexta) {
olda = *nexta;
*nexta |= 0x80;
}
if (nextb) {
oldb = *nextb;
*nextb |= 0x80;
}
/* Go */
Fix up debug/step and janet_step. Also allow debugging on all signals, including errors. This is gated behind (setdyn :debug true) in the repl.
2019-11-26 02:00:13 +00:00
JanetSignal signal = janet_continue(fiber, in, out);
Add debug/step to single step a fiber. Very useful for implementing debuggers.
2019-11-26 00:14:34 +00:00
/* Restore */
if (nexta) *nexta = olda;
if (nextb) *nextb = oldb;
return signal;
}
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
/* Check entry conditions */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (!janet_vm.fiber)
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
janet_panic("janet_call failed because there is no current fiber");
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (janet_vm.stackn >= JANET_RECURSION_GUARD)
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
janet_panic("C stack recursed too deeply");
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
Remove file/fileno and file/fdopen. Also fully add call function pointer to abstract types, including in methods, etc.
2020-01-23 15:01:33 +00:00
/* Tracing */
if (fun->gc.flags & JANET_FUNCFLAG_TRACE) {
vm_do_trace(fun, argc, argv);
}
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
/* Push frame */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_fiber_pushn(janet_vm.fiber, argv, argc);
if (janet_fiber_funcframe(janet_vm.fiber, fun)) {
Improve error message from janet_call. List expected arity in error messages.
2021-02-06 00:01:52 +00:00
int32_t min = fun->def->min_arity;
int32_t max = fun->def->max_arity;
Janet funv = janet_wrap_function(fun);
if (min == max && min != argc)
janet_panicf("arity mismatch in %v, expected %d, got %d", funv, min, argc);
if (min >= 0 && argc < min)
janet_panicf("arity mismatch in %v, expected at least %d, got %d", funv, min, argc);
janet_panicf("arity mismatch in %v, expected at most %d, got %d", funv, max, argc);
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
}
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_fiber_frame(janet_vm.fiber)->flags |= JANET_STACKFRAME_ENTRANCE;
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
/* Set up */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
int32_t oldn = janet_vm.stackn++;
Add highlight.janet tool which can highlight janet source code and output html or terminal escaped code. Also made re entrant calls into the vm provide better error messages.
2019-01-17 23:10:04 +00:00
int handle = janet_gclock();
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
/* Run vm */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
JanetSignal signal = run_vm(janet_vm.fiber, janet_wrap_nil());
Add highlight.janet tool which can highlight janet source code and output html or terminal escaped code. Also made re entrant calls into the vm provide better error messages.
2019-01-17 23:10:04 +00:00
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
/* Teardown */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.stackn = oldn;
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
janet_gcunlock(handle);
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
Working TCP echo server and client. Required a few changes to APIs, namely janet_root_fiber() to get topmost fiber that is active in the current scheduler. This is distinct from janet_current_fiber(), which gets the bottom most fiber in the fiber stack - it might have a parent, and so cannot be reliably resumed. This is the kind of situation that makes symmetric coroutines more attractive.
2020-02-10 01:04:34 +00:00
if (signal != JANET_SIGNAL_OK) {
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_panicv(*janet_vm.return_reg);
Working TCP echo server and client. Required a few changes to APIs, namely janet_root_fiber() to get topmost fiber that is active in the current scheduler. This is distinct from janet_current_fiber(), which gets the bottom most fiber in the fiber stack - it might have a parent, and so cannot be reliably resumed. This is the kind of situation that makes symmetric coroutines more attractive.
2020-02-10 01:04:34 +00:00
}
Experimental changes to janet_call to make it faster. Remove setjmp and fiber creationg from janet_call. This adds the constraint to janet_call can only be called when there is already a current fiber.
2019-02-01 16:56:25 +00:00
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
return *janet_vm.return_reg;
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
}
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out, int is_cancel) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
/* Check conditions */
Restore old status logic - (status checks in run_vm should be using the previous status, not the current which is always JANET_STATUS_ALIVE)
2019-01-08 18:42:29 +00:00
JanetFiberStatus old_status = janet_fiber_status(fiber);
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (janet_vm.stackn >= JANET_RECURSION_GUARD) {
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
janet_fiber_set_status(fiber, JANET_STATUS_ERROR);
*out = janet_cstringv("C stack recursed too deeply");
return JANET_SIGNAL_ERROR;
}
Mark a fiber as a root fiber during scheduling, not resumption. This is more intuitive and avoids the possibilty of strange code to resume or cancel a fiber after it was scheduled but before it was entered for the first time.
2022-02-10 23:40:08 +00:00
/* If a "task" fiber is trying to be used as a normal fiber, detect that. See bug #920.
* Fibers must be marked as root fibers manually, or by the ev scheduler. */
if (janet_vm.fiber != NULL && (fiber->gc.flags & JANET_FIBER_FLAG_ROOT)) {
MSVC unwilling to concatenate strings across preprocessor directives.
2022-02-10 04:36:07 +00:00
#ifdef JANET_EV
*out = janet_cstringv(is_cancel
? "cannot cancel root fiber, use ev/cancel"
: "cannot resume root fiber, use ev/go");
#else
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
*out = janet_cstringv(is_cancel
? "cannot cancel root fiber"
MSVC unwilling to concatenate strings across preprocessor directives.
2022-02-10 04:36:07 +00:00
: "cannot resume root fiber");
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
#endif
return JANET_SIGNAL_ERROR;
}
Restore old status logic - (status checks in run_vm should be using the previous status, not the current which is always JANET_STATUS_ALIVE)
2019-01-08 18:42:29 +00:00
if (old_status == JANET_STATUS_ALIVE ||
old_status == JANET_STATUS_DEAD ||
Add `signal` and `fiber/can-resume?`. These additions, along with the change that user signals 0-4 cannot be resumed, allow delimited continuation semantics, while repsecting existing forms like `defer`, `with`, `with-vars`, etc.
2020-02-23 19:31:27 +00:00
(old_status >= JANET_STATUS_USER0 && old_status <= JANET_STATUS_USER4) ||
Restore old status logic - (status checks in run_vm should be using the previous status, not the current which is always JANET_STATUS_ALIVE)
2019-01-08 18:42:29 +00:00
old_status == JANET_STATUS_ERROR) {
Lots of work on improving debugging. doc macro can take no arguments and print out all bindings. Fix an issues with the vm skipping over a breakpoint in some situations. Add examples/debugger.janet for proof of concept debugger.
2019-11-24 23:45:53 +00:00
const uint8_t *str = janet_formatc("cannot resume fiber with status :%s",
janet_status_names[old_status]);
*out = janet_wrap_string(str);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
return JANET_SIGNAL_ERROR;
}
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
return JANET_SIGNAL_OK;
}
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
void janet_try_init(JanetTryState *state) {
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
state->stackn = janet_vm.stackn++;
state->gc_handle = janet_vm.gc_suspend;
state->vm_fiber = janet_vm.fiber;
state->vm_jmp_buf = janet_vm.signal_buf;
state->vm_return_reg = janet_vm.return_reg;
janet_vm.return_reg = &(state->payload);
janet_vm.signal_buf = &(state->buf);
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
}
void janet_restore(JanetTryState *state) {
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.stackn = state->stackn;
janet_vm.gc_suspend = state->gc_handle;
janet_vm.fiber = state->vm_fiber;
janet_vm.signal_buf = state->vm_jmp_buf;
janet_vm.return_reg = state->vm_return_reg;
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
}
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out) {
JanetFiberStatus old_status = janet_fiber_status(fiber);
Begin clean up of vm.c Replace the oparg macro with 5 named virtual registers, combine pc++ with vm_next() macro to be more terse, and move setup and teardown logic of janet_continue into a separate function. These changes are preparation for using setjmp/longjmp to do error handling in the VM. Introducing longjmp for error handling in the VM would allow it to be used in the C API, which could result in simpler, more compact code.
2019-01-05 01:08:43 +00:00
Add timeouts to net functions. Further debugging of the general timeout system, as well as having a single fiber wait on multiple state machines (select).
2020-07-20 00:41:12 +00:00
#ifdef JANET_EV
Merge branch 'master' into ev
2020-08-16 22:29:57 +00:00
janet_fiber_did_resume(fiber);
Add timeouts to net functions. Further debugging of the general timeout system, as well as having a single fiber wait on multiple state machines (select).
2020-07-20 00:41:12 +00:00
#endif
Allow iterating over fibers with each and similar.
2021-01-03 22:17:36 +00:00
/* Clear last value */
fiber->last_value = janet_wrap_nil();
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
/* Continue child fiber if it exists */
if (fiber->child) {
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (janet_vm.root_fiber == NULL) janet_vm.root_fiber = fiber;
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
JanetFiber *child = fiber->child;
Allow iterating over fibers with each and similar.
2021-01-03 22:17:36 +00:00
uint32_t instr = (janet_stack_frame(fiber->data + fiber->frame)->pc)[0];
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.stackn++;
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
JanetSignal sig = janet_continue(child, in, &in);
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.stackn--;
if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL;
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
if (sig != JANET_SIGNAL_OK && !(child->flags & (1 << sig))) {
*out = in;
Fix #638 - update fiber status in certain cases. This fixes a regression from changes to janet_try. In some cases, we would not update the status of a fiber when signaling, which left the fiber's status as whatever it had previously. This could lead to strange control flow issues.
2021-02-20 16:48:10 +00:00
janet_fiber_set_status(fiber, sig);
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
return sig;
}
Allow iterating over fibers with each and similar.
2021-01-03 22:17:36 +00:00
/* Check if we need any special handling for certain opcodes */
switch (instr & 0x7F) {
default:
break;
case JOP_NEXT: {
if (sig == JANET_SIGNAL_OK ||
sig == JANET_SIGNAL_ERROR ||
sig == JANET_SIGNAL_USER0 ||
sig == JANET_SIGNAL_USER1 ||
sig == JANET_SIGNAL_USER2 ||
sig == JANET_SIGNAL_USER3 ||
sig == JANET_SIGNAL_USER4) {
in = janet_wrap_nil();
} else {
in = janet_wrap_integer(0);
}
break;
}
}
More cleanup in vm.c
2019-01-05 02:15:37 +00:00
fiber->child = NULL;
}
Allow function that takes 1 argument to fiber/new. This allows reuse of closures when creating many fibers.
2020-02-23 20:47:29 +00:00
/* Handle new fibers being resumed with a non-nil value */
if (old_status == JANET_STATUS_NEW && !janet_checktype(in, JANET_NIL)) {
Janet *stack = fiber->data + fiber->frame;
JanetFunction *func = janet_stack_frame(stack)->func;
if (func) {
if (func->def->arity > 0) {
stack[0] = in;
} else if (func->def->flags & JANET_FUNCDEF_FLAG_VARARG) {
stack[0] = janet_wrap_tuple(janet_tuple_n(&in, 1));
}
}
}
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
/* Save global state */
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
JanetTryState tstate;
Fix #638 - update fiber status in certain cases. This fixes a regression from changes to janet_try. In some cases, we would not update the status of a fiber when signaling, which left the fiber's status as whatever it had previously. This could lead to strange control flow issues.
2021-02-20 16:48:10 +00:00
JanetSignal sig = janet_try(&tstate);
if (!sig) {
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
/* Normal setup */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (janet_vm.root_fiber == NULL) janet_vm.root_fiber = fiber;
janet_vm.fiber = fiber;
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
janet_fiber_set_status(fiber, JANET_STATUS_ALIVE);
Fix #638 - update fiber status in certain cases. This fixes a regression from changes to janet_try. In some cases, we would not update the status of a fiber when signaling, which left the fiber's status as whatever it had previously. This could lead to strange control flow issues.
2021-02-20 16:48:10 +00:00
sig = run_vm(fiber, in);
WIP panic functionality.
2019-01-05 04:20:34 +00:00
}
Redo calling convetion for more code reuse. Allow calling gst functions from c.
2017-03-10 05:09:42 +00:00
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
/* Restore */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
if (janet_vm.root_fiber == fiber) janet_vm.root_fiber = NULL;
Fix #638 - update fiber status in certain cases. This fixes a regression from changes to janet_try. In some cases, we would not update the status of a fiber when signaling, which left the fiber's status as whatever it had previously. This could lead to strange control flow issues.
2021-02-20 16:48:10 +00:00
janet_fiber_set_status(fiber, sig);
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
janet_restore(&tstate);
Allow iterating over fibers with each and similar.
2021-01-03 22:17:36 +00:00
fiber->last_value = tstate.payload;
janet_try macro and janet_restore function. This allows catching panics without using pcall.
2020-09-19 23:47:47 +00:00
*out = tstate.payload;
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
Fix #638 - update fiber status in certain cases. This fixes a regression from changes to janet_try. In some cases, we would not update the status of a fiber when signaling, which left the fiber's status as whatever it had previously. This could lead to strange control flow issues.
2021-02-20 16:48:10 +00:00
return sig;
Redo calling convetion for more code reuse. Allow calling gst functions from c.
2017-03-10 05:09:42 +00:00
}
Change fiber signal model to add user signals. This should allow easier implementations of eventloops, threadpools, or custom data flows with fibers.
2018-05-17 02:09:36 +00:00
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
/* Enter the main vm loop */
JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) {
/* Check conditions */
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
JanetSignal tmp_signal = janet_check_can_resume(fiber, out, 0);
Differentiate error from resume and error from resumed fiber.
2020-04-10 23:29:10 +00:00
if (tmp_signal) return tmp_signal;
return janet_continue_no_check(fiber, in, out);
}
Start working on throwing errors from async functions.
2020-08-11 12:19:34 +00:00
/* Enter the main vm loop but immediately raise a signal */
JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig) {
Address #920 - fiber cancellation can hang event loop. The main issue was cancellation of fiber using `cancel` rather than `ev/cancel` could cause issues with the event loop internal ref count. Since this is almost certainly bad usage (and is not something I want to encourage or support), we will warn against trying to resume or error fibers that have already been suspended or scheduled on the event loop. The distinction between "task" fibers and normal fibers is now kept by a flag that is set when a fiber is resumed - if it is the outermost fiber on the stack, it is considered a root fiber. All fibers scheduled with ev/go or by the event loop are root fibers, and thus cannot be cancelled or resumed with `cancel` or `resume` - instead, use `ev/cancel` or `ev/go`.
2022-02-10 03:48:49 +00:00
JanetSignal tmp_signal = janet_check_can_resume(fiber, out, sig != JANET_SIGNAL_OK);
Start working on throwing errors from async functions.
2020-08-11 12:19:34 +00:00
if (tmp_signal) return tmp_signal;
if (sig != JANET_SIGNAL_OK) {
JanetFiber *child = fiber;
while (child->child) child = child->child;
child->gc.flags &= ~JANET_FIBER_STATUS_MASK;
child->gc.flags |= sig << JANET_FIBER_STATUS_OFFSET;
child->flags |= JANET_FIBER_RESUME_SIGNAL;
}
return janet_continue_no_check(fiber, in, out);
}
Update peg to allow functions over captures. Update C API to make janet function calls easier and faster from C (still needs an object pool for fibers, though). Fix bug in scan-number and add many more peg tests.
2019-01-12 22:31:15 +00:00
JanetSignal janet_pcall(
Add make format to format code. A consistent style should help with contributors and readability. We use astyle as the formatter as can make a pretty good approximation of the current style and my preferred style. Astyle can be found at http://astyle.sourceforge.net/astyle.html
2019-02-20 01:51:34 +00:00
JanetFunction *fun,
int32_t argc,
const Janet *argv,
Janet *out,
JanetFiber **f) {
Update janet_pcall interface The programmer can now not only get the used fiber, but provide a fiber to reuse if many calls are made in succession.
2019-02-22 22:10:24 +00:00
JanetFiber *fiber;
if (f && *f) {
fiber = janet_fiber_reset(*f, fun, argc, argv);
} else {
fiber = janet_fiber(fun, 64, argc, argv);
}
Fix web build again, simplify fibers and fiber implementation code.
2018-11-26 14:02:07 +00:00
if (f) *f = fiber;
Fix error behavior when calling functions with incorrect arities.
2018-12-30 23:41:44 +00:00
if (!fiber) {
*out = janet_cstringv("arity mismatch");
return JANET_SIGNAL_ERROR;
}
Rename to janet
2018-09-06 02:18:42 +00:00
return janet_continue(fiber, janet_wrap_nil(), out);
Update thoughts.md, and add dst_call and dst_call suspend. dst_call_suspend migt be redundant (suspension of GC is easy enough).
2018-03-04 23:56:13 +00:00
}
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
Janet janet_mcall(const char *name, int32_t argc, Janet *argv) {
/* At least 1 argument */
Add argument to janet_panicf call
2021-10-07 07:38:40 +00:00
if (argc < 1) {
janet_panicf("method :%s expected at least 1 argument", name);
}
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
/* Find method */
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
Janet method = janet_method_lookup(argv[0], name);
if (janet_checktype(method, JANET_NIL)) {
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
janet_panicf("could not find method :%s for %v", name, argv[0]);
}
/* Invoke method */
Add righthand operator overloading. This is like python. Now, we just need to readd fuzzy comparisons to have what python needs. Overloading math functions would be neat, too.
2020-01-23 00:59:41 +00:00
return janet_method_invoke(method, argc, argv);
Use :length method for (length abstract) Also adds the janet_lengthv API call. This is needed because janet_length returns a 32 bit integer, where as lengthv lets us return larger values (useful for typed arrays). janet_mcall is an api function that should make it easier to call a janet method from C code. It shares a similar signature with janet_call.
2019-09-08 20:36:21 +00:00
}
Change c function macros to be explicitly non functional by capitalizing them.
2018-05-13 00:31:28 +00:00
/* Setup VM */
Rename to janet
2018-09-06 02:18:42 +00:00
int janet_init(void) {
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
Make some changes and begin work on macros.
2017-02-12 20:16:55 +00:00
/* Garbage collection */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.blocks = NULL;
janet_vm.next_collection = 0;
janet_vm.gc_interval = 0x400000;
janet_vm.block_count = 0;
Rename to janet
2018-09-06 02:18:42 +00:00
janet_symcache_init();
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
Merge code back from correctgc.
2018-09-23 21:53:55 +00:00
/* Initialize gc roots */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.roots = NULL;
janet_vm.root_count = 0;
janet_vm.root_capacity = 0;
Add scratch memory API. This should make it easier to write code that does not leak memory on panics.
2019-06-02 03:31:39 +00:00
/* Scratch memory */
Fix ev thread swallowing error in some case.
2021-08-27 16:46:42 +00:00
janet_vm.user = NULL;
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.scratch_mem = NULL;
janet_vm.scratch_len = 0;
janet_vm.scratch_cap = 0;
Add first version of marsh (marshaling).
2018-06-12 18:24:45 +00:00
/* Initialize registry */
Put source mapping info in stack traces.
2021-07-30 02:29:08 +00:00
janet_vm.registry = NULL;
janet_vm.registry_cap = 0;
janet_vm.registry_count = 0;
janet_vm.registry_dirty = 0;
/* Intialize abstract registry */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.abstract_registry = janet_table(0);
janet_gcroot(janet_wrap_table(janet_vm.abstract_registry));
Make janet_equals and janet_compare non recursive This makes these operatios use constant stack space rather than linear stackspace given the size of the inputs. This is important to prevent certain parser input from causing a stack overflow - in general, we try to avoid unbounded recursion.
2020-04-24 21:18:31 +00:00
/* Traversal */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.traversal = NULL;
janet_vm.traversal_base = NULL;
janet_vm.traversal_top = NULL;
Use make-image-dict and load-image-dict in thread/new Rather than messing with janet_core_dictionary, we instead cache the core enevironment, and pull out the needed tables from there. This is more flexible, more correct, and also exposes janet_resolve_core, which can be easily used from the C API.
2019-12-02 10:15:22 +00:00
/* Core env */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.core_env = NULL;
Add janet_interpreter_interrupt for custom scheduling. This would allow an embedder to suspend the current Janet fiber via an external event like a signal, other thread, or really anything. This is a useful primitive for custom schedulers that would call janet_interpreter_interupt periodically (say, in an interval with SIG_ALRM), do some work, and then use janet_continue on the janet_root_fiber, or for embedding into other soft-realtime applications like a game. To say, only allow about 5ms per frame of interpreter time.
2021-07-24 20:14:37 +00:00
/* Auto suspension */
janet_vm.auto_suspend = 0;
Allow setting dynamic bindings at C top level. Before, these bindings we just ignored. However, it useful for controlling janet_printf and janet_eprintf, for example. These can be called from C code without being inside a call to janet_continue.
2020-06-22 13:56:04 +00:00
/* Dynamic bindings */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.top_dyns = NULL;
Add RNG functionality to the math/ module. The new RNG wraps up state for random number generation, so one can have many rngs and even marshal and unmarshal them. Adds math/rng, math/rng-uniform, and math/rng-int. Also introduce `in` and change semantics for indexing out of range. This commit enforces stricter invariants on keys when indexing via a function call on the data structure, or the new `in` function. The `get` function is now more lax about keys, and will not throw an error when a bad key is used for a data structure, instead returning the default value.
2019-11-08 23:35:27 +00:00
/* Seed RNG */
janet_rng_seed(janet_default_rng(), 0);
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
Working TCP echo server and client. Required a few changes to APIs, namely janet_root_fiber() to get topmost fiber that is active in the current scheduler. This is distinct from janet_current_fiber(), which gets the bottom most fiber in the fiber stack - it might have a parent, and so cannot be reliably resumed. This is the kind of situation that makes symmetric coroutines more attractive.
2020-02-10 01:04:34 +00:00
/* Fibers */
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_vm.fiber = NULL;
janet_vm.root_fiber = NULL;
janet_vm.stackn = 0;
Start with ev module.
2020-05-28 15:39:40 +00:00
#ifdef JANET_EV
janet_ev_init();
#endif
#ifdef JANET_NET
janet_net_init();
Keep single global pthread_cond_t per thread. This will allow thread/select to be implemented. Also add thread/close and close method to threads.
2019-12-05 03:44:53 +00:00
#endif
More work. Too many changes to be listed.
2017-11-06 03:05:47 +00:00
return 0;
First commit.
2017-02-09 20:02:59 +00:00
}
/* Clear all memory associated with the VM */
Rename to janet
2018-09-06 02:18:42 +00:00
void janet_deinit(void) {
janet_clear_memory();
janet_symcache_deinit();
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_free(janet_vm.roots);
janet_vm.roots = NULL;
janet_vm.root_count = 0;
janet_vm.root_capacity = 0;
janet_vm.abstract_registry = NULL;
janet_vm.core_env = NULL;
janet_vm.top_dyns = NULL;
Fix ev thread swallowing error in some case.
2021-08-27 16:46:42 +00:00
janet_vm.user = NULL;
Add janet_vm_save and janet_vm_load. This lets a user multiplex multiple Janet VMs on a single thread or process if they are willing to implement context switching themselves.
2021-07-17 01:59:03 +00:00
janet_free(janet_vm.traversal_base);
janet_vm.fiber = NULL;
janet_vm.root_fiber = NULL;
Put source mapping info in stack traces.
2021-07-30 02:29:08 +00:00
janet_free(janet_vm.registry);
Fix some issues and improve channel closing. Still not fully working, seems to be deadlock/channel issue when sending events between threads.
2021-08-15 18:14:33 +00:00
janet_vm.registry = NULL;
Start with ev module.
2020-05-28 15:39:40 +00:00
#ifdef JANET_EV
janet_ev_deinit();
#endif
Port net code to windows. Use winsock2 and WSAPoll. Not the most high performance solution but should work well.
2020-04-18 23:14:38 +00:00
#ifdef JANET_NET
janet_net_deinit();
#endif
First commit.
2017-02-09 20:02:59 +00:00
}
Reference in New Issue Copy Permalink