#ifdef __cplusplus

extern "C" {

#endif

#define PERL_NO_GET_CONTEXT

#include "EXTERN.h"

#include "perl.h"

#include "XSUB.h"

#ifdef WIN32

#include <time.h>

#else

#include <sys/time.h>

#endif

#ifdef HAS_SELECT

# ifdef I_SYS_SELECT

# include <sys/select.h>

# endif

#endif

#ifdef __cplusplus

}

#endif

#ifndef NOOP

# define NOOP (void)0

#endif

#ifndef dNOOP

# define dNOOP extern int Perl___notused

#endif

#ifndef aTHX_

# define aTHX_

# define pTHX_

# define dTHX dNOOP

#endif

#ifdef START_MY_CXT

# ifndef MY_CXT_CLONE

# define MY_CXT_CLONE \

dMY_CXT_SV; \

my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\

Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t); \

sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))

# endif

#else

# define START_MY_CXT static my_cxt_t my_cxt;

# define dMY_CXT dNOOP

# define MY_CXT_INIT NOOP

# define MY_CXT_CLONE NOOP

# define MY_CXT my_cxt

#endif

#ifndef NVTYPE

# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)

# define NVTYPE long double

# else

# define NVTYPE double

# endif

typedef NVTYPE NV;

#endif

#ifndef IVdf

# ifdef IVSIZE

# if IVSIZE == LONGSIZE

# define IVdf "ld"

# define UVuf "lu"

# else

# if IVSIZE == INTSIZE

# define IVdf "d"

# define UVuf "u"

# endif

# endif

# else

# define IVdf "ld"

# define UVuf "lu"

# endif

#endif

#ifndef NVef

# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \

defined(PERL_PRIgldbl) /* Not very likely, but let's try anyway. */

# define NVgf PERL_PRIgldbl

# else

# define NVgf "g"

# endif

#endif

#ifndef INT2PTR

#if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)

# define PTRV UV

# define INT2PTR(any,d) (any)(d)

#else

# if PTRSIZE == LONGSIZE

# define PTRV unsigned long

# else

# define PTRV unsigned

# endif

# define INT2PTR(any,d) (any)(PTRV)(d)

#endif

#define PTR2IV(p) INT2PTR(IV,p)

#endif /* !INT2PTR */

#ifndef SvPV_nolen

static char *

sv_2pv_nolen(pTHX_ register SV *sv)

{

STRLEN n_a;

return sv_2pv(sv, &n_a);

}

# define SvPV_nolen(sv) \

((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \

? SvPVX(sv) : sv_2pv_nolen(sv))

#endif

#ifndef PerlProc_pause

# define PerlProc_pause() Pause()

#endif

#if defined(__CYGWIN__) || defined(WIN32)

# undef ITIMER_VIRTUAL

# undef ITIMER_PROF

# undef ITIMER_REALPROF

#endif

#ifndef ATLEASTFIVEOHOHFIVE

#ifndef PL_sv_undef

#define PL_sv_undef sv_undef

#endif

#endif

#include "const-c.inc"

#ifdef WIN32

#ifndef HAS_GETTIMEOFDAY

# define HAS_GETTIMEOFDAY

#endif

typedef union {

unsigned __int64 ft_i64;

FILETIME ft_val;

} FT_t;

#define MY_CXT_KEY "Time::HiRes_" XS_VERSION

typedef struct {

unsigned long run_count;

unsigned __int64 base_ticks;

unsigned __int64 tick_frequency;

FT_t base_systime_as_filetime;

} my_cxt_t;

#ifdef __GNUC__

#define Const64(x) x##LL

#else

#define Const64(x) x##i64

#endif

#define EPOCH_BIAS Const64(116444736000000000)

#undef gettimeofday

#define gettimeofday(tp, not_used) _gettimeofday(aTHX_ tp, not_used)

#define MAX_DIFF Const64(5000000)

static int

_gettimeofday(pTHX_ struct timeval *tp, void *not_used)

{

dMY_CXT;

unsigned __int64 ticks;

FT_t ft;

if (MY_CXT.run_count++) {

__int64 diff;

FT_t filtim;

GetSystemTimeAsFileTime(&filtim.ft_val);

QueryPerformanceCounter((LARGE_INTEGER*)&ticks);

ticks -= MY_CXT.base_ticks;

ft.ft_i64 = MY_CXT.base_systime_as_filetime.ft_i64

+ Const64(10000000) * (ticks / MY_CXT.tick_frequency)

+(Const64(10000000) * (ticks % MY_CXT.tick_frequency)) / MY_CXT.tick_frequency;

diff = ft.ft_i64 - MY_CXT.base_systime_as_filetime.ft_i64;

if (diff < -MAX_DIFF || diff > MAX_DIFF) {

MY_CXT.base_ticks = ticks;

ft.ft_i64 = filtim.ft_i64;

}

}

else {

QueryPerformanceFrequency((LARGE_INTEGER*)&MY_CXT.tick_frequency);

QueryPerformanceCounter((LARGE_INTEGER*)&MY_CXT.base_ticks);

GetSystemTimeAsFileTime(&MY_CXT.base_systime_as_filetime.ft_val);

ft.ft_i64 = MY_CXT.base_systime_as_filetime.ft_i64;

}

/* seconds since epoch */

tp->tv_sec = (long)((ft.ft_i64 - EPOCH_BIAS) / Const64(10000000));

/* microseconds remaining */

tp->tv_usec = (long)((ft.ft_i64 / Const64(10)) % Const64(1000000));

return 0;

}

#endif

#if defined(WIN32) && !defined(ATLEASTFIVEOHOHFIVE)

static unsigned int

sleep(unsigned int t)

{

Sleep(t*1000);

return 0;

}

#endif

#if !defined(HAS_GETTIMEOFDAY) && defined(VMS)

#define HAS_GETTIMEOFDAY

#include <lnmdef.h>

#include <time.h> /* gettimeofday */

#include <stdlib.h> /* qdiv */

#include <starlet.h> /* sys$gettim */

#include <descrip.h>

#ifdef __VAX

#include <lib$routines.h> /* lib$ediv() */

#endif

#define DIV_100NS_TO_SECS 10000000L

#define DIV_100NS_TO_USECS 10L

static $DESCRIPTOR(dscepoch,"01-JAN-1970 00:00:00.00");

#ifdef __VAX

static long base_adjust[2]={0L,0L};

#else

static __int64 base_adjust=0;

#endif

static int gmtime_emulation_type;

static long int utc_offset_secs;

static struct dsc$descriptor_s fildevdsc =

{ 12, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$FILE_DEV" };

static struct dsc$descriptor_s *fildev[] = { &fildevdsc, NULL };

static time_t toutc_dst(time_t loc) {

struct tm *rsltmp;

if ((rsltmp = localtime(&loc)) == NULL) return -1;

loc -= utc_offset_secs;

if (rsltmp->tm_isdst) loc -= 3600;

return loc;

}

static time_t toloc_dst(time_t utc) {

struct tm *rsltmp;

utc += utc_offset_secs;

if ((rsltmp = localtime(&utc)) == NULL) return -1;

if (rsltmp->tm_isdst) utc += 3600;

return utc;

}

#define _toutc(secs) ((secs) == (time_t) -1 ? (time_t) -1 : \

((gmtime_emulation_type || timezone_setup()), \

(gmtime_emulation_type == 1 ? toutc_dst(secs) : \

((secs) - utc_offset_secs))))

#define _toloc(secs) ((secs) == (time_t) -1 ? (time_t) -1 : \

((gmtime_emulation_type || timezone_setup()), \

(gmtime_emulation_type == 1 ? toloc_dst(secs) : \

((secs) + utc_offset_secs))))

static int

timezone_setup(void)

{

struct tm *tm_p;

if (gmtime_emulation_type == 0) {

int dstnow;

time_t base = 15 * 86400; /* 15jan71; to avoid month/year ends between */

/* results of calls to gmtime() and localtime() */

/* for same &base */

gmtime_emulation_type++;

if ((tm_p = gmtime(&base)) == NULL) { /* CRTL gmtime() is a fake */

char off[LNM$C_NAMLENGTH+1];;

gmtime_emulation_type++;

if (!Perl_vmstrnenv("SYS$TIMEZONE_DIFFERENTIAL",off,0,fildev,0)) {

gmtime_emulation_type++;

utc_offset_secs = 0;

Perl_warn(aTHX_ "no UTC offset information; assuming local time is UTC");

}

else { utc_offset_secs = atol(off); }

}

else { /* We've got a working gmtime() */

struct tm gmt, local;

gmt = *tm_p;

tm_p = localtime(&base);

local = *tm_p;

utc_offset_secs = (local.tm_mday - gmt.tm_mday) * 86400;

utc_offset_secs += (local.tm_hour - gmt.tm_hour) * 3600;

utc_offset_secs += (local.tm_min - gmt.tm_min) * 60;

utc_offset_secs += (local.tm_sec - gmt.tm_sec);

}

}

return 1;

}

gettimeofday (struct timeval *tp, void *tpz)

{

long ret;

#ifdef __VAX

long quad[2];

long quad1[2];

long div_100ns_to_secs;

long div_100ns_to_usecs;

long quo,rem;

long quo1,rem1;

#else

__int64 quad;

__qdiv_t ans1,ans2;

#endif

tp->tv_usec = 0;

#ifdef __VAX

if (base_adjust[0]==0 && base_adjust[1]==0) {

#else

if (base_adjust==0) { /* Need to determine epoch adjustment */

#endif

ret=sys$bintim(&dscepoch,&base_adjust);

if (1 != (ret &&1)) {

tp->tv_sec = ret;

return -1;

}

}

ret=sys$gettim(&quad); /* Get VMS system time */

if ((1 && ret) == 1) {

#ifdef __VAX

quad[0] -= base_adjust[0]; /* convert to epoch offset */

quad[1] -= base_adjust[1]; /* convert 2nd half of quadword */

div_100ns_to_secs = DIV_100NS_TO_SECS;

div_100ns_to_usecs = DIV_100NS_TO_USECS;

lib$ediv(&div_100ns_to_secs,&quad,&quo,&rem);

quad1[0] = rem;

quad1[1] = 0L;

lib$ediv(&div_100ns_to_usecs,&quad1,&quo1,&rem1);

tp->tv_sec = quo; /* Whole seconds */

tp->tv_usec = quo1; /* Micro-seconds */

#else

quad -= base_adjust; /* convert to epoch offset */

ans1=qdiv(quad,DIV_100NS_TO_SECS);

ans2=qdiv(ans1.rem,DIV_100NS_TO_USECS);

tp->tv_sec = ans1.quot; /* Whole seconds */

tp->tv_usec = ans2.quot; /* Micro-seconds */

#endif

} else {

tp->tv_sec = ret;

return -1;

}

# ifdef VMSISH_TIME

# ifdef RTL_USES_UTC

if (VMSISH_TIME) tp->tv_sec = _toloc(tp->tv_sec);

# else

if (!VMSISH_TIME) tp->tv_sec = _toutc(tp->tv_sec);

# endif

# endif

return 0;

}

#endif

/* Do not use H A S _ N A N O S L E E P

#if !defined(HAS_USLEEP) && defined(TIME_HIRES_NANOSLEEP)

#define HAS_USLEEP

#define usleep hrt_nanosleep /* could conflict with ncurses for static build */

hrt_nanosleep(unsigned long usec)

{

struct timespec res;

res.tv_sec = usec/1000/1000;

res.tv_nsec = ( usec - res.tv_sec*1000*1000 ) * 1000;

nanosleep(&res, NULL);

}

#endif

#if !defined(HAS_USLEEP) && defined(HAS_SELECT)

#ifndef SELECT_IS_BROKEN

#define HAS_USLEEP

#define usleep hrt_usleep /* could conflict with ncurses for static build */

hrt_usleep(unsigned long usec)

{

struct timeval tv;

tv.tv_sec = 0;

tv.tv_usec = usec;

select(0, (Select_fd_set_t)NULL, (Select_fd_set_t)NULL,

(Select_fd_set_t)NULL, &tv);

}

#endif

#endif

#if !defined(HAS_USLEEP) && defined(WIN32)

#define HAS_USLEEP

#define usleep hrt_usleep /* could conflict with ncurses for static build */

hrt_usleep(unsigned long usec)

{

long msec;

msec = usec / 1000;

Sleep (msec);

}

#endif

#if !defined(HAS_UALARM) && defined(HAS_SETITIMER)

#define HAS_UALARM

#define ualarm hrt_ualarm /* could conflict with ncurses for static build */

hrt_ualarm(int usec, int interval)

{

struct itimerval itv;

itv.it_value.tv_sec = usec / 1000000;

itv.it_value.tv_usec = usec % 1000000;

itv.it_interval.tv_sec = interval / 1000000;

itv.it_interval.tv_usec = interval % 1000000;

return setitimer(ITIMER_REAL, &itv, 0);

}

#endif

#if !defined(HAS_UALARM) && defined(VMS)

#define HAS_UALARM

#define ualarm vms_ualarm

#include <lib$routines.h>

#include <ssdef.h>

#include <starlet.h>

#include <descrip.h>

#include <signal.h>

#include <jpidef.h>

#include <psldef.h>

#define VMSERR(s) (!((s)&1))

static void

us_to_VMS(useconds_t mseconds, unsigned long v[])

{

int iss;

unsigned long qq[2];

qq[0] = mseconds;

qq[1] = 0;

v[0] = v[1] = 0;

iss = lib$addx(qq,qq,qq);

if (VMSERR(iss)) lib$signal(iss);

iss = lib$subx(v,qq,v);

if (VMSERR(iss)) lib$signal(iss);

iss = lib$addx(qq,qq,qq);

if (VMSERR(iss)) lib$signal(iss);

iss = lib$subx(v,qq,v);

if (VMSERR(iss)) lib$signal(iss);

iss = lib$subx(v,qq,v);

if (VMSERR(iss)) lib$signal(iss);

}

static int

VMS_to_us(unsigned long v[])

{

int iss;

unsigned long div=10,quot, rem;

iss = lib$ediv(&div,v,&quot,&rem);

if (VMSERR(iss)) lib$signal(iss);

return quot;

}

typedef unsigned short word;

typedef struct _ualarm {

int function;

int repeat;

unsigned long delay[2];

unsigned long interval[2];

unsigned long remain[2];

} Alarm;

static int alarm_ef;

static Alarm *a0, alarm_base;

#define UAL_NULL 0

#define UAL_SET 1

#define UAL_CLEAR 2

#define UAL_ACTIVE 4

static void ualarm_AST(Alarm *a);

static int

vms_ualarm(int mseconds, int interval)

{

Alarm *a, abase;

struct item_list3 {

word length;

word code;

void *bufaddr;

void *retlenaddr;

} ;

static struct item_list3 itmlst[2];

static int first = 1;

unsigned long asten;

int iss, enabled;

if (first) {

first = 0;

itmlst[0].code = JPI$_ASTEN;

itmlst[0].length = sizeof(asten);

itmlst[0].retlenaddr = NULL;

itmlst[1].code = 0;

itmlst[1].length = 0;

itmlst[1].bufaddr = NULL;

itmlst[1].retlenaddr = NULL;

iss = lib$get_ef(&alarm_ef);

if (VMSERR(iss)) lib$signal(iss);

a0 = &alarm_base;

a0->function = UAL_NULL;

}

itmlst[0].bufaddr = &asten;

iss = sys$getjpiw(0,0,0,itmlst,0,0,0);

if (VMSERR(iss)) lib$signal(iss);

if (!(asten&0x08)) return -1;

a = &abase;

if (mseconds) {

a->function = UAL_SET;

} else {

a->function = UAL_CLEAR;

}

us_to_VMS(mseconds, a->delay);

if (interval) {

us_to_VMS(interval, a->interval);

a->repeat = 1;

} else

a->repeat = 0;

iss = sys$clref(alarm_ef);

if (VMSERR(iss)) lib$signal(iss);

iss = sys$dclast(ualarm_AST,a,0);

if (VMSERR(iss)) lib$signal(iss);

iss = sys$waitfr(alarm_ef);

if (VMSERR(iss)) lib$signal(iss);

if (a->function == UAL_ACTIVE)

return VMS_to_us(a->remain);

else

return 0;

}

static void

ualarm_AST(Alarm *a)

{

int iss;

unsigned long now[2];

iss = sys$gettim(now);

if (VMSERR(iss)) lib$signal(iss);

if (a->function == UAL_SET || a->function == UAL_CLEAR) {

if (a0->function == UAL_ACTIVE) {

iss = sys$cantim(a0,PSL$C_USER);

if (VMSERR(iss)) lib$signal(iss);

iss = lib$subx(a0->remain, now, a->remain);

if (VMSERR(iss)) lib$signal(iss);

if (a->remain[1] & 0x80000000)

a->remain[0] = a->remain[1] = 0;

}

if (a->function == UAL_SET) {

a->function = a0->function;

a0->function = UAL_ACTIVE;

a0->repeat = a->repeat;

if (a0->repeat) {

a0->interval[0] = a->interval[0];

a0->interval[1] = a->interval[1];

}

a0->delay[0] = a->delay[0];

a0->delay[1] = a->delay[1];

iss = lib$subx(now, a0->delay, a0->remain);

if (VMSERR(iss)) lib$signal(iss);

iss = sys$setimr(0,a0->delay,ualarm_AST,a0);

if (VMSERR(iss)) lib$signal(iss);

} else {

a->function = a0->function;

a0->function = UAL_NULL;

}

iss = sys$setef(alarm_ef);

if (VMSERR(iss)) lib$signal(iss);

} else if (a->function == UAL_ACTIVE) {

if (a->repeat) {

iss = lib$subx(now, a->interval, a->remain);

if (VMSERR(iss)) lib$signal(iss);

iss = sys$setimr(0,a->interval,ualarm_AST,a);

if (VMSERR(iss)) lib$signal(iss);

} else {

a->function = UAL_NULL;

}

iss = sys$wake(0,0);

if (VMSERR(iss)) lib$signal(iss);

lib$signal(SS$_ASTFLT);

} else {

lib$signal(SS$_BADPARAM);

}

}

#endif /* !HAS_UALARM && VMS */

#ifdef HAS_GETTIMEOFDAY

static int

myU2time(pTHX_ UV *ret)

{

struct timeval Tp;

int status;

status = gettimeofday (&Tp, NULL);

ret[0] = Tp.tv_sec;

ret[1] = Tp.tv_usec;

return status;

}

static NV

myNVtime()

{

#ifdef WIN32

dTHX;

#endif

struct timeval Tp;

int status;

status = gettimeofday (&Tp, NULL);

return status == 0 ? Tp.tv_sec + (Tp.tv_usec / 1000000.) : -1.0;

}

#endif

MODULE = Time::HiRes PACKAGE = Time::HiRes

PROTOTYPES: ENABLE

BOOT:

{

#ifdef MY_CXT_KEY

MY_CXT_INIT;

#endif

#ifdef ATLEASTFIVEOHOHFIVE

#ifdef HAS_GETTIMEOFDAY

{

UV auv[2];

hv_store(PL_modglobal, "Time::NVtime", 12, newSViv(PTR2IV(myNVtime)), 0);

if (myU2time(aTHX_ auv) == 0)

hv_store(PL_modglobal, "Time::U2time", 12, newSViv((IV) auv[0]), 0);

}

#endif

#endif

}

#if defined(USE_ITHREADS) && defined(MY_CXT_KEY)

CLONE(...)

CODE:

MY_CXT_CLONE;

#endif

INCLUDE: const-xs.inc

#if defined(HAS_USLEEP) && defined(HAS_GETTIMEOFDAY)

usleep(useconds)

NV useconds

PREINIT:

struct timeval Ta, Tb;

CODE:

gettimeofday(&Ta, NULL);

if (items > 0) {

if (useconds > 1E6) {

IV seconds = (IV) (useconds / 1E6);

/* If usleep() has been implemented using setitimer()

if (seconds) {

sleep(seconds);

useconds -= 1E6 * seconds;

}

} else if (useconds < 0.0)

croak("Time::HiRes::usleep(%"NVgf"): negative time not invented yet", useconds);

usleep((U32)useconds);

} else

PerlProc_pause();

gettimeofday(&Tb, NULL);

#if 0

printf("[%ld %ld] [%ld %ld]\n", Tb.tv_sec, Tb.tv_usec, Ta.tv_sec, Ta.tv_usec);

#endif

RETVAL = 1E6*(Tb.tv_sec-Ta.tv_sec)+(NV)((IV)Tb.tv_usec-(IV)Ta.tv_usec);

OUTPUT:

RETVAL

sleep(...)

PREINIT:

struct timeval Ta, Tb;

CODE:

gettimeofday(&Ta, NULL);

if (items > 0) {

NV seconds = SvNV(ST(0));

if (seconds >= 0.0) {

UV useconds = (UV)(1E6 * (seconds - (UV)seconds));

if (seconds >= 1.0)

sleep((U32)seconds);

if ((IV)useconds < 0) {

#if defined(__sparc64__) && defined(__GNUC__)

/* Sparc64 gcc 2.95.3 (e.g. on NetBSD) has a bug

useconds = -(IV)useconds;

#endif

if ((IV)useconds < 0)

croak("Time::HiRes::sleep(%"NVgf"): internal error: useconds < 0 (unsigned %"UVuf" signed %"IVdf")", seconds, useconds, (IV)useconds);

}

usleep(useconds);

} else

croak("Time::HiRes::sleep(%"NVgf"): negative time not invented yet", seconds);

} else

PerlProc_pause();

gettimeofday(&Tb, NULL);

#if 0

printf("[%ld %ld] [%ld %ld]\n", Tb.tv_sec, Tb.tv_usec, Ta.tv_sec, Ta.tv_usec);

#endif

RETVAL = (NV)(Tb.tv_sec-Ta.tv_sec)+0.000001*(NV)(Tb.tv_usec-Ta.tv_usec);

OUTPUT:

RETVAL

#endif

#ifdef HAS_UALARM

ualarm(useconds,interval=0)

int useconds

int interval

CODE:

if (useconds < 0 || interval < 0)

croak("Time::HiRes::ualarm(%d, %d): negative time not invented yet", useconds, interval);

RETVAL = ualarm(useconds, interval);

OUTPUT:

RETVAL

alarm(seconds,interval=0)

NV seconds

NV interval

CODE:

if (seconds < 0.0 || interval < 0.0)

croak("Time::HiRes::alarm(%"NVgf", %"NVgf"): negative time not invented yet", seconds, interval);

RETVAL = (NV)ualarm(seconds * 1000000,

interval * 1000000) / 1E6;

OUTPUT:

RETVAL

#endif

#ifdef HAS_GETTIMEOFDAY

# ifdef MACOS_TRADITIONAL /* fix epoch TZ and use unsigned time_t */

gettimeofday()

PREINIT:

struct timeval Tp;

struct timezone Tz;

PPCODE:

int status;

status = gettimeofday (&Tp, &Tz);

Tp.tv_sec += Tz.tz_minuteswest * 60; /* adjust for TZ */

if (GIMME == G_ARRAY) {

EXTEND(sp, 2);

/* Mac OS (Classic) has unsigned time_t */

PUSHs(sv_2mortal(newSVuv(Tp.tv_sec)));

PUSHs(sv_2mortal(newSViv(Tp.tv_usec)));

} else {

EXTEND(sp, 1);

PUSHs(sv_2mortal(newSVnv(Tp.tv_sec + (Tp.tv_usec / 1000000.0))));

}

time()

PREINIT:

struct timeval Tp;

struct timezone Tz;

CODE:

int status;

status = gettimeofday (&Tp, &Tz);

Tp.tv_sec += Tz.tz_minuteswest * 60; /* adjust for TZ */

RETVAL = Tp.tv_sec + (Tp.tv_usec / 1000000.0);

OUTPUT:

RETVAL

# else /* MACOS_TRADITIONAL */

gettimeofday()

PREINIT:

struct timeval Tp;

PPCODE:

int status;

status = gettimeofday (&Tp, NULL);

if (GIMME == G_ARRAY) {

EXTEND(sp, 2);

PUSHs(sv_2mortal(newSViv(Tp.tv_sec)));

PUSHs(sv_2mortal(newSViv(Tp.tv_usec)));

} else {

EXTEND(sp, 1);

PUSHs(sv_2mortal(newSVnv(Tp.tv_sec + (Tp.tv_usec / 1000000.0))));

}

time()

PREINIT:

struct timeval Tp;

CODE:

int status;

status = gettimeofday (&Tp, NULL);

RETVAL = Tp.tv_sec + (Tp.tv_usec / 1000000.);

OUTPUT:

RETVAL

# endif /* MACOS_TRADITIONAL */

#endif

#if defined(HAS_GETITIMER) && defined(HAS_SETITIMER)

#define TV2NV(tv) ((NV)((tv).tv_sec) + 0.000001 * (NV)((tv).tv_usec))

setitimer(which, seconds, interval = 0)

int which

NV seconds

NV interval

PREINIT:

struct itimerval newit;

struct itimerval oldit;

PPCODE:

if (seconds < 0.0 || interval < 0.0)

croak("Time::HiRes::setitimer(%"IVdf", %"NVgf", %"NVgf"): negative time not invented yet", (IV)which, seconds, interval);

newit.it_value.tv_sec = seconds;

newit.it_value.tv_usec =

(seconds - (NV)newit.it_value.tv_sec) * 1000000.0;

newit.it_interval.tv_sec = interval;

newit.it_interval.tv_usec =

(interval - (NV)newit.it_interval.tv_sec) * 1000000.0;

if (setitimer(which, &newit, &oldit) == 0) {

EXTEND(sp, 1);

PUSHs(sv_2mortal(newSVnv(TV2NV(oldit.it_value))));

if (GIMME == G_ARRAY) {

EXTEND(sp, 1);

PUSHs(sv_2mortal(newSVnv(TV2NV(oldit.it_interval))));

}

}

getitimer(which)

int which

PREINIT:

struct itimerval nowit;

PPCODE:

if (getitimer(which, &nowit) == 0) {

EXTEND(sp, 1);

PUSHs(sv_2mortal(newSVnv(TV2NV(nowit.it_value))));

if (GIMME == G_ARRAY) {

EXTEND(sp, 1);

PUSHs(sv_2mortal(newSVnv(TV2NV(nowit.it_interval))));

}

}

#endif