This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
update Time-HiRes to CPAN version 1.9722
[perl5.git] / cpan / Time-HiRes / Makefile.PL
1 #!/usr/bin/perl
2 #
3 # In general we trust %Config, but for nanosleep() this trust
4 # may be misplaced (it may be linkable but not really functional).
5 # Use $ENV{FORCE_NANOSLEEP_SCAN} to force rescanning whether there
6 # really is hope.
7
8 require 5.002;
9
10 use Config;
11 use ExtUtils::MakeMaker;
12 use strict;
13
14 my $VERBOSE = $ENV{VERBOSE};
15 my $DEFINE;
16 my $LIBS = [];
17 my $XSOPT = '';
18 my $SYSCALL_H;
19
20 use vars qw($self); # Used in 'sourcing' the hints.
21
22 # TBD: Can we just use $Config(exe_ext) here instead of this complex
23 #      expression?
24 my $ld_exeext = ($^O eq 'cygwin' ||
25                  $^O eq 'os2' && $Config{ldflags} =~ /-Zexe\b/) ? '.exe' :
26                 (($^O eq 'vos') ? $Config{exe_ext} : '');
27
28 unless($ENV{PERL_CORE}) {
29     $ENV{PERL_CORE} = 1 if grep { $_ eq 'PERL_CORE=1' } @ARGV;
30 }
31
32 # Perls 5.002 and 5.003 did not have File::Spec, fake what we need.
33
34 sub my_dirsep {
35     $^O eq 'VMS' ? '.' :
36         $^O =~ /mswin32|netware|djgpp/i ? '\\' :
37             $^O eq 'MacOS' ? ':'
38                 : '/';
39 }
40
41 sub my_catdir {
42     shift;
43     my $catdir = join(my_dirsep, @_);
44     $^O eq 'VMS' ? "[$catdir]" : $catdir;
45 }
46
47 sub my_catfile {
48     shift;
49     return join(my_dirsep, @_) unless $^O eq 'VMS';
50     my $file = pop;
51     return my_catdir (undef, @_) . $file;
52 }
53
54 sub my_updir {
55     shift;
56     $^O eq 'VMS' ? "-" : "..";
57 }
58
59 BEGIN {
60     eval { require File::Spec };
61     if ($@) {
62         *File::Spec::catdir  = \&my_catdir;
63         *File::Spec::updir   = \&my_updir;
64         *File::Spec::catfile = \&my_catfile;
65     }
66 }
67
68 # Avoid 'used only once' warnings.
69 my $nop1 = *File::Spec::catdir;
70 my $nop2 = *File::Spec::updir;
71 my $nop3 = *File::Spec::catfile;
72
73 # if you have 5.004_03 (and some slightly older versions?), xsubpp
74 # tries to generate line numbers in the C code generated from the .xs.
75 # unfortunately, it is a little buggy around #ifdef'd code.
76 # my choice is leave it in and have people with old perls complain
77 # about the "Usage" bug, or leave it out and be unable to compile myself
78 # without changing it, and then I'd always forget to change it before a
79 # release. Sorry, Edward :)
80
81 sub try_compile_and_link {
82     my ($c, %args) = @_;
83
84     my ($ok) = 0;
85     my ($tmp) = "tmp$$";
86     local(*TMPC);
87
88     my $obj_ext = $Config{obj_ext} || ".o";
89     unlink("$tmp.c", "$tmp$obj_ext");
90
91     if (open(TMPC, ">$tmp.c")) {
92         print TMPC $c;
93         close(TMPC);
94
95         my $cccmd = $args{cccmd};
96
97         my $errornull;
98
99         my $COREincdir;
100
101         if ($ENV{PERL_CORE}) {
102             my $updir = File::Spec->updir;
103             $COREincdir = File::Spec->catdir(($updir) x 2);
104         } else {
105             $COREincdir = File::Spec->catdir($Config{'archlibexp'}, 'CORE');
106         }
107
108         if ($ENV{PERL_CORE}) {
109             unless (-f File::Spec->catfile($COREincdir, "EXTERN.h")) {
110                 die <<__EOD__;
111 Your environment variable PERL_CORE is '$ENV{PERL_CORE}' but there
112 is no EXTERN.h in $COREincdir.
113 Cannot continue, aborting.
114 __EOD__
115             }
116         }
117
118         my $ccflags = $Config{'ccflags'} . ' ' . "-I$COREincdir";
119
120         if ($^O eq 'VMS') {
121             $cccmd = "$Config{'cc'} /include=($COREincdir) $tmp.c";
122         }
123
124         if ($args{silent} || !$VERBOSE) {
125             $errornull = "2>/dev/null" unless defined $errornull;
126         } else {
127             $errornull = '';
128         }
129
130         $cccmd = "$Config{'cc'} -o $tmp $ccflags $tmp.c @$LIBS $errornull"
131             unless defined $cccmd;
132
133        if ($^O eq 'VMS') {
134             open( CMDFILE, ">$tmp.com" );
135             print CMDFILE "\$ SET MESSAGE/NOFACILITY/NOSEVERITY/NOIDENT/NOTEXT\n";
136             print CMDFILE "\$ $cccmd\n";
137             print CMDFILE "\$ IF \$SEVERITY .NE. 1 THEN EXIT 44\n"; # escalate
138             close CMDFILE;
139             system("\@ $tmp.com");
140             $ok = $?==0;
141             for ("$tmp.c", "$tmp$obj_ext", "$tmp.com", "$tmp$Config{exe_ext}") {
142                 1 while unlink $_;
143             }
144         }
145         else
146         {
147             my $tmp_exe = "$tmp$ld_exeext";
148             printf "cccmd = $cccmd\n" if $VERBOSE;
149             my $res = system($cccmd);
150             $ok = defined($res) && $res == 0 && -s $tmp_exe && -x _;
151
152             if ( $ok && exists $args{run} && $args{run}) {
153                 my $tmp_exe =
154                     File::Spec->catfile(File::Spec->curdir, $tmp_exe);
155                 printf "Running $tmp_exe..." if $VERBOSE;
156                 if (system($tmp_exe) == 0) {
157                     $ok = 1;
158                 } else {
159                     $ok = 0;
160                     my $errno = $? >> 8;
161                     local $! = $errno;
162                     printf <<EOF;
163
164 *** The test run of '$tmp_exe' failed: status $?
165 *** (the status means: errno = $errno or '$!')
166 *** DO NOT PANIC: this just means that *some* functionality will be missing.
167 EOF
168                 }
169             }
170             unlink("$tmp.c", $tmp_exe);
171         }
172     }
173
174     return $ok;
175 }
176
177 my $TIME_HEADERS = <<EOH;
178 #include "EXTERN.h"
179 #include "perl.h"
180 #include "XSUB.h"
181 #ifdef I_SYS_TYPES
182 #   include <sys/types.h>
183 #endif
184 #ifdef I_SYS_TIME
185 #   include <sys/time.h>
186 #endif
187 #ifdef I_SYS_SELECT
188 #   include <sys/select.h>      /* struct timeval might be hidden in here */
189 #endif
190 EOH
191
192 sub has_gettimeofday {
193     # confusing but true (if condition true ==> -DHAS_GETTIMEOFDAY already)
194     return 0 if $Config{d_gettimeod};
195     return 1 if try_compile_and_link(<<EOM);
196 $TIME_HEADERS
197 static int foo()
198 {
199     struct timeval tv;
200     gettimeofday(&tv, 0);
201 }
202 int main(int argc, char** argv)
203 {
204     foo();
205 }
206 EOM
207     return 0;
208 }
209
210 sub has_x {
211     my ($x, %args) = @_;
212
213     return 1 if
214     try_compile_and_link(<<EOM, %args);
215 #include "EXTERN.h"
216 #include "perl.h"
217 #include "XSUB.h"
218
219 #ifdef I_UNISTD
220 #   include <unistd.h>
221 #endif
222
223 #ifdef I_SYS_TYPES
224 #   include <sys/types.h>
225 #endif
226
227 #ifdef I_SYS_TIME
228 #   include <sys/time.h>
229 #endif
230
231 int main(int argc, char** argv)
232 {
233         $x;
234 }
235 EOM
236     return 0;
237 }
238
239 sub has_nanosleep {
240     print "testing... ";
241     return 1 if
242     try_compile_and_link(<<EOM, run => 1);
243 #include <time.h>
244 #include <sys/time.h>
245 #include <stdio.h>
246 #include <stdlib.h>
247 #include <errno.h>
248
249 /* int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); */
250
251 int main(int argc, char** argv) {
252     struct timespec ts1, ts2;
253     int ret;
254     ts1.tv_sec  = 0;
255     ts1.tv_nsec = 750000000;
256     ts2.tv_sec  = 0;
257     ts2.tv_nsec = 0;
258     errno = 0;
259     ret = nanosleep(&ts1, &ts2); /* E.g. in AIX nanosleep() fails and sets errno to ENOSYS. */
260     ret == 0 ? exit(0) : exit(errno ? errno : -1);
261 }
262 EOM
263 }
264
265 sub has_include {
266     my ($inc) = @_;
267     return 1 if
268     try_compile_and_link(<<EOM);
269 #include "EXTERN.h"
270 #include "perl.h"
271 #include "XSUB.h"
272
273 #include <$inc>
274 int main(int argc, char** argv)
275 {
276         return 0;
277 }
278 EOM
279     return 0;
280 }
281
282 sub has_clock_xxx_syscall {
283     my $x = shift;
284     return 0 unless defined $SYSCALL_H;
285     return 1 if
286     try_compile_and_link(<<EOM, run => 1);
287 #include "EXTERN.h"
288 #include "perl.h"
289 #include "XSUB.h"
290 #include <$SYSCALL_H>
291 int main(int argc, char** argv)
292 {
293     struct timespec ts;
294     /* Many Linuxes get ENOSYS even though the syscall exists. */
295     /* All implementations are supposed to support CLOCK_REALTIME. */
296     int ret = syscall(SYS_clock_$x, CLOCK_REALTIME, &ts);
297     ret == 0 ? exit(0) : exit(errno ? errno : -1);
298 }
299 EOM
300 }
301
302 sub has_clock_xxx {
303     my $xxx = shift;
304     return 1 if
305     try_compile_and_link(<<EOM, run => 1);
306 #include "EXTERN.h"
307 #include "perl.h"
308 #include "XSUB.h"
309 int main(int argc, char** argv)
310 {
311     struct timespec ts;
312     int ret = clock_$xxx(CLOCK_REALTIME, &ts); /* Many Linuxes get ENOSYS. */
313     /* All implementations are supposed to support CLOCK_REALTIME. */
314     ret == 0 ? exit(0) : exit(errno ? errno : -1);
315 }
316 EOM
317 }
318
319 sub has_clock {
320     return 1 if
321     try_compile_and_link(<<EOM, run => 1);
322 #include "EXTERN.h"
323 #include "perl.h"
324 #include "XSUB.h"
325 int main(int argc, char** argv)
326 {
327     clock_t tictoc;
328     clock_t ret = clock();
329     ret == (clock_t)-1 ? exit(errno ? errno : -1) : exit(0);
330 }
331 EOM
332 }
333
334 sub has_clock_nanosleep {
335     return 1 if
336     try_compile_and_link(<<EOM, run => 1);
337 #include "EXTERN.h"
338 #include "perl.h"
339 #include "XSUB.h"
340 #include <time.h>
341 int main(int argc, char** argv)
342 {
343     int ret;
344     struct timespec ts1;
345     struct timespec ts2;
346     ts1.tv_sec  = 0;
347     ts1.tv_nsec = 750000000;;
348     ret = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts1, &ts2);
349     ret == 0 ? exit(0) : exit(errno ? errno : -1);
350 }
351 EOM
352 }
353
354 sub DEFINE {
355     my ($def, $val) = @_;
356     my $define = defined $val ? "$def=$val" : $def ;
357     unless ($DEFINE =~ /(?:^| )-D\Q$define\E(?: |$)/) {
358         $DEFINE .= " -D$define";
359     }
360 }
361
362 sub init {
363     my $hints = File::Spec->catfile("hints", "$^O.pl");
364     if (-f $hints) {
365         print "Using hints $hints...\n";
366         local $self;
367         do $hints;
368         if (exists $self->{LIBS}) {
369             $LIBS = $self->{LIBS};
370             print "Extra libraries: @$LIBS...\n";
371         }
372     }
373
374     $DEFINE = '';
375
376     if ($Config{d_syscall}) {
377         print "Have syscall()... looking for syscall.h... ";
378         if (has_include('syscall.h')) {
379             $SYSCALL_H = 'syscall.h';
380         } elsif (has_include('sys/syscall.h')) {
381             $SYSCALL_H = 'sys/syscall.h';
382         }
383     } else {
384         print "No syscall()...\n";
385     }
386
387     if ($Config{d_syscall}) {
388         if (defined $SYSCALL_H) {
389             print "found <$SYSCALL_H>.\n";
390         } else {
391             print "NOT found.\n";
392         }
393     }
394
395     print "Looking for gettimeofday()... ";
396     my $has_gettimeofday;
397     if (exists $Config{d_gettimeod}) {
398         $has_gettimeofday++ if $Config{d_gettimeod};
399     } elsif (has_gettimeofday()) {
400         $DEFINE .= ' -DHAS_GETTIMEOFDAY';
401         $has_gettimeofday++;
402     }
403
404     if ($has_gettimeofday) {
405         print "found.\n";
406     } else {
407         die <<EOD
408 Your operating system does not seem to have the gettimeofday() function.
409 (or, at least, I cannot find it)
410
411 There is no way Time::HiRes is going to work.
412
413 I am awfully sorry but I cannot go further.
414
415 Aborting configuration.
416
417 EOD
418     }
419
420     print "Looking for setitimer()... ";
421     my $has_setitimer;
422     if (exists $Config{d_setitimer}) {
423         $has_setitimer++ if $Config{d_setitimer};
424     } elsif (has_x("setitimer(ITIMER_REAL, 0, 0)")) {
425         $has_setitimer++;
426         $DEFINE .= ' -DHAS_SETITIMER';
427     }
428
429     if ($has_setitimer) {
430         print "found.\n";
431     } else {
432         print "NOT found.\n";
433     }
434
435     print "Looking for getitimer()... ";
436     my $has_getitimer;
437     if (exists $Config{'d_getitimer'}) {
438         $has_getitimer++ if $Config{'d_getitimer'};
439     } elsif (has_x("getitimer(ITIMER_REAL, 0)")) {
440         $has_getitimer++;
441         $DEFINE .= ' -DHAS_GETITIMER';
442     }
443
444     if ($has_getitimer) {
445         print "found.\n";
446     } else {
447         print "NOT found.\n";
448     }
449
450     if ($has_setitimer && $has_getitimer) {
451         print "You have interval timers (both setitimer and getitimer).\n";
452     } else {
453         print "You do not have interval timers.\n";
454     }
455
456     print "Looking for ualarm()... ";
457     my $has_ualarm;
458     if (exists $Config{d_ualarm}) {
459         $has_ualarm++ if $Config{d_ualarm};
460     } elsif (has_x ("ualarm (0, 0)")) {
461         $has_ualarm++;
462         $DEFINE .= ' -DHAS_UALARM';
463     }
464
465     if ($has_ualarm) {
466         print "found.\n";
467     } else {
468         print "NOT found.\n";
469         if ($has_setitimer) {
470             print "But you have setitimer().\n";
471             print "We can make a Time::HiRes::ualarm().\n";
472         }
473     }
474
475     print "Looking for usleep()... ";
476     my $has_usleep;
477     if (exists $Config{d_usleep}) {
478         $has_usleep++ if $Config{d_usleep};
479     } elsif (has_x ("usleep (0)")) {
480         $has_usleep++;
481         $DEFINE .= ' -DHAS_USLEEP';
482     }
483
484     if ($has_usleep) {
485         print "found.\n";
486     } else {
487         print "NOT found.\n";
488         print "Let's see if you have select()... ";
489         if ($Config{'d_select'}) {
490             print "found.\n";
491             print "We can make a Time::HiRes::usleep().\n";
492         } else {
493             print "NOT found.\n";
494             print "You won't have a Time::HiRes::usleep().\n";
495         }
496     }
497
498     print "Looking for nanosleep()... ";
499     my $has_nanosleep;
500     if ($ENV{FORCE_NANOSLEEP_SCAN}) {
501         print "forced scan... ";
502         if (has_nanosleep()) {
503             $has_nanosleep++;
504             $DEFINE .= ' -DTIME_HIRES_NANOSLEEP';
505         }
506     }
507     elsif (exists $Config{d_nanosleep}) {
508         print "believing \$Config{d_nanosleep}... ";
509         if ($Config{d_nanosleep}) {
510             $has_nanosleep++;
511             $DEFINE .= ' -DTIME_HIRES_NANOSLEEP';
512         }
513     } elsif ($^O =~ /^(mpeix)$/) {
514         # MPE/iX falsely finds nanosleep from its libc equivalent.
515         print "skipping because in $^O... ";
516     } else {
517         if (has_nanosleep()) {
518             $has_nanosleep++;
519             $DEFINE .= ' -DTIME_HIRES_NANOSLEEP';
520         }
521     }
522
523     if ($has_nanosleep) {
524         print "found.\n";
525         print "You can mix subsecond sleeps with signals, if you want to.\n";
526         print "(It's still not portable, though.)\n";
527     } else {
528         print "NOT found.\n";
529         my $nt = ($^O eq 'os2' ? '' : 'not');
530         print "You can$nt mix subsecond sleeps with signals.\n";
531         print "(It would not be portable anyway.)\n";
532     }
533
534     print "Looking for clock_gettime()... ";
535     my $has_clock_gettime;
536     if (exists $Config{d_clock_gettime}) {
537         $has_clock_gettime++ if $Config{d_clock_gettime}; # Unlikely...
538     } elsif (has_clock_xxx('gettime')) {
539         $has_clock_gettime++;
540         $DEFINE .= ' -DTIME_HIRES_CLOCK_GETTIME';
541     } elsif (defined $SYSCALL_H && has_clock_xxx_syscall('gettime')) {
542         $has_clock_gettime++;
543         $DEFINE .= ' -DTIME_HIRES_CLOCK_GETTIME -DTIME_HIRES_CLOCK_GETTIME_SYSCALL';
544     }
545
546     if ($has_clock_gettime) {
547         if ($DEFINE =~ /-DTIME_HIRES_CLOCK_GETTIME_SYSCALL/) {
548             print "found (via syscall).\n";
549         } else {
550             print "found.\n";
551         }
552     } else {
553         print "NOT found.\n";
554     }
555
556     print "Looking for clock_getres()... ";
557     my $has_clock_getres;
558     if (exists $Config{d_clock_getres}) {
559         $has_clock_getres++ if $Config{d_clock_getres}; # Unlikely...
560     } elsif (has_clock_xxx('getres')) {
561         $has_clock_getres++;
562         $DEFINE .= ' -DTIME_HIRES_CLOCK_GETRES';
563     } elsif (defined $SYSCALL_H && has_clock_xxx_syscall('getres')) {
564         $has_clock_getres++;
565         $DEFINE .= ' -DTIME_HIRES_CLOCK_GETRES -DTIME_HIRES_CLOCK_GETRES_SYSCALL';
566     }
567
568     if ($has_clock_getres) {
569         if ($DEFINE =~ /-DTIME_HIRES_CLOCK_GETRES_SYSCALL/) {
570             print "found (via syscall).\n";
571         } else {
572             print "found.\n";
573         }
574     } else {
575         print "NOT found.\n";
576     }
577
578     print "Looking for clock_nanosleep()... ";
579     my $has_clock_nanosleep;
580     if (exists $Config{d_clock_nanosleep}) {
581         $has_clock_nanosleep++ if $Config{d_clock_nanosleep}; # Unlikely...
582     } elsif (has_clock_nanosleep()) {
583         $has_clock_nanosleep++;
584         $DEFINE .= ' -DTIME_HIRES_CLOCK_NANOSLEEP';
585     }
586
587     if ($has_clock_nanosleep) {
588         print "found.\n";
589     } else {
590         print "NOT found.\n";
591     }
592
593     print "Looking for clock()... ";
594     my $has_clock;
595     if (exists $Config{d_clock}) {
596         $has_clock++ if $Config{d_clock}; # Unlikely...
597     } elsif (has_clock()) {
598         $has_clock++;
599         $DEFINE .= ' -DTIME_HIRES_CLOCK';
600     }
601
602     if ($has_clock) {
603         print "found.\n";
604     } else {
605         print "NOT found.\n";
606     }
607
608     print "Looking for stat() subsecond timestamps...\n";
609
610     print "Trying struct stat st_atimespec.tv_nsec...";
611     my $has_stat_st_xtimespec;
612     if (try_compile_and_link(<<EOM)) {
613 $TIME_HEADERS
614 #include <sys/stat.h>
615 int main(int argc, char** argv) {
616     struct stat st;
617     st.st_atimespec.tv_nsec = 0;
618 }
619 EOM
620       $has_stat_st_xtimespec++;
621       DEFINE('TIME_HIRES_STAT', 1);
622     }
623
624     if ($has_stat_st_xtimespec) {
625         print "found.\n";
626     } else {
627         print "NOT found.\n";
628     }
629
630     print "Trying struct stat st_atimensec...";
631     my $has_stat_st_xtimensec;
632     if (try_compile_and_link(<<EOM)) {
633 $TIME_HEADERS
634 #include <sys/stat.h>
635 int main(int argc, char** argv) {
636     struct stat st;
637     st.st_atimensec = 0;
638 }
639 EOM
640       $has_stat_st_xtimensec++;
641       DEFINE('TIME_HIRES_STAT', 2);
642     }
643
644     if ($has_stat_st_xtimensec) {
645         print "found.\n";
646     } else {
647         print "NOT found.\n";
648     }
649
650     print "Trying struct stat st_atime_n...";
651     my $has_stat_st_xtime_n;
652     if (try_compile_and_link(<<EOM)) {
653 $TIME_HEADERS
654 #include <sys/stat.h>
655 int main(int argc, char** argv) {
656     struct stat st;
657     st.st_atime_n = 0;
658 }
659 EOM
660       $has_stat_st_xtime_n++;
661       DEFINE('TIME_HIRES_STAT', 3);
662     }
663
664     if ($has_stat_st_xtime_n) {
665         print "found.\n";
666     } else {
667         print "NOT found.\n";
668     }
669
670     print "Trying struct stat st_atim.tv_nsec...";
671     my $has_stat_st_xtim;
672     if (try_compile_and_link(<<EOM)) {
673 $TIME_HEADERS
674 #include <sys/stat.h>
675 int main(int argc, char** argv) {
676     struct stat st;
677     st.st_atim.tv_nsec = 0;
678 }
679 EOM
680       $has_stat_st_xtim++;
681       DEFINE('TIME_HIRES_STAT', 4);
682     }
683
684     if ($has_stat_st_xtim) {
685         print "found.\n";
686     } else {
687         print "NOT found.\n";
688     }
689
690     print "Trying struct stat st_uatime...";
691     my $has_stat_st_uxtime;
692     if (try_compile_and_link(<<EOM)) {
693 $TIME_HEADERS
694 #include <sys/stat.h>
695 int main(int argc, char** argv) {
696     struct stat st;
697     st.st_uatime = 0;
698 }
699 EOM
700       $has_stat_st_uxtime++;
701       DEFINE('TIME_HIRES_STAT', 5);
702     }
703
704     if ($has_stat_st_uxtime) {
705         print "found.\n";
706     } else {
707         print "NOT found.\n";
708     }
709
710    if ($DEFINE =~ /-DTIME_HIRES_STAT=\d+/) {
711     print "You seem to have stat() subsecond timestamps.\n";
712     print "(Your struct stat has them, but the filesystems must help.)\n";
713    } else {
714     print "You do not seem to have stat subsecond timestamps.\n";
715    }
716
717     my $has_w32api_windows_h;
718
719     if ($^O eq 'cygwin') {
720         print "Looking for <w32api/windows.h>... ";
721         if (has_include('w32api/windows.h')) {
722             $has_w32api_windows_h++;
723             DEFINE('HAS_W32API_WINDOWS_H');
724         }
725         if ($has_w32api_windows_h) {
726             print "found.\n";
727         } else {
728             print "NOT found.\n";
729         }
730     }
731
732     if ($DEFINE) {
733         $DEFINE =~ s/^\s+//;
734         if (open(XDEFINE, ">xdefine")) {
735             print XDEFINE $DEFINE, "\n";
736             close(XDEFINE);
737         }
738     }
739 }
740
741 sub doMakefile {
742     my @makefileopts = ();
743
744     if ($] >= 5.005) {
745         push (@makefileopts,
746             'AUTHOR'    => 'Jarkko Hietaniemi <jhi@iki.fi>',
747             'ABSTRACT_FROM' => 'HiRes.pm',
748         );
749         DEFINE('ATLEASTFIVEOHOHFIVE');
750     }
751
752     push (@makefileopts,
753         'NAME'  => 'Time::HiRes',
754         'VERSION_FROM' => 'HiRes.pm', # finds $VERSION
755         'LIBS'  => $LIBS,   # e.g., '-lm'
756         'DEFINE'        => $DEFINE,     # e.g., '-DHAS_SOMETHING'
757         'XSOPT' => $XSOPT,
758           # Do not even think about 'INC' => '-I/usr/ucbinclude',
759           # Solaris will avenge.
760         'INC'   => '',     # e.g., '-I/usr/include/other'
761         'INSTALLDIRS' => ($] >= 5.008 ? 'perl' : 'site'),
762         'dist'      => {
763             'CI'       => 'ci -l',
764             'COMPRESS' => 'gzip -9f',
765             'SUFFIX'   => 'gz',
766         },
767         clean => { FILES => "xdefine" },
768         realclean => { FILES=> 'const-c.inc const-xs.inc' },
769     );
770
771     if ($^O eq "MSWin32" && !(grep { /\ALD[A-Z]*=/ } @ARGV)) {
772         my $libperl = $Config{libperl} || "";
773         my $gccversion = $Config{gccversion} || "";
774         if ($gccversion =~ /\A3\.4\.[0-9]+/ and $libperl =~ /\.lib\z/) {
775             # Avoid broken linkage with ActivePerl, by linking directly
776             # against the Perl DLL rather than the import library.
777             (my $llibperl = "-l$libperl") =~ s/\.lib\z//;
778             my $lddlflags = $Config{lddlflags} || "";
779             my $ldflags = $Config{ldflags} || "";
780             s/-L(?:".*?"|\S+)//g foreach $lddlflags, $ldflags;
781             my $libdirs = join ' ',
782                 map { s/(?<!\\)((?:\\\\)*")/\\$1/g; qq[-L"$_"] }
783                 @Config{qw/bin sitebin/};
784             push @makefileopts, macro => {
785                 LDDLFLAGS => "$lddlflags $libdirs $llibperl",
786                 LDFLAGS => "$ldflags $libdirs $llibperl",
787                 PERL_ARCHIVE => "",
788             };
789         }
790     }
791
792     if ($ENV{PERL_CORE}) {
793         push @makefileopts, MAN3PODS => {};
794     }
795
796     WriteMakefile(@makefileopts);
797 }
798
799 sub doConstants {
800     if (eval {require ExtUtils::Constant; 1}) {
801         my @names = qw(CLOCK_HIGHRES CLOCK_MONOTONIC
802                        CLOCK_PROCESS_CPUTIME_ID
803                        CLOCK_REALTIME
804                        CLOCK_SOFTTIME
805                        CLOCK_THREAD_CPUTIME_ID
806                        CLOCK_TIMEOFDAY
807                        CLOCKS_PER_SEC
808                        ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF
809                        ITIMER_REALPROF
810                        TIMER_ABSTIME);
811         foreach (qw (d_usleep d_ualarm d_gettimeofday d_getitimer d_setitimer
812                      d_nanosleep d_clock_gettime d_clock_getres
813                      d_clock d_clock_nanosleep d_hires_stat)) {
814             my $macro = $_;
815             if ($macro =~ /^(d_nanosleep|d_clock_gettime|d_clock_getres|d_clock|d_clock_nanosleep)$/) {
816                 $macro =~ s/^d_(.+)/TIME_HIRES_\U$1/;
817             } elsif ($macro =~ /^(d_hires_stat)$/) {
818                 my $d_hires_stat = 0;
819                 $d_hires_stat = $1 if ($DEFINE =~ /-DTIME_HIRES_STAT=(\d+)/);
820                 push @names, {name => $_, macro => "TIME_HIRES_STAT", value => $d_hires_stat,
821                               default => ["IV", "0"]};
822                 next;
823             } else {
824                 $macro =~ s/^d_(.+)/HAS_\U$1/;
825             }
826             push @names, {name => $_, macro => $macro, value => 1,
827                           default => ["IV", "0"]};
828         }
829         ExtUtils::Constant::WriteConstants(
830                                            NAME => 'Time::HiRes',
831                                            NAMES => \@names,
832                                           );
833     } else {
834         my $file;
835         foreach $file ('const-c.inc', 'const-xs.inc') {
836             my $fallback = File::Spec->catfile('fallback', $file);
837             local $/;
838             open IN, "<$fallback" or die "Can't open $fallback: $!";
839             open OUT, ">$file" or die "Can't open $file: $!";
840             print OUT <IN> or die $!;
841             close OUT or die "Can't close $file: $!";
842             close IN or die "Can't close $fallback: $!";
843         }
844     }
845 }
846
847 sub main {
848     if (-f "xdefine" && !(@ARGV  && $ARGV[0] eq '--configure')) {
849         print qq[$0: The "xdefine" exists, skipping the configure step.\n];
850         print qq[("$^X $0 --configure" to force the configure step)\n];
851     } else {
852         print "Configuring Time::HiRes...\n";
853         1 while unlink("define");
854         if ($^O =~ /Win32/i) {
855             DEFINE('SELECT_IS_BROKEN');
856             $LIBS = [];
857             print "System is $^O, skipping full configure...\n";
858             open(XDEFINE, ">xdefine") or die "$0: Cannot create xdefine: $!\n";
859             close(XDEFINE);
860         } else {
861             init();
862         }
863         doMakefile;
864         doConstants;
865     }
866     my $make = $Config{'make'} || "make";
867     unless (exists $ENV{PERL_CORE} && $ENV{PERL_CORE}) {
868         print  <<EOM;
869 Now you may issue '$make'.  Do not forget also '$make test'.
870 EOM
871        if ($] == 5.008 &&
872            ((exists $ENV{LC_ALL}   && $ENV{LC_ALL}   =~ /utf-?8/i) ||
873             (exists $ENV{LC_CTYPE} && $ENV{LC_CTYPE} =~ /utf-?8/i) ||
874             (exists $ENV{LANG}     && $ENV{LANG}     =~ /utf-?8/i))) {
875             print <<EOM;
876
877 NOTE: if you get an error like this (the Makefile line number may vary):
878 Makefile:91: *** missing separator
879 then set the environment variable LC_ALL to "C" and retry
880 from scratch (re-run perl "Makefile.PL").
881 (And consider upgrading your Perl to, say, at least Perl 5.8.8.)
882 (You got this message because you seem to have
883  an UTF-8 locale active in your shell environment, this used
884  to cause broken Makefiles to be created from Makefile.PLs)
885 EOM
886         }
887     }
888 }
889
890 &main;
891
892 # EOF