Provided by: icmake_7.16.01-1ubuntu1_i386 bug

NAME

       icmake - A program maintenance (make) utility using a C-like grammar

SYNOPSIS

       icmake [options] source[.im] [dest[.bim]] [-- [args]]

       icmun bimfile

DESCRIPTION

       Icmake(1)  can  be  used  as an alternative to make(1). In its standard
       operation more, it calls the following programs:

       o      icm-pp  to preprocess the icmake file

       o      icm-comp   to byte-code compile the icmake  s

       o      icm-exec   to interpret the byte-code file

       Icmake allows  the  programmer  to  use  a  program  language  (closely
       resembling the well-known C-programming language) to define the actions
       involved in (complex) program  maintenance.  For  this,  icmake  offers
       various  special  operators  as well as a set of support functions that
       have proven to be useful in program maintenance.

       The program icmun(1) may be used to disassemble the compiled  byte-code
       file.

NEW IN VERSION 7.00

       o      Integral  constants  may be specified using hexadecimal notation
              (e.g., 0x12ab);

       o      The IM environment variable may  contain  multiple  directories,
              separated from each other by colons (:).

       o      #define-directives  may  refer  to other macro definitions using
              the ${identifier} format.

       o      #ifdef, #ifndef, #else and #endif directives can be nested.

       o      The `backtick' operator is defined, executing  a  program  in  a
              shell and collecting its standard output in a list (see below).

       o      The  index  operator  ([])  is  defined as an alternative to the
              pre-defined function element(), and can be  used  on  lists  and
              strings.

       o      The  function  string  getenv(string  envvar)  is predefined. If
              existing scripts already define a  getenv()  function  of  their
              own,  it  it  suggested  to remove this function and use the new
              getenv()   function   instead.   Alternatively,    rename    the
              script-defined  function getenv() and calls of this function to,
              e.g. my_getenv().

       o      The function  int  strstr(string  haystack,  string  needle)  is
              renamed to int strfind(string haystack, string needle).

              NOTE:  this  modification in version 7.00 could very well affect
              your earlier  (6.xx)  icmake  scripts.  Changing  `strstr'  into
              `strfind' should bring your older scripts up-to-date again.

OPTIONS

       Icmake:

       source: icmake script source file (default extension: .im).

       dest:   binary icmake script file (default:  `source'.bim).

       --:  icmake/icmake-script arguments separator

       args:   arguments following -- are entered into the icmake scipt main()
       function's argv-list (see below at section USER DEFINED FUNCTIONS).

       o      -a
              information about icmake

       o      -b
              blunt execution of the destinationfile

       o      -c
              the destination file is only compiled

       o      -i file
              file: name of source.  Icmake argument processing stops.

       o      -o file
              all icmake output is written to file (Not  implemented  on  unix
              platforms)

       o      -p
              only the preprocessor is activated

       o      -q
              quiet mode: copyright banner not displayed

       o      -t file
              file  is  used  as  a temporary bim-file, to be removed on exit.
              Icmake argument processing stops.

       Icmun:

       bimfile:  binary icmake script file.

PREPROCESSOR DIRECTIVES

       The following preprocessor directives are available:

       o      comment:
              standard  C  comment  (all  between  /*  and  */)  as  well   as
              comment-to-end-of-line  (all  line  contents  following  //) are
              ignored.

       o      Shell startup: The first line of  the  icmake-script  may  start
              with  #!path,  where  path  defines the absolute location of the
              icmake program. By making  the  script  executable,  it  can  be
              called without explicitly calling icmake.

              E.g.,  if  the  first  line  of an (executable) icmakefile 'icm'
              (without extension) contains

                          #!/usr/bin/icmake -qi

              then icm may be given as a command, thus executing

                          /usr/bin/icmake -qi icm ...

              Alternatively,

                          #! /usr/bin/icmake -qt /tmp/icm

              may be used, resulting in the execution of

                          #! /usr/bin/icmake -qt /tmp/icm icm ...

              In this case the binary makefile is not kept,  but  a  temporary
              file /tmp/icm.PID is used and removed on exit. The PID extension
              being the process-id of the icmake program executing icm.

       o      #include "filename"
              The file filename is included at the location of the directive

       o      #include <filename>
              The file filename is included at the location  of  the  #include
              directive; filename is searched in the directories pointed to by
              the IM environment variable.

       o      #define identifier definition
              The  text  identifier  will  be  replaced  by  definition.   The
              definition   may   contain   references   to   already   defined
              identifiers,   using   the   ${identifier}   format.   If    the
              ${identifier}  hasn't been defined (yet), the text ${identifier}
              is literally kept. At each #define at most 100 text-replacements
              are performed, preventing infinite recursion.

       o      #ifdef identifier
              If  the  identifier  macro  was  defined  the next block of code
              (until a matching #else or #endif  directive  was  detected)  is
              byte-compiled. Otherwise, the block of code is ignored.

       o      #ifndef identifier
              If  the  identifier macro was not defined the next block of code
              (until a matching #else or #endif  directive  was  detected)  is
              byte-compiled. Otherwise, the block of code is ignored.

       o      #else
              Terminates   a  #ifdef  and  #ifndef  directive,  reversing  the
              acceptance decision about  the following code.

       o      #endif
              Terminates the  preprocessor  block  starting  at  the  matching
              #ifdef, #ifndef or #else directive.

       o      #undef identifier
              Remove identifier from the set of defined symbols. This will not
              affect the specification of any previously  defined  symbols  in
              which identifier was used.

DATA TYPES

       The following data types are available:

       o      int
              Integral   values,   ranging  from  -0x8000  until  0x7fff.  int
              constants may  be  specified  as  decimal  numbers,  hexadecimal
              numbers or as ASCII character constants (e.g., 'x').

       o      string
              Text  variables.  Text constants are delimited by double quotes.
              Multiple text constants may be concatenated, but a text constant
              may  not  extend over multiple lines. To indicate an end-of-line
              in a text constant  use  the  \n  escape  sequence.  The  escape
              sequences  \a \b \f \n \r and \t are available. Otherwise, \x is
              interpreted as a literal x. So, use \\ to indicate  \  within  a
              text constant.

       o      list
              A  data structure containing a series of individually accessible
              string values. When a list contains elements, its first  element
              is indicated by index 0.

       o      void
              Used  with  function  definitions  to indicate that the function
              does not return a value.

       Variables may be defined both at the global level as well as locally to
       functions.  Variables  are  strongly  typed. A variable cannot have the
       type void.

       Variables may be initialized when they are defined. The  initialization
       can  use return values of functions, but cannot use variables. Consider
       initializations as being constructed from constant values.

PREDEFINED SYMBOLS

       The following symbols are predefined by icmake. All  are  constant  int
       values:

       ---------------------------------
       symbol      value   intended for
       ---------------------------------
       O_ALL       8       makelist
       O_DIR       2       makelist
       O_FILE      1       makelist
       O_SUBDIR    4       makelist
       ---------------------------------
       OFF         0       echo
       ON          1       echo
       ---------------------------------
       P_CHECK     0       system calls
       P_NOCHECK   1       system calls
       ---------------------------------
       S_IEXEC     32      stat
       S_IFCHR     1       stat
       S_IFDIR     2       stat
       S_IFREG     4       stat
       S_IREAD     8       stat
       S_IWRITE    16      stat
       ---------------------------------

       The following symbols are available depending on the architecture:

       -----------------------------------------------------------------
       symbol           1 when defined on the platform, otherwise 0
       -----------------------------------------------------------------
       MSDOS            MS-DOS platform (with MSC 7.00 compiler)
       unix             Unix, usually with GNU's gcc compiler
       linux            x86 running Linux (usually with gcc)
       M_SYSV, M_UNIX   x86 running SCO/Unix (usually with) Microsoft C
       _POSIX           _SOURCE   Unix with Posix complient compiler
       __hpux           HP-UX, with the native HP compiler
       -----------------------------------------------------------------

OPERATORS

       All  C  operators,  except  for  the  ternary  operator, are supported,
       operating like their C counterparts on int variables and/or values.

       Additionally, for string type variables  and/or  values  the  following
       operators are available:

       o      a  +  b: returns a new string value containing the concatenation
              of string values a and b. Note  that  string  constants  may  be
              concatetated without using the + operator, e.g.,

                  "hello "   "world"
                  "hello " + "world"

       o      a  +=  b:  a  must  be  a   string variable, to which the string
              variable or value b is appended.

       o      string comparisons: operators == != <= >= < > != and ==  may  be
              applied  to  string  values  or  variables,  returning  1 if the
              comparison   succeeds,   otherwise   0.   Comparison   is   case
              sensitively, and follows the ASCII character set.

       o      !a:  the  boolean ! operator returns 1 if the string a is empty,
              otherwise 0 is returned.

       o      a younger b, a newer b: returns 1 if file a is more recent  than
              file  b. E.g., "source.cc" newer "source.o". If b doesn't exist,
              1 is returned; if a doesn't exist 0 is returned;  if  neither  a
              nor  b  exists, 0 is returned; if they are of the same age, 0 is
              returned. Explicit tests for the existence  of  a  file  can  be
              performed  using  the  exists()  predefined function (see below,
              section PREDEFINED FUNCTIONS).

       o      a older b: turns 1 if  file  a  is  older  than  file  b.  E.g.,
              "libprog.a" older "source.o". If a doesn't exist, 1 is returned;
              if b doesn't exist 0 is returned; if neither a nor b  exists,  0
              is returned; if they are of the same age, 0 is returned.

       o      []:  the  index  operator  is  defined  as an alternative to the
              built-in function element. It can only be applied (as holds true
              for   element()   as   well)  as  so-called  rvalue.  Therefore,
              constructions like:

                      // assume str1 and str2 are strings
                  str1 = str2[3]

              will be accepted, but the following  construction  will  not  be
              accepted:

                  str2[3] = str; // won't compile

       For  list  type  variables  and/or  values  the following operators are
       available:

       o      a + b: returns a new list value containing the concatenation  of
              list  values a and b. This is not a set operation: if an element
              appears both in a and in  b,  they  will  appear  twice  in  the
              resulting list.

       o      a  -  b:  returns  a new list value containing the elements in a
              that are not present in b. This is a set operation.

       o      a += b: elements in b are added to the elements in a, which must
              be a  list variable.  This is not a set operation.

       o      a  -= b: elements in b are removed from the elements in a, which
              must be a list variable.  This is a set operation.

       o      list equality comparisons: operators != and == may be applied to
              list  values  or  variables. Operator == returns 1 if both lists
              have  element-by-element  identical   elements,   0   otherwise.
              Operator != reverses the result of ==.

       o      !a:  the  boolean  !  operator returns 1 if the list a is empty,
              otherwise 0 is returned.

       o      []: the index operator is  defined  as  an  alternative  to  the
              built-in function element. It can only be applied (as holds true
              for  element()  as  well)  as   so-called   rvalue.   Therefore,
              constructions like:

                      // assume lst is a list, str is a string
                  str = lst[3]

              will  be  accepted,  but  the following construction will not be
              accepted:

                  lst[3] = str; // won't compile

       Typecasts may be performed using the standard C cast-operator to cast:

       o      Strings to ints and vice versa ((int)"123", (string)55)

       o      Strings may be cast to lists (list lst = (list)"hello")

FLOW CONTROL

       Icmake offers the following subset of C's statement types. They can  be
       used as in the C programming language.

       o      expression ;
              The plain expression statement;

       o      The compound statement
              Different  from  C  icmake does not support variable definitions
              inside a compound statement. All variables  used  locally  by  a
              function  must  be  defined  as either function parameters or as
              variables that are defined immediately at  the  beginning  of  a
              function's body.

       o      if (condition) statement

       o      if (condition) statement else statement

       o      for (init; condition; increment) statement
              The  variable(s) used in the initialization section must already
              have been defined. The init, condition  and  increment  sections
              may be left empty. The empty condition section is interpreted as
              `always true'.

       o      while (condition) statement
              The do ... while() statement is not implemented for icmake.

       o      return (for void functions)  and  return  expression  for  other
              functions.

       o      break
              To  leave  for  and while statements, overruling the statement's
              condition. C's continue is not available.

       o      exit(expression)
              To terminate the icmake-script. The expression must evaluate  to
              an int value, which becomes the script's exit value.

PREDEFINED FUNCTIONS

       Icmake  offers  the  following  predefined functions, which can be used
       immediately  by  icmake  scripts.  The  function  overview  is  ordered
       alphabetically  by  function  name, but where appropriate short summary
       labels are provided:

       Helper functions of exec() (see also below at exec()):

       o      void arghead(string h)
              Defines the `argument head', to be used with exec(). By default,
              the `argument head' is an empty string.

       o      void argtail (string t)
              Defines the `argument tail', to be used with exec(). By default,
              the `argument tail' is an empty string.

       String-to-ascii converters:

       o      int ascii(string s)
              Returns the first character of s as  an  int;  e.g.,  ascii("A")
              returns 65;

       o      string ascii(int i)
              Returns i as a string, e.g., ascii(65) returns the string "A";

       System calls:

       o      The `backtick` operator (`)
              A  string  placed  between  two  backticks  is  executed  by the
              popen(3) function. The standard output gererated by the  command
              that  is stored in the string argument is returned as a list. An
              empty list indicates that the command could not be  executed.  A
              command  that  could  be executed but did not produce any output
              returns a list  containing  one  empty  element.  The  command's
              standard  error  stream  output  is not automatically collected.
              Standard shell redirection could be used to collect the standard
              error stream's output as well. Example:

                      string s = "ls";
                      printf(`s`);        // prints the elements in the current
                                          // directory

       Filename modifiers:

       o      string change_base(string file, string newbase)
              Changes  the  basename  of  file, returns the changed name. E.g,
              change_base("/path/demo.im", "out") returns "/path/out.im";

       o      string change_ext(string file, string newext)
              Changes the extension of file, returns the  changed  name.  E.g,
              change_ext("source.cc", "o") returns "source.o";

       o      string change_path(string file, string newpath)
              Changes  the  path  specification  of  file, returns the changed
              name.   E.g,   change_path("tmp/binary",   "/usr/bin")   returns
              "/usr/bin/binary".  Note  that  the  /-separator  is inserted if
              required.

       System calls:

       o      string chdir(string newdir)
              Changes the script's working directory, returns the previous dir
              as an absolute path.
              Use  chdir(".")  to get current working directory, chdir("") may
              be  used  to  obtain  the  startup   working   directory   (this
              functionality  was  broken  in releases before than 7.00, but is
              now operational). The function terminates the  icmake-script  if
              the specified newdir does not exist.

       o      string chdir(int checking, string newdir)
              Same  functionality  as the previous function, but by specifying
              checking as P_NOCHECK the function won't terminate  the  script.
              Rather, it will return the script's current working directory.

       Helper functions of exec() (see also below at exec()):

       o      cmdhead(string h)
              Defines  a  `command  head', to be used with exec(). By default,
              the `command head' is an empty string.

       o      cmdtail(string t)
              Defines a `command tail', to be used with  exec().  By  default,
              the `command tail' is an empty string.

       Icmake execution modifier:

       o      echo(int opt)
              Controls  echoing  of  called  programs  (and  their arguments),
              specify OFF if echoing  is  not  requested.  By  default  ON  is
              active.

       Functions returning elements of aggregates:

       o      string element(int index, list lst)
              Returns  string  index  (0-based)  from  lst. An empty string is
              returned if an unavailable index value is provided. See also the
              [] operator in the section OPERATORS.

       o      string element(int index, string str)
              Returns  character  index (0-based) from str. An empty string is
              returned if an unavailable index value is provided. See also the
              [] operator in the section OPERATORS.

       System calls:

       o      exec(string cmd, ...)
              Executes  command with arguments. Each argument will be prefixed
              by arghead()'s argument and postfixed by  argtail()'s  argument.
              Note  that  no blanks are inserted between arghead()'s contents,
              the argument proper, and argtail()'s argument. All thus modified
              arguments  are  concatenated,  this  time  separated  by  single
              blanks, and then cmdhead()'s contents are inserted  between  the
              command  and  the  first  argument  (on either side delimited by
              single blanks) and cmdtail()'s  contents  are  appended  to  the
              arguments (again, separated by a single blank). PATH is searched
              to locate cmd. 0 is returned.

       o      exec(int checkcmd, string cmd, ...)
              Same functionality as the previous function, but  by  specifying
              checking  as  P_NOCHECK the function won't terminate the script.
              Rather, it will return the  called  command's  exit  status,  or
              0x7f00 if the command wasn't found.

       o      execute(string  cmd,  string  cmdhd,  string  arghd, ..., string
              argtl, string cmdtl)
              Same as exec(), but command  head/tail  and  argument  head/tail
              must  be  specified.   The actually executed command starts with
              cmd, followed by cmdhd. Next is a series of  arguments  follows,
              each  enclosed  by  arghd and argtl. The command terminates with
              cmdtl. 0 is returned

       o      execute(int checking, string cmd, string  cmdhd,  string  arghd,
              ..., string argtl, string cmdtl)
              Same  functionality  as the previous function, but by specifying
              checking as P_NOCHECK the function won't terminate  the  script.
              Rather,  it  will  return  the  called command's exit status, or
              0x7f00 if the command wasn't found.  )

       System interface:

       o      int exists(string file)
              Returns  a  non-zero  value  if  file  exists,  otherwise  0  is
              returned.

       Input interface:

       o      list fgets(string file, int offset)
              The  next  line  found  at  offet  offset is read from file.  It
              returns a list retlist containing two elements:
              element(0, retlist) is the string that was read  (including  the
              \n, if found)
              element(1, retlist) is the next offset to read.

              An  empty  return  list  signifies  EOF.  Since  an empty list's
              `first' eement is an empty string, which  is  converted  to  the
              value 0, a file may be read and processed as follows:

                      list line;
                      while (1)
                      {
                          line = fgets("filename", (int)line[1]);
                          if (!line)
                              break;
                          process(line[0]);
                      }

       Output interface:

       o      int fprintf(string filename, ...)
              Appends  all  (comma  separated) arguments to the file filename.
              Returns the number of printed arguments.

       Filename modifier:

       o      string get_base(string file)
              Returns the base name of file. The base name is the file without
              its  path prefix and without its extension. The extension is all
              information starting at the final dot in  the  filename.  If  no
              final  dot  is  found,  the file name is the base name. Eg., the
              base name of a.b equals a, the base name of  a.b.c  equals  a.b,
              the base name of a/b/c equals c.

       System interface:

       o      list getenv(string envvar)
              Returns  the  value  of  environment  variable  envvar in a list
              containing two elements:
              the first element indicates whether the environment variable was
              defined (value "1") or not (value "0");
              the  second  element  indicates  the  value  of  the environment
              variable.

              Enivironment variables are of the form  variable=value,  and  if
              defined  the  list's second element contains value. If the value
              is empty, the variable is defined, but has  no  text  associated
              with it.

       Filename modifier:

       o      string get_ext(string file)
              Returns  the  extension  of file, except for the separating dot.
              The extension is all information starting at the  final  dot  in
              the  filename.  If  no  final  dot is found, the extension is an
              empty string.

       Input interface:

       o      string getch()
              Returns the next pressed key as a string  (no  `Enter'  required
              for ms-dos and unix (incl. linux) systems).

       Filename modifier:

       o      string get_path(string file)
              Returns  the  path-prefix  of  file.  The  path  prefix  is  all
              information up to (and including) the final directory  separator
              (which  is,  depending  on  the  operating system, a forward- or
              backslash).

              If no path is found, an empty strring is returned.

       System interface:

       o      int getpid()
              Returns the process-id (UNIX)  or  PSP-paragraph  (DOS)  of  the
              icmake byte code interpreter icm-exec.

       Input interface:

       o      string gets()
              Returns  the  next  line read from the keyboard as a string. The
              line entered on the keyboard must be terminated  by  an  `Enter'
              key, which is not stored in the returned string.

       Functions creating lists of files:

       o      list makelist(string mask)
              Returns a list of all files matching mask. E.g., makelist("*.c")
              returns a list containing all files ending in .c.

       o      list makelist(type, string mask)
              Same as the previous function, but the  type  of  the  directory
              elements may be specified as its first argument:

              symbol     meaning
              O_ALL      obtain all directory entries
              O_DIR      obtain all directories, including . and ..
              O_FILE     obtain a list of files
              O_SUBDIR   obtain all subdirectories

              Note  that  the  pattern  *  will not match hidden entries under
              Unix-type operating systems. Use .* for that.

       o      list makelist(string mask, newer, string comparefile)
              Returns list of all files matching mask which are newer  than  a
              provided  comparefile.  Operator  younger may be used instead of
              newer. Note that newer and younger are operators, not strings.

       o      list  makelist([int  =  O_FILE,]  string  mask,  newer,   string
              comparefile)
              Same  as  the previous function, but type may be specified as in
              list makelist(type, string mask).

       o      makelist(string mask, older, string comparefile)
              See above; returns a list of  files  that  are  older  than  the
              comparefile.

       o      makelist(type, string mask, older, string comparefile)
              Same  as  the previous function, but type may be specified as in
              list makelist(type, string mask).

       Output interface:

       o      int printf(...)
              Shows all (comma  separated)  arguments  to  screen  (i.e.,  the
              standard   output   stream).   Returns  the  number  of  printed
              arguments.

       System interface:

       o      int putenv(string envvar)
              Adds envvar to the current (icmake) environment Use the  format:
              "VAR=value". Returns 0.

       List information:

       o      int sizeof(list l)
              Returns the number of elements in list

       System information:

       o      list stat(string entry)
              Returns  stat(2) information of directory entry entry as a list.
              The returned list has two elements: element 0 is  the  attribute
              value, element 1 contains the size of the file.

              Attributes   are   returned  as  bit-flags,  composed  from  the
              following predefined constants:

                          S_IFCHR     S_IFDIR     S_IFREG
                          S_IREAD     S_IWRITE    S_IEXEC

              See the stat(2) manual page for the meanings of these constants.

       o      list stat(checking, string entry)
              Same as the previous function, but  by  specifying  checking  as
              P_NOCHECK  the  function  won't terminate the script. Rather, it
              will rturn stat(2)'s return value.

       String support:

       o      int strlen(string s)
              Returns the number of characters in s (not  counting  the  final
              0).

       o      int strfind(string haystack, string needle)
              returns index in haystack where needle is found, or -1 if needle
              is not contained in haystack.
              This function was called strstr() in versions before 7.00.

       o      string strlwr(string s)
              Returns a lower-case duplicate of s.

       o      list strtok(string str, string separators)
              Returns a list containing all substrings of str separated by one
              or   more   (consecutive)   characters   in   separators.  E.g.,
              strtok("hello icmake's+world", " +") returns the list containing
              the three strings "hello", "icmake's", and "world".

       o      string strupr(string s)
              Returns an upper-case duplicate of s.

       o      string substr(string text, int offset, int count)
              Returns  a  substring of text, starting at offset, consisting of
              count characters. If offset exceeds  (or  equals)  the  string's
              size  or  if  count  <=  0, then an empty string is returned. If
              offset is less than 0 then 0 is used.

       System calls:

       o      int system(string command)
              Executes  command.  The  return  value  indicates  the  executed
              command's exit value. The string command may contain redirection
              and/or piping characters.

       o      int system(int checking, string command)
              Same functionality as the previous function, but  by  specifying
              checking  as  P_NOCHECK the function won't terminate the script.
              Rather, it will return the  called  command's  exit  status,  or
              0x7f00 if the command wasn't found.  )

USER DEFINED FUNCTIONS

       Icmake  scripts  may  define  functions,  and a function main() must be
       defined. Functions must have the following elements:

       o      The function's return type. One of the available types  must  be
              used explicitly, e.g., void. There is no default type.

       o      The function's name, e.g., compile.

       o      A   parameter   list,  defining  zero  or  more  comma-separated
              parameters. The parameters themselves consist  of  a  type  name
              followed  by  the parameter's identifier. E.g., (string outfile,
              string source).

       o      A body surrounded by a pair of curly braces ({ and }).

              Function bodies may contain  (optionally  initialized)  variable
              definitions.  Variable  definitions  start  with  a  type  name,
              followed by one or more comma separated (optionally initialized)
              variable   identifiers.    If   a  variable  is  not  explicitly
              initialized it is initialized by default.  An  int  variable  is
              initialized to 0, a string is initialized to empty text ("") and
              a list is initialized to a list of zero elements.

              Following variable definitions, bodies may contain zero or  more
              statements  (see  below  at section FLOW CONTROL for the various
              flow-control statements). Note that all local variables must  be
              defined at the very beginning of function bodies.

       User  defined  functions  must  be  defined  before  they  can be used,
       although they may be called recursively. Therefore, indirect  recursion
       is not supported by icmake.

       The  user-defined  function  main() has three optional arguments, which
       may be omitted from the last one (envp) to the first (argc), as  in  C.
       Its full prototype is (note: void return type):

           void main(int argc, list argv, list envp)

       In main(),

       o      argc represents the number of elements in argv;

       o      argv  contains the arguments, with element 0 the compiled icmake
              script (the `.bim' file);

       o      envp  containts  the  `environment'  variables.   The   function
              sizeof()  (see  below)  may  be  used to determine its elements.
              Elements in envp have the  form  variable=value.  Alternatively,
              the  function  getenv()  (see  below)  can be used to retrieve a
              specific environment variable immediately.  Example:

                  void main(int argc, list argv)
                  {
                      list toCompile;
                      int idx;

                      if (argc == 1)
                          usage(element(0, argv));

                      if (toCompile = altered("*.cc"))
                      {
                          for (idx = sizeof(toCompile); idx--; )
                              compile(element(idx, toCompile));

                          if (getenv("dryrun")[0] == "0")
                              linking(element(2, argv));
                      }
                      exit (0);
                  }

FILES

       The  mentioned  paths  are  sugestive  only  and  may  be  installation
       dependent:

       o      /usr/bin/icmake: the main icmake program;

       o      /usr/bin/icmun: the icmake unassembler;

       o      /usr/lib/icm-pp: the preprocessor called by icmake;

       o      /usr/lib/icm-comp: the compiler called by icmake;

       o      /usr/lib/icm-exec: the byte-code interpreter called by icmake;

EXAMPLES

       The   distribution   (usually   in  /usr/share/doc/icmake)  contains  a
       directory examples containing various examples of icmake  script.  Note
       in  particular  the examples/icmbuild subdirectory containing a general
       script for C++ and C program maintenance.

SEE ALSO

       icmbuild(1), icmconf(7), icmstart(1), icmstart.rc(7), make(1)

BUGS

       None reported

COPYRIGHT

       This is free software, distributed under the terms of the  GNU  General
       Public License (GPL).

AUTHOR

       Frank B. Brokken (f.b.brokken@rug.nl).