makepp takes over from

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 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. – Perl – 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.


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:

v0.5   (2003-05-25)

v0.4   (2003-03-27)

v0.3   (2003-01-25)

v0.2   (2003-01-12)

v0.1.1   (2002-10-31)

v0.1   (2002-10-27)

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