Mercurial > octave
changeset 32423:8d34d9b8b6ee
VM: Rename VM functions with leading and trailing underscores.
This changeset makes the following naming changes to the VM:
* vm_enable, vm_compile, and vm_profile are renamed respectively as
__vm_enable__, __vm_compile__, and __vm_profile__
This was based on the discussion at:
https://octave.discourse.group/t/place-all-vm-functions-under-vm-prefix/4873
| author | Arun Giridhar <arungiridhar@gmail.com> |
|---|---|
| date | Wed, 18 Oct 2023 16:44:22 -0400 |
| parents | 251a5be9a564 |
| children | fd5ae4140483 |
| files | libinterp/corefcn/compile.cc libinterp/parse-tree/pt-bytecode-vm.cc libinterp/parse-tree/pt-bytecode.h test/Makefile.am test/compile-bench/bench-octave/bench.m test/compile-bench/bench-octave/bench_valgrind.m test/compile/bytecode.tst test/compile/shutup_operator_test/bytecode_disp.tst |
| diffstat | 8 files changed, 205 insertions(+), 205 deletions(-) [+] |
line wrap: on
line diff
--- a/libinterp/corefcn/compile.cc Wed Oct 18 16:26:04 2023 -0400 +++ b/libinterp/corefcn/compile.cc Wed Oct 18 16:44:22 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 Vvm_enable = false; +bool V__vm_enable__ = false; // Cleverly hidden in pt-bytecode-vm.cc to prevent inlining here extern "C" void dummy_mark_1 (void); @@ -159,39 +159,39 @@ 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. Profile code running in the VM. @table @code -@item vm_profile on +@item __vm_profile__ on Start the profiler, clearing all previously collected data if there is any. -@item vm_profile off +@item __vm_profile__ off Stop profiling. The collected data can later be retrieved and examined with @code{T = profile ("info")}. -@item vm_profile clear +@item __vm_profile__ clear Clear all collected profiler data. -@item vm_profile resume +@item __vm_profile__ resume Restart profiling without clearing the old data. All newly collected statistics are added to the existing ones. -@item vm_profile +@item __vm_profile__ Toggles between profiling and printing the result of the profiler. Clears the profiler on each print. -@item vm_profile info +@item __vm_profile__ info Prints the profiler data. Not that output to a variable is not implemented yet. @@ -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 () && Vvm_enable && !is_nested; + bool try_compile = !ufn->is_compiled () && V__vm_enable__ && !is_nested; if (try_compile && h && h->is_anonymous ()) h->compile (); @@ -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 (Vvm_enable, args, nargout, - "vm_enable"); + return set_internal_variable (V__vm_enable__, args, nargout, + "__vm_enable__"); } OCTAVE_END_NAMESPACE(octave)
--- a/libinterp/parse-tree/pt-bytecode-vm.cc Wed Oct 18 16:26:04 2023 -0400 +++ b/libinterp/parse-tree/pt-bytecode-vm.cc Wed Oct 18 16:44:22 2023 -0400 @@ -7483,7 +7483,7 @@ if (fn->is_compiled ()) return true; - if (Vvm_enable && !fn->m_compilation_failed) + if (V__vm_enable__ && !fn->m_compilation_failed) { try {
--- a/libinterp/parse-tree/pt-bytecode.h Wed Oct 18 16:26:04 2023 -0400 +++ b/libinterp/parse-tree/pt-bytecode.h Wed Oct 18 16:44:22 2023 -0400 @@ -328,7 +328,7 @@ }; // If TRUE, use VM evaluator rather than tree walker. -extern bool Vvm_enable; +extern bool V__vm_enable__; OCTAVE_END_NAMESPACE(octave)
--- a/test/Makefile.am Wed Oct 18 16:26:04 2023 -0400 +++ b/test/Makefile.am Wed Oct 18 16:44:22 2023 -0400 @@ -152,7 +152,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 Wed Oct 18 16:26:04 2023 -0400 +++ b/test/compile-bench/bench-octave/bench.m Wed Oct 18 16:44:22 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 Wed Oct 18 16:26:04 2023 -0400 +++ b/test/compile-bench/bench-octave/bench_valgrind.m Wed Oct 18 16:44:22 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 Wed Oct 18 16:26:04 2023 -0400 +++ b/test/compile/bytecode.tst Wed Oct 18 16:44:22 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
--- a/test/compile/shutup_operator_test/bytecode_disp.tst Wed Oct 18 16:26:04 2023 -0400 +++ b/test/compile/shutup_operator_test/bytecode_disp.tst Wed Oct 18 16:44:22 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));