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