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