'CONFDIR',          # Overwrite all INSTALL*CONFs; normally determined

  'INSTALLCONF',      # based on $*SYSCONFDIR.

  'INSTALLSITECONF',  #

  'INSTALLVENDORCONF',#

# See lib/ExtUtils/MakeMaker.pm for details of how to influence

# the contents of the Makefile that is written.

$makefile{'macro'}{'CONTACT_ADDRESS'} = $opt{'contact_address'};

$makefile{'macro'}{'TEST_RUN_RAZOR'} = yesno($opt{'run_razor_tests'});

print "Makefile written by ExtUtils::MakeMaker ${mm_version}\n";

use vars qw(

  $MY_GLOBALS_ARE_SANE

  @REPOSITORIES

  $MACRO_RE

  $EQ_RE

  $EQ

  $SELF

);

# For some reason initializing the vars on the global scope doesn't work;

# guess its some weird Perl behaviour in combination with bless().

sub init_MY_globals {

  my $self = shift;

  # Keep a reference to ourselves so we don't have to feed it to the helper

  # scripts.

  $SELF = $self;

  return if $MY_GLOBALS_ARE_SANE;

  $MY_GLOBALS_ARE_SANE = 1;

  # (Current) EU::MMs make a difference between these three possible general

  # install destinations. See also

  # <http://archive.develooper.com/perl5-porters@perl.org/msg94113.html>

  # <https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=78053>

  # <http://www.mail-archive.com/makemaker@perl.org/msg00779.html>

  # <http://www.debian.org/doc/packaging-manuals/perl-policy/ch-module_packages.html#s-vendor_dirs>

  @REPOSITORIES = qw(

    PERL

    SITE

    VENDOR

  );

  # Macro names follow this RE -- at least stricly enough for our purposes.

  $MACRO_RE = qr/[A-Z0-9_]+/;

  # Normally macros are assigned via FOO = bar. But the part with the equal

  # sign might differ from platform to platform. So we use this RE:

  $EQ_RE = qr/\s*:?=\s*/;

  # To assign or own macros we'll follow the first assignment string we find;

  # normally " = ".

  $EQ = undef;

}

# Unset $SELF to avoid any leaking memory.

sub clean_MY_globals {

  my $self = shift;

  $SELF = undef;

}

sub set_EQ_from_line {

  my($line) = (@_);

  return if defined($EQ);

  $line =~ /\S(${EQ_RE})/;

  $EQ = $1;

}

# Converts a version represented as a float to a real three-part version,

# eg.:

#  5.006001 -> 5.6.1

#  5.005_03 -> 5.5.30

#

# The first parameter should be a version, in what format ever.

sub float_to_version {

  my($ver) = (@_);

  if ($ver =~ /^\d\.\d+$/) {

    $ver   =  sprintf("%1.6f", $ver);

    $ver   =~ s/[.0]+([1-9]+)/.$1/g;

  }

  return $ver;

}

# Generates a Makefile-reference to another macro; something like $(FOO).

#

# The first and only parameter should be the name of the referred macro,

# eg. 'FOO' (will return '$(FOO)').

sub macro_ref {

  my($name) = (@_);

  return sprintf('$(%s)', $name);

}

# Generates a line which defines a Makefile macro. Something like FOO = bar.

# The line is *not* followed by a newline!

#

# The first parameter must be the name of the macro. The second is optional.

# If it is omitted, the value set in the current EU::MM instance is used.

sub macro_def {

  my($name, $val) = (@_, undef);

  $val = $SELF->{$name} unless defined $val;

  die unless defined $EQ;

  return $name . $EQ . $val;

}

# Returns true if the given line defines a macro.

#

# The first parameter must be the line to inspect. With the second optional

# parameter the name of a specific macro might be given. If its omitted, any

# macro matching the MACRO_RE pattern will fit.

sub line_has_macro_def {

  my($line, $name) = (@_, undef);

  $name = $MACRO_RE unless defined $name;

  return $line =~ /^($name)${EQ_RE}/;

}

# Reads the name of the macro defined on the given line.

#

# The first parameter must be the line to be expected. If the line doesn't

# contain a macro definition, weird things may happen. So check with

# line_has_macro_def() before!

sub get_macro_name_from_line {

  my($line) = (@_);

  $line =~ /^(${MACRO_RE})${EQ_RE}/;

  return $1;

}

# Reads the value of the given macro from the current instance of EU::MM.

#

# The first parameter must be the name of a macro.

sub get_macro {

  my($name) = (@_);

  return $SELF->{$name};

}

# Reads the value of the given macro from the current instance of EU::MM and

# expands all contained macros. So reading BAZ with these declarations

#   FOO = blah

#   BAR = $(FOO)

#   BAZ = $(BAR)

# gives 'blah'.

#

# The first parameter must be the name of a macro.

sub get_expanded_macro {

  my($name) = (@_);

  my($val);

  $val = get_macro($name);

  # Now expand all macros...

  while ($val =~ s/\Q$(\E(${MACRO_RE})\Q)\E/$SELF->{$1} || ''/ge) {};

  return $val;

}

# Sets the value of the macro with the given name to the given value in the

# current instance of EU::MM. Just sets, doesn't write to the Makefile!

#

# The first parameter must be the macro's name, the second the value.

sub set_macro {

  my($name, $val) = (@_);

  $SELF->{$name} = $val;

}

# Returns the actual "repository" name used in macro names; the point is that

# EU::MM leaves out the name if the repository is 'PERL'. But only for macros

# which don't start with the repository name (like the INSTALL* ones). So the

# following mapping should be made:

#   PERLPREFIX      -> PERLPREFIX

#   PERLSYSCONFDIR  -> PERLSYSCONFDIR

#   INSTALLSITECONF -> INSTALLSITECONF

#   INSTALLPERLCONF -> INSTALLCONF

# Actually, its a bit more complex than that but we follow that simple mapping

# for our vars; one also has to know when to call this function and when not.

sub repository {

  my($repository) = (@_);

  return '' if $repository eq 'PERL';

  return $repository;

}

# This routine determines the correct SYSCONFDIR to use for the given

# repository.

#

# The first parameter must be one value from @REPOSITORIES.

#

# *SYSCONFDIR can be overwritten with:

#   *SYSCONFDIR

#   SYSCONFDIR

# If none of those is specified, it will chose an FHS-compliant dir

# based on the corresponding *PREFIX:

#   *PREFIX     *SYSCONFDIR

#   /usr        /etc

#   /usr/local  /etc

#   /opt/*      /etc/opt

#   /foo/*      /foo/*/etc

sub _set_macro_SYSCONFDIR {

  my($repository) = (@_);

  my($macro);

  $macro = $repository . "SYSCONFDIR";

  # Is this macro already set?

  return if get_macro($macro);

  # Is this macro supposed to be overwritten?

  if (get_macro('SYSCONFDIR')) {

    set_macro($macro, macro_ref('SYSCONFDIR'));

    return;

  }

  my($rprefix);

  $rprefix = get_expanded_macro("${repository}PREFIX");

  # Set the default, depending on the corresponding full PREFIX

  set_macro($macro,

    ($rprefix =~ m{^$})                ? ''         :

    ($rprefix =~ m{^/usr(/local)?/?$}) ? '/etc'     :

    ($rprefix =~ m{^/opt(/|$)})        ? '/etc/opt' :

    macro_ref("${repository}PREFIX") . '/etc'

  );

}

# This routine determines the correct INSTALLDATADIR (aka DEFRULESDIR)

# to use for the given repository.

#

# The first parameter must be one value from @REPOSITORIES.

#

# INSTALL*DATADIR can be overwritten with:

#   INSTALL*DATADIR

#   DATADIR

#   DEFRULESDIR

# If none of those is specified, it will chose an FHS-compliant dir,

# namely *PREFIX/share/spamassassin.

sub _set_macro_DATADIR {

  my($repository) = (@_);

  my($macro);

  $macro = "INSTALL" . repository($repository) . "DATA";

  # Is this macro already set?

  return if get_macro($macro);

  # Is this macro supposed to be overwritten?

  foreach my $omacro (qw(DATADIR DEFRULESDIR)) {

    if (get_macro($omacro)) {

      set_macro($macro, get_macro($omacro));

      return;

    }

  }

  # Set the default value based on the corresponding PREFIX

  set_macro($macro,

    macro_ref("${repository}PREFIX") . '/share/spamassassin'

  );

}

# This routine determines the correct INSTALLCONFDIR (aka LOCALRULESDIR)

# to use for the given repository.

#

# The first parameter must be one value from @REPOSITORIES.

#

# INSTALL*CONFDIR can be overwritten with:

#   INSTALL*CONFDIR

#   CONFDIR

#   LOCALRULESDIR

# If none of those is specified, it will chose an FHS-compliant dir,

# namely *SYSCONFDIR/mail/spamassassin.

sub _set_macro_CONFDIR {

  my($repository) = (@_);

  my($macro);

  $macro = "INSTALL" . repository($repository) . "CONF";

  # Is this macro already set?

  return if get_macro($macro);

  # Is this macro supposed to be overwritten?

  foreach my $omacro (qw(CONFDIR LOCALRULESDIR)) {

    if (get_macro($omacro)) {

      set_macro($macro, get_macro($omacro));

      return;

    }

  }

  # Set the default value based on the corresponding SYSCONFDIR

  set_macro($macro,

    macro_ref("${repository}SYSCONFDIR") . '/mail/spamassassin'

  );

}

# This routine determines the correct value for PERL_BIN.

#

# There are no parameters.

#

# If PERL_BIN wasn't set at the command line, it will fall back to

# $(FULLPERL) which should refer to the current Perl interpreter.

sub _set_macro_PERL_BIN {

  return if get_macro('PERL_BIN');

  set_macro('PERL_BIN', macro_ref('FULLPERL'));

}

# This routine determines the value of the app given in PERL_BIN.

#

# There are no parameters.

#

# If PERL_VERSION wasn't set at the command line, it will try to call

# the app given in PERL_BIN and ask it for its version. If that doesn't

# work for some reason, it will use the version of the current Perl

# interpreter.

sub _set_macro_PERL_VERSION {

  return if get_macro('PERL_VERSION');

  my($perl, $ver);

  #

  $perl = get_expanded_macro('PERL_BIN');

  if (-x $perl) {

    $ver = qx{$perl -V:version};

    $ver =~ s/^version='([0-9.]+).*$/$1/s;

  }

  $ver = $] unless $ver;

  set_macro('PERL_VERSION', float_to_version($ver));

}

# This is a helper routine for PERL_WARN and PERL_TAINT.

#

# The first parameter must be either 'WARN' or 'TAINT'.

sub _set_macro_PERL_yesno {

  my($macro) = (@_);

  my($val);

  $macro = 'PERL_' . $macro;

  $val   = "";

  if (get_macro($macro)) {

    $val = yesno(get_macro($macro));

  }

  set_macro($macro, $val);

}

# This routine sets the value for PERL_WARN.

#

# There are no parameters.

#

# If PERL_WARN wasn't set at the command line, PERL_WARN will be left

# empty (ie: the default is used). If it was set, the value is fed to

# yesno().

sub _set_macro_PERL_WARN {

  _set_macro_PERL_yesno('WARN');

}

# This routine sets the value for PERL_TAINT.

#

# There are no parameters.

#

# If PERL_TAINT wasn't set at the command line, PERL_TAINT will be left

# empty (ie: the default is used). If it was set, the value is fed to

# yesno().

sub _set_macro_PERL_TAINT {

  _set_macro_PERL_yesno('TAINT');

}

# Override the libscan routine so it skips CVS stuff and some common

# patch/backup extensions.

# Override the install routine to add our additional install dirs and

# hack DESTDIR support into old EU::MMs.

# Now override the constants routine to add our own macros.

sub MY::constants {

  my @code = split(/\n/, $self->SUPER::constants(@_));

  init_MY_globals($self);

    # Determine the correct settings for each repository...

    foreach my $r (@REPOSITORIES) {

      _set_macro_SYSCONFDIR($r);

      _set_macro_DATADIR($r);

      _set_macro_CONFDIR($r);

    }

  EOD

Please see the file PACKAGING, sections "Changing paths in the Makefile"

and "Setting further options on the command line" for more informations

on available command line variables.

    Version 6.16 or later is recommended.

Introduction

------------

The Makefile which is used to build SpamAssassin is created by calling

	perl Makefile.PL

This is the standard Perl way of building packages. It involves the

Perl module ExtUtils::MakeMaker (which will hopefully be replaced by

Module::Build one day) which creates a Makefile.

ExtUtils::MakeMaker recognizes several variables which can be set at

the command line to give the user the possibility to influence the

contents of the generated Makefile. All macros written to the Makefile

can be changed with a command line like this:

	perl Makefile.PL FOO="bar"

This would give the (exemplary) macro 'FOO' the value 'bar'.

Now has the internal structure of ExtUtils::MakeMaker and that of the

generated Makefiles changed over the years. For a description of the

features your version supports, please read

	perldoc ExtUtils::MakeMaker

One important thing to know when you're building packages is that Perl

uses three different "repositories" for installed modules and their

corresponding files: 'perl', 'site' and 'vendor' (the latter was

introduced with Perl 5.6.0). These have the following meanings:

  perl:   This should be used only by essential modules shipped with

          Perl or modules required by one of these. And maybe for some

          other important modules chosen by some obscure selection

          process. Only one thing is sure about this set of directories:

          SpamAssassin doesn't belong there.

  site:   This is the default. The libs (.pm files) of the modules are

          installed into the site_perl subdir in the Perl lib dir.

          Everything installed via the CPAN shell or directly from

          sources should go there.

  vendor: This repository was officially introduced some time after

          Perl 5.005_03 (maybe with 5.6.0). It's intended to be the

          target for all modules installed from distribution specific

          packages; that means RPMs, debs, ebuilds, etc. The rationale

          behind this is that this prevents modules installed by the

          user from being overwritten by packaged ones.

The wanted repository can be chosen by setting the variable INSTALLDIRS.

So according to the description above should packages probably use

	perl Makefile.PL INSTALLDIRS=vendor

That's definitely the correct way to go for Debian, according to the

Perl Policy [DEBPERL]. But I've heard that the vendor stuff is either

broken or not set on many other systems, especially Red Hat ones. Google

might help to find more infos on this topic.

SpamAssassin needs some directories which normally aren't supported by

ExtUtils::MakeMaker. So we had to extend its logic quite a bit. And to

make it worse did the internal logic change extremely between the 5.x

and 6.x series, especially for packaging stuff. We had to "backport"

(ie. hack into) some of the functionality ExtUtils::MakeMaker 6.11 and

later offers. That this is very error-prone is obvious. So throughout

this text you'll find some recommendations for versions you should use.

You should definitely use version 5.45 or later, recommended is 6.16

and later.

The following ressources might help understanding this stuff:

[MANEUMM616], [MM00779], [P5P94113].

It's also possible to build SpamAssassin with a current version of

ExtUtils::MakeMaker without upgrading the system. See the section

"Building with another ExtUtils::MakeMaker" for details.

Changing paths in the Makefile

------------------------------

Internally the Makefile defined quite some paths for the different settings

of INSTALLDIRS. One can change them directly but to be independent of the

version of ExtUtils::MakeMaker the following variables should be used:

PREFIX:

  Sets the prefix below which SpamAssassin is installed. Please note the

  exceptions for SYSCONFDIR.

  Default is the prefix Perl was built with (call

  	perl -V:prefix

  to see the value). Normally something like /usr or /usr/local.

  Samples:

    This will install the spamassassin apps in /foo/bin, the libs in

    /foo/lib/perl5, the shared stuff in /foo/share/spamassassin and make

    SpamAssassin look for config files in /foo/etc/mail/spamassassin:

    	perl Makefile.PL PREFIX=/foo

LIB:

  This will change the directory where the SpamAssassin libraries (.pm files

  are installed. The module's architecture-independent files will be put into

  the given directory, the architecture-dependent files into a subdirectory

  with the name of the current architecture.

  The default is something like PREFIX/lib/perl5/site_perl/PERL_VERSION (for

  INSTALLDIRS=site).

  Samples:

    Under i686-Linux, put the architecture-independent files below ~/.libs

    and the architecture-dependent ones below ~/.libs/i686-linux:

    	perl Makefile.PL LIB=~/.libs

DATADIR (DEFRULESDIR):

  SpamAssassin's real logic lies in its shipped rule definitions and the

  corresponding scores. The files with these settings have to be saved

  somewhere, normally below PREFIX/share/spamassassin. The full path to

  that directory can be changed with this variable (DEFRULESDIR is a

  synonyme).

  ATTENTION: All files within this directory are removed when SpamAssassin

  is installed!

  Samples:

    Install everything into the default locations but put the rules in

    /tmp/sa-rules (for whatever reason):

    	perl Makefile.PL DATADIR=/tmp/sa-rules

SYSCONFDIR:

  Sets the base dir for the config files. See also CONFDIR.

  The default depends on the PREFIX and is compliant to the FHS:

    - if PREFIX is either /usr or /usr/local:

      /etc

    - if PREFIX starts with /opt:

      /etc/opt

    - else:

      PREFIX/etc

  Samples:

    This will (on Windows) install below 'C:\Program Files\SpamAssassin' but

    look for the config files in 'C:\Program Files\Shared Files\SpamAssassin':

    	perl Makefile.PL PREFIX="C:/Program Files/SpamAssassin"

    	  SYSCONFDIR="C:/Program Files/Shared Files/SpamAssassin"

    To put the apps and libs below ~/.sa-bin but the config below ~/.sa-etc

    try the following:

    	perl Makefile.PL PREFIX=$HOME/.sa-bin SYSCONFDIR=$HOME/.sa-etc

    And the following installs SpamAssassin in /usr/local and forces the

    config files to be below /usr/local, too:

    	perl Makefile.PL PREFIX=/usr/local SYSCONFDIR=/usr/local/etc

CONFDIR (LOCALRULESDIR):

  SpamAssassin looks for its config files in SYSCONFDIR/mail/spamassassin.

  (There is also a sample local.cf created if such a file doesn't exist yet.)

  Some people didn't like this path for various reasons so the full path to

  the config files can be changed here (this more or less makes SYSCONFDIR

  obsolete). A synonyme for this variable is LOCALRULESDIR.

  Samples:

    If you'd like to have the config files directly in /etc/spamassassin

    try this:

    	perl Makefile.PL CONFDIR=/etc/spamassassin

Installing to a directory different from the final destination

--------------------------------------------------------------

When you're building packages, it's often needed to install the stuff to

some temporary directory and then build the package from there. The problem

with this approach is that the build system of SpamAssassin needs to write

some final paths to the libs and the applications.

Previous versions offered some complicated variables to achieve this. Those

hacks weren't compatible to current versions of ExtUtils::MakeMaker. But

ExtUtils::MakeMaker 6.06 (which was said to be buggy till 6.11) introduced

a feature which is well known from the GNU build tools [GNUMAKECMD]: The

variable DESTDIR.

The value of DESTDIR is simply prepended to all other paths on make install.

So if you wanted to create a SpamAssassin package for a system which will

have it installed in /usr but you want to create that package from some temp

dir, you would do something like this:

	perl Makefile.PL Makefile.PL PREFIX=/usr DESTDIR=/tmp/sa-build

	make

	make disttest

	make install

	cd /tmp/sa-build

	build_some_package

ATTENTION: This method heavily depends on a feature introduced with a newer

version of ExtUtils::MakeMaker. Si it's *strongly* recommended to use

	ExtUtils::MakeMaker 6.16 or later

when building packages. That module is available here [GETEUMM616]. If any

problems occur with previous versions, please report them to [BUGZILLA].

See also "Building with another ExtUtils::MakeMaker".

Setting further options on the command line

-------------------------------------------

Besides the directories, the build process of SpamAssassin supports several

other settings to set or enable some features. For some of these settings

the user is asked before the Makefile is created. To avoid these questions

(and accept the defaults, whatever they are) it is possible to redirect

STDIN from the null device like this:

	perl Makefile.PL < /dev/null

Or, under Windows:

	perl Makefile.PL < nul

The following variables are supported:

ENABLE_SSL:

  Can be set to either "yes" or "no" (default). Makes it possible to use SSL

  encryption on the (TCP) connection between spamc and spamd.

  Sample:

    Build spamc with SSL, use defaults for all other questions:

    	perl Makefile.PL ENABLE_SSL=yes < /dev/null

CONTACT_ADDRESS:

  Each reported spam contains an address under which the confused user/client

  can request more information about the tagging of his mail. That address can

  be set here. The default is to query the buildung user, falling back to the

  string "the administrator of that system".

  Sample:

    The user can find some information on the page http://example.com/tag/:

    	perl Makefile.PL CONTACT_ADDRESS="http://example.com/tag/"

RUN_RAZOR_TESTS:

  Vipul's Razor is an optional module. If that module is found to be installed

  some special tests can be performed when 'make test' is run. The builder is

  asked if he wants to do so. Default is "no" (because those tests can fail if

  there are problems with the network connection or the servers).

  Sample:

    Run only the Razor tests:

	perl Makefile.PL RUN_RAZOR_TESTS=yes < /dev/null

	make test TEST_FILES="t/razor*.t"

Twisting Perl details

---------------------

The build process of SpamAssassin has to know several details of the Perl

calling it later. This is used to work around some Perl bugs and make it

all actually work :o) The following additional variables are supported to

modify these settings:

PERL_BIN:

  The path to the perl application which will be used to call the scripts

  (like spamassassin and spamd). It makes sense to set this if you build

  SpamAssassin on some weird build host which happen to have Perl in

  /some/weird/location which is definitely not the location on the end

  user's box. The default is the macro FULLPERL which should be the path

  to the perl processing Makefile.PL.

  Sample:

    Building with some weird perl:

    	/local/buildsys/perl-5.6.1/bin/perl Makefile.PL PERL_BIN=/usr/bin/perl

PERL_VERSION:

  The build system has to know the version of the Perl which will actually

  call SpamAssassin. Normally the app given by PERL_BIN is executed and asked

  for its version. If that fails, the version of the perl which called

  Makefile.PL is used. Sometimes one might have to correct this.

  ATTENTION: The version always has o be given in the three-component style.

  So the floating-point representation of old Perls has to be "converted".

  Sample:

    Building with Perl 5.8.0 for Perl 5.005_03:

    	perl-5.8.0 Makefile.PL PERL_VERSION=5.5.30

Building with another ExtUtils::MakeMaker

-----------------------------------------

It is possible to use a different version than the one which is installed.

This is very usefule if one wants to package SpamAssassin but can't or doesn't

want to upgrade the module installed on his machine. Follow these steps to

success:

1. Go to CPAN and look for the latest ExtUtils::MakeMaker available.

     <http://search.cpan.org/search?query=ExtUtils::MakeMaker>

   The standalone package (currently mainatined by Michael G Schwern)

   is needed.

2. Get the tar ball and extract it in some temporary directory. For

   version 6.16:

   	cd /tmp

   	wget http://search.cpan.org/CPAN/authors/id/M/MS/MSCHWERN/ExtUtils-MakeMaker-6.16.tar.gz

   	tar xvfz ExtUtils-MakeMaker-6.16.tar.gz

3. You will now have a directory ExtUtils-MakeMaker-X.YY (where X.YY is the

   version). Inside is a subdirectory 'lib'. Add that one to the environment

   variable PERL5LIB, like this:

   	export PERL5LIB="/tmp/ExtUtils-MakeMaker-6.16/lib:$PERL5LIB"

4. Now build SpamAssassin. As long as the PERL5LIB variable is set, the

   updates ExtUtils::MakeMaker is used.

Obsolete Variables

------------------

The following list shows variables recognized by the old build system and

their new counterparts (no, the latter aren't in the wrong order, it actually

was that complicated):

old: PREFIX=/bar/foo INST_PREFIX=/foo

new: PREFIX=/foo     DESTDIR=/bar

old: INST_SITELIB=/foo

new: LIB=/foo

old: SYSCONFDIR=/bar/foo INST_SYSCONFDIR=/foo

new: SYSCONFDIR=/foo     DESTDIR=/bar

old: LOCAL_RULES_DIR=/foo PKG_LOCAL_RULES_DIR=/bar/foo

new: LOCALRULESDIR=/foo   DESTDIR=/bar

old: DEF_RULES_DIR=/foo   PKG_DEF_RULES_DIR=/bar/foo

new: DEFRULESDIR=/foo     DESTDIR=/bar

Unsing one of the following variables will make the Makefile generation

process die:

  INST_PREFIX

  INST_SITELIB

  INST_SYSCONFDIR

  LOCAL_RULES_DIR

  DEF_RULES_DIR

If you think you need to use one of those nevertheless, you can set the

variable IGNORE_CRUFT to "yes".

Ressources

----------

[BUGZILLA] SpamAssassin bug database:

  <http://bugzilla.spamassassin.org>

[DEBPERL] Debian Perl Policy, Chapter 3: Packaged Modules:

  <http://www.debian.org/doc/packaging-manuals/perl-policy/ch-module_packages.html>

[GETEUMM616] Get ExtUtils::MakeMaker 6.16 here:

  <http://search.cpan.org/author/MSCHWERN/ExtUtils-MakeMaker-6.16/>

[GNUMAKECMD] GNU make manual: Make Conventions: Variables for Specifying

  Commands

  <http://www.gnu.org/manual/make-3.79.1/html_chapter/make_14.html#SEC119>

[MANEUMM616] The man page for ExtUtils::MakeMaker 6.16:

  <http://search.cpan.org/author/MSCHWERN/ExtUtils-MakeMaker-6.16/lib/ExtUtils/MakeMaker.pm#Default_Makefile_Behaviour>

[MM00779] makemaker-at-perl-dot-org: Michael G Schwern: "Re: MakeMaker

  problems with relocation" (PREFIX was broken):

  <http://www.mail-archive.com/makemaker@perl.org/msg00779.html>

[P5P94113] perl5-porters: Michael G Schwern: "Re: OS X's vendorlib default

  seems wrong" (description of different repositoreis):

  <http://archive.develooper.com/perl5-porters@perl.org/msg94113.html>

[RHBUG78053] Red Hat bug 78053: "incompatible changes in behavior of

  MakeMaker; affects rpm build process" (introduction of DESTDIR):

  <https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=78053>

PACKAGING

META.yml                                Module meta-data (added by MakeMaker)

* Thu Sep 09 2003 Malte S. Stretz <spamassassin-contrib@msquadrat.de>

- take advantage of the new simplified build system

PREFIX     = /usr

SYSCONFDIR = /etc