*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Tru64 Unix man pages -> imake (1X)              



NAME    [Toc]    [Back]

       imake - C preprocessor interface to the make utility

SYNOPSIS    [Toc]    [Back]

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

OPTIONS    [Toc]    [Back]

       The following command line options may be passed to imake:
       This  option  is  passed directly to cpp.  It is typically
       used to set directory-specific  variables.   For  example,
       the  X Window System uses this option 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.  This option is  passed  directly  to
       cpp.   It  is  typically used to indicate the directory in
       which the imake template and configuration  files  may  be
       found.   This option specifies the name of the master template
 file (which is  usually  located  in  the  directory
       specified with -I) used by cpp. The default is Imake.tmpl.
       This option specifies the name of the per-directory  input
       file.   The  default  is Imakefile.  This option specifies
       the name of the file that is constructed  in  the  current
       directory.  The default is Imakefile.c.  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
       to  generate,  but  not  execute, a Makefile.  This option
       indicates the imake should execute the generated Makefile.
       The  default  is  to  leave this to the user.  This option
       indicates that imake should print  the  cpp  command  line
       that it is using to generate the Makefile.

DESCRIPTION    [Toc]    [Back]

       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 descriptions
 of the various items to be built.

HOW IT WORKS    [Toc]    [Back]

       Imake invokes cpp with any -I or -D options passed on  the
       command  line and passes the name of a file containing the
       following 3 lines:

       #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 Imakefile
 uses the macro functions  to  indicate  what  targets
       should be built; imake takes care of generating the appropriate

       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  convention
 make variables are upper case.

       The  rules file (usually named Imake.rules in the configuration
 directory) contains a variety of  cpp  macro  functions
  that  are configured according to the current platform.
  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
       form XVARdefn, where n is a single digit.  A  unique  make
       variable  will  be  substituted.  Later occurrences of the
       variable XVARusen will be replaced by the variable created
       by the corresponding XVARdefn.

       On systems whose cpp reduces multiple tabs and spaces to a
       single space, imake attempts to  put  back  any  necessary
       tabs (make is very picky about the difference between tabs
       and spaces).  For this reason, colons (:) in command lines
       must be preceded by a backslash (\).


       The  X Window System uses imake extensively, for both full
       builds within the source tree and external  software.   As
       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 generated
 automatically to build the Makefile in  the  directory
 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 special
 symbol UseInstalled is defined and TOPDIR and  CURDIR
       are  omitted.   If the configuration files have been properly
 installed, the xmkmf script may be used.

INPUT FILES    [Toc]    [Back]

       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
               *.cf              machine-specific
                   *Lib.rules    shared library rules
               site.def            site-specific,   AfterVendorCF
               Imake.rules       rules
               Project.tmpl      X-specific variables
                   *Lib.tmpl     shared library variables
                   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 customizations
 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 variable
 AfterVendorCF  is  defined.   All  code  in  site.def
       should be inside an #ifdef for one of these symbols.


       The  following  environment  variables may be set, however
       their use is not recommended as they  introduce  dependencies
  that  are not readily apparent when imake is run: If
       defined, this should be a valid include argument for the C
       preprocessor.  E.g., "-I/usr/include/local". Actually, any
       valid cpp argument  will  work  here.   If  defined,  this
       should  be  a  valid path to a preprocessor program. E.g.,
       "/usr/local/cpp". By default, imake will use /lib/cpp.  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(2).  This
       variable is only used if the "-e" option is specified.

FILES    [Toc]    [Back]

       Temporary input file for cpp Temporary  Makefile  for  -s"
       Temporary Imakefile if specified Imakefile uses # comments
       Default C preprocessor

SEE ALSO    [Toc]    [Back]

       make(1), xmkmf(1X)

       S. I. Feldman, Make -- A Program for Maintaining  Computer

AUTHOR    [Toc]    [Back]

       Todd  Brunhoff, Tektronix and MIT Project Athena; Jim Fulton,
 MIT X Consortium

[ Back ]
 Similar pages
Name OS Title
mmd Tru64 mtools utility to make a DOS directory
make Linux GNU make utility to maintain groups of programs
apt-get Linux APT package handling utility -- command-line interface
accessx Tru64 A graphical interface to the AccessX keyboard enhancement utility
apci OpenBSD Apollo utility chip serial communications interface
cpp-2.96 Linux The C Preprocessor
lesspipe Linux "input preprocessor" for less.
cpp HP-UX the C language preprocessor
cpp Tru64 the C language preprocessor
mmroff FreeBSD reference preprocessor
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service