{progress, Term} sets the "progress" of the
initialization program. The function init:get_status()
returns the current value of the progress, which is
{InternalStatus,Term}.

{path, [Dir]} where Dir is a string. This
argument sets the load path of the system to [Dir]. The
load path used to load modules is obtained from the initial
load path, which is given in the script file, together with
any path flags which were supplied in the command line
arguments. The command line arguments modify the path as
follows:

-pz Dir1 Dir2 ... DirN adds the directories
Dir1, Dir2, ..., DirN to the end of the initial
load path.

-path Dir1 Dir2 ... DirN defines a set of
directories Dir1, Dir2, ..., DirN which replaces
the search path given in the script file. Directory names
in the path are interpreted as follows:

Directory names starting with / are assumed
to be absolute path names.

Directory names not starting with / are
assumed to be relative the current working directory.

The special $ROOT variable can only be used
in the script, not as a command line argument. The
given directory is relative the Erlang installation
directory.

{primLoad, [Mod]} loads the modules [Mod]
from the directories specified in Path. The script
interpreter fetches the appropriate module by calling the
function erl_prim_loader:get_file(Mod). A fatal error
which terminates the system will occur if the module cannot be
located.

{kernel_load_completed} indicates that all modules
which must be loaded before any processes
are started are loaded. In interactive mode, all
{primLoad,[Mod]} commands interpreted after this
command are ignored, and these modules are loaded on demand.
In embedded mode, kernel_load_completed is ignored, and
all modules are loaded during system start.

{kernelProcess, Name, {Mod, Func, Args}} starts a
"kernel process". The kernel process Name is started
by evaluating apply(Mod, Func, Args) which is expected
to return {ok, Pid} or ignore. The init
process monitors the behaviour of Pid and terminates
the system if Pid dies. Kernel processes are key
components of the runtime system. Users do not normally add
new kernel processes.

{apply, {Mod, Func, Args}}. The init process simply
evaluates apply(Mod, Func, Args). The system
terminates if this results in an error. The boot procedure
hangs if this function never returns.

Note

In the interactive system the code loader provides
demand driven code loading, but in the embedded system
the code loader loads all the code immediately. The same
version of code is used in both cases. The code server
calls init:get_argument(mode) to find out if it should
run in demand mode, or non-demand driven mode.