This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
1ec89ee7a5e3b1ae96e2826602f8f77b13a0c9f8
[perl5.git] / lib / ExtUtils / CBuilder / Platform / Windows.pm
1 package ExtUtils::CBuilder::Platform::Windows;
2
3 use strict;
4 use warnings;
5
6 use File::Basename;
7 use File::Spec;
8
9 use ExtUtils::CBuilder::Base;
10
11 use vars qw($VERSION @ISA);
12 $VERSION = '0.12';
13 @ISA = qw(ExtUtils::CBuilder::Base);
14
15 sub new {
16   my $class = shift;
17   my $self = $class->SUPER::new(@_);
18   my $cf = $self->{config};
19
20   # Inherit from an appropriate compiler driver class
21   unshift @ISA, "ExtUtils::CBuilder::Platform::Windows::" . $self->_compiler_type;
22
23   return $self;
24 }
25
26 sub _compiler_type {
27   my $self = shift;
28   my $cc = $self->{config}{cc};
29
30   return (  $cc =~ /cl(\.exe)?$/ ? 'MSVC'
31           : $cc =~ /bcc32(\.exe)?$/ ? 'BCC'
32           : 'GCC');
33 }
34
35 sub split_like_shell {
36   # As it turns out, Windows command-parsing is very different from
37   # Unix command-parsing.  Double-quotes mean different things,
38   # backslashes don't necessarily mean escapes, and so on.  So we
39   # can't use Text::ParseWords::shellwords() to break a command string
40   # into words.  The algorithm below was bashed out by Randy and Ken
41   # (mostly Randy), and there are a lot of regression tests, so we
42   # should feel free to adjust if desired.
43   
44   (my $self, local $_) = @_;
45   
46   return @$_ if defined() && UNIVERSAL::isa($_, 'ARRAY');
47   
48   my @argv;
49   return @argv unless defined() && length();
50   
51   my $arg = '';
52   my( $i, $quote_mode ) = ( 0, 0 );
53   
54   while ( $i < length() ) {
55     
56     my $ch      = substr( $_, $i  , 1 );
57     my $next_ch = substr( $_, $i+1, 1 );
58     
59     if ( $ch eq '\\' && $next_ch eq '"' ) {
60       $arg .= '"';
61       $i++;
62     } elsif ( $ch eq '\\' && $next_ch eq '\\' ) {
63       $arg .= '\\';
64       $i++;
65     } elsif ( $ch eq '"' && $next_ch eq '"' && $quote_mode ) {
66       $quote_mode = !$quote_mode;
67       $arg .= '"';
68       $i++;
69     } elsif ( $ch eq '"' && $next_ch eq '"' && !$quote_mode &&
70               ( $i + 2 == length()  ||
71                 substr( $_, $i + 2, 1 ) eq ' ' )
72             ) { # for cases like: a"" => [ 'a' ]
73       push( @argv, $arg );
74       $arg = '';
75       $i += 2;
76     } elsif ( $ch eq '"' ) {
77       $quote_mode = !$quote_mode;
78     } elsif ( $ch eq ' ' && !$quote_mode ) {
79       push( @argv, $arg ) if $arg;
80       $arg = '';
81       ++$i while substr( $_, $i + 1, 1 ) eq ' ';
82     } else {
83       $arg .= $ch;
84     }
85     
86     $i++;
87   }
88   
89   push( @argv, $arg ) if defined( $arg ) && length( $arg );
90   return @argv;
91 }
92
93 sub arg_defines {
94   my ($self, %args) = @_;
95   s/"/\\"/g foreach values %args;
96   return map qq{"-D$_=$args{$_}"}, keys %args;
97 }
98
99 sub compile {
100   my ($self, %args) = @_;
101   my $cf = $self->{config};
102
103   die "Missing 'source' argument to compile()" unless defined $args{source};
104
105   my ($basename, $srcdir) =
106     ( File::Basename::fileparse($args{source}, '\.[^.]+$') )[0,1];
107
108   $srcdir ||= File::Spec->curdir();
109
110   my @defines = $self->arg_defines( %{ $args{defines} || {} } );
111
112   my %spec = (
113     srcdir      => $srcdir,
114     builddir    => $srcdir,
115     basename    => $basename,
116     source      => $args{source},
117     output      => File::Spec->catfile($srcdir, $basename) . $cf->{obj_ext},
118     cc          => $cf->{cc},
119     cflags      => [
120                      $self->split_like_shell($cf->{ccflags}),
121                      $self->split_like_shell($cf->{cccdlflags}),
122                      $self->split_like_shell($cf->{extra_compiler_flags}),
123                    ],
124     optimize    => [ $self->split_like_shell($cf->{optimize})    ],
125     defines     => \@defines,
126     includes    => [ @{$args{include_dirs} || []} ],
127     perlinc     => [
128                      $self->perl_inc(),
129                      $self->split_like_shell($cf->{incpath}),
130                    ],
131     use_scripts => 1, # XXX provide user option to change this???
132   );
133
134   $self->normalize_filespecs(
135     \$spec{source},
136     \$spec{output},
137      $spec{includes},
138      $spec{perlinc},
139   );
140
141   my @cmds = $self->format_compiler_cmd(%spec);
142   while ( my $cmd = shift @cmds ) {
143     $self->do_system( @$cmd )
144       or die "error building $cf->{dlext} file from '$args{source}'";
145   }
146
147   (my $out = $spec{output}) =~ tr/'"//d;
148   return $out;
149 }
150
151 sub need_prelink { 1 }
152
153 sub link {
154   my ($self, %args) = @_;
155   my $cf = $self->{config};
156
157   my @objects = ( ref $args{objects} eq 'ARRAY' ? @{$args{objects}} : $args{objects} );
158   my $to = join '', (File::Spec->splitpath($objects[0]))[0,1];
159   $to ||= File::Spec->curdir();
160
161   (my $file_base = $args{module_name}) =~ s/.*:://;
162   my $output = $args{lib_file} ||
163     File::Spec->catfile($to, "$file_base.$cf->{dlext}");
164
165   # if running in perl source tree, look for libs there, not installed
166   my $lddlflags = $cf->{lddlflags};
167   my $perl_src = $self->perl_src();
168   $lddlflags =~ s/\Q$cf->{archlibexp}\E[\\\/]CORE/$perl_src/ if $perl_src;
169
170   my %spec = (
171     srcdir        => $to,
172     builddir      => $to,
173     startup       => [ ],
174     objects       => \@objects,
175     libs          => [ ],
176     output        => $output,
177     ld            => $cf->{ld},
178     libperl       => $cf->{libperl},
179     perllibs      => [ $self->split_like_shell($cf->{perllibs})  ],
180     libpath       => [ $self->split_like_shell($cf->{libpth})    ],
181     lddlflags     => [ $self->split_like_shell($lddlflags) ],
182     other_ldflags => [ $self->split_like_shell($args{extra_linker_flags} || '') ],
183     use_scripts   => 1, # XXX provide user option to change this???
184   );
185
186   unless ( $spec{basename} ) {
187     ($spec{basename} = $args{module_name}) =~ s/.*:://;
188   }
189
190   $spec{srcdir}   = File::Spec->canonpath( $spec{srcdir}   );
191   $spec{builddir} = File::Spec->canonpath( $spec{builddir} );
192
193   $spec{output}    ||= File::Spec->catfile( $spec{builddir},
194                                             $spec{basename}  . '.'.$cf->{dlext}   );
195   $spec{implib}    ||= File::Spec->catfile( $spec{builddir},
196                                             $spec{basename}  . $cf->{lib_ext} );
197   $spec{explib}    ||= File::Spec->catfile( $spec{builddir},
198                                             $spec{basename}  . '.exp'  );
199   $spec{def_file}  ||= File::Spec->catfile( $spec{srcdir}  ,
200                                             $spec{basename}  . '.def'  );
201   $spec{base_file} ||= File::Spec->catfile( $spec{srcdir}  ,
202                                             $spec{basename}  . '.base' );
203
204   $self->add_to_cleanup(
205     grep defined,
206     @{[ @spec{qw(implib explib def_file base_file map_file)} ]}
207   );
208
209   foreach my $opt ( qw(output implib explib def_file map_file base_file) ) {
210     $self->normalize_filespecs( \$spec{$opt} );
211   }
212
213   foreach my $opt ( qw(libpath startup objects) ) {
214     $self->normalize_filespecs( $spec{$opt} );
215   }
216
217   (my $def_base = $spec{def_file}) =~ tr/'"//d;
218   $def_base =~ s/\.def$//;
219   $self->prelink( dl_name => $args{module_name},
220                   dl_file => $def_base,
221                   dl_base => $spec{basename} );
222
223   my @cmds = $self->format_linker_cmd(%spec);
224   while ( my $cmd = shift @cmds ) {
225     $self->do_system( @$cmd );
226   }
227
228   $spec{output} =~ tr/'"//d;
229   return wantarray
230     ? grep defined, @spec{qw[output implib explib def_file map_file base_file]}
231     : $spec{output};
232 }
233
234 # canonize & quote paths
235 sub normalize_filespecs {
236   my ($self, @specs) = @_;
237   foreach my $spec ( grep defined, @specs ) {
238     if ( ref $spec eq 'ARRAY') {
239       $self->normalize_filespecs( map {\$_} grep defined, @$spec )
240     } elsif ( ref $spec eq 'SCALAR' ) {
241       $$spec =~ tr/"//d if $$spec;
242       next unless $$spec;
243       $$spec = '"' . File::Spec->canonpath($$spec) . '"';
244     } elsif ( ref $spec eq '' ) {
245       $spec = '"' . File::Spec->canonpath($spec) . '"';
246     } else {
247       die "Don't know how to normalize " . (ref $spec || $spec) . "\n";
248     }
249   }
250 }
251
252 # directory of perl's include files
253 sub perl_inc {
254   my $self = shift;
255
256   my $perl_src = $self->perl_src();
257
258   if ($perl_src) {
259     File::Spec->catdir($perl_src, "lib", "CORE");
260   } else {
261     File::Spec->catdir($self->{config}{archlibexp},"CORE");
262   }
263 }
264
265 1;
266
267 ########################################################################
268
269 =begin comment
270
271 The packages below implement functions for generating properly
272 formatted commandlines for the compiler being used. Each package
273 defines two primary functions 'format_linker_cmd()' &
274 'format_compiler_cmd()' that accepts a list of named arguments (a
275 hash) and returns a list of formatted options suitable for invoking the
276 compiler. By default, if the compiler supports scripting of its
277 operation then a script file is built containing the options while
278 those options are removed from the commandline, and a reference to the
279 script is pushed onto the commandline in their place. Scripting the
280 compiler in this way helps to avoid the problems associated with long
281 commandlines under some shells.
282
283 =end comment
284
285 =cut
286
287 ########################################################################
288 package ExtUtils::CBuilder::Platform::Windows::MSVC;
289
290 sub format_compiler_cmd {
291   my ($self, %spec) = @_;
292
293   foreach my $path ( @{ $spec{includes} || [] },
294                      @{ $spec{perlinc}  || [] } ) {
295     $path = '-I' . $path;
296   }
297
298   %spec = $self->write_compiler_script(%spec)
299     if $spec{use_scripts};
300
301   return [ grep {defined && length} (
302     $spec{cc},'-nologo','-c',
303     @{$spec{includes}}      ,
304     @{$spec{cflags}}        ,
305     @{$spec{optimize}}      ,
306     @{$spec{defines}}       ,
307     @{$spec{perlinc}}       ,
308     "-Fo$spec{output}"      ,
309     $spec{source}           ,
310   ) ];
311 }
312
313 sub write_compiler_script {
314   my ($self, %spec) = @_;
315
316   my $script = File::Spec->catfile( $spec{srcdir},
317                                     $spec{basename} . '.ccs' );
318
319   $self->add_to_cleanup($script);
320   print "Generating script '$script'\n" if !$self->{quiet};
321
322   open( SCRIPT, ">$script" )
323     or die( "Could not create script '$script': $!" );
324
325   print SCRIPT join( "\n",
326     map { ref $_ ? @{$_} : $_ }
327     grep defined,
328     delete(
329       @spec{ qw(includes cflags optimize defines perlinc) } )
330   );
331
332   close SCRIPT;
333
334   push @{$spec{includes}}, '@"' . $script . '"';
335
336   return %spec;
337 }
338
339 sub format_linker_cmd {
340   my ($self, %spec) = @_;
341
342   foreach my $path ( @{$spec{libpath}} ) {
343     $path = "-libpath:$path";
344   }
345
346   $spec{def_file}  &&= '-def:'    . $spec{def_file};
347   $spec{output}    &&= '-out:'    . $spec{output};
348   $spec{implib}    &&= '-implib:' . $spec{implib};
349   $spec{map_file}  &&= '-map:'    . $spec{map_file};
350
351   %spec = $self->write_linker_script(%spec)
352     if $spec{use_scripts};
353
354   return [ grep {defined && length} (
355     $spec{ld}               ,
356     @{$spec{lddlflags}}     ,
357     @{$spec{libpath}}       ,
358     @{$spec{other_ldflags}} ,
359     @{$spec{startup}}       ,
360     @{$spec{objects}}       ,
361     $spec{map_file}         ,
362     $spec{libperl}          ,
363     @{$spec{perllibs}}      ,
364     $spec{def_file}         ,
365     $spec{implib}           ,
366     $spec{output}           ,
367   ) ];
368 }
369
370 sub write_linker_script {
371   my ($self, %spec) = @_;
372
373   my $script = File::Spec->catfile( $spec{srcdir},
374                                     $spec{basename} . '.lds' );
375
376   $self->add_to_cleanup($script);
377
378   print "Generating script '$script'\n" if !$self->{quiet};
379
380   open( SCRIPT, ">$script" )
381     or die( "Could not create script '$script': $!" );
382
383   print SCRIPT join( "\n",
384     map { ref $_ ? @{$_} : $_ }
385     grep defined,
386     delete(
387       @spec{ qw(lddlflags libpath other_ldflags
388                 startup objects libperl perllibs
389                 def_file implib map_file)            } )
390   );
391
392   close SCRIPT;
393
394   push @{$spec{lddlflags}}, '@"' . $script . '"';
395
396   return %spec;
397 }
398
399 1;
400
401 ########################################################################
402 package ExtUtils::CBuilder::Platform::Windows::BCC;
403
404 sub format_compiler_cmd {
405   my ($self, %spec) = @_;
406
407   foreach my $path ( @{ $spec{includes} || [] },
408                      @{ $spec{perlinc}  || [] } ) {
409     $path = '-I' . $path;
410   }
411
412   %spec = $self->write_compiler_script(%spec)
413     if $spec{use_scripts};
414
415   return [ grep {defined && length} (
416     $spec{cc}, '-c'         ,
417     @{$spec{includes}}      ,
418     @{$spec{cflags}}        ,
419     @{$spec{optimize}}      ,
420     @{$spec{defines}}       ,
421     @{$spec{perlinc}}       ,
422     "-o$spec{output}"       ,
423     $spec{source}           ,
424   ) ];
425 }
426
427 sub write_compiler_script {
428   my ($self, %spec) = @_;
429
430   my $script = File::Spec->catfile( $spec{srcdir},
431                                     $spec{basename} . '.ccs' );
432
433   $self->add_to_cleanup($script);
434
435   print "Generating script '$script'\n" if !$self->{quiet};
436
437   open( SCRIPT, ">$script" )
438     or die( "Could not create script '$script': $!" );
439
440   print SCRIPT join( "\n",
441     map { ref $_ ? @{$_} : $_ }
442     grep defined,
443     delete(
444       @spec{ qw(includes cflags optimize defines perlinc) } )
445   );
446
447   close SCRIPT;
448
449   push @{$spec{includes}}, '@"' . $script . '"';
450
451   return %spec;
452 }
453
454 sub format_linker_cmd {
455   my ($self, %spec) = @_;
456
457   foreach my $path ( @{$spec{libpath}} ) {
458     $path = "-L$path";
459   }
460
461   push( @{$spec{startup}}, 'c0d32.obj' )
462     unless ( $spec{starup} && @{$spec{startup}} );
463
464   %spec = $self->write_linker_script(%spec)
465     if $spec{use_scripts};
466
467   return [ grep {defined && length} (
468     $spec{ld}               ,
469     @{$spec{lddlflags}}     ,
470     @{$spec{libpath}}       ,
471     @{$spec{other_ldflags}} ,
472     @{$spec{startup}}       ,
473     @{$spec{objects}}       , ',',
474     $spec{output}           , ',',
475     $spec{map_file}         , ',',
476     $spec{libperl}          ,
477     @{$spec{perllibs}}      , ',',
478     $spec{def_file}
479   ) ];
480 }
481
482 sub write_linker_script {
483   my ($self, %spec) = @_;
484
485   # To work around Borlands "unique" commandline syntax,
486   # two scripts are used:
487
488   my $ld_script = File::Spec->catfile( $spec{srcdir},
489                                        $spec{basename} . '.lds' );
490   my $ld_libs   = File::Spec->catfile( $spec{srcdir},
491                                        $spec{basename} . '.lbs' );
492
493   $self->add_to_cleanup($ld_script, $ld_libs);
494
495   print "Generating scripts '$ld_script' and '$ld_libs'.\n" if !$self->{quiet};
496
497   # Script 1: contains options & names of object files.
498   open( LD_SCRIPT, ">$ld_script" )
499     or die( "Could not create linker script '$ld_script': $!" );
500
501   print LD_SCRIPT join( " +\n",
502     map { @{$_} }
503     grep defined,
504     delete(
505       @spec{ qw(lddlflags libpath other_ldflags startup objects) } )
506   );
507
508   close LD_SCRIPT;
509
510   # Script 2: contains name of libs to link against.
511   open( LD_LIBS, ">$ld_libs" )
512     or die( "Could not create linker script '$ld_libs': $!" );
513
514   print LD_LIBS join( " +\n",
515      (delete $spec{libperl}  || ''),
516     @{delete $spec{perllibs} || []},
517   );
518
519   close LD_LIBS;
520
521   push @{$spec{lddlflags}}, '@"' . $ld_script  . '"';
522   push @{$spec{perllibs}},  '@"' . $ld_libs    . '"';
523
524   return %spec;
525 }
526
527 1;
528
529 ########################################################################
530 package ExtUtils::CBuilder::Platform::Windows::GCC;
531
532 sub format_compiler_cmd {
533   my ($self, %spec) = @_;
534
535   foreach my $path ( @{ $spec{includes} || [] },
536                      @{ $spec{perlinc}  || [] } ) {
537     $path = '-I' . $path;
538   }
539
540   # split off any -arguments included in cc
541   my @cc = split / (?=-)/, $spec{cc};
542
543   return [ grep {defined && length} (
544     @cc, '-c'               ,
545     @{$spec{includes}}      ,
546     @{$spec{cflags}}        ,
547     @{$spec{optimize}}      ,
548     @{$spec{defines}}       ,
549     @{$spec{perlinc}}       ,
550     '-o', $spec{output}     ,
551     $spec{source}           ,
552   ) ];
553 }
554
555 sub format_linker_cmd {
556   my ($self, %spec) = @_;
557
558   # The Config.pm variable 'libperl' is hardcoded to the full name
559   # of the perl import library (i.e. 'libperl56.a'). GCC will not
560   # find it unless the 'lib' prefix & the extension are stripped.
561   $spec{libperl} =~ s/^(?:lib)?([^.]+).*$/-l$1/;
562
563   unshift( @{$spec{other_ldflags}}, '-nostartfiles' )
564     if ( $spec{startup} && @{$spec{startup}} );
565
566   # From ExtUtils::MM_Win32:
567   #
568   ## one thing for GCC/Mingw32:
569   ## we try to overcome non-relocateable-DLL problems by generating
570   ##    a (hopefully unique) image-base from the dll's name
571   ## -- BKS, 10-19-1999
572   File::Basename::basename( $spec{output} ) =~ /(....)(.{0,4})/;
573   $spec{image_base} = sprintf( "0x%x0000", unpack('n', $1 ^ $2) );
574
575   %spec = $self->write_linker_script(%spec)
576     if $spec{use_scripts};
577
578   foreach my $path ( @{$spec{libpath}} ) {
579     $path = "-L$path";
580   }
581
582   my @cmds; # Stores the series of commands needed to build the module.
583
584   push @cmds, [
585     'dlltool', '--def'        , $spec{def_file},
586                '--output-exp' , $spec{explib}
587   ];
588
589   # split off any -arguments included in ld
590   my @ld = split / (?=-)/, $spec{ld};
591
592   push @cmds, [ grep {defined && length} (
593     @ld                       ,
594     '-o', $spec{output}       ,
595     "-Wl,--base-file,$spec{base_file}"   ,
596     "-Wl,--image-base,$spec{image_base}" ,
597     @{$spec{lddlflags}}       ,
598     @{$spec{libpath}}         ,
599     @{$spec{startup}}         ,
600     @{$spec{objects}}         ,
601     @{$spec{other_ldflags}}   ,
602     $spec{libperl}            ,
603     @{$spec{perllibs}}        ,
604     $spec{explib}             ,
605     $spec{map_file} ? ('-Map', $spec{map_file}) : ''
606   ) ];
607
608   push @cmds, [
609     'dlltool', '--def'        , $spec{def_file},
610                '--output-exp' , $spec{explib},
611                '--base-file'  , $spec{base_file}
612   ];
613
614   push @cmds, [ grep {defined && length} (
615     @ld                       ,
616     '-o', $spec{output}       ,
617     "-Wl,--image-base,$spec{image_base}" ,
618     @{$spec{lddlflags}}       ,
619     @{$spec{libpath}}         ,
620     @{$spec{startup}}         ,
621     @{$spec{objects}}         ,
622     @{$spec{other_ldflags}}   ,
623     $spec{libperl}            ,
624     @{$spec{perllibs}}        ,
625     $spec{explib}             ,
626     $spec{map_file} ? ('-Map', $spec{map_file}) : ''
627   ) ];
628
629   return @cmds;
630 }
631
632 sub write_linker_script {
633   my ($self, %spec) = @_;
634
635   my $script = File::Spec->catfile( $spec{srcdir},
636                                     $spec{basename} . '.lds' );
637
638   $self->add_to_cleanup($script);
639
640   print "Generating script '$script'\n" if !$self->{quiet};
641
642   open( SCRIPT, ">$script" )
643     or die( "Could not create script '$script': $!" );
644
645   print( SCRIPT 'SEARCH_DIR(' . $_ . ")\n" )
646     for @{delete $spec{libpath} || []};
647
648   # gcc takes only one startup file, so the first object in startup is
649   # specified as the startup file and any others are shifted into the
650   # beginning of the list of objects.
651   if ( $spec{startup} && @{$spec{startup}} ) {
652     print SCRIPT 'STARTUP(' . shift( @{$spec{startup}} ) . ")\n";
653     unshift @{$spec{objects}},
654       @{delete $spec{startup} || []};
655   }
656
657   print SCRIPT 'INPUT(' . join( ',',
658     @{delete $spec{objects}  || []}
659   ) . ")\n";
660
661   print SCRIPT 'INPUT(' . join( ' ',
662      (delete $spec{libperl}  || ''),
663     @{delete $spec{perllibs} || []},
664   ) . ")\n";
665
666   close SCRIPT;
667
668   push @{$spec{other_ldflags}}, '"' . $script . '"';
669
670   return %spec;
671 }
672
673 1;
674
675 __END__
676
677 =head1 NAME
678
679 ExtUtils::CBuilder::Platform::Windows - Builder class for Windows platforms
680
681 =head1 DESCRIPTION
682
683 This module implements the Windows-specific parts of ExtUtils::CBuilder.
684 Most of the Windows-specific stuff has to do with compiling and
685 linking C code.  Currently we support the 3 compilers perl itself
686 supports: MSVC, BCC, and GCC.
687
688 This module inherits from C<ExtUtils::CBuilder::Base>, so any functionality
689 not implemented here will be implemented there.  The interfaces are
690 defined by the L<ExtUtils::CBuilder> documentation.
691
692 =head1 AUTHOR
693
694 Ken Williams <ken@mathforum.org>
695
696 Most of the code here was written by Randy W. Sims <RandyS@ThePierianSpring.org>.
697
698 =head1 SEE ALSO
699
700 perl(1), ExtUtils::CBuilder(3), ExtUtils::MakeMaker(3)
701
702 =cut