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 #
  19 # IM_INCPATH      colon seperated list of paths to extra include paths
  20 # IM_LIBPATH      colon seperated list of paths to extra library paths
  21 #
  22 # IM_VERBOSE      turns on verbose mode for the library finding and such
  23 # IM_MANUAL       to manually select which libraries are used and which not
  24 # IM_ENABLE       to programmatically select which libraries are used
  25 #                 and which are not
  26 # IM_NOLOG        if true logging will not be compiled into the module
  27 # IM_DEBUG_MALLOC if true malloc debbuging will be compiled into the module
  28 #                 do not use IM_DEBUG_MALLOC in production - this slows
  29 #                 everything down by alot
  30 # IM_CFLAGS       Extra flags to pass to the compiler
  31 # IM_LFLAGS       Extra flags to pass to the linker
  32 # IM_DFLAGS       Extra flags to pass to the preprocessor
  33
  34 my $KEEP_FILES = $ENV{IMAGER_KEEP_FILES};
  35
  36 getenv();     # get environment variables
  37
  38 my $lext=$Config{'so'};   # Get extensions of libraries
  39 my $aext=$Config{'_a'};
  40
  41 my $help; # display help if set
  42 my @enable; # list of drivers to enable
  43 my @disable; # or list of drivers to disable
  44 my @incpaths; # places to look for headers
  45 my @libpaths; # places to look for libraries
  46 my $coverage; # build for coverage testing
  47 my $assert; # build with assertions
  48 GetOptions("help" => \$help,
  49            "enable=s" => \@enable,
  50            "disable=s" => \@disable,
  51            "incpath=s", \@incpaths,
  52            "libpath=s" => \@libpaths,
  53            "verbose|v" => \$VERBOSE,
  54            "nolog" => \$NOLOG,
  55            'coverage' => \$coverage,
  56            "assert|a" => \$assert);
  57
  58 setenv();
  59
  60 if ($ENV{AUTOMATED_TESTING}) {
  61   $assert = 1;
  62 }
  63
  64 if ($VERBOSE) {
  65   print "Verbose mode\n";
  66   require Data::Dumper;
  67   import Data::Dumper qw(Dumper);
  68 }
  69
  70 if ($help) {
  71   usage();
  72 }
  73
  74 my @defines;
  75
  76 if ($NOLOG)   { print "Logging not compiled into module\n"; }
  77 else {
  78   push @defines, [ IMAGER_LOG => 1, "Logging system" ];
  79 }
  80
  81 if ($assert) {
  82   push @defines, [ IM_ASSERT => 1, "im_assert() are effective" ];
  83 }
  84
  85 if ($DEBUG_MALLOC) {
  86   push @defines, [ IMAGER_DEBUG_MALLOC => 1, "Use Imager's DEBUG malloc()" ];
  87   print "Malloc debugging enabled\n";
  88 }
  89
  90 if (@enable && @disable) {
  91   print STDERR "Only --enable or --disable can be used, not both, try --help\n";
  92   exit 1;
  93 }
  94
  95 my %definc;
  96 my %deflib;
  97 my @incs; # all the places to look for headers
  98 my @libs; # all the places to look for libraries
  99
 100 init();       # initialize global data
 101 pathcheck();  # Check if directories exist
 102
 103 if (exists $ENV{IM_ENABLE}) {
 104   my %en = map { $_, 1 } split ' ', $ENV{IM_ENABLE};
 105   for my $key (keys %formats) {
 106     delete $formats{$key} unless $en{$key};
 107   }
 108 }
 109 if (@enable) {
 110   my %en = map { $_ => 1 } map { split /,/ } @enable;
 111   for my $key (keys %formats) {
 112     delete $formats{$key} unless $en{$key};
 113   }
 114 }
 115 elsif (@disable) {
 116   delete @formats{map { split /,/ } @disable};
 117 }
 118
 119 # Pick what libraries are used
 120 if ($MANUAL) {
 121   manual();
 122 } else {
 123   automatic();
 124 }
 125
 126 my $lib_cflags = '';
 127 my $lib_lflags = '';
 128 my $F_LIBS = '';
 129 my $F_OBJECT = '';
 130 for my $frmkey (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
 131   my $frm = $formats{$frmkey};
 132   push @defines, [ $frm->{def}, 1, "$frmkey available" ];
 133   $F_OBJECT .= ' '  .$frm->{objfiles};
 134   if ($frm->{cflags}) {
 135     $lib_cflags   .= ' '  .$frm->{cflags};
 136     ++$definc{$_} for map { /^-I(.*)$/ ? ($1) : () }
 137       grep /^-I./, split ' ', $frm->{cflags};
 138   }
 139   if ($frm->{lflags}) {
 140     $lib_lflags .= ' ' . $frm->{lflags};
 141   }
 142   else {
 143     $F_LIBS   .= ' '  .$frm->{libfiles};
 144   }
 145
 146 }
 147
 148 my $F_INC  = join ' ', map "-I$_", map / / ? qq{"$_"} : $_,
 149   grep !$definc{$_}, @incs;
 150 $F_LIBS = join(' ',map "-L$_", map / / ? qq{"$_"} : $_,
 151                grep !$deflib{$_}++, @libs) . $F_LIBS;
 152
 153 my $OSLIBS = '';
 154 my $OSDEF  = "-DOS_$^O";
 155
 156 if ($^O eq 'hpux')                { $OSLIBS .= ' -ldld'; }
 157 if (defined $Config{'d_dlsymun'}) { $OSDEF  .= ' -DDLSYMUN'; }
 158
 159 my @objs = qw(Imager.o draw.o polygon.o image.o io.o iolayer.o
 160               log.o gaussian.o conv.o pnm.o raw.o feat.o font.o
 161               filters.o dynaload.o stackmach.o datatypes.o
 162               regmach.o trans2.o quant.o error.o convert.o
 163               map.o tags.o palimg.o maskimg.o img16.o rotate.o
 164               bmp.o tga.o color.o fills.o imgdouble.o limits.o hlines.o
 165               imext.o scale.o rubthru.o render.o paste.o compose.o flip.o);
 166
 167 my %opts=(
 168           'NAME'         => 'Imager',
 169           'VERSION_FROM' => 'Imager.pm',
 170           'LIBS'         => "$LFLAGS -lm $lib_lflags $OSLIBS $F_LIBS",
 171           'DEFINE'       => "$OSDEF $CFLAGS",
 172           'INC'          => "$lib_cflags $DFLAGS $F_INC",
 173           'OBJECT'       => join(' ', @objs, $F_OBJECT),
 174           clean          => { FILES=>'testout rubthru.c scale.c conv.c  filters.c gaussian.c render.c rubthru.c' },
 175           PM             => gen_PM(),
 176           PREREQ_PM      => { 'Test::More' => 0.47 },
 177          );
 178
 179 if ($coverage) {
 180     if ($Config{gccversion}) {
 181         push @ARGV, 'OPTIMIZE=-ftest-coverage -fprofile-arcs';
 182         #$opts{dynamic_lib} = { OTHERLDFLAGS => '-ftest-coverage -fprofile-arcs' };
 183     }
 184     else {
 185         die "Don't know the coverage C flags for your compiler\n";
 186     }
 187 }
 188
 189 # eval to prevent warnings about versions with _ in them
 190 my $MM_ver = eval $ExtUtils::MakeMaker::VERSION;
 191 if ($MM_ver > 6.06) {
 192   $opts{AUTHOR} = 'Tony Cook <tony@imager.perl.org>, Arnar M. Hrafnkelsson';
 193   $opts{ABSTRACT} = 'Perl extension for Generating 24 bit Images';
 194 }
 195
 196 if ($MM_ver >= 6.46) {
 197   $opts{META_MERGE} =
 198     {
 199      recommends =>
 200      {
 201       "Parse::RecDescent" => 0
 202      },
 203      license => "perl",
 204      dynamic_config => 1,
 205      no_index =>
 206      {
 207       directory =>
 208       [
 209        "PNG",
 210        "GIF",
 211        "TIFF",
 212        "JPEG",
 213        "W32",
 214        "FT2",
 215       ],
 216      },
 217      resources =>
 218      {
 219       homepage => "http://imager.perl.org/",
 220       repository =>
 221       {
 222        url => "http://imager.perl.org/svn/trunk/Imager",
 223        web => "http://imager.perl.org/svnweb/public/browse/trunk/Imager",
 224        type => "svn",
 225       },
 226       bugtracker =>
 227       {
 228        web => "http://rt.cpan.org/NoAuth/Bugs.html?Dist=Imager",
 229        mailto => 'bug-Imager@rt.cpan.org',
 230       },
 231      },
 232     };
 233 }
 234
 235 make_imconfig(\@defines);
 236
 237 if ($VERBOSE) { print Dumper(\%opts); }
 238 mkdir('testout',0777); # since we cannot include it in the archive.
 239
 240 -d "probe" and rmdir "probe";
 241
 242 WriteMakefile(%opts);
 243
 244 exit;
 245
 246
 247 sub MY::postamble {
 248     my $self = shift;
 249     my $perl = $self->{PERLRUN} ? '$(PERLRUN)' : '$(PERL)';
 250     my $mani = maniread;
 251
 252     my @ims = grep /\.im$/, keys %$mani;
 253 '
 254 dyntest.$(MYEXTLIB) : dynfilt/Makefile
 255         cd dynfilt && $(MAKE) $(PASTHRU)
 256
 257 lib/Imager/Regops.pm : regmach.h regops.perl
 258         $(PERL) regops.perl regmach.h lib/Imager/Regops.pm
 259
 260 imconfig.h : Makefile.PL
 261         $(ECHO) "imconfig.h out-of-date with respect to $?"
 262         $(PERLRUN) Makefile.PL
 263         $(ECHO) "==> Your Makefile has been rebuilt - re-run your make command <=="
 264 '.qq!
 265 lib/Imager/APIRef.pod : \$(C_FILES) \$(H_FILES) apidocs.perl
 266         $perl apidocs.perl lib/Imager/APIRef.pod
 267
 268 !.join('', map _im_rule($perl, $_), @ims)
 269
 270 }
 271
 272 sub _im_rule {
 273   my ($perl, $im) = @_;
 274
 275   (my $c = $im) =~ s/\.im$/.c/;
 276   return <<MAKE;
 277
 278 $c: $im lib/Imager/Preprocess.pm
 279         $perl -Ilib -MImager::Preprocess -epreprocess $im $c
 280
 281 MAKE
 282
 283 }
 284
 285 # manual configuration of helper libraries
 286
 287 sub manual {
 288   print <<EOF;
 289
 290       Please answer the following questions about
 291       which formats are avaliable on your computer
 292
 293 press <return> to continue
 294 EOF
 295
 296   <STDIN>; # eat one return
 297
 298   for my $frm(sort { $formats{$b}{order} <=> $formats{$a}{order} } keys %formats) {
 299   SWX:
 300     if ($formats{$frm}{docs}) { print "\n",$formats{$frm}{docs},"\n\n"; }
 301     print "Enable $frm support: ";
 302     my $gz = <STDIN>;
 303     chomp($gz);
 304     if ($gz =~ m/^(y|yes|n|no)/i) {
 305       $gz=substr(lc($gz),0,1);
 306       if ($gz eq 'n') {
 307         delete $formats{$frm};
 308       }
 309     } else { goto SWX; }
 310   }
 311 }
 312
 313
 314 # automatic configuration of helper libraries
 315
 316 sub automatic {
 317   print "Automatic probing:\n" if $VERBOSE;
 318   for my $frm (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
 319     delete $formats{$frm} if !checkformat($frm);
 320   }
 321 }
 322
 323
 324 # sub gifcheck {
 325 #   if ($formats{'gif'} and $formats{'ungif'}) {
 326 #     print "ungif and gif can not coexist - removing ungif support\n";
 327 #     delete $formats{'ungif'};
 328 #   }
 329
 330 #   for my $frm (qw(gif ungif)) {
 331 #     checkformat($frm) if ($MANUAL and $formats{$frm});
 332 #   }
 333
 334 #   my @dirs;
 335 #   for my $frm (grep $formats{$_}, qw(gif ungif)) {
 336 #     push(@dirs, @{$formats{$frm}{incdir}}) if $formats{$frm}{incdir};
 337 #   }
 338 #   my $minor = 0;
 339 #   my $major = 0;
 340 #   FILES: for my $dir (@dirs) {
 341 #     my $h = "$dir/gif_lib.h";
 342 #     open H, "< $h" or next;
 343 #     while (<H>) {
 344 #       if (/GIF_LIB_VERSION\s+"\s*version\s*(\d+)\.(\d+)/i) {
 345 #       $major = $1;
 346 #       $minor = $2;
 347 #       close H;
 348 #       last FILES;
 349 #       }
 350 #     }
 351 #     close H;
 352 #   }
 353
 354 #   # we need the version in a #ifdefable form
 355
 356 #   push @defines, [ IM_GIFMAJOR => $major, "Parsed giflib version" ];
 357 #   push @defines, [ IM_GIFMINOR => $minor ];
 358 #   push @defines, [ IM_NO_SET_GIF_VERSION => 1, "Disable EGifSetGifVersion" ]
 359 #     if $no_gif_set_version;
 360 # }
 361
 362
 363 sub grep_directory {
 364   my($path, $chk)=@_;
 365
 366 #    print "checking path $path\n";
 367   if ( !opendir(DH,$path) ) {
 368     warn "Cannot open dir $path: $!\n";
 369     return;
 370   }
 371   my @l=grep { $chk->($_) } readdir(DH);
 372   #    print @l;
 373   close(DH);
 374   return map $path, @l;
 375 }
 376
 377 sub _probe_default {
 378   my ($format, $frm) = @_;
 379
 380   my $lib_check=$formats{$frm}{'libcheck'};
 381   my $inc_check=$formats{$frm}{'inccheck'};
 382
 383   if ($lib_check) {
 384     my @l;
 385     for my $lp (@libs) {
 386       push(@l, grep_directory($lp,$lib_check));
 387     }
 388
 389     my @i;
 390     for my $ip (@incs) {
 391       push(@i, $ip) if $inc_check->($ip,$frm);
 392     }
 393
 394     printf("%10s: includes %s - libraries %s\n",$frm,(@i?'found':'not found'),(@l?'found':'not found'));
 395     $formats{$frm}{incdir} = \@i;
 396     $formats{$frm}{libdir} = \@l;
 397     return 1 if scalar(@i && @l);
 398   }
 399   else {
 400     printf("%10s: not available\n", $frm);
 401   }
 402
 403   return 0;
 404 }
 405
 406 sub checkformat {
 407   my $frm=shift;
 408
 409   print "  checkformat($frm)\n" if $VERBOSE;
 410
 411   my $format = $formats{$frm};
 412
 413   my @probes;
 414   if (my $code = $format->{'code'}) {
 415     if (ref $code eq 'ARRAY') {
 416       push @probes, @$code;
 417     }
 418     else {
 419       push @probes, $code;
 420     }
 421   }
 422   push @probes, \&_probe_default;
 423
 424   print "    Calling probe function\n" if $VERBOSE;
 425   my $found;
 426   for my $func (@probes) {
 427     if ($func->($format, $frm)) {
 428       ++$found;
 429       last;
 430     }
 431   }
 432
 433   $found or return;
 434
 435   if ($format->{postcheck}) {
 436     print "    Calling postcheck function\n" if $VERBOSE;
 437     $format->{postcheck}->($format, $frm)
 438       or return;
 439   }
 440
 441   return 1;
 442 }
 443
 444
 445 sub pathcheck {
 446   if ($VERBOSE) {
 447     print "pathcheck\n";
 448     print "  Include paths:\n";
 449     for (@incs) { print $_,"\n"; }
 450   }
 451   @incs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @incs;
 452
 453   if ($VERBOSE) {
 454     print "\nLibrary paths:\n";
 455     for (@libs) { print $_,"\n"; }
 456   }
 457   @libs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @libs;
 458   print "\ndone.\n";
 459 }
 460
 461
 462 # Format data initialization
 463
 464 # format definition is:
 465 # defines needed
 466 # default include path
 467 # files needed for include (boolean perl code)
 468 # default lib path
 469 # libs needed
 470 # files needed for link (boolean perl code)
 471 # object files needed for the format
 472
 473
 474 sub init {
 475
 476   my @definc = qw(/usr/include);
 477   @definc{@definc}=(1) x @definc;
 478   @incs=
 479     (
 480      split(/\Q$Config{path_sep}/, $INCPATH),
 481      map _tilde_expand($_), map { split /\Q$Config{path_sep}/ } @incpaths
 482     );
 483   if ($Config{locincpth}) {
 484     push @incs, grep -d, split ' ', $Config{locincpth};
 485   }
 486   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
 487     push(@incs, split /;/, $ENV{INCLUDE}) if exists $ENV{INCLUDE};
 488   }
 489   if ($Config{incpath}) {
 490     push @incs, grep -d, split /\Q$Config{path_sep}/, $Config{incpath};
 491   }
 492   push @incs, grep -d,
 493       qw(/sw/include
 494          /usr/include/freetype2
 495          /usr/local/include/freetype2
 496          /usr/local/include/freetype1/freetype
 497          /usr/include /usr/local/include /usr/include/freetype
 498          /usr/local/include/freetype);
 499   if ($Config{ccflags}) {
 500     my @hidden = map { /^-I(.*)$/ ? ($1) : () } split ' ', $Config{ccflags};
 501     push @incs, @hidden;
 502     @definc{@hidden} = (1) x @hidden;
 503   }
 504
 505   @libs= ( split(/\Q$Config{path_sep}/,$LIBPATH),
 506     map _tilde_expand($_), map { split /\Q$Config{path_sep}/} @libpaths );
 507   if ($Config{loclibpth}) {
 508     push @libs, grep -d, split ' ', $Config{loclibpth};
 509   }
 510
 511   push @libs, grep -d, qw(/sw/lib),  split(/ /, $Config{'libpth'});
 512   push @libs, grep -d, split / /, $Config{libspath} if $Config{libspath};
 513   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
 514     push(@libs, split /;/, $ENV{LIB}) if exists $ENV{LIB};
 515   }
 516   if ($^O eq 'cygwin') {
 517     push(@libs, '/usr/lib/w32api') if -d '/usr/lib/w32api';
 518     push(@incs, '/usr/include/w32api') if -d '/usr/include/w32api';
 519   }
 520   if ($Config{ldflags}) {
 521     # some builds of perl put -Ldir into ldflags without putting it in
 522     # loclibpth, let's extract them
 523     my @hidden = grep -d, map { /^-L(.*)$/ ? ($1) : () }
 524       split ' ', $Config{ldflags};
 525     push @libs, @hidden;
 526     # don't mark them as seen - EU::MM will remove any libraries
 527     # it can't find and it doesn't look for -L in ldflags
 528     #@deflib{@hidden} = @hidden;
 529   }
 530   push @libs, grep -d, qw(/usr/local/lib);
 531
 532 #   $formats{'jpeg'}={
 533 #                   order=>'21',
 534 #                   def=>'HAVE_LIBJPEG',
 535 #                   inccheck=>sub { -e catfile($_[0], 'jpeglib.h') },
 536 #                   libcheck=>sub { $_[0] eq "libjpeg$aext" or $_ eq "libjpeg.$lext" },
 537 #                   libfiles=>'-ljpeg',
 538 #                   objfiles=>'jpeg.o',
 539 #                   docs=>q{
 540 #                           In order to use jpeg with this module you need to have libjpeg
 541 #                           installed on your computer}
 542 #                  };
 543
 544 #   $formats{'tiff'}={
 545 #                   order=>'23',
 546 #                   def=>'HAVE_LIBTIFF',
 547 #                   inccheck=>sub { -e catfile($_[0], 'tiffio.h') },
 548 #                   libcheck=>sub { $_[0] eq "libtiff$aext" or $_ eq "libtiff.$lext" },
 549 #                   libfiles=>'-ltiff',
 550 #                   objfiles=>'tiff.o',
 551 #                   docs=>q{
 552 #                           In order to use tiff with this module you need to have libtiff
 553 #                           installed on your computer},
 554 #                   postcheck => \&postcheck_tiff,
 555 #                  };
 556
 557 #   $formats{'png'}={
 558 #                  order=>'22',
 559 #                  def=>'HAVE_LIBPNG',
 560 #                  inccheck=>sub { -e catfile($_[0], 'png.h') },
 561 #                  libcheck=>sub { $_[0] eq "libpng$aext" or $_[0] eq "libpng.$lext" },
 562 #                  libfiles=>$^O eq 'MSWin32' ? '-lpng -lzlib' : '-lpng -lz',
 563 #                  objfiles=>'png.o',
 564 #                  docs=>q{
 565 #                          Png stands for Portable Network Graphics and is intended as
 566 #                          a replacement for gif on the web. It is patent free and
 567 #                          is recommended by the w3c, you need libpng to use these formats},
 568 #                    code => \&png_probe,
 569 #                 };
 570
 571 #   $formats{'gif'}={
 572 #                  order=>'20',
 573 #                  def=>'HAVE_LIBGIF',
 574 #                  inccheck=>sub { -e catfile($_[0], 'gif_lib.h') },
 575 #                  libcheck=>sub { $_[0] eq "libgif$aext" or $_[0] eq "libgif.$lext" },
 576 #                  libfiles=>'-lgif',
 577 #                  objfiles=>'gif.o',
 578 #                  docs=>q{
 579 #                          gif is the de facto standard for webgraphics at the moment,
 580 #                          it does have some patent problems. If you have giflib and
 581 #                          are not in violation with the unisys patent you should use
 582 #                          this instead of the 'ungif' option.  Note that they cannot
 583 #                          be in use at the same time}
 584 #                 };
 585
 586 #   $formats{'ungif'}={
 587 #                    order=>'21',
 588 #                    def=>'HAVE_LIBGIF',
 589 #                    inccheck=>sub { -e catfile($_[0], 'gif_lib.h') },
 590 #                    libcheck=>sub { $_[0] eq "libungif$aext" or $_[0] eq "libungif.$lext" },
 591 #                    libfiles=>'-lungif',
 592 #                    objfiles=>'gif.o',
 593 #                    docs=>q{
 594 #                            gif is the de facto standard for webgraphics at the moment,
 595 #                            it does have some patent problems. If you have libungif and
 596 #                            want to create images free from LZW patented compression you
 597 #                            should use this option instead of the 'gif' option}
 598 #                   };
 599
 600   $formats{'T1-fonts'}={
 601                         order=>'30',
 602                         def=>'HAVE_LIBT1',
 603                         inccheck=>sub { -e catfile($_[0], 't1lib.h') },
 604                         libcheck=>sub { $_[0] eq "libt1$aext" or $_[0] eq "libt1.$lext" },
 605                         libfiles=>'-lt1',
 606                         objfiles=>'',
 607                         docs=>q{
 608                                 postscript t1 fonts are scalable fonts. They can include
 609                                 ligatures and kerning information and generally yield good
 610                                 visual quality. We depend on libt1 to rasterize the fonts
 611                                 for use in images.}
 612                        };
 613
 614   $formats{'TT-fonts'}=
 615     {
 616      order=>'31',
 617      def=>'HAVE_LIBTT',
 618      inccheck=>sub { -e catfile($_[0], 'freetype.h')
 619                        && !-e catfile($_[0], 'fterrors.h') },
 620      libcheck=>sub { $_[0] eq "libttf$aext" or $_[0] eq "libttf.$lext" },
 621      libfiles=>'-lttf',
 622      objfiles=>'',
 623      code => \&freetype1_probe,
 624      docs=>q{
 625 Truetype fonts are scalable fonts. They can include
 626 kerning and hinting information and generally yield good
 627 visual quality esp on low resultions. The freetype library is
 628 used to rasterize for us. The only drawback is that there
 629 are alot of badly designed fonts out there.}
 630                        };
 631 #   $formats{'w32'} = {
 632 #                    order=>40,
 633 #                    def=>'HAVE_WIN32',
 634 #                    inccheck=>sub { -e catfile($_[0], 'windows.h') },
 635 #                    libcheck=>sub { lc $_[0] eq 'gdi32.lib'
 636 #                                      || lc $_[0] eq 'libgdi32.a' },
 637 #                    libfiles=>$^O eq 'cygwin' ? '-lgdi32' : '',
 638 #                    objfiles=>'win32.o',
 639 #                    docs => <<DOCS
 640 # Uses the Win32 GDI for rendering text.
 641
 642 # This currently only works on under normal Win32 and cygwin.
 643 # DOCS
 644 #                   };
 645 #   $formats{'freetype2'} =
 646 #   {
 647 #    order=>'29',
 648 #    def=>'HAVE_FT2',
 649 #    # we always use a probe function
 650 #    #inccheck=>sub { -e catfile($_[0], 'ft2build.h') },
 651 #    #libcheck=>sub { $_[0] eq "libfreetype$aext" or $_[0] eq "libfreetype.$lext" },
 652 #    libfiles=>'-lfreetype',
 653 #    objfiles=>'freetyp2.o',
 654 #    docs=><<DOCS,
 655 # Freetype 2 supports both Truetype and Type 1 fonts, both of which are
 656 # scalable.  It also supports a variety of other fonts.
 657 # DOCS
 658 #    code =>
 659 #    [
 660 #     \&freetype2_probe_ftconfig,
 661 #     \&freetype2_probe_scan
 662 #    ],
 663 #   };
 664
 665   # Make fix indent
 666   for (keys %formats) { $formats{$_}->{docs} =~ s/^\s+/  /mg; }
 667 }
 668
 669
 670
 671 sub gen {
 672   my $V = $ENV{$_[0]};
 673   defined($V) ? $V : "";
 674 }
 675
 676
 677 # Get information from environment variables
 678
 679 sub getenv {
 680
 681   ($VERBOSE,
 682    $INCPATH,
 683    $LIBPATH,
 684    $NOLOG,
 685    $DEBUG_MALLOC,
 686    $MANUAL,
 687    $CFLAGS,
 688    $LFLAGS,
 689    $DFLAGS) = map { gen $_ } qw(IM_VERBOSE
 690                                 IM_INCPATH
 691                                 IM_LIBPATH
 692                                 IM_NOLOG
 693                                 IM_DEBUG_MALLOC
 694                                 IM_MANUAL
 695                                 IM_CFLAGS
 696                                 IM_LFLAGS
 697                                 IM_DFLAGS);
 698
 699 }
 700
 701 # populate the environment so that sub-modules get the same info
 702 sub setenv {
 703   $ENV{IM_VERBOSE} = 1 if $VERBOSE;
 704   $ENV{IM_INCPATH} = join $Config{path_sep}, @incpaths if @incpaths;
 705   $ENV{IM_LIBPATH} = join $Config{path_sep}, @libpaths if @libpaths;
 706 }
 707
 708 sub make_imconfig {
 709   my ($defines) = @_;
 710
 711   open CONFIG, "> imconfig.h"
 712     or die "Cannot create imconfig.h: $!\n";
 713   print CONFIG <<EOS;
 714 /* This file is automatically generated by Makefile.PL.
 715    Don't edit this file, since any changes will be lost */
 716
 717 #ifndef IMAGER_IMCONFIG_H
 718 #define IMAGER_IMCONFIG_H
 719 EOS
 720   for my $define (@$defines) {
 721     if ($define->[2]) {
 722       print CONFIG "\n/*\n  $define->[2]\n*/\n\n";
 723     }
 724     print CONFIG "#define $define->[0] $define->[1]\n";
 725   }
 726   print CONFIG "\n#endif\n";
 727   close CONFIG;
 728 }
 729
 730 # # use pkg-config to probe for libraries
 731 # # works around the junk that pkg-config dumps on FreeBSD
 732 # sub _pkg_probe {
 733 #   my ($pkg) = @_;
 734
 735 #   is_exe('pkg-config') or return;
 736
 737 #   my $redir = $^O eq 'MSWin32' ? '' : '2>/dev/null';
 738
 739 #   !system("pkg-config $pkg --exists $redir");
 740 # }
 741
 742 # probes for freetype1 by scanning @incs for the includes and
 743 # @libs for the libs.  This is done separately because freetype's headers
 744 # are stored in a freetype or freetype1 directory under PREFIX/include.
 745 #
 746 # we could find the files with the existing mechanism, but it won't set
 747 # -I flags correctly.
 748 #
 749 # This could be extended to freetype2 too, but freetype-config catches
 750 # that
 751 sub freetype1_probe {
 752   my ($frm, $frmkey) = @_;
 753
 754   my $found_inc;
 755  INCS:
 756   for my $inc (@incs) {
 757     for my $subdir (qw/freetype freetype1/) {
 758       my $path = File::Spec->catfile($inc, $subdir, 'freetype.h');
 759       -e $path or next;
 760       $path = File::Spec->catfile($inc, $subdir, 'fterrors.h');
 761       -e $path and next;
 762
 763       $found_inc = File::Spec->catdir($inc, $subdir);
 764       last INCS;
 765     }
 766   }
 767
 768   my $found_lib;
 769  LIBS:
 770   for my $lib (@libs) {
 771     my $a_path = File::Spec->catfile($lib, "libttf$aext");
 772     my $l_path = File::Spec->catfile($lib, "libttf.$lext");
 773     if (-e $a_path || -e $l_path) {
 774       $found_lib = $lib;
 775       last LIBS;
 776     }
 777   }
 778
 779   return unless $found_inc && $found_lib;
 780   printf("%10s: includes %s - libraries %s\n", $frmkey,
 781          ($found_inc ? 'found' : 'not found'),
 782          ($found_lib ? 'found' : 'not found'));
 783
 784   $frm->{cflags} = "-I$found_inc";
 785   $frm->{libfiles} = "-lttf";
 786
 787   return 1;
 788 }
 789
 790 # probes for freetype2 by trying to run freetype-config
 791 # sub freetype2_probe_ftconfig {
 792 #   my ($frm, $frmkey) = @_;
 793
 794 #   is_exe('freetype-config') or return;
 795
 796 #   my $cflags = `freetype-config --cflags`
 797 #     and !$? or return;
 798 #   chomp $cflags;
 799
 800 #   my $lflags = `freetype-config --libs`
 801 #     and !$? or return;
 802 #   chomp $lflags;
 803
 804 #   # before 2.1.5 freetype-config --cflags could output
 805 #   # the -I options in the wrong order, causing a conflict with
 806 #   # freetype1.x installed with the same --prefix
 807 #   #
 808 #   # can happen iff:
 809 #   #  - both -Iprefix/include and -Iprefix/include/freetype2 are in cflags
 810 #   #    in that order
 811 #   #  - freetype 1.x headers are in prefix/include/freetype
 812 #   my @incdirs = map substr($_, 2), grep /^-I/, split ' ', $cflags;
 813 #   if (@incdirs == 2
 814 #       && $incdirs[1] eq "$incdirs[0]/freetype2"
 815 #       && -e "$incdirs[0]/freetype/freetype.h"
 816 #       && -e "$incdirs[0]/freetype/fterrid.h") {
 817 #     print "** freetype-config provided -I options out of order, correcting\n"
 818 #       if $VERBOSE;
 819 #     $cflags = join(' ', grep(!/-I/, split ' ', $cflags),
 820 #                  map "-I$_", reverse @incdirs);
 821 #   }
 822 #   $frm->{cflags} = $cflags;
 823 #   $frm->{lflags} = $lflags;
 824
 825 #   printf "%10s: configured via freetype-config\n", $frmkey;
 826
 827 #   return 1;
 828 # }
 829
 830 # attempt to probe for freetype2 by scanning directories
 831 # we can't use the normal scan since we need to find the directory
 832 # containing most of the includes
 833 # sub freetype2_probe_scan {
 834 #   my ($frm, $frmkey) = @_;
 835
 836 #   my $found_inc;
 837 #   my $found_inc2;
 838 #  INCS:
 839 #   for my $inc (@incs) {
 840 #     my $path = File::Spec->catfile($inc, 'ft2build.h');
 841 #     -e $path or next;
 842
 843 #     # try to find what it's including
 844 #     my $ftheader;
 845 #     open FT2BUILD, "< $path"
 846 #       or next;
 847 #     while (<FT2BUILD>) {
 848 #       if (m!^\s*\#\s*include\s+<([\w/.]+)>!
 849 #         || m!^\s*\#\s*include\s+"([\w/.]+)"!) {
 850 #       $ftheader = $1;
 851 #       last;
 852 #       }
 853 #     }
 854 #     close FT2BUILD;
 855 #     $ftheader
 856 #       or next;
 857 #     # non-Unix installs put this directly under the same directory in
 858 #     # theory
 859 #     if (-e File::Spec->catfile($inc, $ftheader)) {
 860 #       $found_inc = $inc;
 861 #       last INCS;
 862 #     }
 863 #     for my $subdir (qw/freetype2 freetype/) {
 864 #       $path = File::Spec->catfile($inc, $subdir, 'fterrors.h');
 865 #       -e $path and next;
 866
 867 #       $found_inc = $inc;
 868 #       $found_inc2 = File::Spec->catdir($inc, $subdir);
 869 #       last INCS;
 870 #     }
 871 #   }
 872
 873 #   my $found_lib;
 874 #  LIBS:
 875 #   for my $lib (@libs) {
 876 #     my $a_path = File::Spec->catfile($lib, "libfreetype$aext");
 877 #     my $l_path = File::Spec->catfile($lib, "libfreetype.$lext");
 878 #     if (-e $a_path || -e $l_path) {
 879 #       $found_lib = $lib;
 880 #       last LIBS;
 881 #     }
 882 #   }
 883
 884 #   printf("%10s: includes %s - libraries %s\n", $frmkey,
 885 #        ($found_inc ? 'found' : 'not found'),
 886 #        ($found_lib ? 'found' : 'not found'));
 887
 888 #   return unless $found_inc && $found_lib;
 889
 890 #   $frm->{cflags} = _make_I($found_inc);
 891 #   $frm->{cflags} .= " " . _make_I($found_inc2) if $found_inc2;
 892 #   $frm->{libfiles} = "-lfreetype";
 893
 894 #   return 1;
 895 # }
 896
 897 sub _make_I {
 898   my ($inc_dir) = @_;
 899
 900   $definc{$inc_dir}
 901     and return '';
 902
 903   $inc_dir =~ / / ? qq!-I"$inc_dir"! : "-I$inc_dir";
 904 }
 905
 906 # probes for libpng via pkg-config
 907 # sub png_probe {
 908 #   my ($frm, $frmkey) = @_;
 909
 910 #   is_exe('pkg-config') or return;
 911
 912 #   my $config;
 913 #   for my $check_conf (qw(libpng libpng12 libpng10)) {
 914 #     if (_pkg_probe($check_conf)) {
 915 #       $config = $check_conf;
 916 #       last;
 917 #     }
 918 #   }
 919 #   $config or return;
 920
 921 #   my $cflags = `pkg-config $config --cflags`
 922 #     and !$? or return;
 923
 924 #   my $lflags = `pkg-config $config --libs`
 925 #     and !$? or return;
 926
 927 #   chomp $cflags;
 928 #   chomp $lflags;
 929 #   $frm->{cflags} = $cflags;
 930 #   $frm->{lflags} = $lflags;
 931
 932 #   printf "%10s: configured via `pkg-config $config ...`\n", $frmkey;
 933
 934 #   return 1;
 935 # }
 936
 937 sub catfile {
 938   return File::Spec->catfile(@_);
 939 }
 940
 941 # sub is_exe {
 942 #   my ($name) = @_;
 943
 944 #   my @exe_suffix = $Config{_exe};
 945 #   if ($^O eq 'MSWin32') {
 946 #     push @exe_suffix, qw/.bat .cmd/;
 947 #   }
 948
 949 #   for my $dir (File::Spec->path) {
 950 #     for my $suffix (@exe_suffix) {
 951 #       -x catfile($dir, "$name$suffix")
 952 #       and return 1;
 953 #     }
 954 #   }
 955
 956 #   return;
 957 # }
 958
 959 sub usage {
 960   print STDERR <<EOS;
 961 Usage: $0 [--enable feature1,feature2,...] [other options]
 962        $0 [--disable feature1,feature2,...]  [other options]
 963        $0 --help
 964 Possible feature names are:
 965   T1-fonts TT-fonts freetype2
 966 Other options:
 967   --verbose | -v
 968     Verbose library probing (or set IM_VERBOSE in the environment)
 969   --nolog
 970     Disable logging (or set IM_NOLOG in the environment)
 971   --incpath dir
 972     Add to the include search path
 973   --libpath dir
 974     Add to the library search path
 975   --coverage
 976     Build for coverage testing.
 977   --assert
 978     Build with assertions active.
 979 EOS
 980   exit 1;
 981
 982 }
 983
 984 # generate the PM MM argument
 985 # I'd prefer to modify the public version, but there doesn't seem to be
 986 # a public API to do that
 987 sub gen_PM {
 988   my %pm;
 989   my $instbase = '$(INST_LIBDIR)';
 990
 991   # first the basics, .pm and .pod files
 992   $pm{"Imager.pm"} = "$instbase/Imager.pm";
 993
 994   my $mani = maniread();
 995
 996   for my $filename (keys %$mani) {
 997     if ($filename =~ m!^lib/! && $filename =~ /\.(pm|pod)$/) {
 998       (my $work = $filename) =~ s/^lib//;
 999       $pm{$filename} = $instbase . $work;
1000     }
1001   }
1002
1003   # need the typemap
1004   $pm{typemap} = $instbase . '/Imager/typemap';
1005
1006   # and the core headers
1007   for my $filename (keys %$mani) {
1008     if ($filename =~ /^\w+\.h$/) {
1009       $pm{$filename} = $instbase . '/Imager/include/' . $filename;
1010     }
1011   }
1012
1013   # and the generated header
1014   $pm{"imconfig.h"} = $instbase . '/Imager/include/imconfig.h';
1015
1016   \%pm;
1017 }
1018
1019 my $home;
1020 sub _tilde_expand {
1021   my ($path) = @_;
1022
1023   if ($path =~ m!^~[/\\]!) {
1024     defined $home or $home = $ENV{HOME};
1025     if (!defined $home && $^O eq 'MSWin32'
1026        && defined $ENV{HOMEDRIVE} && defined $ENV{HOMEPATH}) {
1027       $home = $ENV{HOMEDRIVE} . $ENV{HOMEPATH};
1028     }
1029     unless (defined $home) {
1030       $home = eval { (getpwuid($<))[7] };
1031     }
1032     defined $home or die "You supplied $path, but I can't find your home directory\n";
1033     $path =~ s/^~//;
1034     $path = File::Spec->catdir($home, $path);
1035   }
1036
1037   $path;
1038 }
1039
1040 # sub postcheck_tiff {
1041 #   my ($format, $frm) = @_;
1042
1043 #   -d "probe" or mkdir "probe";
1044
1045 #   my $tiffver_name = "probe/tiffver.txt";
1046
1047 #   my $lib;
1048 #   if ($Config{cc} =~ /\b(cl|bcc)\b/) {
1049 #     $lib = "libtiff";
1050 #   }
1051 #   else {
1052 #     $lib = "tiff";
1053 #   }
1054
1055 #   # setup LD_RUN_PATH to match link time
1056 #   my $lopts = join " " , map("-L$_", @{$format->{libdir}}), " -ltiff";
1057 #   my ($extra, $bs_load, $ld_load, $ld_run_path) =
1058 #     ExtUtils::Liblist->ext($lopts, $VERBOSE);
1059 #   local $ENV{LD_RUN_PATH};
1060
1061 #   if ($ld_run_path) {
1062 #     print "Setting LD_RUN_PATH=$ld_run_path for TIFF probe\n" if $VERBOSE;
1063 #     $ENV{LD_RUN_PATH} = $ld_run_path;
1064 #   }
1065
1066 #   my $good =
1067 #     eval {
1068 #       assert_lib
1069 #       (
1070 #        debug => $VERBOSE,
1071 #        incpath => $format->{incdir},
1072 #        libpath => $format->{libdir},
1073 #        lib => $lib,
1074 #        header => [ qw(stdio.h tiffio.h) ],
1075 #        function => <<FUNCTION,
1076 #   {
1077 #     const char *vers = TIFFGetVersion();
1078 #     FILE *f = fopen("$tiffver_name", "wb");
1079 #     if (!f)
1080 #       return 1;
1081 #     fputs(vers, f);
1082 #     if (fclose(f))
1083 #       return 1;
1084 #     return 0;
1085 #   }
1086 # FUNCTION
1087 #       );
1088 #       1;
1089 #     };
1090
1091 #   unless ($good && -s $tiffver_name
1092 #         && open(VERS, "< $tiffver_name")) {
1093 #     unlink $tiffver_name unless $KEEP_FILES;
1094 #     print <<EOS;
1095 #     **tiff: cannot determine libtiff version number
1096 #       tiff: DISABLED
1097 # EOS
1098 #     return;
1099 #   }
1100
1101 #   # version file seems to be there, load it up
1102 #   my $ver_str = do { local $/; <VERS> };
1103 #   close VERS;
1104 #   unlink $tiffver_name unless $KEEP_FILES;
1105
1106 #   my ($version) = $ver_str =~ /(\d+\.\d+\.\d+)/;
1107
1108 #   if ($version eq '3.9.0') {
1109 #     print <<EOS;
1110 #     **tiff: libtiff 3.9.0 introduced a serious bug, please install 3.9.1
1111 #       tiff: DISABLED
1112 # EOS
1113 #     return;
1114 #   }
1115
1116 #   return 1;
1117 # }
1118
1119 # This isn't a module, but some broken tools, like
1120 # Module::Depends::Instrusive insist on treating it like one.
1121 #
1122 # http://rt.cpan.org/Public/Bug/Display.html?id=21229
1123
1124 1;