imake - C preprocessor interface to the make utility


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


   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.


   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 used 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

           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 is passed directly to cpp.  It is typically used to
           unset variables when debugging imake configuration files.

           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.

   -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

   -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
           to generate, but not execute, a Makefile.

   -e      This option indicates the imake should  execute  the  generated
           Makefile.  The default is to leave this to the user.

   -v      This  option  indicates that imake should print the cpp command
           line that it is using to generate the Makefile.


   Imake invokes cpp with any -I or -D flags 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 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 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  used  imake  extensively up through the X11R6.9
   release, for both full builds  within  the  source  tree  and  external
   software.  X has since moved to GNU autoconf and automake for its build
   system in X11R7.0 and later releases, but  still  maintains  imake  for
   building   existing  external  software  programs  that  have  not  yet

   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 script xmkmf(1)
   may be used.


   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
               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


          temporary input file for cpp

          temporary Makefile for -s

          temporary Imakefile if specified Imakefile uses # comments

          default C preprocessor


   make(1), xmkmf(1)

   Paul DuBois
          imake-Related         Software         and        Documentation,

   Paul DuBois
          Software Portability with  imake,  Second  Edition,  O'Reilly  &
          Associates, 1996.

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


   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  specifies a ``-I'' include argument to pass to
        the C preprocessor.  E.g., ``-I/usr/X11/config''.

        If defined, this should be a valid path to a preprocessor program.
        E.g.,  ``/usr/local/cpp''.   By  default,  imake will use cc -E or
        /usr/bin/cpp, depending on the OS specific configuration.

        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.


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


Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.

Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.

Free Software

Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.

Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.

Free Books

The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.

Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.


Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.

Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.