imake - C preprocessor interface to the make utility


SYNOPSIS

       imake  [ -Ddefine ] [ -Idir ] [ -Ttemplate ] [ -f filename
       ] [ -C filename ] [ -s filename ] [ -e ] [ -v ]


DESCRIPTION

       Imake is used to generate Makefiles from a template, a set
       of  cpp  macro  functions,  and a per-directory input file
       called an Imakefile.   This  allows  machine  dependencies
       (such  as  compiler  options, alternate command names, and
       special make rules) to be kept separate from the  descrip-
       tions of the various items to be built.


OPTIONS

       The following command line options may be passed to imake:

       -Ddefine
               This option is passed directly to cpp.  It is typ-
               ically  used  to set directory-specific variables.
               For example, the X Window System uses this flag to
               set TOPDIR to the name of the directory containing
               the top of the core distribution and CURDIR to the
               name  of  the  current  directory, relative to the
               top.

       -Idirectory
               This option is passed directly to cpp.  It is typ-
               ically used to indicate the directory in which the
               imake template  and  configuration  files  may  be
               found.

       -Ttemplate
               This  option specifies the name of the master tem-
               plate file (which is usually located in the direc-
               tory  specified with -I) used by cpp.  The default
               is Imake.tmpl.

       -f filename
               This  option  specifies  the  name  of  the   per-
               directory input file.  The default is Imakefile.

       -C filename
               This option specifies the name of the .c file that
               is constructed  in  the  current  directory.   The
               default is Imakefile.c.

       -s filename
               This   option  specifies  the  name  of  the  make
               description file to be generated but  make  should
               not  be  invoked.   If the filename is a dash (-),
               the output is written to stdout.  The  default  is

                 #define IMAKE_TEMPLATE "Imake.tmpl"
                 #define INCLUDE_IMAKEFILE <Imakefile>
                 #include IMAKE_TEMPLATE

       where Imake.tmpl and Imakefile may be overridden by the -T
       and -f command options, respectively.

       The IMAKE_TEMPLATE typically reads in  a  file  containing
       machine-dependent parameters (specified as cpp symbols), a
       site-specific parameters file, a file defining  variables,
       a  file containing cpp macro functions for generating make
       rules,   and   finally   the   Imakefile   (specified   by
       INCLUDE_IMAKEFILE)  in  the current directory.  The Imake-
       file uses the macro functions  to  indicate  what  targets
       should be built; imake takes care of generating the appro-
       priate rules.

       Imake configuration files contain two types of  variables,
       imake  variables  and make variables.  The imake variables
       are interpreted by cpp when imake is run.   By  convention
       they  are mixed case.  The make variables are written into
       the Makefile for later interpretation by make.  By conven-
       tion make variables are upper case.

       The  rules file (usually named Imake.rules in the configu-
       ration directory) contains a variety of  cpp  macro  func-
       tions  that  are configured according to the current plat-
       form.  Imake replaces any occurrences of the string ``@@''
       with a newline to allow macros that generate more than one
       line of make rules.  For example, the macro

       #define   program_target(program, objlist)        @@\
       program:  objlist                                 @@\
                 $(CC)  -o  $@  objlist  $(LDFLAGS)

       when called with program_target(foo, foo1.o  foo2.o)  will
       expand to

       foo:      foo1.o  foo2.o
                 $(CC)  -o  $@  foo1.o  foo2.o  $(LDFLAGS)


       Imake  also replaces any occurrences of the word ``XCOMM''
       with the character ``#'' to permit placing comments in the
       Makefile without causing ``invalid directive'' errors from
       the preprocessor.

       Some complex imake macros require generated make variables
       local to each invocation of the macro, often because their
       value depends on parameters passed  to  the  macro.   Such
       variables can be created by using an imake variable of the
       mentioned above, two special variables, TOPDIR and CURDIR,
       are set to make  referencing  files  using  relative  path
       names  easier.  For example, the following command is gen-
       erated automatically to build the Makefile in  the  direc-
       tory lib/X/ (relative to the top of the sources):

                 %  ../.././config/imake  -I../.././config  \
                       -DTOPDIR=../../.   -DCURDIR=./lib/X

       When  building  X programs outside the source tree, a spe-
       cial symbol UseInstalled is defined and TOPDIR and  CURDIR
       are  omitted.   If the configuration files have been prop-
       erly installed, the script xmkmf(1) may be used.


INPUT FILES

       Here is a summary of the files read by imake as used by X.
       The indentation shows what files include what other files.

           Imake.tmpl                generic variables
               site.def              site-specific, BeforeVendorCF defined
               *.cf                  machine-specific
                   *Lib.rules        shared library rules
               site.def              site-specific, AfterVendorCF defined
               Imake.rules           rules
               Project.tmpl          X-specific variables
                   *Lib.tmpl         shared library variables
               Imakefile
                   Library.tmpl      library rules
                   Server.tmpl       server rules
                   Threads.tmpl      multi-threaded rules

       Note that site.def gets included twice,  once  before  the
       *.cf  file  and once after.  Although most site customiza-
       tions should be specified after the *.cf file, some,  such
       as  the  choice  of compiler, need to be specified before,
       because other variable settings may depend on them.

       The  first  time  site.def  is  included,   the   variable
       BeforeVendorCF  is defined, and the second time, the vari-
       able AfterVendorCF  is  defined.   All  code  in  site.def
       should be inside an #ifdef for one of these symbols.


FILES

       Imakefile.c                   temporary input file for cpp
       /tmp/Imf.XXXXXX               temporary Makefile for -s
       /tmp/IIf.XXXXXX               temporary Imakefile if spec-
       ified Imakefile uses # comments
       /lib/cpp                      default C preprocessor


SEE ALSO

       make(1), xmkmf(1)
       S.  I. Feldman, Make -- A Program for Maintaining Computer
            If  defined, this should be a valid path to a prepro-
            cessor  program.    E.g.,   ``/usr/local/cpp''.    By
            default, imake will use /lib/cpp.

       IMAKEMAKE
            If  defined,  this  should  be a valid path to a make
            program, such as  ``/usr/local/make''.   By  default,
            imake  will  use whatever make program is found using
            execvp(3).  This variable is only used if the  ``-e''
            option is specified.


AUTHOR

       Todd  Brunhoff, Tektronix and MIT Project Athena; Jim Ful-
       ton, MIT X Consortium

X Version 11                Release 6                           4