It is sometime desirable to lock a function into memory with the
function. This is typically used for dynamically linked functions in
oct-files or mex-files that contain some initialization, and it is desirable
clear does not remove this initialization.
As an example,
function my_function () mlock (); … endfunction
my_function from being removed from memory after it is called,
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
Lock the current function into memory so that it can’t be removed with
Unlock the named function fcn so that it may be removed from memory with
If no function is named then unlock the current function.