imake Frequently Asked Questions

Paul DuBois

Wisconsin Regional Primate Research Center
Version 1.01
Revision date: 1 May 1997

Table of Contents


This document is the imake Frequently Asked Questions (FAQ) list. It tries to answer some of the commonly-asked questions about imake, a Makefile generator used for software configuration.

This document is available in the imake-stuff archive, which is located at:

If you have comments about this FAQ or suggestions for material to be included, please send them to the FAQ maintainer, Paul DuBois, At the moment, this FAQ is very new and in great need of suggestions for improvement.


What is imake? How does it work?

imake is a Makefile-generator that is intended to make it easier to develop software portably for multiple systems. Makefiles are inherently non-portable, so instead of writing them by hand, machine-dependencies are specified explicitly in a set of configuration files. Instead of writing a Makefile, you write an Imakefile, which is a machine-independent description of what targets you want to build. This way your description file doesn't need to change when you build your software on different systems. imake reads the Imakefile and combines the specifications in it with the proper machine dependencies from the configuration files to write a Makefile tailored for a specific system. The Imakefile and the configuration files are processed by cpp, so they are written using conventions that should be familiar to most C programmers.

What systems does imake run on?

imake runs primarily on UNIX sytems and Windows NT as distributed (see "Where can I get imake?"). There are also ports to other systems such as OS/2, AmigaOS, and reputedly OpenVMS (though I have not been able to confirm this). Port information is available at the imake-stuff archive.

Who owns imake? What is its redistribution status?

imake is a product of The Open Group:
   The Open Group
   11 Cambridge Center
   Cambridge, MA 02142-1405

imake is copyrighted by The Open Group, but is freely available and redistributable.

Where can I get imake?

imake is distributed as part of the X Window System (another product of The Open Group), which is available online at:

There are also several mirror sites; a list is available in the GettingR6 file at the locations just shown.

If you don't want to get the X11 distribution, the imake-related parts of X11 are packaged as the itools distribution, which is available at:

You should use the most recent version of imake you can. The current version is the one distributed with X11R6.3. However, you need an ANSI C compiler to build it. If you don't have one, you may be able to build the version distributed with X11R6.1. There is also an R6.1-based itools distribution.

Many of the freely-available UNIX variants (e.g., FreeBSD, Linux) include imake in their standard distributions. Check the distribution for an X developer's package, since imake may not be installed if you install only the X server and X client packages.

Similarly, XFree86 includes imake, but it won't be installed unless you install the developer's part of the distribution.

What do I need in order to be able to run imake?

At a minimum, you need imake itself, a set of configuration files, cpp, make, and a bootstrapper such as xmkmf or imboot.

Also recommended are makedepend, mkdirhier (if your system doesn't support mkdir -p), and bsdinst or (if your system doesn't have a BSD-compatible install program).

All of these are available in the X11 or itools distributions.

Where can I find information about imake?

There are several sources of information about imake:

Using imake

How do I build a project that has an Imakefile?

For projects that include an Imakefile, you need to run imake to generate the corresponding Makefile. However, you never run imake directly. Instead, you run a bootstrapper that invokes imake for you and passes to it any flags that are needed. (For instance, the bootstapper will tell imake what directory to look in to find the configuration files.)

If the project is for an X program, try generating the Makefile by running xmkmf. If that works, try make and make install. If you don't have xmkmf, see "Where can I get imake?"

If the program isn't an X program, then its documentation should say something about how to bootstrap the Makefiles.

To regenerate the Makefile (e.g., after making a change to the Imakefile), you can either run the bootstrapper again, or else run this command:

   % make Makefile
If the project has multiple directories, you'll need to generate the Makefiles in any subdirectories:
   % make Makefiles

I make a change to the Imakefile, but it's not reflected in the Makefile. Why?

You need to rerun imake to regenerate the Makefile from the modified Imakefile. See "How do I build a project that has an Imakefile?"

How do I write an Imakefile?

That depends on the configuration files you're using, although the general principles are similar for any set of configuration files. Probably the easiest way to write an Imakefile is to find a project similar to yours, and modify a copy of the Imakefile from that project. For further reading, the config/cf/README file in the X11 or itools distributions contains some tips on Imakefile writing, and the boa book discusses this topic extensively.

Problems Generating Makefiles

I get this error: "Imake.tmpl: no such file or directory"

This message means that imake is unable to find the configuration files. (The message names Imake.tmpl because that is the first file that imake tries to read.) This error message can occur for several reasons:

I get XCOMM symbols all through my Makefile and make complains about them. What's going on?

XCOMM is used in Imakefiles and configuration files to write lines that should end up in Makefiles as comments. For instance, this line:
   XCOMM this is a comment
should end up as:
   # this is a comment
The XCOMM symbol is supposed to be translated to # during Makefile generation.

If translation fails and you see XCOMM symbols in your Makefile, you're probably using a newer set of configuration files (e.g., from X11R6 or later) that expect XCOMM to be translated to # by imake and an older version of imake (e.g., from X11R5 or before) that expects the configuration files to handle the translation. The solution is to upgrade to a version of imake from X11R6 or later.

Why can't imake find cpp under AIX?

Try setting the environment variable IMAKECPP to /usr/lpp/X11/Xamples/util/cpp/cpp.

When I run "make install", it complains about not being able to find

Install in a public directory as mkdirhier (no .sh suffix), make it executable, and change MKDIRHIER in Imake.tmpl from this:
   #ifdef UseInstalled
     ...other stuff...
       MKDIRHIER = BourneShell $(BINDIR)/mkdirhier
     ...other stuff...
       MKDIRHIER = BourneShell $(SCRIPTSRC)/
to this:
       MKDIRHIER = mkdirhier
   #ifdef UseInstalled
     ...other stuff...
     ...other stuff...
Another solution is to upgrade to a more recent set of configuration files, since this problem occurs with the X11R4 and X11R5 configuration files, but has been fixed in later X11 releases.

How can I get imake to work with my OpenWindows setup?

See Appendix J of the boa book (2nd edition) or check the imake-stuff archive for the "imake vs. OpenWindows" documentation. The documentation describes why OpenWindows systems have problems with imake and how to fix them. The archive also contains a software distribution that makes it easier to use imake with OpenWindows.

How can I use gcc with OpenWindows imake support?

See previous question. The software distribution mentioned there contains configuration file patches for gcc support.

How can I build Motif 2.x using imake?

Check the imake-stuff archive for the "Motif Support" documentation.

Debugging imake

How can I see what flags imake passes to cpp?

Try this command:
   % imake -v -s/dev/null -f/dev/null -T/dev/null
If your shell supports {...} expansion, the following command is equivalent but simpler to type:
   % imake -v -{s,f,T}/dev/null

How can I see what imake writes to Imakefile.c?

When imake runs, it creates a file Imakefile.c that contains the initial input to be given to cpp. (This assumes you're running an X11R6 or later version of imake). Sometimes it's useful to be able to see what is being passed to cpp, but imake removes Imakefile.c when cpp terminates.

However, if you create Imakefile.c as a link to another file before running imake, then that file will still exist and contain the contents of Imakefile.c after imake runs, even though Imakefile.c will have been removed. Then you can look at the file to see what's in it.

You can use this trick with a sequence of commands such as the following:

   % touch fake
   % ln fake Imakefile.c
   % make Makefile     (or xmkmf, imboot, etc.)
   % more fake
This works by creating Imakefile.c as a link to a file fake before running imake. imake writes the contents of Imakefile.c, then removes it later, but since fake is a link to Imakefile.c, it remains in existence after imake runs and you can take a look at it.

Note that you'll need to re-run the ln command each time you run imake to be able to see what gets written to Imakefile.c.