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