This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
cf64bc1fbba4deee779418d5b500a0837c5bb020
[perl5.git] / cpan / Time-HiRes / HiRes.pm
1 package Time::HiRes;
2
3 { use 5.006; }
4 use strict;
5
6 require Exporter;
7 require DynaLoader;
8
9 our @ISA = qw(Exporter DynaLoader);
10
11 our @EXPORT = qw( );
12 our @EXPORT_OK = qw (usleep sleep ualarm alarm gettimeofday time tv_interval
13                  getitimer setitimer nanosleep clock_gettime clock_getres
14                  clock clock_nanosleep
15                  CLOCK_HIGHRES CLOCK_MONOTONIC CLOCK_PROCESS_CPUTIME_ID
16                  CLOCK_REALTIME CLOCK_SOFTTIME CLOCK_THREAD_CPUTIME_ID
17                  CLOCK_TIMEOFDAY CLOCKS_PER_SEC
18                  ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF
19                  TIMER_ABSTIME
20                  d_usleep d_ualarm d_gettimeofday d_getitimer d_setitimer
21                  d_nanosleep d_clock_gettime d_clock_getres
22                  d_clock d_clock_nanosleep
23                  stat lstat
24                 );
25
26 our $VERSION = '1.9726';
27 our $XS_VERSION = $VERSION;
28 $VERSION = eval $VERSION;
29
30 our $AUTOLOAD;
31 sub AUTOLOAD {
32     my $constname;
33     ($constname = $AUTOLOAD) =~ s/.*:://;
34     # print "AUTOLOAD: constname = $constname ($AUTOLOAD)\n";
35     die "&Time::HiRes::constant not defined" if $constname eq 'constant';
36     my ($error, $val) = constant($constname);
37     # print "AUTOLOAD: error = $error, val = $val\n";
38     if ($error) {
39         my (undef,$file,$line) = caller;
40         die "$error at $file line $line.\n";
41     }
42     {
43         no strict 'refs';
44         *$AUTOLOAD = sub { $val };
45     }
46     goto &$AUTOLOAD;
47 }
48
49 sub import {
50     my $this = shift;
51     for my $i (@_) {
52         if (($i eq 'clock_getres'    && !&d_clock_getres)    ||
53             ($i eq 'clock_gettime'   && !&d_clock_gettime)   ||
54             ($i eq 'clock_nanosleep' && !&d_clock_nanosleep) ||
55             ($i eq 'clock'           && !&d_clock)           ||
56             ($i eq 'nanosleep'       && !&d_nanosleep)       ||
57             ($i eq 'usleep'          && !&d_usleep)          ||
58             ($i eq 'ualarm'          && !&d_ualarm)) {
59             require Carp;
60             Carp::croak("Time::HiRes::$i(): unimplemented in this platform");
61         }
62     }
63     Time::HiRes->export_to_level(1, $this, @_);
64 }
65
66 bootstrap Time::HiRes;
67
68 # Preloaded methods go here.
69
70 sub tv_interval {
71     # probably could have been done in C
72     my ($a, $b) = @_;
73     $b = [gettimeofday()] unless defined($b);
74     (${$b}[0] - ${$a}[0]) + ((${$b}[1] - ${$a}[1]) / 1_000_000);
75 }
76
77 # Autoload methods go after =cut, and are processed by the autosplit program.
78
79 1;
80 __END__
81
82 =head1 NAME
83
84 Time::HiRes - High resolution alarm, sleep, gettimeofday, interval timers
85
86 =head1 SYNOPSIS
87
88   use Time::HiRes qw( usleep ualarm gettimeofday tv_interval nanosleep
89                       clock_gettime clock_getres clock_nanosleep clock
90                       stat lstat );
91
92   usleep ($microseconds);
93   nanosleep ($nanoseconds);
94
95   ualarm ($microseconds);
96   ualarm ($microseconds, $interval_microseconds);
97
98   $t0 = [gettimeofday];
99   ($seconds, $microseconds) = gettimeofday;
100
101   $elapsed = tv_interval ( $t0, [$seconds, $microseconds]);
102   $elapsed = tv_interval ( $t0, [gettimeofday]);
103   $elapsed = tv_interval ( $t0 );
104
105   use Time::HiRes qw ( time alarm sleep );
106
107   $now_fractions = time;
108   sleep ($floating_seconds);
109   alarm ($floating_seconds);
110   alarm ($floating_seconds, $floating_interval);
111
112   use Time::HiRes qw( setitimer getitimer );
113
114   setitimer ($which, $floating_seconds, $floating_interval );
115   getitimer ($which);
116
117   use Time::HiRes qw( clock_gettime clock_getres clock_nanosleep
118                       ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF );
119
120   $realtime   = clock_gettime(CLOCK_REALTIME);
121   $resolution = clock_getres(CLOCK_REALTIME);
122
123   clock_nanosleep(CLOCK_REALTIME, 1.5e9);
124   clock_nanosleep(CLOCK_REALTIME, time()*1e9 + 10e9, TIMER_ABSTIME);
125
126   my $ticktock = clock();
127
128   use Time::HiRes qw( stat lstat );
129
130   my @stat = stat("file");
131   my @stat = stat(FH);
132   my @stat = lstat("file");
133
134 =head1 DESCRIPTION
135
136 The C<Time::HiRes> module implements a Perl interface to the
137 C<usleep>, C<nanosleep>, C<ualarm>, C<gettimeofday>, and
138 C<setitimer>/C<getitimer> system calls, in other words, high
139 resolution time and timers. See the L</EXAMPLES> section below and the
140 test scripts for usage; see your system documentation for the
141 description of the underlying C<nanosleep> or C<usleep>, C<ualarm>,
142 C<gettimeofday>, and C<setitimer>/C<getitimer> calls.
143
144 If your system lacks C<gettimeofday()> or an emulation of it you don't
145 get C<gettimeofday()> or the one-argument form of C<tv_interval()>.
146 If your system lacks all of C<nanosleep()>, C<usleep()>,
147 C<select()>, and C<poll>, you don't get C<Time::HiRes::usleep()>,
148 C<Time::HiRes::nanosleep()>, or C<Time::HiRes::sleep()>.
149 If your system lacks both C<ualarm()> and C<setitimer()> you don't get
150 C<Time::HiRes::ualarm()> or C<Time::HiRes::alarm()>.
151
152 If you try to import an unimplemented function in the C<use> statement
153 it will fail at compile time.
154
155 If your subsecond sleeping is implemented with C<nanosleep()> instead
156 of C<usleep()>, you can mix subsecond sleeping with signals since
157 C<nanosleep()> does not use signals.  This, however, is not portable,
158 and you should first check for the truth value of
159 C<&Time::HiRes::d_nanosleep> to see whether you have nanosleep, and
160 then carefully read your C<nanosleep()> C API documentation for any
161 peculiarities.
162
163 If you are using C<nanosleep> for something else than mixing sleeping
164 with signals, give some thought to whether Perl is the tool you should
165 be using for work requiring nanosecond accuracies.
166
167 Remember that unless you are working on a I<hard realtime> system,
168 any clocks and timers will be imprecise, especially so if you are working
169 in a pre-emptive multiuser system.  Understand the difference between
170 I<wallclock time> and process time (in UNIX-like systems the sum of
171 I<user> and I<system> times).  Any attempt to sleep for X seconds will
172 most probably end up sleeping B<more> than that, but don't be surprised
173 if you end up sleeping slightly B<less>.
174
175 The following functions can be imported from this module.
176 No functions are exported by default.
177
178 =over 4
179
180 =item gettimeofday ()
181
182 In array context returns a two-element array with the seconds and
183 microseconds since the epoch.  In scalar context returns floating
184 seconds like C<Time::HiRes::time()> (see below).
185
186 =item usleep ( $useconds )
187
188 Sleeps for the number of microseconds (millionths of a second)
189 specified.  Returns the number of microseconds actually slept.
190 Can sleep for more than one second, unlike the C<usleep> system call.
191 Can also sleep for zero seconds, which often works like a I<thread yield>.
192 See also C<Time::HiRes::usleep()>, C<Time::HiRes::sleep()>, and
193 C<Time::HiRes::clock_nanosleep()>.
194
195 Do not expect usleep() to be exact down to one microsecond.
196
197 =item nanosleep ( $nanoseconds )
198
199 Sleeps for the number of nanoseconds (1e9ths of a second) specified.
200 Returns the number of nanoseconds actually slept (accurate only to
201 microseconds, the nearest thousand of them).  Can sleep for more than
202 one second.  Can also sleep for zero seconds, which often works like
203 a I<thread yield>.  See also C<Time::HiRes::sleep()>,
204 C<Time::HiRes::usleep()>, and C<Time::HiRes::clock_nanosleep()>.
205
206 Do not expect nanosleep() to be exact down to one nanosecond.
207 Getting even accuracy of one thousand nanoseconds is good.
208
209 =item ualarm ( $useconds [, $interval_useconds ] )
210
211 Issues a C<ualarm> call; the C<$interval_useconds> is optional and
212 will be zero if unspecified, resulting in C<alarm>-like behaviour.
213
214 Returns the remaining time in the alarm in microseconds, or C<undef>
215 if an error occurred.
216
217 ualarm(0) will cancel an outstanding ualarm().
218
219 Note that the interaction between alarms and sleeps is unspecified.
220
221 =item tv_interval 
222
223 tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] )
224
225 Returns the floating seconds between the two times, which should have
226 been returned by C<gettimeofday()>. If the second argument is omitted,
227 then the current time is used.
228
229 =item time ()
230
231 Returns a floating seconds since the epoch. This function can be
232 imported, resulting in a nice drop-in replacement for the C<time>
233 provided with core Perl; see the L</EXAMPLES> below.
234
235 B<NOTE 1>: This higher resolution timer can return values either less
236 or more than the core C<time()>, depending on whether your platform
237 rounds the higher resolution timer values up, down, or to the nearest second
238 to get the core C<time()>, but naturally the difference should be never
239 more than half a second.  See also L</clock_getres>, if available
240 in your system.
241
242 B<NOTE 2>: Since Sunday, September 9th, 2001 at 01:46:40 AM GMT, when
243 the C<time()> seconds since epoch rolled over to 1_000_000_000, the
244 default floating point format of Perl and the seconds since epoch have
245 conspired to produce an apparent bug: if you print the value of
246 C<Time::HiRes::time()> you seem to be getting only five decimals, not
247 six as promised (microseconds).  Not to worry, the microseconds are
248 there (assuming your platform supports such granularity in the first
249 place).  What is going on is that the default floating point format of
250 Perl only outputs 15 digits.  In this case that means ten digits
251 before the decimal separator and five after.  To see the microseconds
252 you can use either C<printf>/C<sprintf> with C<"%.6f">, or the
253 C<gettimeofday()> function in list context, which will give you the
254 seconds and microseconds as two separate values.
255
256 =item sleep ( $floating_seconds )
257
258 Sleeps for the specified amount of seconds.  Returns the number of
259 seconds actually slept (a floating point value).  This function can
260 be imported, resulting in a nice drop-in replacement for the C<sleep>
261 provided with perl, see the L</EXAMPLES> below.
262
263 Note that the interaction between alarms and sleeps is unspecified.
264
265 =item alarm ( $floating_seconds [, $interval_floating_seconds ] )
266
267 The C<SIGALRM> signal is sent after the specified number of seconds.
268 Implemented using C<setitimer()> if available, C<ualarm()> if not.
269 The C<$interval_floating_seconds> argument is optional and will be
270 zero if unspecified, resulting in C<alarm()>-like behaviour.  This
271 function can be imported, resulting in a nice drop-in replacement for
272 the C<alarm> provided with perl, see the L</EXAMPLES> below.
273
274 Returns the remaining time in the alarm in seconds, or C<undef>
275 if an error occurred.
276
277 B<NOTE 1>: With some combinations of operating systems and Perl
278 releases C<SIGALRM> restarts C<select()>, instead of interrupting it.
279 This means that an C<alarm()> followed by a C<select()> may together
280 take the sum of the times specified for the C<alarm()> and the
281 C<select()>, not just the time of the C<alarm()>.
282
283 Note that the interaction between alarms and sleeps is unspecified.
284
285 =item setitimer ( $which, $floating_seconds [, $interval_floating_seconds ] )
286
287 Start up an interval timer: after a certain time, a signal ($which) arrives,
288 and more signals may keep arriving at certain intervals.  To disable
289 an "itimer", use C<$floating_seconds> of zero.  If the
290 C<$interval_floating_seconds> is set to zero (or unspecified), the
291 timer is disabled B<after> the next delivered signal.
292
293 Use of interval timers may interfere with C<alarm()>, C<sleep()>,
294 and C<usleep()>.  In standard-speak the "interaction is unspecified",
295 which means that I<anything> may happen: it may work, it may not.
296
297 In scalar context, the remaining time in the timer is returned.
298
299 In list context, both the remaining time and the interval are returned.
300
301 There are usually three or four interval timers (signals) available: the
302 C<$which> can be C<ITIMER_REAL>, C<ITIMER_VIRTUAL>, C<ITIMER_PROF>, or
303 C<ITIMER_REALPROF>.  Note that which ones are available depends: true
304 UNIX platforms usually have the first three, but only Solaris seems to
305 have C<ITIMER_REALPROF> (which is used to profile multithreaded programs).
306 Win32 unfortunately does not have interval timers.
307
308 C<ITIMER_REAL> results in C<alarm()>-like behaviour.  Time is counted in
309 I<real time>; that is, wallclock time.  C<SIGALRM> is delivered when
310 the timer expires.
311
312 C<ITIMER_VIRTUAL> counts time in (process) I<virtual time>; that is,
313 only when the process is running.  In multiprocessor/user/CPU systems
314 this may be more or less than real or wallclock time.  (This time is
315 also known as the I<user time>.)  C<SIGVTALRM> is delivered when the
316 timer expires.
317
318 C<ITIMER_PROF> counts time when either the process virtual time or when
319 the operating system is running on behalf of the process (such as I/O).
320 (This time is also known as the I<system time>.)  (The sum of user
321 time and system time is known as the I<CPU time>.)  C<SIGPROF> is
322 delivered when the timer expires.  C<SIGPROF> can interrupt system calls.
323
324 The semantics of interval timers for multithreaded programs are
325 system-specific, and some systems may support additional interval
326 timers.  For example, it is unspecified which thread gets the signals.
327 See your C<setitimer()> documentation.
328
329 =item getitimer ( $which )
330
331 Return the remaining time in the interval timer specified by C<$which>.
332
333 In scalar context, the remaining time is returned.
334
335 In list context, both the remaining time and the interval are returned.
336 The interval is always what you put in using C<setitimer()>.
337
338 =item clock_gettime ( $which )
339
340 Return as seconds the current value of the POSIX high resolution timer
341 specified by C<$which>.  All implementations that support POSIX high
342 resolution timers are supposed to support at least the C<$which> value
343 of C<CLOCK_REALTIME>, which is supposed to return results close to the
344 results of C<gettimeofday>, or the number of seconds since 00:00:00:00
345 January 1, 1970 Greenwich Mean Time (GMT).  Do not assume that
346 CLOCK_REALTIME is zero, it might be one, or something else.
347 Another potentially useful (but not available everywhere) value is
348 C<CLOCK_MONOTONIC>, which guarantees a monotonically increasing time
349 value (unlike time() or gettimeofday(), which can be adjusted).
350 See your system documentation for other possibly supported values.
351
352 =item clock_getres ( $which )
353
354 Return as seconds the resolution of the POSIX high resolution timer
355 specified by C<$which>.  All implementations that support POSIX high
356 resolution timers are supposed to support at least the C<$which> value
357 of C<CLOCK_REALTIME>, see L</clock_gettime>.
358
359 =item clock_nanosleep ( $which, $nanoseconds, $flags = 0)
360
361 Sleeps for the number of nanoseconds (1e9ths of a second) specified.
362 Returns the number of nanoseconds actually slept.  The $which is the
363 "clock id", as with clock_gettime() and clock_getres().  The flags
364 default to zero but C<TIMER_ABSTIME> can specified (must be exported
365 explicitly) which means that C<$nanoseconds> is not a time interval
366 (as is the default) but instead an absolute time.  Can sleep for more
367 than one second.  Can also sleep for zero seconds, which often works
368 like a I<thread yield>.  See also C<Time::HiRes::sleep()>,
369 C<Time::HiRes::usleep()>, and C<Time::HiRes::nanosleep()>.
370
371 Do not expect clock_nanosleep() to be exact down to one nanosecond.
372 Getting even accuracy of one thousand nanoseconds is good.
373
374 =item clock()
375
376 Return as seconds the I<process time> (user + system time) spent by
377 the process since the first call to clock() (the definition is B<not>
378 "since the start of the process", though if you are lucky these times
379 may be quite close to each other, depending on the system).  What this
380 means is that you probably need to store the result of your first call
381 to clock(), and subtract that value from the following results of clock().
382
383 The time returned also includes the process times of the terminated
384 child processes for which wait() has been executed.  This value is
385 somewhat like the second value returned by the times() of core Perl,
386 but not necessarily identical.  Note that due to backward
387 compatibility limitations the returned value may wrap around at about
388 2147 seconds or at about 36 minutes.
389
390 =item stat
391
392 =item stat FH
393
394 =item stat EXPR
395
396 =item lstat
397
398 =item lstat FH
399
400 =item lstat EXPR
401
402 As L<perlfunc/stat> or L<perlfunc/lstat>
403 but with the access/modify/change file timestamps
404 in subsecond resolution, if the operating system and the filesystem
405 both support such timestamps.  To override the standard stat():
406
407     use Time::HiRes qw(stat);
408
409 Test for the value of &Time::HiRes::d_hires_stat to find out whether
410 the operating system supports subsecond file timestamps: a value
411 larger than zero means yes. There are unfortunately no easy
412 ways to find out whether the filesystem supports such timestamps.
413 UNIX filesystems often do; NTFS does; FAT doesn't (FAT timestamp
414 granularity is B<two> seconds).
415
416 A zero return value of &Time::HiRes::d_hires_stat means that
417 Time::HiRes::stat is a no-op passthrough for CORE::stat()
418 (and likewise for lstat),
419 and therefore the timestamps will stay integers.  The same
420 thing will happen if the filesystem does not do subsecond timestamps,
421 even if the &Time::HiRes::d_hires_stat is non-zero.
422
423 In any case do not expect nanosecond resolution, or even a microsecond
424 resolution.  Also note that the modify/access timestamps might have
425 different resolutions, and that they need not be synchronized, e.g.
426 if the operations are
427
428     write
429     stat # t1
430     read
431     stat # t2
432
433 the access time stamp from t2 need not be greater-than the modify
434 time stamp from t1: it may be equal or I<less>.
435
436 =back
437
438 =head1 EXAMPLES
439
440   use Time::HiRes qw(usleep ualarm gettimeofday tv_interval);
441
442   $microseconds = 750_000;
443   usleep($microseconds);
444
445   # signal alarm in 2.5s & every .1s thereafter
446   ualarm(2_500_000, 100_000);
447   # cancel that ualarm
448   ualarm(0);
449
450   # get seconds and microseconds since the epoch
451   ($s, $usec) = gettimeofday();
452
453   # measure elapsed time 
454   # (could also do by subtracting 2 gettimeofday return values)
455   $t0 = [gettimeofday];
456   # do bunch of stuff here
457   $t1 = [gettimeofday];
458   # do more stuff here
459   $t0_t1 = tv_interval $t0, $t1;
460
461   $elapsed = tv_interval ($t0, [gettimeofday]);
462   $elapsed = tv_interval ($t0); # equivalent code
463
464   #
465   # replacements for time, alarm and sleep that know about
466   # floating seconds
467   #
468   use Time::HiRes;
469   $now_fractions = Time::HiRes::time;
470   Time::HiRes::sleep (2.5);
471   Time::HiRes::alarm (10.6666666);
472
473   use Time::HiRes qw ( time alarm sleep );
474   $now_fractions = time;
475   sleep (2.5);
476   alarm (10.6666666);
477
478   # Arm an interval timer to go off first at 10 seconds and
479   # after that every 2.5 seconds, in process virtual time
480
481   use Time::HiRes qw ( setitimer ITIMER_VIRTUAL time );
482
483   $SIG{VTALRM} = sub { print time, "\n" };
484   setitimer(ITIMER_VIRTUAL, 10, 2.5);
485
486   use Time::HiRes qw( clock_gettime clock_getres CLOCK_REALTIME );
487   # Read the POSIX high resolution timer.
488   my $high = clock_gettime(CLOCK_REALTIME);
489   # But how accurate we can be, really?
490   my $reso = clock_getres(CLOCK_REALTIME);
491
492   use Time::HiRes qw( clock_nanosleep TIMER_ABSTIME );
493   clock_nanosleep(CLOCK_REALTIME, 1e6);
494   clock_nanosleep(CLOCK_REALTIME, 2e9, TIMER_ABSTIME);
495
496   use Time::HiRes qw( clock );
497   my $clock0 = clock();
498   ... # Do something.
499   my $clock1 = clock();
500   my $clockd = $clock1 - $clock0;
501
502   use Time::HiRes qw( stat );
503   my ($atime, $mtime, $ctime) = (stat("istics"))[8, 9, 10];
504
505 =head1 C API
506
507 In addition to the perl API described above, a C API is available for
508 extension writers.  The following C functions are available in the
509 modglobal hash:
510
511   name             C prototype
512   ---------------  ----------------------
513   Time::NVtime     double (*)()
514   Time::U2time     void (*)(pTHX_ UV ret[2])
515
516 Both functions return equivalent information (like C<gettimeofday>)
517 but with different representations.  The names C<NVtime> and C<U2time>
518 were selected mainly because they are operating system independent.
519 (C<gettimeofday> is Unix-centric, though some platforms like Win32 and
520 VMS have emulations for it.)
521
522 Here is an example of using C<NVtime> from C:
523
524   double (*myNVtime)(); /* Returns -1 on failure. */
525   SV **svp = hv_fetch(PL_modglobal, "Time::NVtime", 12, 0);
526   if (!svp)         croak("Time::HiRes is required");
527   if (!SvIOK(*svp)) croak("Time::NVtime isn't a function pointer");
528   myNVtime = INT2PTR(double(*)(), SvIV(*svp));
529   printf("The current time is: %f\n", (*myNVtime)());
530
531 =head1 DIAGNOSTICS
532
533 =head2 useconds or interval more than ...
534
535 In ualarm() you tried to use number of microseconds or interval (also
536 in microseconds) more than 1_000_000 and setitimer() is not available
537 in your system to emulate that case.
538
539 =head2 negative time not invented yet
540
541 You tried to use a negative time argument.
542
543 =head2 internal error: useconds < 0 (unsigned ... signed ...)
544
545 Something went horribly wrong-- the number of microseconds that cannot
546 become negative just became negative.  Maybe your compiler is broken?
547
548 =head2 useconds or uinterval equal to or more than 1000000
549
550 In some platforms it is not possible to get an alarm with subsecond
551 resolution and later than one second.
552
553 =head2 unimplemented in this platform
554
555 Some calls simply aren't available, real or emulated, on every platform.
556
557 =head1 CAVEATS
558
559 Notice that the core C<time()> maybe rounding rather than truncating.
560 What this means is that the core C<time()> may be reporting the time
561 as one second later than C<gettimeofday()> and C<Time::HiRes::time()>.
562
563 Adjusting the system clock (either manually or by services like ntp)
564 may cause problems, especially for long running programs that assume
565 a monotonously increasing time (note that all platforms do not adjust
566 time as gracefully as UNIX ntp does).  For example in Win32 (and derived
567 platforms like Cygwin and MinGW) the Time::HiRes::time() may temporarily
568 drift off from the system clock (and the original time())  by up to 0.5
569 seconds. Time::HiRes will notice this eventually and recalibrate.
570 Note that since Time::HiRes 1.77 the clock_gettime(CLOCK_MONOTONIC)
571 might help in this (in case your system supports CLOCK_MONOTONIC).
572
573 Some systems have APIs but not implementations: for example QNX and Haiku
574 have the interval timer APIs but not the functionality.
575
576 =head1 SEE ALSO
577
578 Perl modules L<BSD::Resource>, L<Time::TAI64>.
579
580 Your system documentation for C<clock>, C<clock_gettime>,
581 C<clock_getres>, C<clock_nanosleep>, C<clock_settime>, C<getitimer>,
582 C<gettimeofday>, C<setitimer>, C<sleep>, C<stat>, C<ualarm>.
583
584 =head1 AUTHORS
585
586 D. Wegscheid <wegscd@whirlpool.com>
587 R. Schertler <roderick@argon.org>
588 J. Hietaniemi <jhi@iki.fi>
589 G. Aas <gisle@aas.no>
590
591 =head1 COPYRIGHT AND LICENSE
592
593 Copyright (c) 1996-2002 Douglas E. Wegscheid.  All rights reserved.
594
595 Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 Jarkko Hietaniemi.
596 All rights reserved.
597
598 Copyright (C) 2011, 2012, 2013 Andrew Main (Zefram) <zefram@fysh.org>
599
600 This program is free software; you can redistribute it and/or modify
601 it under the same terms as Perl itself.
602
603 =cut