ICMAKE Part 2

Icmake allows the construction of user-defined functions in a makefile. The definition of a function must follow an ansi-C-like syntax, however, minor differences exist between an icmake function and a C function. These differences are highlighted in this section.

The definition of a function must follow the syntax:

In contrast to C, local variables can only be defined immediately after the outer curly brace of the function code block. Variables cannot be defined within a block of statements.

In contrast to C, icmake initializes all local variables to zero.

Icmake does not allow forward references. This means that a function may be called only after it has been defined. Recursive function calls are accepted. Furthermore, the statement which calls a function must supply the exact number of required arguments and each argument type must match the parameter list of the function. The built-in functions are predefined and may therefore be used anywhere within functions.

The code section of a makefile must contain at least one user-defined function, called main(). The execution of a makefile starts at this function. The run-time support system of icmake provides three arguments which the function main() may use. The arguments are used to hold the command line parameters of the icmake invocation and the environment setting.

The three arguments are most commonly referred to as argc, argv and envp. Argc is an int argument, holding the number of command line parameters. Argv is a list, holding the command line parameters themselves. Envp is a list holding the environment setting. A definition of the main() function which uses all arguments argc, argv and envp is given below:

int main(int argc, list argv, list envp)
        {
            // statement(s)
        }

Users may wish to define the main() function without arguments when the command line parameters need not be examined. In this case, the main() function can be defined as:

int main
{
//statements(s)
}

It is also possible to define the main() function to use only the first or the first two arguments (argc and argv). A sample makefile which prints its command line arguments is given below. The functions printf() and element() used in this example are discussed in the function-section below:

The arguments passed to main() functions as the list argv are:

void main (int argc, list argv)
   {
       int
           i;
       for (i = 0; i < argc; i++)
           printf ("Argument ", i, " is ", element (i, argv), "\n");
   }

For example, to supply the arguments one, two and three to a makefile called try.im, one of the following invocations can be used:

        icmake test - one two three
                or:
        icmake -i test.im one two three

In both cases, the first int argument of the function main() will have the value four. The first element of the list argv holds the name of the binary makefile (test.bim); the remaining elements of argv hold the arguments one, two and three.

The third argument of main(), envp, is a list holding the setting of the environment (the environment variables). An example of such a variable is PATH, specifying where the operating system searches for executable files. The envp list consists of pairs of elements, where each first element of the pair holds the variable name (e.g., the string PATH) and where the second element of each pair holds the value of the variable (e.g., a list of directories where executable files may be found).

An example of a makefile which prints the settings of environment variables is given below:

void main (int argc, list argv, list envp)
        {
            int
                i;
            for (i = 0; i < sizeof (envp); i += 2)
                printf ("variable ", element (i, envp), " has value ",
                       element (i + 1, envp));
        }