Go to the first, previous, next, last section, table of contents.

The Ciao lpmake scripting facility

Author(s): Manuel Hermenegildo, clip@dia.fi.upm.es, http://www.clip.dia.fi.upm.es/, The CLIP Group, Facultad de Informática, Universidad Politécnica de Madrid.

Version: 1.10#6 (2004/8/7, 21:46:39 CEST)

Version of last change: 1.9#27 (2002/11/20, 13:4:12 CET)

Note: lpmake and the make library are still under development, and they may change in future releases.

lpmake is a Ciao application which uses the Ciao make library to implement a dependency-driven scripts in a similar way to the Un*x make facility.

The original purpose of the Un*x make utility is to determine automatically which pieces of a large program needed to be recompiled, and issue the commands to recompile them. In practice, make is often used for many other purposes: it can be used to describe any task where some files must be updated automatically from others whenever these change. lpmake can be used for the same types of applications as make, and also for some new ones, and, while being simpler, it offers a number of advantages over make. The first one is portability. When compiled to a bytecode executable lpmake runs on any platform where a Ciao engine is available. Also, the fact that typically many of the operations are programmed in Prolog within the makefile, not needing external applications, improves portability further. The second advantage of lpmake is improved programming capabilities. While lpmake is simpler than make, lpmake allows using the Ciao Prolog language within the scripts. This allows establising more complex dependencies and programming powerful operations within the make file, and without resorting to external packages (e.g., operating system commands), which also helps portability. A final advantage of lpmake is that it supports a form of autodocumentation: comments associated to targets can be included in the configuration files. Calling lpmake in a directory which has such a configuration file explains what commands the configuration file support and what these commands will do.

General operation

To prepare to use lpmake, and in a similar way to make, you must write a configuration file: a module (typically called Makefile.pl) that describes the relationships among files in your program or application, and states the commands for updating each file. In a program, typically the executable file is updated from object files, which are in turn made by compiling source files. Another example is running latex and dvips on a set of source .tex files to generate a document in dvi and postscript formats. Once a suitable makefile exists, each time you change some source files, simply typing lpmake suffices to perform all necessary operations (recompilations, processing text files, etc.). The lpmake program uses the dependency rules in the makefile and the last modification times of the files to decide which of the files need to be updated. For each of those files, it issues the commands recorded in the makefile. For example, in the latex/ dvips case one rule states that the .dvi file whould be updated from the .tex files whenever one of them changes and another rule states that the .ps file needs to be updated from a .dvi file every time it changes. The rules also describe the commands to be issued to update the files.

So, the general process is as follows: lpmake executes commands in the configuration file to update one or more target names, where name is often a program, but can also be a file to be generated or even a "virtual" target. lpmake updates a target if it depends on prerequisite files that have been modified since the target was last modified, or if the target does not exist. You can provide command line arguments to lpmake to control which files should be regenerated, or how.

Format of the Configuration File

lpmake uses as default configuration file the file Makefile.pl, if it is present in the current directory. This can be overridden and another file used by means of the -m option. The configuration file must a module that uses the make package. This package provides syntax for defining the dependency rules and functionality for correctly interpreting these rules. The configuration files can contain such rules and also arbitrary Ciao Prolog predicates. The syntax of the rules is described in section The Ciao Make Package, together with some examples.

lpmake usage

Supported command line options:

lpmake [-v] <command1> ... <commandn>

  Process commands <command1> ... <commandn>, using 
  file 'Makefile.pl' in the current directory as 
  configuration file. The configuration file must 
  be a module. This is useful to implement 
  inherintance across diferent configuration files, 
  i.e., the values declared in a configuration file 
  can be easily made to override those defined in 

  The optional argument '-v' produces verbose output, 
  reporting on the processing of the dependency rules. 
  Very useful for debugging Makefiles.

lpmake [-v] [-m <.../Configfile.pl>] <command1> ... <commandn>

  Same as above, but using file <.../Configfile.pl> 
  as configuration file. 

lpmake -h     [ -m <.../Configfile.pl> ]
lpmake -help  [ -m <.../Configfile.pl> ]

  Print this help message. If a configuration file is given, 
  and the commands in it are commented, then information on 
  these commands is also printed.

Acknowledgments (lpmake)

Some parts of the documentation are taken from the documentation of GNU's gmake.

Go to the first, previous, next, last section, table of contents.