The hmake compilation management tool

Hmake is an intelligent compilation management tool for Haskell programs. It automatically extracts dependencies between source modules, and issues the appropriate compiler commands to rebuild only those that have changed, given just the name of the program or module that you want to build. Yes, you need never write a Makefile again!

Highlights

• hmake knows about interface (.hi) files. Even though a source module has changed, if its interface file has not changed, then other modules which import it do not need to be recompiled.
• hmake is compiler-independent. The installation process automatically detects which Haskell compilers you have, and sets up hmake to use any of them. You can separately add or remove compilers to the configuration at any time after installation, and change which compiler is used as the default. You can easily use different versions of a compiler (e.g. ghc 4.08 + 5.02) without any extra hassle. (See hmake-config.)
• hmake is aware of many pre-processors. Not only is the C preprocessor commonly used for selective imports, but tools such as happy, hsc2hs, c2hs, greencard, are also often used to generate Haskell modules. If hmake finds a module with the appropriate filename extension (.y, .ly, .hsc, .chs, .gc), it automatically runs the preprocessor before the compiler.

Minor Features

• hmake can generate object files in a separate directory from your sources.
• hmake understands the library package system.
• hmake understands hierarchical module namespaces.
• hmake understands the Hat tracer.

The basic option summary is:

    Usage: hmake [compiler] [hmake-opts] [compiler-opts] target ...

You can use any form of the compiler name that would normally work directly on the command-line, for instance

  hmake -ghc Prog.hs
  hmake -HC=/usr/local/bin/ghc-5.02.2 Prog.hs
  hmake -hc ghc-5.02.2 Prog.hs

Targets

• You can have more than one target: all of them are built.
• If the target is a module source filename (i.e. with .lhs, .hs, .hi, or pre-processor extension), the module and everything it depends on is compiled, but not linked. e.g.

      hmake LiterateMod.lhs HappyMod.ly 

• If the target is a program name (i.e. no extension), the appropriate modules are linked as well as compiled. e.g.

      hmake Prog 

• An object or archive filename (.o, .a extension) cannot be a target, but if you add it to the commandline, it will be added into the final link.

Hmake Options

Most options are passed straight through to the appropriate compiler. However, hmake understands and strips the following options.

Compiler Options

Hmake also makes use of some compiler options if you specify them. (That is, the options are used by hmake as well as being passed on to the compiler, with suitable translation if necessary.)

Some options are passed to the compiler's runtime system (using whatever underlying mechanism is appropriate for the particular compiler).

You can force an option which would otherwise be interpreted by another part of the system to be passed to the compiler by enclosing it within +CTS ... -CTS delimiters. For example, with nhc98, to set the final executable's default heapsize rather than the compiler's heapsize, use +CTS -H4mb -CTS.

Pre-processors

hmake understands cpp directives in the source modules: this is particularly useful for imports which differ depending on which compiler you are using. For example,

        #if defined(__HBC__) || defined(__GLASGOW_HASKELL__)
        import Native
        #elsif __NHC__
        import Binary
        #endif

Various other Haskell-specific preprocessors (happy, c2hs, hsc2hs, greencard) are recognised and called automatically when the source filename indicates by its extension that they are required. It is not currently possible to pass extra options just to the preprocessor.

Hat Options

hmake understands the Hat tracing system. This is essentially just a more complex pre-processor. For every module, the file is first transformed by hat-trans, generating a new module which is then compiled with some extra options. Additionally, if any other pre-processing is required, it must be done before hat-trans is called; an auxiliary interface file (.hx) is also tracked.

The latest updates to this software are available on the WWW from http://www.haskell.org/hmake/ ( http://www.cs.york.ac.uk/fp/hmake/)

Information last updated: 24th June 2004
York Functional Programming Group
Malcolm.Wallace@cs.york.ac.uk