The remaining action options are:

MODIFIED: source -> :
o  -t tmpspec [options] : [arguments] script
 
       This option is intended for icmake-scripts although it can also be used
        in a command-line icmake call. Its argument tmpspec is either a
        single dot (as in -t.) in which case icmake determines the name of
        the bim-file in the directory icmake uses for temporary files (see
        option --tmpdir below), or it uses tmpspec as 
 the first part of the bim-file's path (like /tmp/scr, filename to
        write the bim-file to (which file is also removed once the script's
        execution ends) 
 or it can be a directory specification (which must then end in a /), where
        the bim file 'script's filename'.bim will be / remain available,
        recompiling it when it's older than 'script', but otherwise it's kept,
        so future executions of 'script' can skip the compilation phase:

-t.     
    icmake writes the temporary .bim file in its standard tmpdir directory,
    which is /tmp if /tmp is writable or ~/ if not.

-t~/dir/name or -t/dir/name
    icmake writes the temporary .bim file in ~/dir/nameUnique (or
        /dir/nameUnique where Unique is a unique addition to 'name'

-t~/dir/ or -t/path/
    icmake compiles/uses the .bim file [filesystem::stem(script).bim in the
        specified path in which case the file to compile is a temp. file
        written in that dir.



       The final 'script' argument must be provided when calling icmake -t
        using a command-line call. When using an executable icmake script its
        first line must start with #!/tmp/bin/icmake -t... replacing ... with
        the arguments supported by -t, without specifying script which is
        provided by the operating system to the executable icmake
        script. Single and double quotes around arguments specified in
        executable icmake scripts are not interpreted.
       
       Icmake skips the script's 1st line, and compiles and executes the
        compiled icmake script.

MODIFY -n: specify with -e, e.g. -en or -e --no-version-check

       At the options pre-processor options as well as the 
        --no-version-check execute option can be specified. When using the
        latter option it must follow the pre-processor options (if specified)
        and it must be preceded by --execute (or -e).

MODIFY (complete section)

        OBS The argument source is the name of the icmake script to process,
        OBS  and source may optionally be followed by arguments. 
        (replace 'source' by ':')

        The argument ':' is a separator (which may be any argument which does
        not start with - or -- and is not considered the argument of a
        preceding option requiring an argument), and is used to separate
        icmake's (pre)compile and execute options from arguments which are
        passed as-is to the icmake script's main function, where
        they appear as elements of its list argv parameter.

       Rather than using the explicit command-line call icmake -t. ... the
        -t option is normally used in the first line of an (executable) (so
        usually chmod +x source has been specified before calling the
        script), where its pre-processor and execute options can also be
        specified. For example after writing the executable script hello:
       
            #!/usr/bin/icmake -t. : one -two --three
            
            int main(int argc, list argv)
            {
                printf << "hello: " << argv << '\n';
            }
       
       the icmake script is compiled to, e.g., /tmp/104abc and called as
        /tmp/104abc one -two --three, producing the following output:
       
            hello: /tmp/104abc one -two --three
       
       (the name following hello: will be different, as it is the name of
        the compiled temporary bim-file). If icmake pre-process and/or execute
        options are required they can be specified in the first line,
        following the -t option. E.g.,
       
            #!/usr/bin/icmake -t. -d one --define two -e n
       

-----------------------------------------------------------------
    o  --about (-a)

       Shows some information about icmake;

o  --help (-h)
 
       Provides usage info, returning 0 to the operating system. Usage
        information is also provided if icmake is started without providing
        arguments. In that case 1 is returned to the operating system;

o  --version (-v)

       Displays icmake's version.

The remaining action options require additional options and/or arguments,
and most of them process icmake source- or bim-files. Several of these action
options write output files. By default these files are located in the same
directories as the source files' directories.

-------------------------------------------------------------------------
Finally, there are some (non-action) options that can be specified before
specifying action options:


    o  --no-process (-N)

       Implies option --verbose. This option may precede options -d,
        -e, -s and -t (either as two separate options or by `gluing' both
        options together, like -Ne). When specified, the actions are not
        activated, but the command(s) that would have been used are shown to
        the standard output;

o   --no-version-check (-n)

MODIFIED
       This option is available with the action options --unassemble, 
        --execute (and by actions implying --execute: --source, and -t). 
       When specified the main versions of icm-bim files and icmake itself may
        differ. This option should normally not be used, and was added for
        development purposes only;

o  --tmpdir=directory (-T)
 
       The specified directory is used for storing temporary files. E.g., when
        compiling an icmake script, the output of icmake's preprocessor is
        written to a temporary file which is removed when icmake ends. By
        default /tmp is used, unless /tmp is not a writable directory,
        in which case the current user's $HOME directory is used;

o  --verbose (-V)

       The child processes and their arguments are written to the standard
        output stream before they are called. This option may precede options
        -d, -e, -s and -t (either as two separate options or by
        `gluing' both options together, like -Ve).

-------------------------------------------------------------------------
o  --multicomp (-m) [options] jobs 'compiler-spec' 

       The optional options are the options of the icm-multicomp
        program: --threads (-t) and/or --quiet (-q). The
        'compiler-spec' argument is the (quoted) compiler call
        specification, using $1 to refer to the source file to compile, $2
        to refer to the object file's path, like
       
            '/usr/bin/g++ -c -o $2 --Wall -Werror $1'

       Threaded compilation is automatically used when the #define
        MULTICOMP directive is specified in projects' icmconf files.

       Refer to section ICM-MULTICOMP (below) for a description of
        icm-spch's usage and arguments.

o  --preprocess (-p)  [options] source [pim-file] 

       The file specified as first argument is pre-processed, producing a
        `.pim' file. If a second filename argument is provided then that
        file becomes the .pim file. If not specified, then
        the first filename, using the extension .pim, is used. 

       With this option pre-processor symbol-defining options can be used:
        symbols having values 1 which can be used in source. E.g., when
        issuing the command
       
            icmake -p -d one --define two source dest.pim
       
       then icmake pre-processes source, defines the pre-processor symbols
        one and two (each having value 1), and produces the pim-file
        dest.pim. Note that instead of using long options --define
        short options -d can also be used;

Direct forwarding       

o  --dependencies (-d) [options] action

       Icmake calls icm-dep to determine the dependencies among
        classes. All options and arguments following this option are forwarded
        to icm-dep. Refer to the ICM-DEP section of this man-page for
        information about icm-dep;

o  --unassemble (-u)

       The file specified as first argument is an icmake bim-file, which is
        unassembled. Refer to the icmun section further down this man-page
        for more information about icmun;

       The program icmun unassembles bim-files. This program also
        supports the --no-version-check (-n) option.

o  --spch (-S) ... 

       A SPCH is built. All options and arguments following --spch are
        forwarded to the icm-spch support program.

       A SPCH is automatically constructed when the #define SPCH directive
        is specified in projects' icmconf files.

       Refer to section ICM-SPCH (below) for a description of
        icm-spch's usage and arguments.

MODIFIED:
    separate call examples:        
icmake -S -i .ih -o -fdiagnostics-color=never -k xerr/xerr.ih -l spch
icmake -S -p spch -o -fdiagnostics-color=never  -k xerr/xerr.ih tmp/spch.gch
icmake -S -s spch -o -fdiagnostics-color=never -k xerr/xerr.ih  tmp/spch.gch

o  --execute (-e) [option] bim-file [arguments]
 
       Executes the bim-file, specified as icmake's first file argument. Before
        the bim-file option --no-version-check (or the equivalent
        short option -n) can be specified to allow mismatches between
        icmake's main version and the icmake version that was used to compile
        the bim-file. See also the description of the --no-version-check
        option at the description of the non-action options below.

       Options and arguments specified beyond the bim-file are forwarded
        as arguments to the bim-file's main function (refer to the
        icmscript(7) man-page for details about how to write
        icmake-scripts);

    o  --compile (-c) [options] source [bim-file] 

       The source file is first pre-processed (by icm-pp) whereafter
        the pre-processed file is compiled (by icm-comp), producing a
        bim-file.  If the bim-file name is not specified then
        source's base-name, receiving extension .bim, is used.

       If the bim-file exists and is younger than source then source
        is not compiled.

       With this option pre-processor symbol-defining options can be used:
        symbols having values 1 which can be used in source. E.g., when
        issuing the command
       
            icmake -c -d one --define two source dest.bim
       
       then icmake compiles source, defines the pre-processor symbols
        one and two (each having value 1), and produces the bim-file
        dest.bim. Note that instead of using long options --define
        short options -d can also be used.

       If source is a previously pre-processed file then option -P
        must be specified to compile it. E.g.,
       
            icmake -c -P source dest.bim

o  --force (-f) [options] source [bim-file] 

       Acts like option --compile, but compilation is always performed,
        even if the bim-file is up-to-date. As with --compile, if
        source is a previously pre-processed file then option -P must
        be specified to compile it. E.g.,
       
    icmake -f -P source dest.bim
       

o  --source (-s)  [options] source [arguments] 

       Icmake uses --compile to compile the icmake source file specified as
        first argument (constructing the default bim-file if necessary) and
        then uses --execute to execute the bim-file, forwarding any
        subsequent arguments as-is to the bim-file's main
        function.

       With this option pre-processor options as well as the 
        --no-version-check execute option can be used. When using the
        latter option it must follow the pre-processor options (if specified)
        and it must be preceded by --execute (or -e). E.g., when
        issuing the command
       
            icmake -s -d one -en source 
       
       then icmake first compiles source, defining the pre-processor symbol
        one, and then executes the bim-file, passing
        --no-version-check to icm-exec;

