makepp takes over from make.pl

Since my project was progressing very slowly, I took a new look at its closest competitor, makepp. It is so much superior to GNU make, that I am putting up with make's strange syntax. With that make.pl is dead, and I will also contribute my builtin commands to makepp.

I had not seen the advantage of my 100% Perl syntax in a makefile. It makes a makefile rather hard to read, and forces build system maintaners to know Perl. The same is true of a coming up hybrid, PBS, which writes the makefiles in Perl, yet puts in the commands in strings, like make.

make.pl – Perl Make

Here comes a make in everybody's favourite programming language, Perl, giving you the best of both worlds. You can use it to write a plain makefile, though in Perl syntax. Or, at the other extreme, you can write a program, that besides other actions ends with a few file-dependency driven things.
Background
Arcane make and its various derivatives (cook, GNU make, jam, makepp, ...) use a weird language mix of a variable and rule syntax plus, for actually doing something, embedded shell (along with sed, awk ...) The derivatives improve this language, but the improvements are not accessible with automake, and still don't make a really useable language.
Very clever make systems, like omniORB's GNU-make-based one are powerful, but hard to understand, because of the many tricks for building such a complex project. Many wrappers, like imake or configure, try to hide some of the complexity of typical projects.
There are several countermovements like ExtUtils::MakeMaker, a Makefile generator based on a Perl configuration spec, icmake, a language similar to C, or ant, which specifies the dependencies in XML and the operations in Java.
There's also the Perl module Make. That emulates make with a bit of GNU extensions. While the parrot makefile uses its internals, that's almost undocumented and hardly intuitive. It's not been touched since April 1999.
Finally, and maybe most promisingly, there's Cons. It adresses neatly many of the problems of (GNU) make. But, while it's Perl, it has its own sublanguage within strings. While builtins are possible, they have to go through this sublanguage. Not even the development branch has been touched since May 2001.

Though it already works, it's still a prototype. Currently it only has a small rule base, for C and C++, though you can easily add your own. Plans – besides doing anything GNU make can – are to automatically extract all dependencies incurred through #include. And to only recompile if there are changes other than comments or whitespace in the source or any included file. This is to be done in a configurable way, so you'll be able to write your own function for deciding these things.

My problem, where I am looking forward to suggestions, is make. One very good suggestion comes from Peter Miller. My rule function closely follows the way make works and thus inherits some of its weaknesses:

Makefiles will often have rules depend on subdirectories. A submake will be called and build the directory. But in complex projects, different things (generated headers, libraries ...) from the directory will be needed at different times. But if you ignore directories, you have to check every compiler how it copes with relative paths, or painstakingly specify every output file.
One reason why many build system sometimes require a "make clean", are insufficient dependencies. A good example of this are object libraries with their names which vary with systems and kind of lib. Translating these into dependencies and generating the right -L and -l options therefrom isn't trivial.
Also, for performance, it would be quite interesting to batch-compile several files in one call, but again every compiler may handle this a little differently – or not at all.

Also available on FSF/UNESCO Free Software Directory

v0.5 (2003-05-25)

Small beginning towards classical make environment variables made, with $CC, $CFLAGS, $CXX and $CXXFLAGS.
New arguments --first and --last of function sh.
New functions shellparse (shell-compatible where shellwords.pl is not) and determine.
once code now performed in list context.
Greatly optimized deferred variables processing.

v0.4 (2003-03-27)

Function io now allows chaining redirections, e.g. for pipelines.

Function command replaced by directive use command.

Replaced --keep-going/keep_going by --ignore-errors/ignore_errors, matching GNU make

When you ignore errors, failing commands now consistently return undef.

New options --keep-going, --no-builtin-commands, --no-builtin-rules and --no-builtin-variables, matching GNU make

v0.3 (2003-01-25)

Made rule resolution work, and actually use it productively

New deferred variable type once

Replaced ignore by keep_going, matching command line option

Completed and added new autoloadable builtin commands (fsort, head, pod2usage, rev, tail, template)

Fixed links in POD

Also available on CPAN

v0.2 (2003-01-12)

added many builtins (cat, egrep, false, fsort, head, paste, pod2html, sed, tail, uniq) and made them all autoloadable

function io replaces silent and gives full I/O handling

bugfixes

v0.1.1 (2002-10-31)

minor bugfixes

corrected and completed documentation

v0.1 (2002-10-27)

initial release

Last modified: 2003-09-08
Powered by the GPL and the Artistic License