lib/DateTime/Lite/PP.pm

filter: Statementstmt 31.8% 73 / 229 Branchbran 1.4% 2 / 134 Conditioncond 5.7% 2 / 35 MC/DCmcdc 0.0% 0 / 21 Subroutinesub 50.0% 18 / 36 Podpod n/a totaltotal 20.8% 95 / 455 CC 80 SCAR 53.8
CC
80
Cov
19%
_leap_seconds_for
812.0
_normalize_leap_seconds
62.8
_rd2ymd
52.6
CRAP 216.8
« lib/DateTime/Lite/Duration.pm ↑ Summary lib/DateTime/Lite/TimeZone.pm »
1 ##----------------------------------------------------------------------------
2 ## Lightweight DateTime Alternative - ~/lib/DateTime/Lite/PP.pm
3 ## Version v0.1.2
4 ## Copyright(c) 2026 DEGUEST Pte. Ltd.
5 ## Author: Jacques Deguest <jack@deguest.jp>
6 ## Created 2026/04/03
7 ## Modified 2026/09/08
8 ## All rights reserved
9 ##
10 ##
11 ## This program is free software; you can redistribute it and/or modify it
12 ## under the same terms as Perl itself.
13 ##----------------------------------------------------------------------------
14 # Pure-Perl fallback implementations for all functions that are otherwise
15 # provided by the DateTime::Lite XS layer. Loaded automatically by
16 # DateTime::Lite when XSLoader fails, such as during development or on platforms
17 # without a C compiler.
18 #
19 # Each sub is injected directly into the DateTime::Lite namespace at the end
20 # of this file, so callers see them as methods on the main class.
21 ##----------------------------------------------------------------------------
22 package DateTime::Lite::PP;
23 BEGIN
24 1 ▶{
Subroutine BEGIN: called CC=3 SCAR=16.1
25 1 ▶ use v5.10.1;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 1 ▶ use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
27 1 ▶ use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
28 1 ▶ if( $] < 5.013 )
Branch: 1 branch
BranchTrueFalseTotal
if ($] < "5.013") 0 1 1
29 {
30 1 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
31 0 ▶ unless( defined( &warnings::register_categories ) )
Branch: 1 branch
BranchTrueFalseTotal
unless (defined &warnings::register_categories) 0 0 0
32 {
33 *warnings::_mkMask = sub
34 0 ▶ {
Subroutine __ANON__: not called CC=1 SCAR=6.9
35 0 my $bit = shift( @_ );
36 0 my $mask = "";
37 0 vec( $mask, $bit, 1 ) = 1;
38 0 return( $mask );
39 0 };
40  
41 *warnings::register_categories = sub
42 0 ▶ {
Subroutine __ANON__: not called CC=4 SCAR=30.0
43 0 my @names = @_;
44 0 foreach my $name ( @names )
45 {
46 0 ▶ if( !defined( $warnings::Bits{ $name } ) )
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $warnings::Bits{$name}) 0 0 0
47 {
48 0 $warnings::Offsets{ $name } = $warnings::LAST_BIT;
49 0 $warnings::Bits{ $name } = warnings::_mkMask( $warnings::LAST_BIT++ );
50 0 $warnings::DeadBits{ $name } = warnings::_mkMask( $warnings::LAST_BIT++ );
51 0 ▶ if( length( $warnings::Bits{ $name } ) > length( $warnings::Bits{all} ) )
Branch: 1 branch
BranchTrueFalseTotal
if (length $warnings::Bits{$name} > length $warnings::Bits{"all"}) 0 0 0
52 {
53 0 $warnings::Bits{all} .= "\x55";
54 0 $warnings::DeadBits{all} .= "\xaa";
55 }
56 }
57 }
58 0 };
59 }
60 }
61 1 warnings::register_categories( 'DateTime::Lite' );
62 1 our $VERSION = 'v0.1.2';
63 };
64  
65 1 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
66 1 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
67  
68 {
69 1 ▶ no warnings 'once';
Subroutine BEGIN: called CC=1 SCAR=0.0
70 1 ▶ $DateTime::Lite::IsPurePerl //= 1;
Condition50%1/2
$DateTime::Lite::IsPurePerl //= 1
l!l
10
MC/DC0%0/1
$DateTime::Lite::IsPurePerl //= 1
$DateTime::Lite::IsPurePerl
Truth table50%1/2
A
A= $DateTime::Lite::IsPurePerl
Aresult
11
00
71 }
72  
73 1 my @MonthLengths = ( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
74  
75 1 my @LeapYearMonthLengths = @MonthLengths;
76 1 $LeapYearMonthLengths[1]++;
77  
78 1 my( @EndOfLastMonthDOY, @EndOfLastMonthDOLY );
79 {
80 1 my( $x, $xl ) = ( 0, 0 );
81 1 for my $i ( 0 .. 11 )
82 {
83 12 push( @EndOfLastMonthDOY, $x );
84 12 push( @EndOfLastMonthDOLY, $xl );
85 12 $x += $MonthLengths[$i];
86 12 $xl += $LeapYearMonthLengths[$i];
87 }
88 }
89  
90 # NOTE: Leap second data - mirrors leap_seconds.h (same source as the XS path).
91 # This makes PP.pm fully self-contained without requiring DateTime::LeapSecond.
92 1 my %_EXTRA_SECONDS = (
93 720075 => +1, 720259 => +1, 720624 => +1, 720989 => +1,
94 721354 => +1, 721720 => +1, 722085 => +1, 722450 => +1,
95 722815 => +1, 723362 => +1, 723727 => +1, 724092 => +1,
96 724823 => +1, 725737 => +1, 726468 => +1, 726833 => +1,
97 727380 => +1, 727745 => +1, 728110 => +1, 728659 => +1,
98 729206 => +1, 729755 => +1, 732312 => +1, 733408 => +1,
99 734685 => +1, 735780 => +1, 736330 => +1,
100 );
101  
102 # NOTE: _accumulated_leap_seconds
103 sub _accumulated_leap_seconds
104 0 ▶{
Subroutine _accumulated_leap_seconds: not called CC=1 SCAR=6.9
105 0 shift( @_ ); # class/self
106 0 return( _leap_seconds_for( $_[0] ) );
107 }
108  
109 # NOTE: _compare_rd( self, d1, s1, ns1, d2, s2, ns2 )
110 sub _compare_rd
111 0 ▶{
Subroutine _compare_rd: not called CC=4 SCAR=30.0
112 0 my( undef, $d1, $s1, $ns1, $d2, $s2, $ns2 ) = @_;
113 0 ▶ return( $d1 != $d2 ? ( $d1 <=> $d2 )
Branch: 3 branches
BranchTrueFalseTotal
$d1 != $d2 ? : 0 0 0
$s1 != $s2 ? : 0 0 0
$ns1 != $ns2 ? : 0 0 0
114 : $s1 != $s2 ? ( $s1 <=> $s2 )
115 : $ns1 != $ns2 ? ( $ns1 <=> $ns2 )
116 : 0 );
117 }
118  
119 # NOTE: _day_length
120 sub _day_length
121 0 ▶{
Subroutine _day_length: not called CC=1 SCAR=6.9
122 0 shift( @_ );
123 0 return( _day_length_for( $_[0] ) );
124 }
125  
126 sub _day_length_for
127 0 ▶{
Subroutine _day_length_for: not called CC=2 SCAR=17.9
128 0 my $utc_rd = $_[0];
129 0 ▶ return( 86400 + ( $_EXTRA_SECONDS{ $utc_rd } // 0 ) );
Condition0%0/2
$_EXTRA_SECONDS{$utc_rd} // 0
l!l
00
MC/DC0%0/1
$_EXTRA_SECONDS{$utc_rd} // 0
$_EXTRA_SECONDS{$utc_rd}
Truth table0%0/2
A
A= $_EXTRA_SECONDS{$utc_rd}
Aresult
11
00
130 }
131  
132 # NOTE: _day_has_leap_second
133 sub _day_has_leap_second
134 0 ▶{
Subroutine _day_has_leap_second: not called CC=2 SCAR=17.9
135 0 my( undef, $utc_rd ) = @_;
136 0 ▶ return( exists( $_EXTRA_SECONDS{ $utc_rd } ) ? 1 : 0 );
Branch: 1 branch
BranchTrueFalseTotal
exists $_EXTRA_SECONDS{$utc_rd} ? : 0 0 0
137 }
138  
139 # NOTE: _epoch_to_rd( self, epoch )
140 sub _epoch_to_rd
141 0 ▶{
Subroutine _epoch_to_rd: not called CC=2 SCAR=13.4
142 0 my( undef, $epoch ) = @_;
143 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
144 0 my $d = $epoch / 86400;
145 0 my $s = $epoch - $d * 86400;
146 0 ▶ if( $s < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if ($s < 0) 0 0 0
147 {
148 0 $d--;
149 0 $s += 86400;
150 }
151 0 $d += 719163; # UNIX_EPOCH_RD_DAYS
152 0 return( $d, $s );
153 }
154  
155 # NOTE: _is_leap_year
156 sub _is_leap_year
157 0 ▶{
Subroutine _is_leap_year: not called CC=6 SCAR=37.4
158 0 my( undef, $y ) = @_;
159 # Guard against infinities
160 0 ▶ return(0) if( $y == DateTime::Lite::INFINITY() ||
Branch: 1 branch
BranchTrueFalseTotal
if $y == "Inf" or $y == "-Inf" 0 0 0
Condition0%0/3
$y == "Inf" or $y == "-Inf"
l!l&&r!l&&!r
000
MC/DC0%0/2
$y == "Inf" or $y == "-Inf"
$y == "Inf" $y == "-Inf"
Truth table0%0/3
A or B
A= $y == "Inf"B= $y == "-Inf"
ABresult
1X1
011
000
161 $y == DateTime::Lite::NEG_INFINITY() );
162 0 ▶ return(0) if( $y % 4 );
Branch: 1 branch
BranchTrueFalseTotal
if $y % 4 0 0 0
163 0 ▶ return(1) if( $y % 100 );
Branch: 1 branch
BranchTrueFalseTotal
if $y % 100 0 0 0
164 0 ▶ return(0) if( $y % 400 );
Branch: 1 branch
BranchTrueFalseTotal
if $y % 400 0 0 0
165 0 return(1);
166 }
167  
168 sub _leap_seconds_for
169 0 ▶{
Subroutine _leap_seconds_for: not called CC=28 SCAR=67.0
170 0 my $utc_rd = $_[0];
171 return(
172 0 ▶ $utc_rd >= 736330 ? 27 :
Branch: 27 branches
BranchTrueFalseTotal
$utc_rd >= 736330 ? : 0 0 0
$utc_rd >= 735780 ? : 0 0 0
$utc_rd >= 734685 ? : 0 0 0
$utc_rd >= 733408 ? : 0 0 0
$utc_rd >= 732312 ? : 0 0 0
$utc_rd >= 729755 ? : 0 0 0
$utc_rd >= 729206 ? : 0 0 0
$utc_rd >= 728659 ? : 0 0 0
$utc_rd >= 728110 ? : 0 0 0
$utc_rd >= 727745 ? : 0 0 0
$utc_rd >= 727380 ? : 0 0 0
$utc_rd >= 726833 ? : 0 0 0
$utc_rd >= 726468 ? : 0 0 0
$utc_rd >= 725737 ? : 0 0 0
$utc_rd >= 724823 ? : 0 0 0
$utc_rd >= 724092 ? : 0 0 0
$utc_rd >= 723727 ? : 0 0 0
$utc_rd >= 723362 ? : 0 0 0
$utc_rd >= 722815 ? : 0 0 0
$utc_rd >= 722450 ? : 0 0 0
$utc_rd >= 722085 ? : 0 0 0
$utc_rd >= 721720 ? : 0 0 0
$utc_rd >= 721354 ? : 0 0 0
$utc_rd >= 720989 ? : 0 0 0
$utc_rd >= 720624 ? : 0 0 0
$utc_rd >= 720259 ? : 0 0 0
$utc_rd >= 720075 ? : 0 0 0
173 $utc_rd >= 735780 ? 26 :
174 $utc_rd >= 734685 ? 25 :
175 $utc_rd >= 733408 ? 24 :
176 $utc_rd >= 732312 ? 23 :
177 $utc_rd >= 729755 ? 22 :
178 $utc_rd >= 729206 ? 21 :
179 $utc_rd >= 728659 ? 20 :
180 $utc_rd >= 728110 ? 19 :
181 $utc_rd >= 727745 ? 18 :
182 $utc_rd >= 727380 ? 17 :
183 $utc_rd >= 726833 ? 16 :
184 $utc_rd >= 726468 ? 15 :
185 $utc_rd >= 725737 ? 14 :
186 $utc_rd >= 724823 ? 13 :
187 $utc_rd >= 724092 ? 12 :
188 $utc_rd >= 723727 ? 11 :
189 $utc_rd >= 723362 ? 10 :
190 $utc_rd >= 722815 ? 9 :
191 $utc_rd >= 722450 ? 8 :
192 $utc_rd >= 722085 ? 7 :
193 $utc_rd >= 721720 ? 6 :
194 $utc_rd >= 721354 ? 5 :
195 $utc_rd >= 720989 ? 4 :
196 $utc_rd >= 720624 ? 3 :
197 $utc_rd >= 720259 ? 2 :
198 $utc_rd >= 720075 ? 1 :
199 0
200 );
201 }
202  
203 # _normalize_nanoseconds( self, \$secs, \$nanosecs )
204 #
205 # Note: the XS version modifies SVs in-place. Here we operate on the actual scalars
206 # held in the object hash and accept them as lvalue aliases via @_ aliasing.
207 sub _normalize_nanoseconds
208 0 ▶{
Subroutine _normalize_nanoseconds: not called CC=5 SCAR=30.3
209 # $_[1] = secs (aliased), $_[2] = nanosecs (aliased)
210 # Do NOT shift self - operate via @_ aliases
211 0 my $ns = $_[2];
212 0 ▶ return if( $ns >= 0 && $ns < 1_000_000_000 );
Branch: 1 branch
BranchTrueFalseTotal
if $ns >= 0 and $ns < 1000000000 0 0 0
Condition0%0/3
$ns >= 0 and $ns < 1000000000
!ll&&!rl&&r
000
MC/DC0%0/2
$ns >= 0 and $ns < 1000000000
$ns >= 0 $ns < 1000000000
Truth table0%0/3
A and B
A= $ns >= 0B= $ns < 1000000000
ABresult
0X0
100
111
213  
214 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
215 0 ▶ if( $ns < 0 )
Branch: 2 branches
BranchTrueFalseTotal
if ($ns < 0) { } 0 0 0
elsif ($ns >= 1000000000) { } 0 0 0
216 {
217 0 my $overflow = 1 + ( -$ns - 1 ) / 1_000_000_000;
218 0 $_[2] += $overflow * 1_000_000_000;
219 0 $_[1] -= $overflow;
220 }
221 elsif( $ns >= 1_000_000_000 )
222 {
223 0 my $overflow = $ns / 1_000_000_000;
224 0 $_[2] -= $overflow * 1_000_000_000;
225 0 $_[1] += $overflow;
226 }
227 }
228  
229 # NOTE: _normalize_leap_seconds( self, \$days, \$secs )
230 sub _normalize_leap_seconds
231 0 ▶{
Subroutine _normalize_leap_seconds: not called CC=9 SCAR=41.4
232 # $_[1] = days (aliased), $_[2] = secs (aliased)
233 # Short-circuit for non-finite values (Inf/-Inf from Infinite objects)
234 0 ▶ return unless( defined( $_[2] ) && ( $_[2] - $_[2] ) == 0 );
Branch: 1 branch
BranchTrueFalseTotal
unless defined $_[2] and $_[2] - $_[2] == 0 0 0 0
Condition0%0/3
defined $_[2] and $_[2] - $_[2] == 0
!ll&&!rl&&r
000
MC/DC0%0/2
defined $_[2] and $_[2] - $_[2] == 0
defined $_[2] $_[2] - $_[2] == 0
Truth table0%0/3
A and B
A= defined $_[2]B= $_[2] - $_[2] == 0
ABresult
0X0
100
111
235  
236 0 my $old_days = $_[1];
237  
238 # Step 1: fast constant-time normalisation, ignoring leap seconds.
239 # This handles large $secs values in O(1) via integer division, mirroring what
240 # _normalize_tai_seconds does.
241 # Previously, this method looped one day at a time, which allowed a caller who
242 # controls $secs (for example using $dt->add(seconds => $N) on a non-floating timezone)
243 # to hold a worker process for O(|N|/86400) iterations. This is an
244 # inefficient-algorithmic-complexity issue (CWE-407).
245 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
246 0 ▶ if( $_[2] < 0 )
Branch: 2 branches
BranchTrueFalseTotal
if ($_[2] < 0) { } 0 0 0
elsif ($_[2] >= 86400) { } 0 0 0
247 {
248 # For negative values, subtracting 86399 before dividing floors the quotient
249 # toward negative infinity under C-style truncation-toward-zero division.
250 # The same formula is used in _normalize_tai_seconds.
251 0 my $adj = ( $_[2] - 86399 ) / 86400;
252 0 $_[1] += $adj;
253 0 $_[2] -= $adj * 86400;
254 }
255 elsif( $_[2] >= 86400 )
256 {
257 0 my $adj = $_[2] / 86400;
258 0 $_[1] += $adj;
259 0 $_[2] -= $adj * 86400;
260 }
261 1 ▶ no integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
262  
263 # Step 2: correct for leap seconds that occurred in the interval we crossed during
264 # step 1. Each real leap-second day is 86401 seconds long rather than 86400, so the
265 # constant-time normalisation over-counted forward moves (or under-counted backward
266 # moves) by the number of leap seconds in the crossed interval.
267 # _leap_seconds_for() returns the cumulative count in O(1) via a bounded chain of
268 # comparisons over the IANA leap-second table (currently 27 entries covering all
269 # history since 1972).
270 0 my $new_days = $_[1];
271 0 ▶ if( $new_days > $old_days )
Branch: 2 branches
BranchTrueFalseTotal
if ($new_days > $old_days) { } 0 0 0
elsif ($new_days < $old_days) { } 0 0 0
272 {
273 # Forward: crossed days are [old_days, new_days - 1].
274 0 my $leap_delta = _leap_seconds_for( $new_days - 1 )
275 - _leap_seconds_for( $old_days - 1 );
276 0 $_[2] -= $leap_delta;
277 }
278 elsif( $new_days < $old_days )
279 {
280 # Backward: crossed days are [new_days, old_days - 1].
281 0 my $leap_delta = _leap_seconds_for( $old_days - 1 )
282 - _leap_seconds_for( $new_days - 1 );
283 0 $_[2] += $leap_delta;
284 }
285  
286 # Step 3: residual normalisation. The leap-second adjustment above may have pushed
287 # $secs slightly out of [0, day_length($days)). This loop is bounded by the total
288 # leap seconds in the crossed interval (at most 27 across all IANA history), and in
289 # practice runs at most a handful of times.
290 0 ▶ while( $_[2] < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if ($_[2] < 0) 0 0 0
291 {
292 0 my $dl = _day_length_for( $_[1] - 1 );
293 0 $_[2] += $dl;
294 0 $_[1]--;
295 }
296 0 my $dl = _day_length_for( $_[1] );
297 0 ▶ while( $_[2] > $dl - 1 )
Branch: 1 branch
BranchTrueFalseTotal
if ($_[2] > $dl - 1) 0 0 0
298 {
299 0 $_[2] -= $dl;
300 0 $_[1]++;
301 0 $dl = _day_length_for( $_[1] );
302 }
303 }
304  
305 # NOTE: _normalize_tai_seconds( self, \$days, \$secs )
306 sub _normalize_tai_seconds
307 0 ▶{
Subroutine _normalize_tai_seconds: not called CC=6 SCAR=34.1
308 # $_[1] = days (aliased), $_[2] = secs (aliased)
309 # Short-circuit for non-finite values (Inf/-Inf from Infinite objects)
310 0 ▶ return unless( defined( $_[2] ) && ( $_[2] - $_[2] ) == 0 );
Branch: 1 branch
BranchTrueFalseTotal
unless defined $_[2] and $_[2] - $_[2] == 0 0 0 0
Condition0%0/3
defined $_[2] and $_[2] - $_[2] == 0
!ll&&!rl&&r
000
MC/DC0%0/2
defined $_[2] and $_[2] - $_[2] == 0
defined $_[2] $_[2] - $_[2] == 0
Truth table0%0/3
A and B
A= defined $_[2]B= $_[2] - $_[2] == 0
ABresult
0X0
100
111
311 0 ▶ return if( $_[2] >= 0 && $_[2] < 86400 );
Branch: 1 branch
BranchTrueFalseTotal
if $_[2] >= 0 and $_[2] < 86400 0 0 0
Condition0%0/3
$_[2] >= 0 and $_[2] < 86400
!ll&&!rl&&r
000
MC/DC0%0/2
$_[2] >= 0 and $_[2] < 86400
$_[2] >= 0 $_[2] < 86400
Truth table0%0/3
A and B
A= $_[2] >= 0B= $_[2] < 86400
ABresult
0X0
100
111
312  
313 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
314 0 ▶ if( $_[2] < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if ($_[2] < 0) { } 0 0 0
315 {
316 0 my $adj = ( $_[2] - 86399 ) / 86400;
317 0 $_[1] += $adj;
318 0 $_[2] -= $adj * 86400;
319 }
320 else
321 {
322 0 my $adj = $_[2] / 86400;
323 0 $_[1] += $adj;
324 0 $_[2] -= $adj * 86400;
325 }
326 }
327  
328 # NOTE: _rd2ymd( self, $rd_days [, $extra] )
329 sub _rd2ymd
330 0 ▶{
Subroutine _rd2ymd: not called CC=8 SCAR=39.6
331 0 my $class = shift( @_ );
332 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
333  
334 0 my $d = shift( @_ );
335 0 my $rd = $d;
336  
337 0 my $yadj = 0;
338 0 my( $c, $y, $m );
339  
340 0 ▶ if( ( $d += 306 ) <= 0 )
Branch: 1 branch
BranchTrueFalseTotal
if (($d += 306) <= 0) 0 0 0
341 {
342 0 $yadj = -( -$d / 146097 + 1 );
343 0 $d -= $yadj * 146097;
344 }
345  
346 0 $c = ( $d * 4 - 1 ) / 146097;
347 0 $d -= $c * 146097 / 4;
348 0 $y = ( $d * 4 - 1 ) / 1461;
349 0 $d -= $y * 1461 / 4;
350 0 $m = ( $d * 12 + 1093 ) / 367;
351 0 $d -= ( $m * 367 - 1094 ) / 12;
352 0 $y += $c * 100 + $yadj * 400;
353  
354 0 ▶ if( $m > 12 )
Branch: 1 branch
BranchTrueFalseTotal
if ($m > 12) 0 0 0
355 {
356 0 ++$y;
357 0 $m -= 12;
358 }
359  
360 0 ▶ if( $_[0] )
Branch: 1 branch
BranchTrueFalseTotal
if ($_[0]) 0 0 0
361 {
362 0 my $dow;
363 0 ▶ if( $rd < -6 )
Branch: 1 branch
BranchTrueFalseTotal
if ($rd < -6) { } 0 0 0
364 {
365 0 $dow = ( $rd + 6 ) % 7;
366 0 ▶ $dow += $dow ? 8 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$dow ? : 0 0 0
367 }
368 else
369 {
370 0 $dow = ( ( $rd + 6 ) % 7 ) + 1;
371 }
372  
373 0 my $is_leap = _is_leap_year( undef, $y );
374 0 ▶ my $doy = ( $is_leap ? $EndOfLastMonthDOLY[$m - 1] : $EndOfLastMonthDOY[$m - 1] ) + $d;
Branch: 1 branch
BranchTrueFalseTotal
$is_leap ? : 0 0 0
375  
376 0 my $quarter;
377 {
378 0 ▶ no integer;
Subroutine BEGIN: called CC=1 SCAR=0.2
379 0 $quarter = int( ( 1 / 3.1 ) * $m ) + 1;
380 }
381  
382 0 my $qm = ( 3 * $quarter ) - 2;
383 0 ▶ my $doq = $doy - ( $is_leap ? $EndOfLastMonthDOLY[$qm - 1] : $EndOfLastMonthDOY[$qm - 1] );
Branch: 1 branch
BranchTrueFalseTotal
$is_leap ? : 0 0 0
384  
385 0 return( $y, $m, $d, $dow, $doy, $quarter, $doq );
386 }
387  
388 0 return( $y, $m, $d );
389 }
390  
391 # NOTE: _rd_to_epoch( self, $rd_days, $rd_secs )
392 sub _rd_to_epoch
393 0 ▶{
Subroutine _rd_to_epoch: not called CC=1 SCAR=6.9
394 0 my( undef, $rd_days, $rd_secs ) = @_;
395 0 return( ( $rd_days - 719163 ) * 86400 + $rd_secs );
396 }
397  
398 # NOTE: _seconds_as_components( self, $secs [, $utc_secs [, $modifier]] )
399 sub _seconds_as_components
400 0 ▶{
Subroutine _seconds_as_components: not called CC=7 SCAR=37.7
401 0 shift( @_ );
402 0 my $secs = shift( @_ );
403 0 ▶ my $utc_secs = shift( @_ ) // 0;
Condition0%0/2
shift @_ // 0
l!l
00
MC/DC0%0/1
shift @_ // 0
shift @_
Truth table0%0/2
A
A= shift @_
Aresult
11
00
404 0 ▶ my $modifier = shift( @_ ) // 0;
Condition0%0/2
shift @_ // 0
l!l
00
MC/DC0%0/1
shift @_ // 0
shift @_
Truth table0%0/2
A
A= shift @_
Aresult
11
00
405  
406 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
407  
408 0 $secs -= $modifier;
409  
410 0 my $hour = $secs / 3600;
411 0 $secs -= $hour * 3600;
412 0 my $minute = $secs / 60;
413 0 my $second = $secs - ( $minute * 60 );
414  
415 0 ▶ if( $utc_secs && $utc_secs >= 86400 )
Branch: 1 branch
BranchTrueFalseTotal
if ($utc_secs and $utc_secs >= 86400) 0 0 0
Condition0%0/3
$utc_secs and $utc_secs >= 86400
!ll&&!rl&&r
000
MC/DC0%0/2
$utc_secs and $utc_secs >= 86400
$utc_secs $utc_secs >= 86400
Truth table0%0/3
A and B
A= $utc_secsB= $utc_secs >= 86400
ABresult
0X0
100
111
416 {
417 0 ▶ die( "Invalid UTC RD seconds value: $utc_secs" ) if( $utc_secs > 86401 );
Branch: 1 branch
BranchTrueFalseTotal
if $utc_secs > 86401 0 0 0
418 0 $second += $utc_secs - 86400 + 60;
419 0 $minute = 59;
420 0 $hour--;
421 0 ▶ $hour = 23 if( $hour < 0 );
Branch: 1 branch
BranchTrueFalseTotal
if $hour < 0 0 0 0
422 }
423  
424 0 return( $hour, $minute, $second );
425 }
426  
427 # NOTE: _time_as_seconds( self, $h, $m, $s )
428 sub _time_as_seconds
429 0 ▶{
Subroutine _time_as_seconds: not called CC=4 SCAR=30.0
430 0 shift( @_ );
431 0 my( $h, $m, $s ) = @_;
432 0 ▶ $h //= 0;
Condition0%0/2
$h //= 0
l!l
00
MC/DC0%0/1
$h //= 0
$h
Truth table0%0/2
A
A= $h
Aresult
11
00
433 0 ▶ $m //= 0;
Condition0%0/2
$m //= 0
l!l
00
MC/DC0%0/1
$m //= 0
$m
Truth table0%0/2
A
A= $m
Aresult
11
00
434 0 ▶ $s //= 0;
Condition0%0/2
$s //= 0
l!l
00
MC/DC0%0/1
$s //= 0
$s
Truth table0%0/2
A
A= $s
Aresult
11
00
435 0 return( $h * 3600 + $m * 60 + $s );
436 }
437  
438 # NOTE: _ymd2rd( self, $y, $m, $d )
439 sub _ymd2rd
440 0 ▶{
Subroutine _ymd2rd: not called CC=4 SCAR=26.6
441 0 shift( @_ );
442 1 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
443 0 my( $y, $m, $d ) = @_;
444 0 my $adj;
445  
446 0 ▶ if( $m <= 2 )
Branch: 2 branches
BranchTrueFalseTotal
if ($m <= 2) { } 0 0 0
elsif ($m > 14) { } 0 0 0
447 {
448 0 $y -= ( $adj = ( 14 - $m ) / 12 );
449 0 $m += 12 * $adj;
450 }
451 elsif( $m > 14 )
452 {
453 0 $y += ( $adj = ( $m - 3 ) / 12 );
454 0 $m -= 12 * $adj;
455 }
456  
457 0 ▶ if( $y < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if ($y < 0) 0 0 0
458 {
459 0 $d -= 146097 * ( $adj = ( 399 - $y ) / 400 );
460 0 $y += 400 * $adj;
461 }
462  
463 0 $d += ( $m * 367 - 1094 ) / 12
464 + $y % 100 * 1461 / 4
465 + ( $y / 100 * 36524 + $y / 400 )
466 - 306;
467 0 return( $d );
468 }
469  
470 # NOTE: Inject all subs into DateTime::Lite's namespace
471 1 my @subs = qw(
472 _accumulated_leap_seconds
473 _compare_rd
474 _day_has_leap_second
475 _day_length
476 _epoch_to_rd
477 _is_leap_year
478 _normalize_leap_seconds
479 _normalize_nanoseconds
480 _normalize_tai_seconds
481 _rd2ymd
482 _rd_to_epoch
483 _seconds_as_components
484 _time_as_seconds
485 _ymd2rd
486 );
487  
488 1 foreach my $sub ( @subs )
489 {
490 1 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
491 14 my $target = 'DateTime::Lite::' . $sub;
492 # Install the PP fallback if either:
493 # - We are running in pure-Perl mode ($IsPurePerl = 1). This guarantees the
494 # fallback is in place even if XS loading partially populated the DateTime::Lite::
495 # namespace with empty XSUB stubs before failing (observed on MSWin32 with
496 # Strawberry Perl 5.14 to 5.20).
497 # - The XS version has not populated the glob (normal path).
498 14 ▶ if( $DateTime::Lite::IsPurePerl || !defined( &{ $target } ) )
Branch: 1 branch
BranchTrueFalseTotal
if ($DateTime::Lite::IsPurePerl or not defined &{$target;}) 0 14 14
Condition33%1/3
$DateTime::Lite::IsPurePerl or not defined &{$target;}
l!l&&r!l&&!r
0014
MC/DC0%0/2
$DateTime::Lite::IsPurePerl or not defined &{$target;}
$DateTime::Lite::IsPurePerl not defined &{$target;}
Truth table33%1/3
A or not(B)
A= $DateTime::Lite::IsPurePerlB= not defined &{$target;}
ABresult
1X1
011
000
499 {
500 0 *{ $target } = __PACKAGE__->can( $sub );
501 }
502 }
503  
504 1 1;
505 # NOTE: POD
506 __END__
« lib/DateTime/Lite/Duration.pm ↑ Summary lib/DateTime/Lite/TimeZone.pm »