Makefile.PL

   1 #!perl -w
   2 use strict;
   3 use ExtUtils::MakeMaker;
   4 use Cwd;
   5 use Config;
   6 use File::Spec;
   7 use Getopt::Long;
   8 use ExtUtils::Manifest qw(maniread);
   9 use ExtUtils::Liblist;
  10 use vars qw(%formats $VERBOSE $INCPATH $LIBPATH $NOLOG $DEBUG_MALLOC $MANUAL $CFLAGS $LFLAGS $DFLAGS);
  11 use lib 'inc';
  12 use Devel::CheckLib;
  13
  14 # EU::MM runs Makefile.PL all in the same process, so sub-modules will
  15 # see this
  16 our $BUILDING_IMAGER = 1;
  17
  18 # used to display a summary after we've probed the world
  19 our %IMAGER_LIBS;
  20
  21 #
  22 # IM_INCPATH      colon seperated list of paths to extra include paths
  23 # IM_LIBPATH      colon seperated list of paths to extra library paths
  24 #
  25 # IM_VERBOSE      turns on verbose mode for the library finding and such
  26 # IM_MANUAL       to manually select which libraries are used and which not
  27 # IM_ENABLE       to programmatically select which libraries are used
  28 #                 and which are not
  29 # IM_NOLOG        if true logging will not be compiled into the module
  30 # IM_DEBUG_MALLOC if true malloc debbuging will be compiled into the module
  31 #                 do not use IM_DEBUG_MALLOC in production - this slows
  32 #                 everything down by alot
  33 # IM_CFLAGS       Extra flags to pass to the compiler
  34 # IM_LFLAGS       Extra flags to pass to the linker
  35 # IM_DFLAGS       Extra flags to pass to the preprocessor
  36
  37 my $KEEP_FILES = $ENV{IMAGER_KEEP_FILES};
  38
  39 getenv();     # get environment variables
  40
  41 my $lext=$Config{'so'};   # Get extensions of libraries
  42 my $aext=$Config{'_a'};
  43
  44 my $help; # display help if set
  45 my @enable; # list of drivers to enable
  46 my @disable; # or list of drivers to disable
  47 my @incpaths; # places to look for headers
  48 my @libpaths; # places to look for libraries
  49 my $coverage; # build for coverage testing
  50 my $assert; # build with assertions
  51 GetOptions("help" => \$help,
  52            "enable=s" => \@enable,
  53            "disable=s" => \@disable,
  54            "incpath=s", \@incpaths,
  55            "libpath=s" => \@libpaths,
  56            "verbose|v" => \$VERBOSE,
  57            "nolog" => \$NOLOG,
  58            'coverage' => \$coverage,
  59            "assert|a" => \$assert);
  60
  61 setenv();
  62
  63 if ($ENV{AUTOMATED_TESTING}) {
  64   $assert = 1;
  65 }
  66
  67 if ($VERBOSE) {
  68   print "Verbose mode\n";
  69   require Data::Dumper;
  70   import Data::Dumper qw(Dumper);
  71 }
  72
  73 if ($help) {
  74   usage();
  75 }
  76
  77 my @defines;
  78
  79 if ($NOLOG)   { print "Logging not compiled into module\n"; }
  80 else {
  81   push @defines, [ IMAGER_LOG => 1, "Logging system" ];
  82 }
  83
  84 if ($assert) {
  85   push @defines, [ IM_ASSERT => 1, "im_assert() are effective" ];
  86 }
  87
  88 if ($DEBUG_MALLOC) {
  89   push @defines, [ IMAGER_DEBUG_MALLOC => 1, "Use Imager's DEBUG malloc()" ];
  90   print "Malloc debugging enabled\n";
  91 }
  92
  93 if (@enable && @disable) {
  94   print STDERR "Only --enable or --disable can be used, not both, try --help\n";
  95   exit 1;
  96 }
  97
  98 my %definc;
  99 my %deflib;
 100 my @incs; # all the places to look for headers
 101 my @libs; # all the places to look for libraries
 102
 103 init();       # initialize global data
 104 pathcheck();  # Check if directories exist
 105
 106 if (exists $ENV{IM_ENABLE}) {
 107   my %en = map { $_, 1 } split ' ', $ENV{IM_ENABLE};
 108   for my $key (keys %formats) {
 109     delete $formats{$key} unless $en{$key};
 110   }
 111 }
 112 if (@enable) {
 113   my %en = map { $_ => 1 } map { split /,/ } @enable;
 114   for my $key (keys %formats) {
 115     delete $formats{$key} unless $en{$key};
 116   }
 117 }
 118 elsif (@disable) {
 119   delete @formats{map { split /,/ } @disable};
 120 }
 121
 122 # Pick what libraries are used
 123 if ($MANUAL) {
 124   manual();
 125 } else {
 126   automatic();
 127 }
 128
 129 my $lib_cflags = '';
 130 my $lib_lflags = '';
 131 my $F_LIBS = '';
 132 my $F_OBJECT = '';
 133 for my $frmkey (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
 134   my $frm = $formats{$frmkey};
 135   push @defines, [ $frm->{def}, 1, "$frmkey available" ];
 136   $F_OBJECT .= ' '  .$frm->{objfiles};
 137   if ($frm->{cflags}) {
 138     $lib_cflags   .= ' '  .$frm->{cflags};
 139     ++$definc{$_} for map { /^-I(.*)$/ ? ($1) : () }
 140       grep /^-I./, split ' ', $frm->{cflags};
 141   }
 142   if ($frm->{lflags}) {
 143     $lib_lflags .= ' ' . $frm->{lflags};
 144   }
 145   else {
 146     $F_LIBS   .= ' '  .$frm->{libfiles};
 147   }
 148
 149 }
 150
 151 my $F_INC  = join ' ', map "-I$_", map / / ? qq{"$_"} : $_,
 152   grep !$definc{$_}, @incs;
 153 $F_LIBS = join(' ',map "-L$_", map / / ? qq{"$_"} : $_,
 154                grep !$deflib{$_}++, @libs) . $F_LIBS;
 155
 156 my $OSLIBS = '';
 157 my $OSDEF  = "-DOS_$^O";
 158
 159 if ($^O eq 'hpux')                { $OSLIBS .= ' -ldld'; }
 160 if (defined $Config{'d_dlsymun'}) { $OSDEF  .= ' -DDLSYMUN'; }
 161
 162 my @objs = qw(Imager.o draw.o polygon.o image.o io.o iolayer.o
 163               log.o gaussian.o conv.o pnm.o raw.o feat.o font.o combine.o
 164               filters.o dynaload.o stackmach.o datatypes.o
 165               regmach.o trans2.o quant.o error.o convert.o
 166               map.o tags.o palimg.o maskimg.o img8.o img16.o rotate.o
 167               bmp.o tga.o color.o fills.o imgdouble.o limits.o hlines.o
 168               imext.o scale.o rubthru.o render.o paste.o compose.o flip.o);
 169
 170 my %opts=(
 171           'NAME'         => 'Imager',
 172           'VERSION_FROM' => 'Imager.pm',
 173           'LIBS'         => "$LFLAGS -lm $lib_lflags $OSLIBS $F_LIBS",
 174           'DEFINE'       => "$OSDEF $CFLAGS",
 175           'INC'          => "$lib_cflags $DFLAGS $F_INC",
 176           'OBJECT'       => join(' ', @objs, $F_OBJECT),
 177           clean          => { FILES=>'testout rubthru.c scale.c conv.c  filters.c gaussian.c render.c rubthru.c' },
 178           PM             => gen_PM(),
 179           PREREQ_PM      => { 'Test::More' => 0.47 },
 180          );
 181
 182 if ($coverage) {
 183     if ($Config{gccversion}) {
 184         push @ARGV, 'OPTIMIZE=-ftest-coverage -fprofile-arcs';
 185         #$opts{dynamic_lib} = { OTHERLDFLAGS => '-ftest-coverage -fprofile-arcs' };
 186     }
 187     else {
 188         die "Don't know the coverage C flags for your compiler\n";
 189     }
 190 }
 191
 192 # eval to prevent warnings about versions with _ in them
 193 my $MM_ver = eval $ExtUtils::MakeMaker::VERSION;
 194 if ($MM_ver > 6.06) {
 195   $opts{AUTHOR} = 'Tony Cook <tonyc@cpan.org>, Arnar M. Hrafnkelsson';
 196   $opts{ABSTRACT} = 'Perl extension for Generating 24 bit Images';
 197 }
 198
 199 if ($MM_ver >= 6.46) {
 200   $opts{META_MERGE} =
 201     {
 202      recommends =>
 203      {
 204       "Parse::RecDescent" => 0
 205      },
 206      license => "perl",
 207      dynamic_config => 1,
 208      no_index =>
 209      {
 210       directory =>
 211       [
 212        "PNG",
 213        "GIF",
 214        "TIFF",
 215        "JPEG",
 216        "W32",
 217        "FT2",
 218        "T1",
 219       ],
 220      },
 221      resources =>
 222      {
 223       homepage => "http://imager.perl.org/",
 224       repository => "git://git.imager.perl.org/imager.git",
 225       bugtracker => "http://rt.cpan.org/NoAuth/Bugs.html?Dist=Imager",
 226      },
 227     };
 228 }
 229
 230 make_imconfig(\@defines);
 231
 232 if ($VERBOSE) { print Dumper(\%opts); }
 233 mkdir('testout',0777); # since we cannot include it in the archive.
 234
 235 -d "probe" and rmdir "probe";
 236
 237 WriteMakefile(%opts);
 238
 239 my @good;
 240 my @bad;
 241 for my $name (sort { lc $a cmp lc $b } keys %IMAGER_LIBS) {
 242   if ($IMAGER_LIBS{$name}) {
 243     push @good, $name;
 244   }
 245   else {
 246     push @bad, $name;
 247   }
 248 }
 249
 250 print "\n";
 251 print "Libraries found:\n" if @good;
 252 print "  $_\n" for @good;
 253 print "Libraries *not* found:\n" if @bad;
 254 print "  $_\n" for @bad;
 255
 256 exit;
 257
 258
 259 sub MY::postamble {
 260     my $self = shift;
 261     my $perl = $self->{PERLRUN} ? '$(PERLRUN)' : '$(PERL)';
 262     my $mani = maniread;
 263
 264     my @ims = grep /\.im$/, keys %$mani;
 265 '
 266 dyntest.$(MYEXTLIB) : dynfilt/Makefile
 267         cd dynfilt && $(MAKE) $(PASTHRU)
 268
 269 lib/Imager/Regops.pm : regmach.h regops.perl
 270         $(PERL) regops.perl regmach.h lib/Imager/Regops.pm
 271
 272 imconfig.h : Makefile.PL
 273         $(ECHO) "imconfig.h out-of-date with respect to $?"
 274         $(PERLRUN) Makefile.PL
 275         $(ECHO) "==> Your Makefile has been rebuilt - re-run your make command <=="
 276 '.qq!
 277 lib/Imager/APIRef.pod : \$(C_FILES) \$(H_FILES) apidocs.perl
 278         $perl apidocs.perl lib/Imager/APIRef.pod
 279
 280 !.join('', map _im_rule($perl, $_), @ims)
 281
 282 }
 283
 284 sub _im_rule {
 285   my ($perl, $im) = @_;
 286
 287   (my $c = $im) =~ s/\.im$/.c/;
 288   return <<MAKE;
 289
 290 $c: $im lib/Imager/Preprocess.pm
 291         $perl -Ilib -MImager::Preprocess -epreprocess $im $c
 292
 293 MAKE
 294
 295 }
 296
 297 # manual configuration of helper libraries
 298
 299 sub manual {
 300   print <<EOF;
 301
 302       Please answer the following questions about
 303       which formats are avaliable on your computer
 304
 305 press <return> to continue
 306 EOF
 307
 308   <STDIN>; # eat one return
 309
 310   for my $frm(sort { $formats{$b}{order} <=> $formats{$a}{order} } keys %formats) {
 311   SWX:
 312     if ($formats{$frm}{docs}) { print "\n",$formats{$frm}{docs},"\n\n"; }
 313     print "Enable $frm support: ";
 314     my $gz = <STDIN>;
 315     chomp($gz);
 316     if ($gz =~ m/^(y|yes|n|no)/i) {
 317       $gz=substr(lc($gz),0,1);
 318       if ($gz eq 'n') {
 319         delete $formats{$frm};
 320       }
 321     } else { goto SWX; }
 322   }
 323 }
 324
 325
 326 # automatic configuration of helper libraries
 327
 328 sub automatic {
 329   print "Automatic probing:\n" if $VERBOSE;
 330   for my $frm (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
 331     delete $formats{$frm} if !checkformat($frm);
 332   }
 333 }
 334
 335 sub grep_directory {
 336   my($path, $chk)=@_;
 337
 338 #    print "checking path $path\n";
 339   if ( !opendir(DH,$path) ) {
 340     warn "Cannot open dir $path: $!\n";
 341     return;
 342   }
 343   my @l=grep { $chk->($_) } readdir(DH);
 344   #    print @l;
 345   close(DH);
 346   return map $path, @l;
 347 }
 348
 349 sub _probe_default {
 350   my ($format, $frm) = @_;
 351
 352   my $lib_check=$formats{$frm}{'libcheck'};
 353   my $inc_check=$formats{$frm}{'inccheck'};
 354
 355   if ($lib_check) {
 356     my @l;
 357     for my $lp (@libs) {
 358       push(@l, grep_directory($lp,$lib_check));
 359     }
 360
 361     my @i;
 362     for my $ip (@incs) {
 363       push(@i, $ip) if $inc_check->($ip,$frm);
 364     }
 365
 366     printf("%10s: includes %s - libraries %s\n",$frm,(@i?'found':'not found'),(@l?'found':'not found'));
 367     $formats{$frm}{incdir} = \@i;
 368     $formats{$frm}{libdir} = \@l;
 369     return 1 if scalar(@i && @l);
 370   }
 371   else {
 372     printf("%10s: not available\n", $frm);
 373   }
 374
 375   return 0;
 376 }
 377
 378 sub checkformat {
 379   my $frm=shift;
 380
 381   print "  checkformat($frm)\n" if $VERBOSE;
 382
 383   my $format = $formats{$frm};
 384
 385   my @probes;
 386   if (my $code = $format->{'code'}) {
 387     if (ref $code eq 'ARRAY') {
 388       push @probes, @$code;
 389     }
 390     else {
 391       push @probes, $code;
 392     }
 393   }
 394   push @probes, \&_probe_default;
 395
 396   print "    Calling probe function\n" if $VERBOSE;
 397   my $found;
 398   for my $func (@probes) {
 399     if ($func->($format, $frm)) {
 400       ++$found;
 401       last;
 402     }
 403   }
 404
 405   $found or return;
 406
 407   if ($format->{postcheck}) {
 408     print "    Calling postcheck function\n" if $VERBOSE;
 409     $format->{postcheck}->($format, $frm)
 410       or return;
 411   }
 412
 413   return 1;
 414 }
 415
 416
 417 sub pathcheck {
 418   if ($VERBOSE) {
 419     print "pathcheck\n";
 420     print "  Include paths:\n";
 421     for (@incs) { print $_,"\n"; }
 422   }
 423   @incs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @incs;
 424
 425   if ($VERBOSE) {
 426     print "\nLibrary paths:\n";
 427     for (@libs) { print $_,"\n"; }
 428   }
 429   @libs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @libs;
 430   print "\ndone.\n";
 431 }
 432
 433
 434 # Format data initialization
 435
 436 # format definition is:
 437 # defines needed
 438 # default include path
 439 # files needed for include (boolean perl code)
 440 # default lib path
 441 # libs needed
 442 # files needed for link (boolean perl code)
 443 # object files needed for the format
 444
 445
 446 sub init {
 447
 448   my @definc = qw(/usr/include);
 449   @definc{@definc}=(1) x @definc;
 450   @incs=
 451     (
 452      split(/\Q$Config{path_sep}/, $INCPATH),
 453      map _tilde_expand($_), map { split /\Q$Config{path_sep}/ } @incpaths
 454     );
 455   if ($Config{locincpth}) {
 456     push @incs, grep -d, split ' ', $Config{locincpth};
 457   }
 458   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
 459     push(@incs, split /;/, $ENV{INCLUDE}) if exists $ENV{INCLUDE};
 460   }
 461   if ($Config{incpath}) {
 462     push @incs, grep -d, split /\Q$Config{path_sep}/, $Config{incpath};
 463   }
 464   push @incs, grep -d,
 465       qw(/sw/include
 466          /usr/include/freetype2
 467          /usr/local/include/freetype2
 468          /usr/local/include/freetype1/freetype
 469          /usr/include /usr/local/include /usr/include/freetype
 470          /usr/local/include/freetype);
 471   if ($Config{ccflags}) {
 472     my @hidden = map { /^-I(.*)$/ ? ($1) : () } split ' ', $Config{ccflags};
 473     push @incs, @hidden;
 474     @definc{@hidden} = (1) x @hidden;
 475   }
 476
 477   @libs= ( split(/\Q$Config{path_sep}/,$LIBPATH),
 478     map _tilde_expand($_), map { split /\Q$Config{path_sep}/} @libpaths );
 479   if ($Config{loclibpth}) {
 480     push @libs, grep -d, split ' ', $Config{loclibpth};
 481   }
 482
 483   push @libs, grep -d, qw(/sw/lib),  split(/ /, $Config{'libpth'});
 484   push @libs, grep -d, split / /, $Config{libspath} if $Config{libspath};
 485   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
 486     push(@libs, split /;/, $ENV{LIB}) if exists $ENV{LIB};
 487   }
 488   if ($^O eq 'cygwin') {
 489     push(@libs, '/usr/lib/w32api') if -d '/usr/lib/w32api';
 490     push(@incs, '/usr/include/w32api') if -d '/usr/include/w32api';
 491   }
 492   if ($Config{ldflags}) {
 493     # some builds of perl put -Ldir into ldflags without putting it in
 494     # loclibpth, let's extract them
 495     my @hidden = grep -d, map { /^-L(.*)$/ ? ($1) : () }
 496       split ' ', $Config{ldflags};
 497     push @libs, @hidden;
 498     # don't mark them as seen - EU::MM will remove any libraries
 499     # it can't find and it doesn't look for -L in ldflags
 500     #@deflib{@hidden} = @hidden;
 501   }
 502   push @libs, grep -d, qw(/usr/local/lib);
 503
 504   $formats{'TT-fonts'}=
 505     {
 506      order=>'31',
 507      def=>'HAVE_LIBTT',
 508      inccheck=>sub { -e catfile($_[0], 'freetype.h')
 509                        && !-e catfile($_[0], 'fterrors.h') },
 510      libcheck=>sub { $_[0] eq "libttf$aext" or $_[0] eq "libttf.$lext" },
 511      libfiles=>'-lttf',
 512      objfiles=>'',
 513      code => \&freetype1_probe,
 514      docs=>q{
 515 Truetype fonts are scalable fonts. They can include
 516 kerning and hinting information and generally yield good
 517 visual quality esp on low resultions. The freetype library is
 518 used to rasterize for us. The only drawback is that there
 519 are alot of badly designed fonts out there.}
 520                        };
 521   # Make fix indent
 522   for (keys %formats) { $formats{$_}->{docs} =~ s/^\s+/  /mg; }
 523 }
 524
 525
 526
 527 sub gen {
 528   my $V = $ENV{$_[0]};
 529   defined($V) ? $V : "";
 530 }
 531
 532
 533 # Get information from environment variables
 534
 535 sub getenv {
 536
 537   ($VERBOSE,
 538    $INCPATH,
 539    $LIBPATH,
 540    $NOLOG,
 541    $DEBUG_MALLOC,
 542    $MANUAL,
 543    $CFLAGS,
 544    $LFLAGS,
 545    $DFLAGS) = map { gen $_ } qw(IM_VERBOSE
 546                                 IM_INCPATH
 547                                 IM_LIBPATH
 548                                 IM_NOLOG
 549                                 IM_DEBUG_MALLOC
 550                                 IM_MANUAL
 551                                 IM_CFLAGS
 552                                 IM_LFLAGS
 553                                 IM_DFLAGS);
 554
 555 }
 556
 557 # populate the environment so that sub-modules get the same info
 558 sub setenv {
 559   $ENV{IM_VERBOSE} = 1 if $VERBOSE;
 560   $ENV{IM_INCPATH} = join $Config{path_sep}, @incpaths if @incpaths;
 561   $ENV{IM_LIBPATH} = join $Config{path_sep}, @libpaths if @libpaths;
 562 }
 563
 564 sub make_imconfig {
 565   my ($defines) = @_;
 566
 567   open CONFIG, "> imconfig.h"
 568     or die "Cannot create imconfig.h: $!\n";
 569   print CONFIG <<EOS;
 570 /* This file is automatically generated by Makefile.PL.
 571    Don't edit this file, since any changes will be lost */
 572
 573 #ifndef IMAGER_IMCONFIG_H
 574 #define IMAGER_IMCONFIG_H
 575 EOS
 576   for my $define (@$defines) {
 577     if ($define->[2]) {
 578       print CONFIG "\n/*\n  $define->[2]\n*/\n\n";
 579     }
 580     print CONFIG "#define $define->[0] $define->[1]\n";
 581   }
 582   if ($Config{gccversion} && $Config{gccversion} =~ /^([0-9]+)/ && $1 > 3) {
 583     print CONFIG <<EOS;
 584 /*
 585
 586 Compiler supports the GCC __attribute__((format...)) syntax.
 587
 588 */
 589
 590 #define IMAGER_FORMAT_ATTR 1
 591
 592 EOS
 593   }
 594
 595   if ($Config{d_snprintf}) {
 596     print CONFIG <<EOS;
 597 /* We can use snprintf() */
 598 #define IMAGER_SNPRINTF 1
 599
 600 EOS
 601   }
 602
 603   if ($Config{d_vsnprintf}) {
 604     print CONFIG <<EOS;
 605 /* We can use vsnprintf() */
 606 #define IMAGER_VSNPRINTF 1
 607
 608 EOS
 609   }
 610
 611   print CONFIG <<EOS;
 612 /*
 613  Type and format code for formatted output as with printf.
 614
 615  This is intended for formatting i_img_dim values.
 616 */
 617 typedef $Config{ivtype} i_dim_format_t;
 618 #define i_DF $Config{ivdformat}
 619 EOS
 620
 621   print CONFIG "\n#endif\n";
 622   close CONFIG;
 623 }
 624
 625 # probes for freetype1 by scanning @incs for the includes and
 626 # @libs for the libs.  This is done separately because freetype's headers
 627 # are stored in a freetype or freetype1 directory under PREFIX/include.
 628 #
 629 # we could find the files with the existing mechanism, but it won't set
 630 # -I flags correctly.
 631 #
 632 # This could be extended to freetype2 too, but freetype-config catches
 633 # that
 634 sub freetype1_probe {
 635   my ($frm, $frmkey) = @_;
 636
 637   my $found_inc;
 638  INCS:
 639   for my $inc (@incs) {
 640     for my $subdir (qw/freetype freetype1/) {
 641       my $path = File::Spec->catfile($inc, $subdir, 'freetype.h');
 642       -e $path or next;
 643       $path = File::Spec->catfile($inc, $subdir, 'fterrors.h');
 644       -e $path and next;
 645
 646       $found_inc = File::Spec->catdir($inc, $subdir);
 647       last INCS;
 648     }
 649   }
 650
 651   my $found_lib;
 652  LIBS:
 653   for my $lib (@libs) {
 654     my $a_path = File::Spec->catfile($lib, "libttf$aext");
 655     my $l_path = File::Spec->catfile($lib, "libttf.$lext");
 656     if (-e $a_path || -e $l_path) {
 657       $found_lib = $lib;
 658       last LIBS;
 659     }
 660   }
 661
 662   return unless $found_inc && $found_lib;
 663   printf("%10s: includes %s - libraries %s\n", $frmkey,
 664          ($found_inc ? 'found' : 'not found'),
 665          ($found_lib ? 'found' : 'not found'));
 666
 667   $frm->{cflags} = "-I$found_inc";
 668   $frm->{libfiles} = "-lttf";
 669
 670   return 1;
 671 }
 672
 673 sub catfile {
 674   return File::Spec->catfile(@_);
 675 }
 676
 677 sub usage {
 678   print STDERR <<EOS;
 679 Usage: $0 [--enable feature1,feature2,...] [other options]
 680        $0 [--disable feature1,feature2,...]  [other options]
 681        $0 --help
 682 Possible feature names are:
 683   T1-fonts
 684 Other options:
 685   --verbose | -v
 686     Verbose library probing (or set IM_VERBOSE in the environment)
 687   --nolog
 688     Disable logging (or set IM_NOLOG in the environment)
 689   --incpath dir
 690     Add to the include search path
 691   --libpath dir
 692     Add to the library search path
 693   --coverage
 694     Build for coverage testing.
 695   --assert
 696     Build with assertions active.
 697 EOS
 698   exit 1;
 699
 700 }
 701
 702 # generate the PM MM argument
 703 # I'd prefer to modify the public version, but there doesn't seem to be
 704 # a public API to do that
 705 sub gen_PM {
 706   my %pm;
 707   my $instbase = '$(INST_LIBDIR)';
 708
 709   # first the basics, .pm and .pod files
 710   $pm{"Imager.pm"} = "$instbase/Imager.pm";
 711
 712   my $mani = maniread();
 713
 714   for my $filename (keys %$mani) {
 715     if ($filename =~ m!^lib/! && $filename =~ /\.(pm|pod)$/) {
 716       (my $work = $filename) =~ s/^lib//;
 717       $pm{$filename} = $instbase . $work;
 718     }
 719   }
 720
 721   # need the typemap
 722   $pm{typemap} = $instbase . '/Imager/typemap';
 723
 724   # and the core headers
 725   for my $filename (keys %$mani) {
 726     if ($filename =~ /^\w+\.h$/) {
 727       $pm{$filename} = $instbase . '/Imager/include/' . $filename;
 728     }
 729   }
 730
 731   # and the generated header
 732   $pm{"imconfig.h"} = $instbase . '/Imager/include/imconfig.h';
 733
 734   \%pm;
 735 }
 736
 737 my $home;
 738 sub _tilde_expand {
 739   my ($path) = @_;
 740
 741   if ($path =~ m!^~[/\\]!) {
 742     defined $home or $home = $ENV{HOME};
 743     if (!defined $home && $^O eq 'MSWin32'
 744        && defined $ENV{HOMEDRIVE} && defined $ENV{HOMEPATH}) {
 745       $home = $ENV{HOMEDRIVE} . $ENV{HOMEPATH};
 746     }
 747     unless (defined $home) {
 748       $home = eval { (getpwuid($<))[7] };
 749     }
 750     defined $home or die "You supplied $path, but I can't find your home directory\n";
 751     $path =~ s/^~//;
 752     $path = File::Spec->catdir($home, $path);
 753   }
 754
 755   $path;
 756 }
 757
 758 1;