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 vars qw(%Recommends);
   9 use ExtUtils::Manifest qw(maniread);
  10 use vars qw(%formats $VERBOSE $INCPATH $LIBPATH $NOLOG $DEBUG_MALLOC $MANUAL $CFLAGS $LFLAGS $DFLAGS);
  11
  12 #
  13 # IM_INCPATH      colon seperated list of paths to extra include paths
  14 # IM_LIBPATH      colon seperated list of paths to extra library paths
  15 #
  16 # IM_VERBOSE      turns on verbose mode for the library finding and such
  17 # IM_MANUAL       to manually select which libraries are used and which not
  18 # IM_ENABLE       to programmatically select which libraries are used
  19 #                 and which are not
  20 # IM_NOLOG        if true logging will not be compiled into the module
  21 # IM_DEBUG_MALLOC if true malloc debbuging will be compiled into the module
  22 #                 do not use IM_DEBUG_MALLOC in production - this slows
  23 #                 everything down by alot
  24 # IM_CFLAGS       Extra flags to pass to the compiler
  25 # IM_LFLAGS       Extra flags to pass to the linker
  26 # IM_DFLAGS       Extra flags to pass to the preprocessor
  27 # IM_SUPPRESS_PROMPT  Suppress the prompt asking about gif support
  28
  29 getenv();     # get environment variables
  30
  31 my $lext=$Config{'so'};   # Get extensions of libraries
  32 my $aext=$Config{'_a'};
  33
  34 my $help; # display help if set
  35 my @enable; # list of drivers to enable
  36 my @disable; # or list of drivers to disable
  37 my @incpaths; # places to look for headers
  38 my @libpaths; # places to look for libraries
  39 my $noprobe; # non-zero to disable newer probes
  40 my $noexif; # non-zero to disable EXIF parsing of JPEGs
  41 GetOptions("help" => \$help,
  42            "enable=s" => \@enable,
  43            "disable=s" => \@disable,
  44            "incpath=s", \@incpaths,
  45            "libpath=s" => \@libpaths,
  46            "noprobe" => \$noprobe,
  47            "verbose|v" => \$VERBOSE,
  48            "nolog" => \$NOLOG,
  49            "noexif" => \$noexif);
  50
  51 if ($VERBOSE) {
  52   print "Verbose mode\n";
  53   require Data::Dumper;
  54   import Data::Dumper qw(Dumper);
  55 }
  56
  57 if ($help) {
  58   usage();
  59 }
  60
  61 my @defines;
  62
  63 if ($NOLOG)   { print "Logging not compiled into module\n"; }
  64 else {
  65   push @defines, [ IMAGER_LOG => 1, "Logging system" ];
  66 }
  67
  68 if ($DEBUG_MALLOC) {
  69   push @defines, [ IMAGER_DEBUG_MALLOC => 1, "Use Imager's DEBUG malloc()" ];
  70   print "Malloc debugging enabled\n";
  71 }
  72
  73 if (@enable && @disable) {
  74   print STDERR "Only --enable or --disable can be used, not both, try --help\n";
  75   exit 1;
  76 }
  77
  78 my %definc;
  79 my %deflib;
  80 my @incs; # all the places to look for headers
  81 my @libs; # all the places to look for libraries
  82
  83 init();       # initialize global data
  84 pathcheck();  # Check if directories exist
  85
  86 if (exists $ENV{IM_ENABLE}) {
  87   my %en = map { $_, 1 } split ' ', $ENV{IM_ENABLE};
  88   for my $key (keys %formats) {
  89     delete $formats{$key} unless $en{$key};
  90   }
  91 }
  92 if (@enable) {
  93   my %en = map { $_ => 1 } map { split /,/ } @enable;
  94   for my $key (keys %formats) {
  95     delete $formats{$key} unless $en{$key};
  96   }
  97 }
  98 elsif (@disable) {
  99   delete @formats{map { split /,/ } @disable};
 100 }
 101
 102 # Pick what libraries are used
 103 if ($MANUAL) {
 104   manual();
 105 } else {
 106   automatic();
 107 }
 108
 109 # Make sure there isn't a clash between the gif libraries.
 110 gifcheck();
 111
 112 my $lib_cflags = '';
 113 my $F_LIBS = '';
 114 my $F_OBJECT = '';
 115 for my $frmkey (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
 116   my $frm = $formats{$frmkey};
 117   push @defines, [ $frm->{def}, 1, "$frmkey available" ];
 118   $F_LIBS   .= ' '  .$frm->{libfiles};
 119   $F_OBJECT .= ' '  .$frm->{objfiles};
 120   if ($frm->{cflags}) {
 121     $lib_cflags   .= ' '  .$frm->{cflags};
 122     ++$definc{$_} for map { /^-I(.*)$/ ? ($1) : () }
 123       grep /^-I./, split ' ', $frm->{cflags};
 124   }
 125 }
 126
 127 unless ($noexif) {
 128   print "EXIF support enabled\n";
 129   push @defines, [ 'IMEXIF_ENABLE', 1, "Enable experimental EXIF support" ];
 130   $F_OBJECT .= ' imexif.o';
 131 }
 132
 133 my $F_INC  = join ' ', map "-I$_", map / / ? qq{"$_"} : $_,
 134   grep !$definc{$_}, @incs;
 135 $F_LIBS = join(' ',map "-L$_", map / / ? qq{"$_"} : $_,
 136                grep !$deflib{$_}++, @libs) . $F_LIBS;
 137
 138 my $OSLIBS = '';
 139 my $OSDEF  = "-DOS_$^O";
 140
 141 if ($^O eq 'hpux')                { $OSLIBS .= ' -ldld'; }
 142 if (defined $Config{'d_dlsymun'}) { $OSDEF  .= ' -DDLSYMUN'; }
 143
 144 my @objs = qw(Imager.o draw.o polygon.o image.o io.o iolayer.o
 145               log.o gaussian.o conv.o pnm.o raw.o feat.o font.o
 146               filters.o dynaload.o stackmach.o datatypes.o
 147               regmach.o trans2.o quant.o error.o convert.o
 148               map.o tags.o palimg.o maskimg.o img16.o rotate.o
 149               bmp.o tga.o rgb.o color.o fills.o imgdouble.o limits.o hlines.o
 150               imext.o);
 151
 152 $Recommends{Imager} =
 153   { 'Parse::RecDescent' => 0 };
 154
 155 my %opts=(
 156           'NAME'         => 'Imager',
 157           'VERSION_FROM' => 'Imager.pm',
 158           'LIBS'         => "$LFLAGS -lm $OSLIBS $F_LIBS",
 159           'DEFINE'       => "$OSDEF $CFLAGS",
 160           'INC'          => "$lib_cflags $DFLAGS $F_INC",
 161           'OBJECT'       => join(' ', @objs, $F_OBJECT),
 162           clean          => { FILES=>'testout meta.tmp' },
 163           PM             => gen_PM(),
 164          );
 165
 166 if ($ExtUtils::MakeMaker::VERSION > 6.06) {
 167   $opts{AUTHOR} = 'Tony Cook <tony@imager.perl.org>, Arnar M. Hrafnkelsson';
 168   $opts{ABSTRACT} = 'Perl extension for Generating 24 bit Images';
 169 }
 170 if ($ExtUtils::MakeMaker::VERSION > 6.10) {
 171   $opts{NO_META} = 1;
 172 }
 173
 174 make_imconfig(\@defines);
 175
 176 if ($VERBOSE) { print Dumper(\%opts); }
 177 mkdir('testout',0777); # since we cannot include it in the archive.
 178
 179 make_metafile(\%opts);
 180
 181 WriteMakefile(%opts);
 182
 183 exit;
 184
 185
 186 sub MY::postamble {
 187     my $self = shift;
 188     my $perl = $self->{PERLRUN} ? '$(PERLRUN)' : '$(PERL)';
 189 '
 190 dyntest.$(MYEXTLIB) : dynfilt/Makefile
 191         cd dynfilt && $(MAKE) $(PASTHRU)
 192
 193 lib/Imager/Regops.pm : regmach.h regops.perl
 194         $(PERL) regops.perl regmach.h lib/Imager/Regops.pm
 195
 196 imconfig.h : Makefile.PL
 197         $(ECHO) "imconfig.h out-of-date with respect to $?"
 198         $(PERLRUN) Makefile.PL
 199         $(ECHO) "==> Your Makefile has been rebuilt - re-run your make command <=="
 200 '.qq!
 201 lib/Imager/APIRef.pm : \$(C_FILES) apidocs.perl
 202         $perl apidocs.perl lib/Imager/APIRef.pm
 203
 204 !;
 205
 206 }
 207
 208 # manual configuration of helper libraries
 209
 210 sub manual {
 211   print <<EOF;
 212
 213       Please answer the following questions about
 214       which formats are avaliable on your computer
 215
 216 press <return> to continue
 217 EOF
 218
 219   <STDIN>; # eat one return
 220
 221   for my $frm(sort { $formats{$b}{order} <=> $formats{$a}{order} } keys %formats) {
 222   SWX:
 223     if ($formats{$frm}{docs}) { print "\n",$formats{$frm}{docs},"\n\n"; }
 224     print "Enable $frm support: ";
 225     my $gz = <STDIN>;
 226     chomp($gz);
 227     if ($gz =~ m/^(y|yes|n|no)/i) {
 228       $gz=substr(lc($gz),0,1);
 229       if ($gz eq 'n') {
 230         delete $formats{$frm};
 231       }
 232     } else { goto SWX; }
 233   }
 234 }
 235
 236
 237 # automatic configuration of helper libraries
 238
 239 sub automatic {
 240   print "Automatic probing:\n" if $VERBOSE;
 241   for my $frm (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
 242     delete $formats{$frm} if !checkformat($frm);
 243   }
 244 }
 245
 246
 247 sub gifcheck {
 248   if ($formats{'gif'} and $formats{'ungif'}) {
 249     print "ungif and gif can not coexist - removing ungif support\n";
 250     delete $formats{'ungif'};
 251   }
 252
 253  RETR:
 254   if (($formats{'gif'} or $formats{'ungif'}) && !$ENV{IM_SUPPRESS_PROMPT}) {
 255     print <<EOFF;
 256
 257 You have libgif or libungif installed.  They are both known to have
 258 bugs.  Imager can crash or display other strange behaviour after
 259 reading or writing gif images.  Some of the gif tests can even fail
 260 since they stress some parts of the buggy code.
 261
 262 libungif 4.1.2 and later is safe.  giflib 4.1.3 needs at least one
 263 patch to have all the bugs fixed, see README for details.
 264
 265 Of course it's possible your operating system distributor has patched
 266 all of these problems and you have nothing to worry about.
 267
 268 Do you want to remove gif support? [Y/n]
 269 EOFF
 270     my $resp = <STDIN>;
 271     chomp($resp);
 272     if ($resp ne "n") {
 273       delete $formats{'gif'};
 274       delete $formats{'ungif'};
 275       return;
 276     }
 277   }
 278
 279   for my $frm (qw(gif ungif)) {
 280     checkformat($frm) if ($MANUAL and $formats{$frm});
 281   }
 282
 283   my @dirs;
 284   for my $frm (grep $formats{$_}, qw(gif ungif)) {
 285     push(@dirs, @{$formats{$frm}{incdir}}) if $formats{$frm}{incdir};
 286   }
 287   my $minor = 0;
 288   my $major = 0;
 289   FILES: for my $dir (@dirs) {
 290     my $h = "$dir/gif_lib.h";
 291     open H, "< $h" or next;
 292     while (<H>) {
 293       if (/GIF_LIB_VERSION\s+"\s*version\s*(\d+)\.(\d+)/i) {
 294         $major = $1;
 295         $minor = $2;
 296         close H;
 297         last FILES;
 298       }
 299     }
 300     close H;
 301   }
 302
 303   # we need the version in a #ifdefable form
 304
 305   push @defines, [ IM_GIFMAJOR => $major, "Parsed giflib version" ];
 306   push @defines, [ IM_GIFMINOR => $minor ];
 307 }
 308
 309
 310 sub gd {
 311   my($path,$chk)=@_;
 312
 313 #    print "checking path $path\n";
 314   if ( !opendir(DH,$path) ) {
 315     warn "Cannot open dir $path: $!\n";
 316     return;
 317   }
 318   my @l=grep { $chk->($_) } readdir(DH);
 319   #    print @l;
 320   close(DH);
 321   return map $path, @l;
 322 }
 323
 324
 325 sub checkformat {
 326   my $frm=shift;
 327
 328   print "  checkformat($frm)\n" if $VERBOSE;
 329
 330   my $code = $formats{$frm}{'code'};
 331   if ($code && !$noprobe) {
 332     print "    Calling probe function\n" if $VERBOSE;
 333     return 1 if $code->($formats{$frm}, $frm);
 334   }
 335
 336   my $libchk=$formats{$frm}{'libcheck'};
 337   my $incchk=$formats{$frm}{'inccheck'};
 338
 339   my @l;
 340   for my $lp (@libs) {
 341     push(@l, gd($lp,$libchk));
 342   }
 343
 344   my @i;
 345   for my $ip (@incs) {
 346     push(@i, $ip) if $incchk->($ip,$frm);
 347   }
 348
 349   printf("%10s: includes %s - libraries %s\n",$frm,(@i?'found':'not found'),(@l?'found':'not found'));
 350   $formats{$frm}{incdir} = \@i;
 351   $formats{$frm}{libdir} = \@l;
 352   return scalar(@i && @l);
 353 }
 354
 355
 356 sub pathcheck {
 357   if ($VERBOSE) {
 358     print "pathcheck\n";
 359     print "  Include paths:\n";
 360     for (@incs) { print $_,"\n"; }
 361   }
 362   @incs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @incs;
 363
 364   if ($VERBOSE) {
 365     print "\nLibrary paths:\n";
 366     for (@libs) { print $_,"\n"; }
 367   }
 368   @libs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @libs;
 369   print "\ndone.\n";
 370 }
 371
 372
 373 # Format data initialization
 374
 375 # format definition is:
 376 # defines needed
 377 # default include path
 378 # files needed for include (boolean perl code)
 379 # default lib path
 380 # libs needed
 381 # files needed for link (boolean perl code)
 382 # object files needed for the format
 383
 384
 385 sub init {
 386
 387   my @definc = qw(/usr/include);
 388   @definc{@definc}=(1) x @definc;
 389   @incs=(split(/\Q$Config{path_sep}/, $INCPATH),
 390         map { split /\Q$Config{path_sep}/} @incpaths );
 391   if ($Config{locincpth}) {
 392     push @incs, grep -d, split ' ', $Config{locincpth};
 393   }
 394   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
 395     push(@incs, split /;/, $ENV{INCLUDE}) if exists $ENV{INCLUDE};
 396   }
 397   push @incs, grep -d,
 398       qw(/sw/include
 399          /usr/include/freetype2
 400          /usr/local/include/freetype2
 401          /usr/local/include/freetype1/freetype
 402          /usr/include /usr/local/include /usr/include/freetype
 403          /usr/local/include/freetype);
 404   if ($Config{ccflags}) {
 405     my @hidden = map { /^-I(.*)$/ ? ($1) : () } split ' ', $Config{ccflags};
 406     push @incs, @hidden;
 407     @definc{@hidden} = (1) x @hidden;
 408   }
 409
 410   @libs= ( split(/\Q$Config{path_sep}/,$LIBPATH),
 411     map { split /\Q$Config{path_sep}/} @libpaths );
 412   if ($Config{loclibpth}) {
 413     push @libs, grep -d, split ' ', $Config{loclibpth};
 414   }
 415
 416   push @libs, grep -d, qw(/sw/lib),  split(/ /, $Config{'libpth'});
 417   push @libs, grep -d, split / /, $Config{libspath} if $Config{libspath};
 418   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
 419     push(@libs, split /;/, $ENV{LIB}) if exists $ENV{LIB};
 420   }
 421   if ($^O eq 'cygwin') {
 422     push(@libs, '/usr/lib/w32api') if -d '/usr/lib/w32api';
 423     push(@incs, '/usr/include/w32api') if -d '/usr/include/w32api';
 424   }
 425   if ($Config{ldflags}) {
 426     # some builds of perl put -Ldir into ldflags without putting it in
 427     # loclibpth, let's extract them
 428     my @hidden = grep -d, map { /^-L(.*)$/ ? ($1) : () }
 429       split ' ', $Config{ldflags};
 430     push @libs, @hidden;
 431     # don't mark them as seen - EU::MM will remove any libraries
 432     # it can't find and it doesn't look for -L in ldflags
 433     #@deflib{@hidden} = @hidden;
 434   }
 435
 436   $formats{'jpeg'}={
 437                     order=>'21',
 438                     def=>'HAVE_LIBJPEG',
 439                     inccheck=>sub { -e catfile($_[0], 'jpeglib.h') },
 440                     libcheck=>sub { $_[0] eq "libjpeg$aext" or $_ eq "libjpeg.$lext" },
 441                     libfiles=>'-ljpeg',
 442                     objfiles=>'jpeg.o',
 443                     docs=>q{
 444                             In order to use jpeg with this module you need to have libjpeg
 445                             installed on your computer}
 446                    };
 447
 448   $formats{'tiff'}={
 449                     order=>'23',
 450                     def=>'HAVE_LIBTIFF',
 451                     inccheck=>sub { -e catfile($_[0], 'tiffio.h') },
 452                     libcheck=>sub { $_[0] eq "libtiff$aext" or $_ eq "libtiff.$lext" },
 453                     libfiles=>'-ltiff',
 454                     objfiles=>'tiff.o',
 455                     docs=>q{
 456                             In order to use tiff with this module you need to have libtiff
 457                             installed on your computer}
 458                    };
 459
 460   $formats{'png'}={
 461                    order=>'22',
 462                    def=>'HAVE_LIBPNG',
 463                    inccheck=>sub { -e catfile($_[0], 'png.h') },
 464                    libcheck=>sub { $_[0] eq "libpng$aext" or $_[0] eq "libpng.$lext" },
 465                    libfiles=>'-lpng -lz',
 466                    objfiles=>'png.o',
 467                    docs=>q{
 468                            Png stands for Portable Network Graphics and is intended as
 469                            a replacement for gif on the web. It is patent free and
 470                            is recommended by the w3c, you need libpng to use these formats},
 471                    code => \&png_probe,
 472                   };
 473
 474   $formats{'gif'}={
 475                    order=>'20',
 476                    def=>'HAVE_LIBGIF',
 477                    inccheck=>sub { -e catfile($_[0], 'gif_lib.h') },
 478                    libcheck=>sub { $_[0] eq "libgif$aext" or $_[0] eq "libgif.$lext" },
 479                    libfiles=>'-lgif',
 480                    objfiles=>'gif.o',
 481                    docs=>q{
 482                            gif is the de facto standard for webgraphics at the moment,
 483                            it does have some patent problems. If you have giflib and
 484                            are not in violation with the unisys patent you should use
 485                            this instead of the 'ungif' option.  Note that they cannot
 486                            be in use at the same time}
 487                   };
 488
 489   $formats{'ungif'}={
 490                      order=>'21',
 491                      def=>'HAVE_LIBGIF',
 492                      inccheck=>sub { -e catfile($_[0], 'gif_lib.h') },
 493                      libcheck=>sub { $_[0] eq "libungif$aext" or $_[0] eq "libungif.$lext" },
 494                      libfiles=>'-lungif',
 495                      objfiles=>'gif.o',
 496                      docs=>q{
 497                              gif is the de facto standard for webgraphics at the moment,
 498                              it does have some patent problems. If you have libungif and
 499                              want to create images free from LZW patented compression you
 500                              should use this option instead of the 'gif' option}
 501                     };
 502
 503   $formats{'T1-fonts'}={
 504                         order=>'30',
 505                         def=>'HAVE_LIBT1',
 506                         inccheck=>sub { -e catfile($_[0], 't1lib.h') },
 507                         libcheck=>sub { $_[0] eq "libt1$aext" or $_[0] eq "libt1.$lext" },
 508                         libfiles=>'-lt1',
 509                         objfiles=>'',
 510                         docs=>q{
 511                                 postscript t1 fonts are scalable fonts. They can include
 512                                 ligatures and kerning information and generally yield good
 513                                 visual quality. We depend on libt1 to rasterize the fonts
 514                                 for use in images.}
 515                        };
 516
 517   $formats{'TT-fonts'}=
 518     {
 519      order=>'31',
 520      def=>'HAVE_LIBTT',
 521      inccheck=>sub { -e catfile($_[0], 'freetype.h')
 522                        && !-e catfile($_[0], 'fterrors.h') },
 523      libcheck=>sub { $_[0] eq "libttf$aext" or $_[0] eq "libttf.$lext" },
 524      libfiles=>'-lttf',
 525      objfiles=>'',
 526      code => \&freetype1_probe,
 527      docs=>q{
 528 Truetype fonts are scalable fonts. They can include
 529 kerning and hinting information and generally yield good
 530 visual quality esp on low resultions. The freetype library is
 531 used to rasterize for us. The only drawback is that there
 532 are alot of badly designed fonts out there.}
 533                        };
 534   $formats{'w32'} = {
 535                      order=>40,
 536                      def=>'HAVE_WIN32',
 537                      inccheck=>sub { -e catfile($_[0], 'windows.h') },
 538                      libcheck=>sub { lc $_[0] eq 'gdi32.lib'
 539                                        || lc $_[0] eq 'libgdi32.a' },
 540                      libfiles=>$^O eq 'cygwin' ? '-lgdi32' : '',
 541                      objfiles=>'win32.o',
 542                      docs => <<DOCS
 543 Uses the Win32 GDI for rendering text.
 544
 545 This currently only works on under normal Win32 and cygwin.
 546 DOCS
 547                     };
 548   $formats{'freetype2'} = {
 549                            order=>'29',
 550                            def=>'HAVE_FT2',
 551                            inccheck=>sub { -e catfile($_[0], 'ft2build.h') },
 552                            libcheck=>sub { $_[0] eq "libfreetype$aext" or $_[0] eq "libfreetype.$lext" },
 553                            libfiles=>'-lfreetype',
 554                            objfiles=>'freetyp2.o',
 555                            docs=><<DOCS,
 556 Freetype 2 supports both Truetype and Type 1 fonts, both of which are
 557 scalable.  It also supports a variety of other fonts.
 558 DOCS
 559                            code => \&freetype2_probe,
 560                           };
 561
 562   # Make fix indent
 563   for (keys %formats) { $formats{$_}->{docs} =~ s/^\s+/  /mg; }
 564 }
 565
 566
 567
 568 sub gen {
 569   my $V = $ENV{$_[0]};
 570   defined($V) ? $V : "";
 571 }
 572
 573
 574 # Get information from environment variables
 575
 576 sub getenv {
 577
 578   ($VERBOSE,
 579    $INCPATH,
 580    $LIBPATH,
 581    $NOLOG,
 582    $DEBUG_MALLOC,
 583    $MANUAL,
 584    $CFLAGS,
 585    $LFLAGS,
 586    $DFLAGS) = map { gen $_ } qw(IM_VERBOSE
 587                                 IM_INCPATH
 588                                 IM_LIBPATH
 589                                 IM_NOLOG
 590                                 IM_DEBUG_MALLOC
 591                                 IM_MANUAL
 592                                 IM_CFLAGS
 593                                 IM_LFLAGS
 594                                 IM_DFLAGS);
 595
 596 }
 597
 598 sub make_imconfig {
 599   my ($defines) = @_;
 600
 601   open CONFIG, "> imconfig.h"
 602     or die "Cannot create imconfig.h: $!\n";
 603   print CONFIG <<EOS;
 604 /* This file is automatically generated by Makefile.PL.
 605    Don't edit this file, since any changes will be lost */
 606
 607 #ifndef IMAGER_IMCONFIG_H
 608 #define IMAGER_IMCONFIG_H
 609 EOS
 610   for my $define (@$defines) {
 611     if ($define->[2]) {
 612       print CONFIG "\n/*\n  $define->[2]\n*/\n\n";
 613     }
 614     print CONFIG "#define $define->[0] $define->[1]\n";
 615   }
 616   print CONFIG "\n#endif\n";
 617   close CONFIG;
 618 }
 619
 620 # use pkg-config to probe for libraries
 621 # works around the junk that pkg-config dumps on FreeBSD
 622 sub _pkg_probe {
 623   my ($pkg) = @_;
 624
 625   is_exe('pkg-config') or return;
 626
 627   my $redir = $^O eq 'MSWin32' ? '' : '2>/dev/null';
 628
 629   !system("pkg-config $pkg --exists $redir");
 630 }
 631
 632 # probes for freetype1 by scanning @incs for the includes and
 633 # @libs for the libs.  This is done separately because freetype's headers
 634 # are stored in a freetype or freetype1 directory under PREFIX/include.
 635 #
 636 # we could find the files with the existing mechanism, but it won't set
 637 # -I flags correctly.
 638 #
 639 # This could be extended to freetype2 too, but freetype-config catches
 640 # that
 641 sub freetype1_probe {
 642   my ($frm, $frmkey) = @_;
 643
 644   my $found_inc;
 645  INCS:
 646   for my $inc (@incs) {
 647     for my $subdir (qw/freetype freetype1/) {
 648       my $path = File::Spec->catfile($inc, $subdir, 'freetype.h');
 649       -e $path or next;
 650       $path = File::Spec->catfile($inc, $subdir, 'fterrors.h');
 651       -e $path and next;
 652
 653       $found_inc = File::Spec->catdir($inc, $subdir);
 654       last INCS;
 655     }
 656   }
 657
 658   my $found_lib;
 659  LIBS:
 660   for my $lib (@libs) {
 661     my $a_path = File::Spec->catfile($lib, "libttf$aext");
 662     my $l_path = File::Spec->catfile($lib, "libttf.$lext");
 663     if (-e $a_path || -e $l_path) {
 664       $found_lib = $lib;
 665       last LIBS;
 666     }
 667   }
 668
 669   return unless $found_inc && $found_lib;
 670   printf("%10s: includes %s - libraries %s\n", $frmkey,
 671          ($found_inc ? 'found' : 'not found'),
 672          ($found_lib ? 'found' : 'not found'));
 673
 674   $frm->{cflags} = "-I$found_inc";
 675   $frm->{libfiles} = "-lttf";
 676
 677   return 1;
 678 }
 679
 680 # probes for freetype2 by trying to run freetype-config
 681 sub freetype2_probe {
 682   my ($frm, $frmkey) = @_;
 683
 684   is_exe('freetype-config') or return;
 685
 686   my $cflags = `freetype-config --cflags`
 687     and !$? or return;
 688   chomp $cflags;
 689
 690   my $lflags = `freetype-config --libs`
 691     and !$? or return;
 692   chomp $lflags;
 693
 694   # before 2.1.5 freetype-config --cflags could output
 695   # the -I options in the wrong order, causing a conflict with
 696   # freetype1.x installed with the same --prefix
 697   #
 698   # can happen iff:
 699   #  - both -Iprefix/include and -Iprefix/include/freetype2 are in cflags
 700   #    in that order
 701   #  - freetype 1.x headers are in prefix/include/freetype
 702   my @incdirs = map substr($_, 2), grep /^-I/, split ' ', $cflags;
 703   if (@incdirs == 2
 704       && $incdirs[1] eq "$incdirs[0]/freetype2"
 705       && -e "$incdirs[0]/freetype/freetype.h"
 706       && -e "$incdirs[0]/freetype/fterrid.h") {
 707     print "** freetype-config provided -I options out of order, correcting\n"
 708       if $VERBOSE;
 709     $cflags = join(' ', grep(!/-I/, split ' ', $cflags),
 710                    map "-I$_", reverse @incdirs);
 711   }
 712   $frm->{cflags} = $cflags;
 713   $frm->{libfiles} = $lflags;
 714
 715   printf "%10s: configured via freetype-config\n", $frmkey;
 716
 717   return 1;
 718 }
 719
 720 # probes for libpng via pkg-config
 721 sub png_probe {
 722   my ($frm, $frmkey) = @_;
 723
 724   is_exe('pkg-config') or return;
 725
 726   my $config;
 727   for my $check_conf (qw(libpng libpng12 libpng10)) {
 728     if (_pkg_probe($check_conf)) {
 729       $config = $check_conf;
 730       last;
 731     }
 732   }
 733   $config or return;
 734
 735   my $cflags = `pkg-config $config --cflags`
 736     and !$? or return;
 737
 738   my $lflags = `pkg-config $config --libs`
 739     and !$? or return;
 740
 741   chomp $cflags;
 742   chomp $lflags;
 743   $frm->{cflags} = $cflags;
 744   $frm->{libfiles} = $lflags;
 745
 746   printf "%10s: configured via `pkg-config $config ...`\n", $frmkey;
 747
 748   return 1;
 749 }
 750
 751 sub catfile {
 752   return File::Spec->catfile(@_);
 753 }
 754
 755 sub is_exe {
 756   my ($name) = @_;
 757
 758   for my $dir (File::Spec->path) {
 759     -x catfile($dir, "$name$Config{_exe}")
 760       and return 1;
 761   }
 762
 763   return;
 764 }
 765
 766 sub usage {
 767   print STDERR <<EOS;
 768 Usage: $0 [--enable feature1,feature2,...] [other options]
 769        $0 [--disable feature1,feature2,...]  [other options]
 770        $0 --help
 771 Possible feature names are:
 772   png gif ungif jpeg tiff T1-fonts TT-fonts freetype2
 773 Other options:
 774   --verbose | -v
 775     Verbose library probing (or set IM_VERBOSE in the environment)
 776   --nolog
 777     Disable logging (or set IM_NOLOG in the environment)
 778   --incpath dir
 779     Add to the include search path
 780   --libpath dir
 781     Add to the library search path
 782   --noprobe
 783     Don't use pkg-config or freetype2-config to probe for freetype2 and libpng
 784 EOS
 785   exit 1;
 786
 787 }
 788
 789 # generate the PM MM argument
 790 # I'd prefer to modify the public version, but there doesn't seem to be
 791 # a public API to do that
 792 sub gen_PM {
 793   my %pm;
 794   my $instbase = '$(INST_LIBDIR)';
 795
 796   # first the basics, .pm and .pod files
 797   $pm{"Imager.pm"} = "$instbase/Imager.pm";
 798
 799   my $mani = maniread();
 800
 801   for my $filename (keys %$mani) {
 802     if ($filename =~ m!^lib/! && $filename =~ /\.(pm|pod)$/) {
 803       (my $work = $filename) =~ s/^lib//;
 804       $pm{$filename} = $instbase . $work;
 805     }
 806   }
 807
 808   # need the typemap
 809   $pm{typemap} = $instbase . '/Imager/typemap';
 810
 811   # and the core headers
 812   for my $filename (keys %$mani) {
 813     if ($filename =~ /^\w+\.h$/) {
 814       $pm{$filename} = $instbase . '/Imager/include/' . $filename;
 815     }
 816   }
 817
 818   # and the generated header
 819   $pm{"imconfig.h"} = $instbase . '/Imager/include/imconfig.h';
 820
 821   \%pm;
 822 }
 823
 824 sub make_metafile {
 825   my ($opts) = @_;
 826
 827   # extract the version
 828   my $version = MM->parse_version($opts->{VERSION_FROM})
 829     or die "Could not extract version number from $opts->{VERSION_FROM}\n";
 830
 831   my $meta = <<YAML;
 832 --- #YAML:1.0
 833 name: $opts->{NAME}
 834 version: $version
 835 version_from: $opts->{VERSION_FROM}
 836 author: $opts->{AUTHOR}
 837 abstract: $opts->{ABSTRACT}
 838 installdirs: site
 839 YAML
 840   if (keys %{$Recommends{$opts->{NAME}}}) {
 841     $meta .= "recommends:\n";
 842     while (my ($module, $version) = each %{$Recommends{$opts->{NAME}}}) {
 843       $meta .= "  $module: $version\n";
 844     }
 845   }
 846   $meta .= <<YAML;
 847 license: perl
 848 dynamic_config: 1
 849 distribution_type: module
 850 generated_by: $opts->{NAME} version $version
 851 YAML
 852   my $save_meta;
 853   if (open META, "< META.yml") {
 854     my $old_meta = do { local $/; <META> };
 855     close META;
 856
 857     $save_meta = $old_meta ne $meta;
 858   }
 859   else {
 860     ++$save_meta;
 861   }
 862   if ($save_meta) {
 863     print "Updating META.yml\n";
 864     open META, "> META.yml" or die "Cannot create META.yml: $!";
 865     print META $meta;
 866     close META;
 867   }
 868 }