1c4b32c8b62dbdf879104dbc877a5c10bea085ec
[imager.git] / 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   (
172    'NAME'         => 'Imager',
173    'VERSION_FROM' => 'Imager.pm',
174    'LIBS'         => "$LFLAGS -lm $lib_lflags $OSLIBS $F_LIBS",
175    'DEFINE'       => "$OSDEF $CFLAGS",
176    'INC'          => "$lib_cflags $DFLAGS $F_INC",
177    'OBJECT'       => join(' ', @objs, $F_OBJECT),
178    clean          => { FILES=>'testout rubthru.c scale.c conv.c  filters.c gaussian.c render.c rubthru.c' },
179    PM             => gen_PM(),
180    PREREQ_PM      =>
181    { 
182     'Test::More' => 0.47,
183     'Scalar::Util' => 1.00,
184    },
185   );
186
187 if ($coverage) {
188     if ($Config{gccversion}) {
189         push @ARGV, 'OPTIMIZE=-ftest-coverage -fprofile-arcs -g';
190         $opts{dynamic_lib} = { OTHERLDFLAGS => '-ftest-coverage -fprofile-arcs' };
191     }
192     else {
193         die "Don't know the coverage C flags for your compiler\n";
194     }
195 }
196
197 # eval to prevent warnings about versions with _ in them
198 my $MM_ver = eval $ExtUtils::MakeMaker::VERSION;
199 if ($MM_ver > 6.06) {
200   $opts{AUTHOR} = 'Tony Cook <tonyc@cpan.org>, Arnar M. Hrafnkelsson';
201   $opts{ABSTRACT} = 'Perl extension for Generating 24 bit Images';
202 }
203
204 if ($MM_ver >= 6.46) {
205   $opts{META_MERGE} =
206     {
207      recommends =>
208      {
209       "Parse::RecDescent" => 0
210      },
211      license => "perl",
212      dynamic_config => 1,
213      no_index =>
214      {
215       directory =>
216       [
217        "PNG",
218        "GIF",
219        "TIFF",
220        "JPEG",
221        "W32",
222        "FT2",
223        "T1",
224       ],
225      },
226      resources =>
227      {
228       homepage => "http://imager.perl.org/",
229       repository => "git://git.imager.perl.org/imager.git",
230       bugtracker => "http://rt.cpan.org/NoAuth/Bugs.html?Dist=Imager",
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 my @good;
245 my @bad;
246 for my $name (sort { lc $a cmp lc $b } keys %IMAGER_LIBS) {
247   if ($IMAGER_LIBS{$name}) {
248     push @good, $name;
249   }
250   else {
251     push @bad, $name;
252   }
253 }
254
255 print "\n";
256 print "Libraries found:\n" if @good;
257 print "  $_\n" for @good;
258 print "Libraries *not* found:\n" if @bad;
259 print "  $_\n" for @bad;
260
261 exit;
262
263
264 sub MY::postamble {
265     my $self = shift;
266     my $perl = $self->{PERLRUN} ? '$(PERLRUN)' : '$(PERL)';
267     my $mani = maniread;
268
269     my @ims = grep /\.im$/, keys %$mani;
270 '
271 dyntest.$(MYEXTLIB) : dynfilt/Makefile
272         cd dynfilt && $(MAKE) $(PASTHRU)
273
274 lib/Imager/Regops.pm : regmach.h regops.perl
275         $(PERL) regops.perl regmach.h lib/Imager/Regops.pm
276
277 imconfig.h : Makefile.PL
278         $(ECHO) "imconfig.h out-of-date with respect to $?"
279         $(PERLRUN) Makefile.PL
280         $(ECHO) "==> Your Makefile has been rebuilt - re-run your make command <=="
281 '.qq!
282 lib/Imager/APIRef.pod : \$(C_FILES) \$(H_FILES) apidocs.perl
283         $perl apidocs.perl lib/Imager/APIRef.pod
284
285 !.join('', map _im_rule($perl, $_), @ims)
286
287 }
288
289 sub _im_rule {
290   my ($perl, $im) = @_;
291
292   (my $c = $im) =~ s/\.im$/.c/;
293   return <<MAKE;
294
295 $c: $im lib/Imager/Preprocess.pm
296         $perl -Ilib -MImager::Preprocess -epreprocess $im $c
297
298 MAKE
299
300 }
301
302 # manual configuration of helper libraries
303
304 sub manual {
305   print <<EOF;
306
307       Please answer the following questions about
308       which formats are avaliable on your computer
309
310 press <return> to continue
311 EOF
312
313   <STDIN>; # eat one return
314
315   for my $frm(sort { $formats{$b}{order} <=> $formats{$a}{order} } keys %formats) {
316   SWX:
317     if ($formats{$frm}{docs}) { print "\n",$formats{$frm}{docs},"\n\n"; }
318     print "Enable $frm support: ";
319     my $gz = <STDIN>;
320     chomp($gz);
321     if ($gz =~ m/^(y|yes|n|no)/i) {
322       $gz=substr(lc($gz),0,1);
323       if ($gz eq 'n') {
324         delete $formats{$frm};
325       }
326     } else { goto SWX; }
327   }
328 }
329
330
331 # automatic configuration of helper libraries
332
333 sub automatic {
334   print "Automatic probing:\n" if $VERBOSE;
335   for my $frm (sort { $formats{$a}{order} <=> $formats{$b}{order} } keys %formats) {
336     delete $formats{$frm} if !checkformat($frm);        
337   }
338 }
339
340 sub grep_directory {
341   my($path, $chk)=@_;
342
343 #    print "checking path $path\n";
344   if ( !opendir(DH,$path) ) {
345     warn "Cannot open dir $path: $!\n";
346     return;
347   }
348   my @l=grep { $chk->($_) } readdir(DH);
349   #    print @l;
350   close(DH);
351   return map $path, @l;
352 }
353
354 sub _probe_default {
355   my ($format, $frm) = @_;
356
357   my $lib_check=$formats{$frm}{'libcheck'};
358   my $inc_check=$formats{$frm}{'inccheck'};
359
360   if ($lib_check) {
361     my @l;
362     for my $lp (@libs) {
363       push(@l, grep_directory($lp,$lib_check));
364     }
365     
366     my @i;
367     for my $ip (@incs) {
368       push(@i, $ip) if $inc_check->($ip,$frm);
369     }
370     
371     printf("%10s: includes %s - libraries %s\n",$frm,(@i?'found':'not found'),(@l?'found':'not found'));
372     $formats{$frm}{incdir} = \@i;
373     $formats{$frm}{libdir} = \@l;
374     return 1 if scalar(@i && @l);
375   }
376   else {
377     printf("%10s: not available\n", $frm);
378   }
379
380   return 0;
381 }
382
383 sub checkformat {
384   my $frm=shift;
385
386   print "  checkformat($frm)\n" if $VERBOSE;
387   
388   my $format = $formats{$frm};
389
390   my @probes;
391   if (my $code = $format->{'code'}) {
392     if (ref $code eq 'ARRAY') {
393       push @probes, @$code;
394     }
395     else {
396       push @probes, $code;
397     }
398   }
399   push @probes, \&_probe_default;
400
401   print "    Calling probe function\n" if $VERBOSE;
402   my $found;
403   for my $func (@probes) {
404     if ($func->($format, $frm)) {
405       ++$found;
406       last;
407     }
408   }
409
410   $found or return;
411
412   if ($format->{postcheck}) {
413     print "    Calling postcheck function\n" if $VERBOSE;
414     $format->{postcheck}->($format, $frm)
415       or return;
416   }
417
418   return 1;
419 }
420
421
422 sub pathcheck {
423   if ($VERBOSE) {
424     print "pathcheck\n";
425     print "  Include paths:\n";
426     for (@incs) { print $_,"\n"; }
427   }
428   @incs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @incs;
429
430   if ($VERBOSE) {
431     print "\nLibrary paths:\n";
432     for (@libs) { print $_,"\n"; }
433   }
434   @libs=grep { -d $_ && -r _ && -x _ or ( print("  $_ doesnt exist or is unaccessible - removed.\n"),0) } @libs;
435   print "\ndone.\n";
436 }
437
438
439 # Format data initialization
440
441 # format definition is:
442 # defines needed
443 # default include path
444 # files needed for include (boolean perl code)
445 # default lib path
446 # libs needed
447 # files needed for link (boolean perl code)
448 # object files needed for the format
449
450
451 sub init {
452
453   my @definc = qw(/usr/include);
454   @definc{@definc}=(1) x @definc;
455   @incs=
456     (
457      split(/\Q$Config{path_sep}/, $INCPATH),
458      map _tilde_expand($_), map { split /\Q$Config{path_sep}/ } @incpaths 
459     );
460   if ($Config{locincpth}) {
461     push @incs, grep -d, split ' ', $Config{locincpth};
462   }
463   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
464     push(@incs, split /;/, $ENV{INCLUDE}) if exists $ENV{INCLUDE};
465   }
466   if ($Config{incpath}) {
467     push @incs, grep -d, split /\Q$Config{path_sep}/, $Config{incpath};
468   }
469   push @incs, grep -d,
470       qw(/sw/include 
471          /usr/include/freetype2
472          /usr/local/include/freetype2
473          /usr/local/include/freetype1/freetype
474          /usr/include /usr/local/include /usr/include/freetype
475          /usr/local/include/freetype);
476   if ($Config{ccflags}) {
477     my @hidden = map { /^-I(.*)$/ ? ($1) : () } split ' ', $Config{ccflags};
478     push @incs, @hidden;
479     @definc{@hidden} = (1) x @hidden;
480   }
481
482   @libs= ( split(/\Q$Config{path_sep}/,$LIBPATH),
483     map _tilde_expand($_), map { split /\Q$Config{path_sep}/} @libpaths );
484   if ($Config{loclibpth}) {
485     push @libs, grep -d, split ' ', $Config{loclibpth};
486   }
487   
488   push @libs, grep -d, qw(/sw/lib),  split(/ /, $Config{'libpth'});
489   push @libs, grep -d, split / /, $Config{libspath} if $Config{libspath};
490   if ($^O =~ /win32/i && $Config{cc} =~ /\bcl\b/i) {
491     push(@libs, split /;/, $ENV{LIB}) if exists $ENV{LIB};
492   }
493   if ($^O eq 'cygwin') {
494     push(@libs, '/usr/lib/w32api') if -d '/usr/lib/w32api';
495     push(@incs, '/usr/include/w32api') if -d '/usr/include/w32api';
496   }
497   if ($Config{ldflags}) {
498     # some builds of perl put -Ldir into ldflags without putting it in
499     # loclibpth, let's extract them
500     my @hidden = grep -d, map { /^-L(.*)$/ ? ($1) : () }
501       split ' ', $Config{ldflags};
502     push @libs, @hidden;
503     # don't mark them as seen - EU::MM will remove any libraries
504     # it can't find and it doesn't look for -L in ldflags
505     #@deflib{@hidden} = @hidden;
506   }
507   push @libs, grep -d, qw(/usr/local/lib);
508
509   $formats{'TT-fonts'}=
510     {
511      order=>'31',
512      def=>'HAVE_LIBTT',
513      inccheck=>sub { -e catfile($_[0], 'freetype.h')
514                        && !-e catfile($_[0], 'fterrors.h') },
515      libcheck=>sub { $_[0] eq "libttf$aext" or $_[0] eq "libttf.$lext" },
516      libfiles=>'-lttf',
517      objfiles=>'',
518      code => \&freetype1_probe,
519      docs=>q{
520 Truetype fonts are scalable fonts. They can include 
521 kerning and hinting information and generally yield good
522 visual quality esp on low resultions. The freetype library is
523 used to rasterize for us. The only drawback is that there
524 are alot of badly designed fonts out there.}
525                        };
526   # Make fix indent
527   for (keys %formats) { $formats{$_}->{docs} =~ s/^\s+/  /mg; }
528 }
529
530
531
532 sub gen {
533   my $V = $ENV{$_[0]};
534   defined($V) ? $V : "";
535 }
536
537
538 # Get information from environment variables
539
540 sub getenv {
541
542   ($VERBOSE,
543    $INCPATH,
544    $LIBPATH,
545    $NOLOG,
546    $DEBUG_MALLOC,
547    $MANUAL,
548    $CFLAGS,
549    $LFLAGS,
550    $DFLAGS) = map { gen $_ } qw(IM_VERBOSE
551                                 IM_INCPATH
552                                 IM_LIBPATH
553                                 IM_NOLOG
554                                 IM_DEBUG_MALLOC
555                                 IM_MANUAL
556                                 IM_CFLAGS
557                                 IM_LFLAGS
558                                 IM_DFLAGS);
559
560 }
561
562 # populate the environment so that sub-modules get the same info
563 sub setenv {
564   $ENV{IM_VERBOSE} = 1 if $VERBOSE;
565   $ENV{IM_INCPATH} = join $Config{path_sep}, @incpaths if @incpaths;
566   $ENV{IM_LIBPATH} = join $Config{path_sep}, @libpaths if @libpaths;
567 }
568
569 sub make_imconfig {
570   my ($defines) = @_;
571
572   open CONFIG, "> imconfig.h"
573     or die "Cannot create imconfig.h: $!\n";
574   print CONFIG <<EOS;
575 /* This file is automatically generated by Makefile.PL.
576    Don't edit this file, since any changes will be lost */
577
578 #ifndef IMAGER_IMCONFIG_H
579 #define IMAGER_IMCONFIG_H
580 EOS
581   for my $define (@$defines) {
582     if ($define->[2]) {
583       print CONFIG "\n/*\n  $define->[2]\n*/\n\n";
584     }
585     print CONFIG "#define $define->[0] $define->[1]\n";
586   }
587   if ($Config{gccversion} && $Config{gccversion} =~ /^([0-9]+)/ && $1 > 3) {
588     print CONFIG <<EOS;
589 /*
590
591 Compiler supports the GCC __attribute__((format...)) syntax.
592
593 */
594
595 #define IMAGER_FORMAT_ATTR 1
596
597 EOS
598   }
599
600   if ($Config{d_snprintf}) {
601     print CONFIG <<EOS;
602 /* We can use snprintf() */
603 #define IMAGER_SNPRINTF 1
604
605 EOS
606   }
607
608   if ($Config{d_vsnprintf}) {
609     print CONFIG <<EOS;
610 /* We can use vsnprintf() */
611 #define IMAGER_VSNPRINTF 1
612
613 EOS
614   }
615
616   print CONFIG <<EOS;
617 /*
618  Type and format code for formatted output as with printf.
619
620  This is intended for formatting i_img_dim values.
621 */
622 typedef $Config{ivtype} i_dim_format_t;
623 #define i_DF $Config{ivdformat}
624 EOS
625
626   print CONFIG "\n#endif\n";
627   close CONFIG;
628 }
629
630 # probes for freetype1 by scanning @incs for the includes and 
631 # @libs for the libs.  This is done separately because freetype's headers
632 # are stored in a freetype or freetype1 directory under PREFIX/include.
633 #
634 # we could find the files with the existing mechanism, but it won't set
635 # -I flags correctly.
636 #
637 # This could be extended to freetype2 too, but freetype-config catches
638 # that
639 sub freetype1_probe {
640   my ($frm, $frmkey) = @_;
641
642   my $found_inc;
643  INCS:
644   for my $inc (@incs) {
645     for my $subdir (qw/freetype freetype1/) {
646       my $path = File::Spec->catfile($inc, $subdir, 'freetype.h');
647       -e $path or next;
648       $path = File::Spec->catfile($inc, $subdir, 'fterrors.h');
649       -e $path and next;
650
651       $found_inc = File::Spec->catdir($inc, $subdir);
652       last INCS;
653     }
654   }
655
656   my $found_lib;
657  LIBS:
658   for my $lib (@libs) {
659     my $a_path = File::Spec->catfile($lib, "libttf$aext");
660     my $l_path = File::Spec->catfile($lib, "libttf.$lext");
661     if (-e $a_path || -e $l_path) {
662       $found_lib = $lib;
663       last LIBS;
664     }
665   }
666
667   return unless $found_inc && $found_lib;
668   printf("%10s: includes %s - libraries %s\n", $frmkey,
669          ($found_inc ? 'found' : 'not found'), 
670          ($found_lib ? 'found' : 'not found'));
671
672   $frm->{cflags} = "-I$found_inc";
673   $frm->{libfiles} = "-lttf";
674
675   return 1;
676 }
677
678 sub catfile {
679   return File::Spec->catfile(@_);
680 }
681
682 sub usage {
683   print STDERR <<EOS;
684 Usage: $0 [--enable feature1,feature2,...] [other options]
685        $0 [--disable feature1,feature2,...]  [other options]
686        $0 --help
687 Possible feature names are:
688   T1-fonts
689 Other options:
690   --verbose | -v
691     Verbose library probing (or set IM_VERBOSE in the environment)
692   --nolog
693     Disable logging (or set IM_NOLOG in the environment)
694   --incpath dir
695     Add to the include search path
696   --libpath dir
697     Add to the library search path
698   --coverage
699     Build for coverage testing.
700   --assert
701     Build with assertions active.
702 EOS
703   exit 1;
704
705 }
706
707 # generate the PM MM argument
708 # I'd prefer to modify the public version, but there doesn't seem to be 
709 # a public API to do that
710 sub gen_PM {
711   my %pm;
712   my $instbase = '$(INST_LIBDIR)';
713
714   # first the basics, .pm and .pod files
715   $pm{"Imager.pm"} = "$instbase/Imager.pm";
716
717   my $mani = maniread();
718
719   for my $filename (keys %$mani) {
720     if ($filename =~ m!^lib/! && $filename =~ /\.(pm|pod)$/) {
721       (my $work = $filename) =~ s/^lib//;
722       $pm{$filename} = $instbase . $work;
723     }
724   }
725
726   # need the typemap
727   $pm{typemap} = $instbase . '/Imager/typemap';
728
729   # and the core headers
730   for my $filename (keys %$mani) {
731     if ($filename =~ /^\w+\.h$/) {
732       $pm{$filename} = $instbase . '/Imager/include/' . $filename;
733     }
734   }
735
736   # and the generated header
737   $pm{"imconfig.h"} = $instbase . '/Imager/include/imconfig.h';
738
739   \%pm;
740 }
741
742 my $home;
743 sub _tilde_expand {
744   my ($path) = @_;
745
746   if ($path =~ m!^~[/\\]!) {
747     defined $home or $home = $ENV{HOME};
748     if (!defined $home && $^O eq 'MSWin32'
749        && defined $ENV{HOMEDRIVE} && defined $ENV{HOMEPATH}) {
750       $home = $ENV{HOMEDRIVE} . $ENV{HOMEPATH};
751     }
752     unless (defined $home) {
753       $home = eval { (getpwuid($<))[7] };
754     }
755     defined $home or die "You supplied $path, but I can't find your home directory\n";
756     $path =~ s/^~//;
757     $path = File::Spec->catdir($home, $path);
758   }
759
760   $path;
761 }
762
763 1;