Provided by: erlang-manpages_13.b.3-dfsg-2ubuntu2_all bug

NAME

       script - Boot script

DESCRIPTION

       The  boot script describes how the Erlang runtime system is started. It
       contains instructions on which code to load  and  which  processes  and
       applications to start.

       The  command  erl  -boot Name starts the system with a boot file called
       Name.boot,  which  is  generated  from  the  Name.script  file,   using
       systools:script2boot/1.

       The  .script  file  is  generated by systools from a .rel file and .app
       files.

FILE SYNTAX

       The boot script is stored in a file with the extension .script

       The file has the following syntax:

       {script, {Name, Vsn},
        [
         {progress, loading},
         {preLoaded, [Mod1, Mod2, ...]},
         {path, [Dir1,"$ROOT/Dir",...]}.
         {primLoad, [Mod1, Mod2, ...]},
         ...
         {kernel_load_completed},
         {progress, loaded},
         {kernelProcess, Name, {Mod, Func, Args}},
         ...
         {apply, {Mod, Func, Args}},
         ...
         {progress, started}]}.

         * Name = string() defines the name of the system.

         * Vsn = string() defines the version of the system.

         * {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:  .br .br .RS 2 .TP 2 * -pa Dir1 Dir2 ... DirN adds the
           directories Dir1, Dir2, ..., DirN to the front of the initial  load
           path.  .br  .br .TP 2 * -pz Dir1 Dir2 ... DirN adds the directories
           Dir1, Dir2, ..., DirN to the end of the initial load path. .br  .br
           .TP 2 * -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: .br
           .br .RS 2 .TP 2 * Directory names starting with / are assumed to be
           absolute  path  names. .br .br .TP 2 * Directory names not starting
           with / are assumed to be relative the  current  working  directory.
           .br  .br .TP 2 * 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. .br .br .RE .br .br .RE

         * {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.

SEE ALSO

       systools(3erl)