Free made software for linux

Make is a Perl module for processing makefiles.

SYNOPSIS

require Make;
my $make = Make->new(...);
$make->parse($file);
$make->Script(@ARGV)
$make->Make(@ARGV)
$make->Print(@ARGV)

my $targ = $make->Target($name);
$targ->colon([dependancy...],[command...]);
$targ->dolon([dependancy...],[command...]);
my @depends = $targ->colon->depend;
my @commands = $targ->colon->command;

Make->new creates an object if new(Makefile => $file) is specified then it is parsed. If not the usual makefile Makefile sequence is used. (If GNU => 1 is passed to new then GNUmakefile is looked for first.)

$make->Make(target...) makes the target(s) specified (or the first real target in the makefile).

$make->Print can be used to print to current selected stream a form of the makefile with all variables expanded.

$make->Script(target...) can be used to print to current selected stream the equivalent bourne shell script that a make would perform i.e. the output of make -n.

There are other methods (used by parse) which can be used to add and manipulate targets and their dependants. There is a hierarchy of classes which is still evolving. These classes and their methods will be documented when they are a little more stable.

The syntax of makefile accepted is reasonably generic, but I have not re-read any documentation yet, rather I have implemented my own mental model of how make works (then fixed it...).

In addition to traditional

.c.o :
$(CC) -c ...

GNU makes pattern rules e.g.

%.o : %.c
$(CC) -c ...

Likewise a subset of GNU makes $(function arg...) syntax is supported.
Via pmake Make has built perl/Tk from the MakeMaker generated Makefiles...

GNU make is a tool which controls the generation of executables and other non-source files of a program from the programs source files.
Make gets its knowledge of how to build your program from a file called the makefile, which lists each of the non-source files and how to compute it from other files. When you write a program, you should write a makefile for it, so that it is possible to use Make to build and install the program.
Capabilities of Make
- Make enables the end user to build and install your package without knowing the details of how that is done -- because these details are recorded in the makefile that you supply.
- Make figures out automatically which files it needs to update, based on which source files have changed. It also automatically determines the proper order for updating files, in case one non-source file depends on another non-source file.
As a result, if you change a few source files and then run Make, it does not need to recompile all of your program. It updates only those non-source files that depend directly or indirectly on the source files that you changed.
- Make is not limited to any particular language. For each non-source file in the program, the makefile specifies the shell commands to compute it. These shell commands can run a compiler to produce an object file, the linker to produce an executable, ar to update a library, or TeX or Makeinfo to format documentation.
- Make is not limited to building a package. You can also use Make to control installing or deinstalling a package, generate tags tables for it, or anything else you want to do often enough to make it worth while writing down how to do it.
Make Rules and Targets
A rule in the makefile tells Make how to execute a series of commands in order to build a target file from source files. It also specifies a list of dependencies of the target file. This list should include all files (whether source files or other targets) which are used as inputs to the commands in the rule.
Here is what a simple rule looks like:
target: dependencies ...
commands
...
When you run Make, you can specify particular targets to update; otherwise, Make updates the first target listed in the makefile. Of course, any other target files needed as input for generating these targets must be updated first.
Make uses the makefile to figure out which target files ought to be brought up to date, and then determines which of them actually need to be updated. If a target file is newer than all of its dependencies, then it is already up to date, and it does not need to be regenerated. The other target files do need to be updated, but in the right order: each target file must be regenerated before it is used in regenerating other targets.
Advantages of GNU Make
GNU Make has many powerful features for use in makefiles, beyond what other Make versions have. It can also regenerate, use, and then delete intermediate files which need not be saved.
GNU Make also has a few simple features that are very convenient. For example, the -o file option which says ``pretend that source file file has not changed, even though it has changed. This is extremely useful when you add a new macro to a header file. Most versions of Make will assume they must therefore recompile all the source files that use the header file; but GNU Make gives you a way to avoid the recompilation, in the case where you know your change to the header file does not require it.
However, the most important difference between GNU Make and most versions of Make is that GNU Make is free software.
Enhancements:
- Major bugfixes

DPKG::Make is a Perl module for cleanly generate an Debian package (.dpkg).

SYNOPSIS

use DPKG::Make;

# The "Manifest": list of files that will comprise the software package.
my @filelist=(tmproot/file1.txt,
tmproot/file2.txt,
tmproot/file3.txt,
tmproot/file4.txt);

my %doc; my %conf; my %metadata;

# Define special handling of files.
$doc{tmproot/file1.txt}=1;
$conf{tmproot/file2.txt}=1;

# Bare minimum metadata (descriptive data of the software package).
my $pathprefix=tmproot;
my $tag=test; # cannot use uppercase characters
my $version=0.1;
my $release=1;

# Highly descriptive metadata.
%metadata=(
vendor=>Excellence in Perl Laboratory,
summary=>a Test Software Package,
name=>$tag,
copyrightname=>...,
group=>base,
AutoReqProv=>no,
requires=>[()],
email=>joe@somewhere.com,
description=>This package is generated by DPKG::Make. .
This implements the .$tag. software package,
pre=>echo "You are installing a package built by DPKG::Make; .
DPKG::Make is available at http://www.cpan.org/.",
);

# Temporary "sandbox" (this should not be /tmp because this is deleted!).
my $buildloc=TempBuildLoc;

# The "execute" subroutine coordinates all of the DPKG building steps.
DPKG::Make::execute($tag,$version,$release,$arch,$buildloc,$pathprefix,
@filelist,%doc,%conf,
%metadata);

# You can also build a DPKG in more atomic steps; these three smaller
# steps are equivalent to the execute command.

# Step 1: Generate the rpm source location.
DPKG::Make::dpkgsrc($tag,$version,$release,$arch,$buildloc,$pathprefix,
@filelist,%doc,%conf,
%metadata);

# Step 2: Build the rpm and copy into the invoking directory.
DPKG::Make::compiledpkg($buildloc,$metadata{name},$version,
$release,$arch,
$currentdir,$invokingdir);

# Step 3: clean the location used to gather and build the rpm.
DPKG::Make::cleanbuildloc($buildloc);

Make audio is a graphical tool to create audio CDs from MP3 or wav files. You can simply arrange a playlist of all songs that you want. The application converts MP3 files to WAV and then burns them on the CD.