It is sometime desirable to lock a function into memory with the mlock
function. This is typically used for dynamically linked functions in
oct-files or mex-files that contain some initialization, and it is desirable
that calling clear does not remove this initialization.
As an example,
function my_function () mlock (); ... endfunction
prevents my_function from being removed from memory after it is called,
even if clear is called. It is possible to determine if a function is
locked into memory with the mislocked, and to unlock a function with
munlock, which the following code illustrates.
my_function ();
mislocked ("my_function")
⇒ ans = 1
munlock ("my_function");
mislocked ("my_function")
⇒ ans = 0
A common use of mlock is to prevent persistent variables from being
removed from memory, as the following example shows:
function count_calls ()
mlock ();
persistent calls = 0;
printf ("count_calls() has been called %d times\n", ++calls);
endfunction
count_calls ();
-| count_calls() has been called 1 times
clear count_calls
count_calls ();
-| count_calls() has been called 2 times
mlock might also be used to prevent changes to an m-file, such as in an
external editor, from having any effect in the current Octave session; A
similar effect can be had with the ignore_function_time_stamp function.
() ¶Lock the current function into memory so that it can’t be removed with
clear.
See also: munlock, mislocked, persistent, clear.
() ¶(fcn) ¶Unlock the named function fcn so that it may be removed from memory with
clear.
If no function is named then unlock the current function.
See also: mlock, mislocked, persistent, clear.