Mercurial > octave
changeset 32395:d738b7d335b5
VM: Rename __vm_XXX__ functions to vm_XXX
Nearly all the VM functions are intended to be directly called by the user
like the debug_XXX or dbXXX functions, not like the private __profiler_XXX
functions. This patch renames all VM functions named __vm_XXX__ to the plain
vm_XXX without the leading and trailing underscores, across all VM code, tests,
and documentation.
| author | Arun Giridhar <arungiridhar@gmail.com> |
|---|---|
| date | Sun, 08 Oct 2023 15:12:10 -0400 |
| parents | 1e775db0cff5 |
| children | fc3f9660d5f2 |
| files | doc/interpreter/vectorize.txi libinterp/corefcn/compile.cc libinterp/parse-tree/pt-bytecode-vm.cc libinterp/parse-tree/pt-bytecode.h scripts/help/vm.m test/Makefile.am test/compile-bench/bench-octave/bench.m test/compile-bench/bench-octave/bench_valgrind.m test/compile/bytecode.tst test/compile/bytecode_misc.m test/compile/bytecode_nested.m test/compile/shutup_operator_test/bytecode_disp.tst |
| diffstat | 12 files changed, 240 insertions(+), 240 deletions(-) [+] |
line wrap: on
line diff
--- a/doc/interpreter/vectorize.txi Sun Oct 08 20:16:02 2023 +0200 +++ b/doc/interpreter/vectorize.txi Sun Oct 08 15:12:10 2023 -0400 @@ -636,22 +636,22 @@ code. Octave versions 9 onwards have the VM built-in by default. At its simplest, the only thing a user needs is to run the single command -@code{__vm_enable__ (1)} on starting Octave, and the rest of the user's +@code{vm_enable (1)} on starting Octave, and the rest of the user's session is as before, except that some code will likely run faster. If you find yourself doing this frequently, you can also add the following code to your Octave startup file (`.octaverc` or similar): @example @group -if (exist ("__vm_enable__") == 5) # built-in function exists - __vm_enable__ (1); +if (exist ("vm_enable") == 5) # built-in function exists + vm_enable (1); end @end group @end example -The full calling form for @code{__vm_enable__} is: +The full calling form for @code{vm_enable} is: -@DOCSTRING(__vm_enable__) +@DOCSTRING(vm_enable) A more comprehensive list of VM-related functions is given by the @code{vm} command. @@ -663,19 +663,19 @@ VM compilation for specific functions as the user needs. In general, these might be done for frequently called functions ("hotspots"). -@DOCSTRING(__vm_compile__) +@DOCSTRING(vm_compile) -@DOCSTRING(__vm_clear_cache__) +@DOCSTRING(vm_clear_cache) -@DOCSTRING(__vm_is_compiled__) +@DOCSTRING(vm_is_compiled) -@DOCSTRING(__vm_is_executing__) +@DOCSTRING(vm_is_executing) -@DOCSTRING(__vm_print_bytecode__) +@DOCSTRING(vm_print_bytecode) -@DOCSTRING(__vm_print_trace__) +@DOCSTRING(vm_print_trace) -@DOCSTRING(__vm_profile__) +@DOCSTRING(vm_profile) @node Miscellaneous Techniques @section Miscellaneous Techniques
--- a/libinterp/corefcn/compile.cc Sun Oct 08 20:16:02 2023 +0200 +++ b/libinterp/corefcn/compile.cc Sun Oct 08 15:12:10 2023 -0400 @@ -41,7 +41,7 @@ // If TRUE, use VM evaluator rather than tree walker. // FIXME: Use OCTAVE_ENABLE_VM_EVALUATOR define to set it to true when // the VM has been tested properly. -bool V__vm_enable__ = false; +bool Vvm_enable = false; // Cleverly hidden in pt-bytecode-vm.cc to prevent inlining here extern "C" void dummy_mark_1 (void); @@ -81,9 +81,9 @@ return {}; } -DEFUN (__vm_clear_cache__, , , +DEFUN (vm_clear_cache, , , doc: /* -*- texinfo -*- -@deftypefn {} {@var{val} =} __vm_clear_cache__ () +@deftypefn {} {@var{val} =} vm_clear_cache () Internal function. @@ -94,9 +94,9 @@ return octave_value {true}; } -DEFUN (__vm_print_trace__, , , +DEFUN (vm_print_trace, , , doc: /* -*- texinfo -*- -@deftypefn {} {@var{prints_trace} =} __vm_print_trace__ ()) +@deftypefn {} {@var{prints_trace} =} vm_print_trace ()) Internal function. @@ -134,13 +134,13 @@ return octave_value {ov.get_count ()}; } -DEFMETHOD (__vm_is_executing__, interp, , , +DEFMETHOD (vm_is_executing, interp, , , doc: /* -*- texinfo -*- -@deftypefn {} {@var{is_executing} =} __vm_is_executing__ ()) +@deftypefn {} {@var{is_executing} =} vm_is_executing ()) Internal function. -Returns true if the VM is executing the function calling __vm_is_executing__ (). +Returns true if the VM is executing the function calling vm_is_executing (). False otherwise. @@ -159,14 +159,14 @@ return octave_value {bytecode_running}; } -DEFMETHOD (__vm_profile__, interp, args, , +DEFMETHOD (vm_profile, interp, args, , doc: /* -*- texinfo -*- -@deftypefn {} {} __vm_profile__ on -@deftypefnx {} {} __vm_profile__ off -@deftypefnx {} {} __vm_profile__ resume -@deftypefnx {} {} __vm_profile__ clear -@deftypefnx {} {@var{T} =} __vm_profile__ ("info") -@deftypefnx {} {} __vm_profile__ +@deftypefn {} {} vm_profile on +@deftypefnx {} {} vm_profile off +@deftypefnx {} {} vm_profile resume +@deftypefnx {} {} vm_profile clear +@deftypefnx {} {@var{T} =} vm_profile ("info") +@deftypefnx {} {} vm_profile Internal function. @@ -272,10 +272,10 @@ return octave_value {true}; } -DEFMETHOD (__vm_print_bytecode__, interp, args, , +DEFMETHOD (vm_print_bytecode, interp, args, , doc: /* -*- texinfo -*- -@deftypefn {} {@var{success} =} __vm_print_bytecode__ (@var{fn_name})) -@deftypefnx {} {@var{success} =} __vm_print_bytecode__ (@var{fn_handle})) +@deftypefn {} {@var{success} =} vm_print_bytecode (@var{fn_name})) +@deftypefnx {} {@var{success} =} vm_print_bytecode (@var{fn_handle})) Internal function. @@ -328,7 +328,7 @@ // Nested functions need to be compiled via their parent bool is_nested = ufn->is_nested_function (); - bool try_compile = !ufn->is_compiled () && V__vm_enable__ && !is_nested; + bool try_compile = !ufn->is_compiled () && Vvm_enable && !is_nested; if (try_compile && h && h->is_anonymous ()) h->compile (); @@ -347,10 +347,10 @@ return octave_value {true}; } -DEFMETHOD (__vm_is_compiled__, interp, args, , +DEFMETHOD (vm_is_compiled, interp, args, , doc: /* -*- texinfo -*- -@deftypefn {} {@var{is_compiled} =} __vm_is_compiled__ (@var{fn_name}) -@deftypefnx {} {@var{is_compiled} =} __vm_is_compiled__ (@var{fn_handle}) +@deftypefn {} {@var{is_compiled} =} vm_is_compiled (@var{fn_name}) +@deftypefnx {} {@var{is_compiled} =} vm_is_compiled (@var{fn_handle}) Internal function. @@ -411,11 +411,11 @@ } } -DEFMETHOD (__vm_compile__, interp, args, , +DEFMETHOD (vm_compile, interp, args, , doc: /* -*- texinfo -*- -@deftypefn {} {@var{success} =} __vm_compile__ (@var{fn_name}) -@deftypefnx {} {@var{success} =} __vm_compile__ (@var{fn_name}, "clear") -@deftypefnx {} {@var{success} =} __vm_compile__ (@var{fn_name}, "print") +@deftypefn {} {@var{success} =} vm_compile (@var{fn_name}) +@deftypefnx {} {@var{success} =} vm_compile (@var{fn_name}, "clear") +@deftypefnx {} {@var{success} =} vm_compile (@var{fn_name}, "print") Internal function. @@ -426,7 +426,7 @@ Returns true on success, otherwise false. -Don't recompile or clear the bytecode of a running function with __vm_compile__. +Don't recompile or clear the bytecode of a running function with vm_compile. The @qcode{"print"} option prints the bytecode after compilation. @@ -564,18 +564,18 @@ return octave_value {true}; } -DEFUN (__vm_enable__, args, nargout, +DEFUN (vm_enable, args, nargout, doc: /* -*- texinfo -*- -@deftypefn {} {@var{val} =} __vm_enable__ () -@deftypefnx {} {@var{old_val} =} __vm_enable__ (@var{new_val}) -@deftypefnx {} {@var{old_val} =} __vm_enable__ (@var{new_val}, "local") +@deftypefn {} {@var{val} =} vm_enable () +@deftypefnx {} {@var{old_val} =} vm_enable (@var{new_val}) +@deftypefnx {} {@var{old_val} =} vm_enable (@var{new_val}, "local") Query or set whether Octave automatically compiles functions to bytecode and executes them in a virtual machine (VM). Note that the virtual machine feature is experimental. The default value is currently false, while the VM is still experimental. -Users need to explicitly call @code{__vm_enable__ (1)} to enable it. +Users need to explicitly call @code{vm_enable (1)} to enable it. In future, this will be set to the value of the OCTAVE_ENABLE_VM_EVALUATOR flag that was set when building Octave. @@ -589,16 +589,16 @@ setting is restored when exiting the function. Once compiled to bytecode, the function will always be evaluated by the -VM no matter the state of @qcode{"__vm_enable__"}, until the bytecode is +VM no matter the state of @qcode{"vm_enable"}, until the bytecode is cleared, by e.g. @qcode{"clear all"} or an modification to the function's m-file. -@seealso{__vm_compile__} +@seealso{vm_compile} @end deftypefn */) { - return set_internal_variable (V__vm_enable__, args, nargout, - "__vm_enable__"); + return set_internal_variable (Vvm_enable, args, nargout, + "vm_enable"); } OCTAVE_END_NAMESPACE(octave)
--- a/libinterp/parse-tree/pt-bytecode-vm.cc Sun Oct 08 20:16:02 2023 +0200 +++ b/libinterp/parse-tree/pt-bytecode-vm.cc Sun Oct 08 15:12:10 2023 -0400 @@ -7404,7 +7404,7 @@ if (fn->is_compiled ()) return true; - if (V__vm_enable__ && !fn->m_compilation_failed) + if (Vvm_enable && !fn->m_compilation_failed) { try {
--- a/libinterp/parse-tree/pt-bytecode.h Sun Oct 08 20:16:02 2023 +0200 +++ b/libinterp/parse-tree/pt-bytecode.h Sun Oct 08 15:12:10 2023 -0400 @@ -328,7 +328,7 @@ }; // If TRUE, use VM evaluator rather than tree walker. -extern bool V__vm_enable__; +extern bool Vvm_enable; OCTAVE_END_NAMESPACE(octave)
--- a/scripts/help/vm.m Sun Oct 08 20:16:02 2023 +0200 +++ b/scripts/help/vm.m Sun Oct 08 15:12:10 2023 -0400 @@ -33,37 +33,37 @@ ## The VM commands available in Octave are: ## ## @table @code -## @item __vm_enable__ +## @item vm_enable ## Main VM user function. Switch on or off the VM as a whole. ## -## @item __vm_compile__ +## @item vm_compile ## VM user function. Compile a specified function to bytecode. ## -## @item __vm_clear_cache__ +## @item vm_clear_cache ## Internal function. Clear the cache of already-processed code. ## -## @item __vm_is_compiled__ +## @item vm_is_compiled ## VM internal function. Return true if the specified function is compiled. ## -## @item __vm_is_executing__ +## @item vm_is_executing ## Internal function. Return true if the VM is executing. ## -## @item __vm_print_bytecode__ +## @item vm_print_bytecode ## Internal function. Print bytecode of specified function. ## -## @item __vm_print_trace__ +## @item vm_print_trace ## Internal function. Print a debug trace from the VM. ## -## @item __vm_profile__ +## @item vm_profile ## Internal function. Profile the code running in the VM. ## ## @end table ## ## @noindent ## -## @seealso{__vm_enable__, __vm_compile__, __vm_clear_cache__, -## __vm_is_compiled__, __vm_is_executing__, __vm_print_bytecode__, -## __vm_print_trace__, __vm_profile__} +## @seealso{vm_enable, vm_compile, vm_clear_cache, +## vm_is_compiled, vm_is_executing, vm_print_bytecode, +## vm_print_trace, vm_profile} ## @end deftypefn function vm ()
--- a/test/Makefile.am Sun Oct 08 20:16:02 2023 +0200 +++ b/test/Makefile.am Sun Oct 08 15:12:10 2023 -0400 @@ -150,7 +150,7 @@ if AMCOND_ENABLE_VM_EVALUATOR check-vm: $(BUILT_SOURCES) $(GENERATED_TEST_FILES) $(MEX_TEST_FUNCTIONS) | $(OCTAVE_INTERPRETER_TARGETS) $(octave_dirstamp) - $(AM_V_at)$(call run-octave-tests,__vm_enable__ (1)) + $(AM_V_at)$(call run-octave-tests,vm_enable (1)) endif COVERAGE_DIR = coverage
--- a/test/compile-bench/bench-octave/bench.m Sun Oct 08 20:16:02 2023 +0200 +++ b/test/compile-bench/bench-octave/bench.m Sun Oct 08 15:12:10 2023 -0400 @@ -28,8 +28,8 @@ end % For compatibility with older releases and Matlab - if ~exist("__vm_compile__") - __vm_compile__ = @(varargin) true; + if ~exist("vm_compile") + vm_compile = @(varargin) true; end if ~exist("__dummy_mark_1__") __dummy_mark_1__ = @() true; @@ -112,7 +112,7 @@ tic; [ccttot0, cctuser0, cctsys0] = cputime; if !no_compile - if ! __vm_compile__ (name) + if ! vm_compile (name) warning ("Could not compile %s, skipping ...", name) continue; end
--- a/test/compile-bench/bench-octave/bench_valgrind.m Sun Oct 08 20:16:02 2023 +0200 +++ b/test/compile-bench/bench-octave/bench_valgrind.m Sun Oct 08 15:12:10 2023 -0400 @@ -37,7 +37,7 @@ % logfilename, octbin, bench folder, benchname filter cmd_template = ["valgrind --tool=callgrind --callgrind-out-file=%s --separate-recs=10 " ... "--dump-instr=yes --collect-jumps=yes \"--dump-after=dummy_mark_1\" " ... - " %s -W --eval \"__vm_enable__ (1); cd %s; bench('reg','%s','n_factor', %d);exit(0)\""]; + " %s -W --eval \"vm_enable (1); cd %s; bench('reg','%s','n_factor', %d);exit(0)\""]; logfilename1 = ["callgrind.out.log_mark_", name, "_", num2str(i), "_", name, ".log"]; logfilename2 = ["callgrind.out.log_ref1_", name, "_", num2str(i), "_", name, ".log"];
--- a/test/compile/bytecode.tst Sun Oct 08 20:16:02 2023 +0200 +++ b/test/compile/bytecode.tst Sun Oct 08 15:12:10 2023 -0400 @@ -33,25 +33,25 @@ ## Test binary expressions %!test -%! __vm_enable__ (0, "local"); % Disable the vm for the tree_walker run +%! vm_enable (0, "local"); % Disable the vm for the tree_walker run %! %! clear all % We want all compiled functions to be cleared so that we can run the tree_walker %! %! key = "10 -10 24 0.041666666666666664 1 -5.0915810909090906 13 1 0 1 0 truthy1 1 falsy3 falsy4 truthy5 1 truthy7 truthy8 1 falsy9 falsy11 0 1 0 1 0 0 1 1 0 1 0 1 1 1 0 1 0 1 0 0 0 0 1 1 1 1 1 1 1 1 "; %! -%! __vm_compile__ bytecode_binops clear; +%! vm_compile bytecode_binops clear; %! bytecode_binops (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! % We wanna know the function compiles, so do a explicit compile -%! assert (__vm_compile__ ("bytecode_binops")); +%! assert (vm_compile ("bytecode_binops")); %! bytecode_binops (); %! assert (__prog_output_assert__ (key)); ## Test subfunctions %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "2 2 2 11 30 10 30 5 0 0 double 1 2 1 2 double 30 11 5 0 0 double 1 2 1 2 double 11 11 12 13 1 1 double 14 1 1 double 11 11 5 13 1 1 double 14 1 1 double 11 3 3 3 2 2 2 313 ret32:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ret32:1 ret32:ret32:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 take32:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 1 18 59 64 "; %! a = 313; @@ -59,261 +59,261 @@ %! % externally scoped variables work %! h = @() __printf_assert__ ("%d ", a); %! -%! __vm_compile__ bytecode_subfuncs clear; +%! vm_compile bytecode_subfuncs clear; %! bytecode_subfuncs (h); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_subfuncs")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_subfuncs")); %! bytecode_subfuncs (h); %! assert (__prog_output_assert__ (key)); ## Test if:s %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "0 1 2 3 4 5 6 7 8 1 2 yay1 3 5 7 8 1 yay1 3 4 yay2 5 6 7 yay3 "; %! -%! __vm_compile__ bytecode_if clear; +%! vm_compile bytecode_if clear; %! bytecode_if (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_if")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_if")); %! bytecode_if (); %! assert (__prog_output_assert__ (key)); ## Test for:s %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "1 2 3 4 4 1 3 5 5 1 4 4 4 3 2 1 1 0.200 0.300 0.400 0.400 0.300 0.200 0.100 0.000 0.000 NaN NaN NaN 1 4 2 2 16 4 3 3 256 3 2 1 double 1 3 size 2 size 1 2 4 size 2 size 1 double q size 1 size 1 w size 1 size 1 e size 1 size 1 char single single 5 1 11 2 12 key:a val:1 1val:1 key:b val:1 3val:2 4val:2 2key:c val:string "; %! -%! __vm_compile__ bytecode_for clear; +%! vm_compile bytecode_for clear; %! bytecode_for (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_for")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_for")); %! bytecode_for (); %! assert (__prog_output_assert__ (key)); ## Test while %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "5 4 3 2 1 3 5 4 4 3 3 4 1 2 1 3 2 8 3 1 3 "; %! -%! __vm_compile__ bytecode_while clear; +%! vm_compile bytecode_while clear; %! bytecode_while (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_while")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_while")); %! bytecode_while (); %! assert (__prog_output_assert__ (key)); ## Test assign %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "2 3 1 1 2 3 2 3 2 2 6 18 2.000000 2.000000 3.000000 4.000000 5.000000 1 4 double 729.000000 324.000000 182.250000 116.640000 4 1 double 37.000000 81.000000 54.000000 118.000000 2 2 double "; %! -%! __vm_compile__ bytecode_assign clear; +%! vm_compile bytecode_assign clear; %! bytecode_assign (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_assign")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_assign")); %! bytecode_assign (); %! assert (__prog_output_assert__ (key)); ## Test unary %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "-1 4 1 2 3 4 1 3 2 4 0 0 "; %! -%! __vm_compile__ bytecode_unary clear; +%! vm_compile bytecode_unary clear; %! bytecode_unary (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_unary")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_unary")); %! bytecode_unary (); %! assert (__prog_output_assert__ (key)); ## Test range %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "1 2 3 1 3 5 1 3 5 1 1.1 1.2 1.3 1.4 1 0.9 0.8 0.7 7 7 1 8 10 8 10 8 9 10 11 8 9 10 11 10 8 10 8 -10 -9 -8 -7 -10 -9 -8 -7 "; %! -%! __vm_compile__ bytecode_range clear; +%! vm_compile bytecode_range clear; %! bytecode_range (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_range")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_range")); %! bytecode_range (); %! assert (__prog_output_assert__ (key)); ## Test multi assign %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "3 4 2 2 1 2 3 4 1 2 3 4 1 1 3 2 3 4 1 1 1 2 3 4 1 1 1 2 3 4 1 2 3 "; %! -%! __vm_compile__ bytecode_multi_assign clear; +%! vm_compile bytecode_multi_assign clear; %! bytecode_multi_assign (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_multi_assign")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_multi_assign")); %! bytecode_multi_assign (); %! assert (__prog_output_assert__ (key)); ## Test subsasgn %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! clear functions % persistent variables in bytecode_subsasgn %! key = "3 5 9 8 11 13 1 2 3 4 5 6 77 88 99 1010 1 2 3 987 987 6 77 88 99 1010 0 0 0 0 0 13 double 3 2 4 2 3 cell 1 3 6 7 2 3 1 4 5 1 3 5 2 4 6 7 7 7 7 7 7 1 2 3 1 3 3 2 3 2 3 1 3 1 2 3 4 4 4 3 4 5 6 1 5 3 4 1 5 -1 4 1 5 -1 8 3 3 3 3 3 3 3 3 1 1 3 1 "; %! -%! __vm_compile__ bytecode_subsasgn clear; +%! vm_compile bytecode_subsasgn clear; %! bytecode_subsasgn (); %! assert (__prog_output_assert__ (key), "bytecode_subsasgn failed uncompiled"); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_subsasgn")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_subsasgn")); %! bytecode_subsasgn (); %! assert (__prog_output_assert__ (key), "bytecode_subsasgn failed compiled"); ## Test end %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "1 3 2 4 1 5 6 7 2 2 5 5 6 6 1 2 3 4 5 2 2 2 3 3 4 fs 2 3 1 foo oo "; %! -%! __vm_compile__ bytecode_end clear; +%! vm_compile bytecode_end clear; %! bytecode_end (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_end")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_end")); %! bytecode_end (); %! assert (__prog_output_assert__ (key)); ## Test matrix %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "1 2 3 4 1 4 1 2 3 4 4 1 1 3 2 4 2 2 1 3 1 3 2 4 2 4 4 2 0 0 a b c d 7 15 10 22 2 2 30 1 1 1 2 3 4 2 4 6 8 3 6 9 12 4 8 12 16 4 4 1 1 1 0.0333333 0.0666667 0.1 0.133333 0.0666667 0.133333 0.2 0.266667 0.1 0.2 0.3 0.4 0.133333 0.266667 0.4 0.533333 4 4 1 0 0 1 2 2 30 1 1 10 14 14 20 2 2 0.0333333 0.0666667 0.1 0.133333 0.0666667 0.133333 0.2 0.266667 0.1 0.2 0.3 0.4 0.133333 0.266667 0.4 0.533333 4 4 2.5 -0.5 2 0 2 2 2 6 4 8 2 2 2 3 4 5 3 4 5 6 4 5 6 7 5 6 7 8 4 4 3 4 5 6 1 4 3 4 5 6 1 4 -1 0 1 2 1 4 2 4 6 8 1 4 0.5 1 1.5 2 1 4 0.5 1 1.5 2 1 4 1 4 9 16 1 4 1 1 1 1 1 4 1 1 1 1 1 4 1 4 27 256 1 4 1 2 3 4 2 4 6 8 3 6 9 12 4 8 12 16 4 4 1 0.5 0.333333 0.25 2 1 0.666667 0.5 3 1.5 1 0.75 4 2 1.33333 1 4 4 1 2 3 4 0.5 1 1.5 2 0.333333 0.666667 1 1.33333 0.25 0.5 0.75 1 4 4 1 4 27 256 4 1 qzwxeca s d zzxxccz x c 1 258 33264 258 1 33264 "; %! -%! __vm_compile__ bytecode_matrix clear; +%! vm_compile bytecode_matrix clear; %! bytecode_matrix (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_matrix")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_matrix")); %! bytecode_matrix (); %! assert (__prog_output_assert__ (key)); ## Test return %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "2 baaar bääär baaaaz bääääz bååååz booz 1 1 2 1 1 1 2 1 silly silly "; %! -%! __vm_compile__ bytecode_return clear; +%! vm_compile bytecode_return clear; %! bytecode_return (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_return")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_return")); %! bytecode_return (); %! assert (__prog_output_assert__ (key)); ## Test word list command %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "A B C QWE "; %! -%! __vm_compile__ bytecode_wordlistcmd clear; +%! vm_compile bytecode_wordlistcmd clear; %! bytecode_wordlistcmd (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_wordlistcmd")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_wordlistcmd")); %! bytecode_wordlistcmd (); %! assert (__prog_output_assert__ (key)); ## Test do until %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "5 3 5 5 4 4 3 4 1 2 1 3 2 12 3 0 3 "; %! -%! __vm_compile__ bytecode_dountil clear; +%! vm_compile bytecode_dountil clear; %! bytecode_dountil (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_dountil")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_dountil")); %! bytecode_dountil (); %! assert (__prog_output_assert__ (key)); ## Test cell %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "a b a b 1 2 b c b c 1 2 char b c c d b d c e 2 2 b d f h j l c e g i k m 6 2 1 2 2 3 1 3 2 4 1 3 1 2 1 3 2 4 2 2 double qwe 1 3 char 1 2 "; %! -%! __vm_compile__ bytecode_cell clear; +%! vm_compile bytecode_cell clear; %! bytecode_cell (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_cell")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_cell")); %! bytecode_cell (); %! assert (__prog_output_assert__ (key)); ## Test varargin %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "2 3 1 2 1 1 1 1 1 2 3 4 1 4 4 0 0 0 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 0 0 1 0 0 0 2 1 1 1 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 2 1 2 4 1 2 0 0 2 1 nob 0 0 1 noa nob 0 0 0 2 1 2 4 1 2 3 4 3 3 2 1 0 "; %! -%! __vm_compile__ bytecode_varargin clear; +%! vm_compile bytecode_varargin clear; %! bytecode_varargin (1,2,3); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_varargin")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_varargin")); %! bytecode_varargin (1,2,3); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "0 0 1 1 1 1 1 2 3 4 1 4 4 0 0 0 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 0 0 1 0 0 0 2 1 1 1 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 2 1 2 4 1 2 0 0 2 1 nob 0 0 1 noa nob 0 0 0 2 1 2 4 1 2 3 4 1 3 2 1 0 "; %! -%! __vm_compile__ bytecode_varargin clear; +%! vm_compile bytecode_varargin clear; %! bytecode_varargin (1); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_varargin")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_varargin")); %! bytecode_varargin (1); %! assert (__prog_output_assert__ (key)); ## Test global variables %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "double 0 0 1 1 1 1 1 2 2 2 400 100 0 1 3 double 1 1 1 2 double 1 2 1 1 11 eclass:double 1 1 3 4 double 1 2 400 100 1 1 1 1 3 4 1 1 5 6 1 1 1 2 double 1 2 1 2 double 1 2 1 1 3 4 eclass:double 1 2 3 4 double 1 2 0 0 1 1 3 4 1 1 5 6 1 0 2 double 2 double 11 2 6 4 5 double 1 5 11 double 1 1 22 double 1 1 33 double 1 1 3 double 1 1 4 double 1 1 10 double 1 1 2 3 double 1 2 3 double 1 1 2 double 1 1 55 double 1 1 7 double 1 1 0 11 12 4 11 12 4 "; %! -%! __vm_compile__ bytecode_global_1 clear; +%! vm_compile bytecode_global_1 clear; %! clear global a; %! clear global b; %! clear global q @@ -324,8 +324,8 @@ %! assert (length(who('global','a'))); %! assert (length(who('global','b'))); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_global_1")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_global_1")); %! clear global a; %! clear global b; %! clear global q; @@ -346,37 +346,37 @@ ## Test switch %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "yay yay2 yay3 yay4 yay5 yay6 yay7 yay8 1 2 3 3 1 3 3 4 4 1 3 3 4 4 2 yoo 2 3 3 1:1 for-end:12:2 3:3 for-end:3breaking:4 "; %! -%! __vm_compile__ bytecode_switch clear; +%! vm_compile bytecode_switch clear; %! bytecode_switch; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_switch")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_switch")); %! bytecode_switch; %! assert (__prog_output_assert__ (key)); ## Test eval (dynamic stack frames) %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "3.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 5.000000 4.000000 2.000000 3.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 5.000000 4.000000 2.000000 1:11.000000 2:22.000000 3:33.000000 4:3.000000 5:22.000000 6:3.000000 7:3.000000 3 3 2 2 3.000000 3.000000 "; %! -%! __vm_compile__ bytecode_eval_1 clear; +%! vm_compile bytecode_eval_1 clear; %! bytecode_eval_1; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_eval_1")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_eval_1")); %! bytecode_eval_1; %! assert (__prog_output_assert__ (key)); ## Test evalin and assignin %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! % We want to test all combinations of compiled and uncompiled evalin_1 and 2. %! @@ -385,28 +385,28 @@ %! caller_a = 2; %! %! -%! __vm_compile__ bytecode_evalin_1 clear; -%! __vm_compile__ bytecode_evalin_2 clear; +%! vm_compile bytecode_evalin_1 clear; +%! vm_compile bytecode_evalin_2 clear; %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_evalin_1")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_evalin_1")); %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! %! -%! __vm_compile__ bytecode_evalin_1 clear; -%! __vm_compile__ bytecode_evalin_2 clear; -%! assert (__vm_compile__ ("bytecode_evalin_1")); -%! assert (__vm_compile__ ("bytecode_evalin_2")); +%! vm_compile bytecode_evalin_1 clear; +%! vm_compile bytecode_evalin_2 clear; +%! assert (vm_compile ("bytecode_evalin_1")); +%! assert (vm_compile ("bytecode_evalin_2")); %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! -%! __vm_compile__ bytecode_evalin_1 clear; -%! __vm_compile__ bytecode_evalin_2 clear; -%! assert (__vm_compile__ ("bytecode_evalin_2")); +%! vm_compile bytecode_evalin_1 clear; +%! vm_compile bytecode_evalin_2 clear; +%! assert (vm_compile ("bytecode_evalin_2")); %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! @@ -414,9 +414,9 @@ ## Test error messages %!test %! ## Interpreter reference -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all -%! __vm_compile__ bytecode_errors clear; +%! vm_compile bytecode_errors clear; %! fail ("bytecode_errors (0)", ... %! "'qweqwe' undefined near line 9, column 6"); %! fail ("bytecode_errors (1)", ... @@ -436,9 +436,9 @@ %! fail ("bytecode_errors (8)", ... %! 'operator \+: nonconformant arguments \(op1 is 1x3, op2 is 1x2\)'); %! -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! ## Bytecode running the same errors -%! __vm_compile__ bytecode_errors; +%! vm_compile bytecode_errors; %! fail ("bytecode_errors (0)", ... %! "'qweqwe' undefined near line 9, column 6"); %! fail ("bytecode_errors (1)", ... @@ -460,153 +460,153 @@ ## Test try catch %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "yay yay2 yay3 ooo yay2 yay3 ooo2 ooo2 yay3 yay4 Nested error yay5 yay6 In catch yay7 qwe yay8 Error in subfunction yay9 'asd' undefined near line 87, column 11 yay10 operator *: nonconformant arguments (op1 is 1x2, op2 is 1x3) yay11 yoyo yay12 foo yay12 foo yay12 foo yay13 foo yay13 foo yay13 foo "; %! -%! __vm_compile__ bytecode_trycatch clear; +%! vm_compile bytecode_trycatch clear; %! bytecode_trycatch; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_trycatch")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_trycatch")); %! bytecode_trycatch; %! assert (__prog_output_assert__ (key)); ## Test unwind protect %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "yay1 yay2 yay3 e1 subyyay1 subyyay2 subyyay3 subyyay4 subyyay5 subyyay6 subyyay7 subyyay8 subyyay9 subyyay10 subyyay11 subyyay12 subyyay13 subyyay14 subyyay15 subyyay16 subyyay17 subyyay18 yay4 yay5 yay6 "; -%! __vm_compile__ bytecode_unwind clear; +%! vm_compile bytecode_unwind clear; %! bytecode_unwind; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_unwind")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_unwind")); %! bytecode_unwind; %! assert (__prog_output_assert__ (key)); ## Test persistant %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! clear functions % clear persistent variables in bytecode_persistant %! key = "a:3 b: double 0 0 0 c:3 c:4 a:4 b:1 double 1 1 0 c:5 c:6 "; %! -%! __vm_compile__ bytecode_persistant clear; +%! vm_compile bytecode_persistant clear; %! bytecode_persistant; %! bytecode_persistant; %! assert (__prog_output_assert__ (key)); %! %! clear all; -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! key = "a:3 b: double 0 0 0 c:3 c:4 a:4 b:1 double 1 1 0 c:5 c:6 "; -%! assert (__vm_compile__ ("bytecode_persistant")); +%! assert (vm_compile ("bytecode_persistant")); %! bytecode_persistant; %! %! bytecode_persistant; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (0, "local"); -%! __vm_compile__ bytecode_persistant clear; +%! vm_enable (0, "local"); +%! vm_compile bytecode_persistant clear; %! clear all; %! key = "a:3 b: double 0 0 0 c:3 c:4 a:4 b:1 double 1 1 0 c:5 c:6 "; %! bytecode_persistant; -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_persistant")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_persistant")); %! %! bytecode_persistant; %! assert (__prog_output_assert__ (key)); ## Test structs %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "1 2 double 1 1 struct 3 4 "; -%! __vm_compile__ bytecode_struct clear; +%! vm_compile bytecode_struct clear; %! bytecode_struct; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_struct")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_struct")); %! bytecode_struct; %! assert (__prog_output_assert__ (key)); ## Test indexing chained objects and strange indexing %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "2 2 3 3 2 cell 1 1 3 3 2 3 22 double 33 3 4 matlab.lang.MemoizedFunction 2 "; -%! __vm_compile__ bytecode_index_obj clear; +%! vm_compile bytecode_index_obj clear; %! bytecode_index_obj; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_index_obj")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_index_obj")); %! bytecode_index_obj; %! assert (__prog_output_assert__ (key)); ## Test varargout %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "7 8 1 1 2 1 0 0 0 1 0 1 0 0 0 1 0 "; -%! __vm_compile__ bytecode_varargout clear; +%! vm_compile bytecode_varargout clear; %! bytecode_varargout; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_varargout")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_varargout")); %! bytecode_varargout; %! assert (__prog_output_assert__ (key)); ## Test inputname %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "a a b + 1 a a b b aa aa bb bb aa + 1 bb * 3 a + 1 b * 3 aa aa bb bb aa + 1 bb * 3 a a b b a + 1 b * 3 "; -%! __vm_compile__ bytecode_inputname clear; +%! vm_compile bytecode_inputname clear; %! a = 9; b = 8; %! bytecode_inputname (a, b + 1); %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_inputname")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_inputname")); %! bytecode_inputname (a, b + 1); %! assert (__prog_output_assert__ (key)); ## Test ans %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "2 5 1 1 1 "; -%! __vm_compile__ bytecode_ans clear; +%! vm_compile bytecode_ans clear; %! bytecode_ans; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_ans")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_ans")); %! bytecode_ans; %! assert (__prog_output_assert__ (key)); ## Test using classdef %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! global cdef_foo_ctor_cnt; clear global cdef_foo_ctor_cnt; %! global cdef_foo_dtor_cnt; clear global cdef_foo_dtor_cnt; %! key = ". 1 f1 . 2 f3 3 f2 . sumf2f3 2 . . call14 f4 . a a_1 . 5 f8 . 6 f10 7 f9 . sumf9f10 2 . . call18 f11 . 2 2 3 4 4 4 3 2 2 3 . 9 sumf9f10 10 f12 11 f13 12 f14 13 sumf2f3 14 f5 15 f6 16 f7 "; -%! __vm_compile__ bytecode_cdef_use clear; +%! vm_compile bytecode_cdef_use clear; %! bytecode_cdef_use (); %! assert (__prog_output_assert__ (key)); %! global cdef_foo_ctor_cnt; global cdef_foo_dtor_cnt; %! assert (cdef_foo_ctor_cnt == cdef_foo_dtor_cnt); % Check, as many ctor and dtor executions %! -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! global cdef_foo_ctor_cnt; clear global cdef_foo_ctor_cnt; %! global cdef_foo_dtor_cnt; clear global cdef_foo_dtor_cnt; -%! assert (__vm_compile__ ("bytecode_cdef_use")); +%! assert (vm_compile ("bytecode_cdef_use")); %! bytecode_cdef_use (); %! assert (__prog_output_assert__ (key)); %! global cdef_foo_ctor_cnt; global cdef_foo_dtor_cnt; @@ -619,18 +619,18 @@ ## Test anonymous function handles %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "1 2 12 3 4 4 4 1 2 3 1 2 3 1 2 1 2 11 12 11 12 1 4 4 1 1 1 2 1 2 1 2 3 1 2 3 1 3 1 3 9 0 1 fooo ~101 103 ~101 103 ~110 123 ~101 123 ~010 123 ~000 123 ~011 123 "; -%! __vm_compile__ bytecode_anon_handles clear; +%! vm_compile bytecode_anon_handles clear; %! bytecode_anon_handles; %! %! global __assert_printf__; %! %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_anon_handles")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_anon_handles")); %! bytecode_anon_handles; %! global __assert_printf__; %! assert (__prog_output_assert__ (key)); @@ -639,23 +639,23 @@ ## m-file %!test %! clear all -%! __vm_enable__ (1, "local"); -%! __vm_compile__ wrongname_fn clear; -%! assert (__vm_compile__ ("wrongname_fn")); +%! vm_enable (1, "local"); +%! vm_compile wrongname_fn clear; +%! assert (vm_compile ("wrongname_fn")); %! %! assert (wrongname_fn (77) == 78); ## Test some misc stuff %!test %! clear all -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! %! bytecode_misc; % asserts inernally ## Leak check %!test %! clear all -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! %! c = 2; %! d = 3; @@ -668,15 +668,15 @@ ## Test scripts %!test -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! key = "0 1 3 4 5 3 "; -%! __vm_compile__ bytecode_scripts clear; +%! vm_compile bytecode_scripts clear; %! bytecode_scripts; %! assert (__prog_output_assert__ (key)); %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_scripts")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_scripts")); %! bytecode_scripts; %! assert (__prog_output_assert__ (key)); @@ -685,16 +685,16 @@ %! global cdef_bar_cnt %! cdef_bar_cnt = 0; %! -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all -%! __vm_compile__ bytecode_nested clear; +%! vm_compile bytecode_nested clear; %! % These tests uses asserts in themself %! bytecode_nested; %! %! cdef_bar_cnt = 0; %! -%! __vm_enable__ (1, "local"); -%! assert (__vm_compile__ ("bytecode_nested")); +%! vm_enable (1, "local"); +%! assert (vm_compile ("bytecode_nested")); %! bytecode_nested; %! %! assert (cdef_bar_cnt == 0); @@ -703,7 +703,7 @@ ## Test script interaction when called from top scope %!test %! -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! %! global bytecode_script_topscope_place; % Used in bytecode_script_topscope the select where to evalin @@ -718,10 +718,10 @@ %! %! bytecode_script_topscope_assert; % Does some asserts and cleans up the globals and locals added %! -%! __vm_enable__ (1, "local"); +%! vm_enable (1, "local"); %! bytecode_script_topscope_setup; %! evalin ("base", "bytecode_script_topscope_setup_script"); -%! assert (__vm_compile__ ("bytecode_script_topscope")); +%! assert (vm_compile ("bytecode_script_topscope")); %! evalin ("base", "bytecode_script_topscope"); %! bytecode_script_topscope_assert; %! @@ -730,7 +730,7 @@ %! %! bytecode_script_topscope_setup; %! evalin ("base", "bytecode_script_topscope_setup_script"); -%! assert (__vm_compile__ ("bytecode_script_topscope")); +%! assert (vm_compile ("bytecode_script_topscope")); %! evalin ("base", "bytecode_script_topscope"); %! bytecode_script_topscope_assert; %! @@ -747,7 +747,7 @@ %! %! %% Redo the test, but test all 15 different combinations of compiled and uncompiled functions and scripts %! -%! __vm_enable__ (0, "local"); +%! vm_enable (0, "local"); %! clear all %! %! global bytecode_script_topscope_place % An assert in nbytecode_script_topscope need to know whether to check in caller or base @@ -763,7 +763,7 @@ %! eval ("function bytecode_script_topscope_cli_fn ()\nbytecode_script_topscope_setup ('caller');\nbytecode_script_topscope_setup_script;\nbytecode_script_topscope;\nbytecode_script_topscope_assert ('caller');\nend"); %! %! for fn = choise' -%! assert (__vm_compile__ (fn{1})) +%! assert (vm_compile (fn{1})) %! end %! %! % Check if it works in the CLI function @@ -792,7 +792,7 @@ %! clear all %! %! for use_vm = [true, false] % Test with and without VM -%! __vm_enable__ (use_vm, "local"); +%! vm_enable (use_vm, "local"); %! %! % We need to pass the file name to the scripts with a global %! global bytecode_load_script_file @@ -801,9 +801,9 @@ %! eval ("function bytecode_load_script_save_fn\n bytecode_load_script_save\n; bytecode_load_script_load_and_assert;\n end\n") %! %! if use_vm -%! assert (__vm_compile__ ("bytecode_load_script_save")) -%! assert (__vm_compile__ ("bytecode_load_script_load_and_assert")) -%! assert (__vm_compile__ ("bytecode_load_script_save_fn")) +%! assert (vm_compile ("bytecode_load_script_save")) +%! assert (vm_compile ("bytecode_load_script_load_and_assert")) +%! assert (vm_compile ("bytecode_load_script_save_fn")) %! end %! %! unwind_protect @@ -825,4 +825,4 @@ %! %! clear all %! end -%! \ No newline at end of file +%!
--- a/test/compile/bytecode_misc.m Sun Oct 08 20:16:02 2023 +0200 +++ b/test/compile/bytecode_misc.m Sun Oct 08 15:12:10 2023 -0400 @@ -20,7 +20,7 @@ % Try to run out of VM stack space % Assure that the VM is running, since we will disable the tree_evaluators % stack limit mechanism. - if __vm_is_executing__ () + if vm_is_executing () absurd_frame_limit = max_stack_depth * 10000; max_stack_depth (absurd_frame_limit, "local"); @@ -140,4 +140,4 @@ function [a, b] = suby2 a = 1; b = 2; -end \ No newline at end of file +end
--- a/test/compile/bytecode_nested.m Sun Oct 08 20:16:02 2023 +0200 +++ b/test/compile/bytecode_nested.m Sun Oct 08 15:12:10 2023 -0400 @@ -338,8 +338,8 @@ % Try some legacy inline functions h1i = inline ("x + 1"); assert (h1i (2) == 3) - h2i = inline ("__vm_is_executing__()"); - assert (h2i() == __vm_is_executing__); + h2i = inline ("vm_is_executing()"); + assert (h2i() == vm_is_executing); end function subby
--- a/test/compile/shutup_operator_test/bytecode_disp.tst Sun Oct 08 20:16:02 2023 +0200 +++ b/test/compile/shutup_operator_test/bytecode_disp.tst Sun Oct 08 15:12:10 2023 -0400 @@ -9,10 +9,10 @@ %! % double's display. Is this a bug ??? %! clear classes %! key = "ans = 1 . ans = 5 . . ans = 0 . ans = 8 . ans = 3 . x = 3 . x = 1 y = 2 . x = 1 . . x = 1 . y = 2 . x = 1 "; -%! __vm_compile__ bytecode_disp clear; +%! vm_compile bytecode_disp clear; %! bytecode_disp; %! assert (__prog_output_assert__ (key)); %! -%! assert (__vm_compile__ ("bytecode_disp")); +%! assert (vm_compile ("bytecode_disp")); %! bytecode_disp; %! assert (__prog_output_assert__ (key));