DateTime-Lite.xs

filter: Statementstmt 83.4% 166 / 199 Branchbran 36.6% 142 / 388 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 52.4% 308 / 587 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« lib/DateTime/Lite/Infinite.pm ↑ Summary dtl_posix.h »
1 /*---------------------------------------------------------------------------
2 * DateTime::Lite - DateTime-Lite.xs
3 * Version v0.1.1
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 *
9 * XS implementations of keys functions for DateTime-Lite.
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 #include "EXTERN.h"
15 #include "perl.h"
16 #include "XSUB.h"
17 #include "ppport.h"
18 #include "dtl_posix.h"
19  
20 #include <stdlib.h>
21 #include <math.h>
22  
23 /* This file is generated by scripts/leap_seconds_header.pl */
24 #include "leap_seconds.h"
25  
26 #if defined(WIN32)
27 # include <math.h>
28 # include <float.h>
29 # define dtl_isfinite(x) _finite(x)
30 #elif defined(PERL_DARWIN)
31 # include <math.h>
32 # define dtl_isfinite(x) isfinite(x)
33 #else
34 # define dtl_isfinite Perl_isfinite
35 #endif
36  
37 #define DAYS_PER_400_YEARS 146097
38 #define DAYS_PER_4_YEARS 1461
39 #define MARCH_1 306
40  
41 #define SECONDS_PER_DAY 86400
42 #define MAX_NANOSECONDS 1000000000
43  
44 /* Ratnum: RD day 719163 = 1970-01-01 (Unix epoch) */
45 #define UNIX_EPOCH_RD_DAYS 719163
46  
47 const int PREVIOUS_MONTH_DOY[12] = { 0,
48 31,
49 59,
50 90,
51 120,
52 151,
53 181,
54 212,
55 243,
56 273,
57 304,
58 334 };
59  
60 const int PREVIOUS_MONTH_DOLY[12] = { 0,
61 31,
62 60,
63 91,
64 121,
65 152,
66 182,
67 213,
68 244,
69 274,
70 305,
71 335 };
72  
73  
74 static IV
75 274 _real_is_leap_year(IV y)
76 {
77 /* See http://www.perlmonks.org/?node_id=274247 for where this silliness comes from */
78 274 ▶ return (y % 4) ? 0 : (y % 100) ? 1 : (y % 400) ? 0 : 1;
Branch: 3 branches
BranchTrueFalseTotal
return (y % 4) ? 0 : (y % 100) ? 1 : (y % 400) ? 0 : 1; 33 241 274
return (y % 4) ? 0 : (y % 100) ? 1 : (y % 400) ? 0 : 1; 9 24 33
return (y % 4) ? 0 : (y % 100) ? 1 : (y % 400) ? 0 : 1; 4 5 9
79 }
80  
81 /*-------------------------------------------------------------------
82 * dtl_clone_flat_hv( src )
83 *
84 * Copies a hashref whose values are all scalars (no nested refs).
85 * Used by clone() to duplicate the tz and locale blessed hashrefs,
86 * and the local_c cache hashref, all of which contain only scalar
87 * values at the time of cloning.
88 *-------------------------------------------------------------------*/
89 static HV *
90 186 dtl_clone_flat_hv(HV *src)
91 {
92 HV *dst;
93 HE *entry;
94  
95 186 dst = newHV();
96  
97 /* Pre-size to avoid incremental bucket resizing */
98 186 ▶ if( HvKEYS(src) > 0 )
Branch: 2 branches
BranchTrueFalseTotal
if( HvKEYS(src) > 0 ) 0 186 186
if( HvKEYS(src) > 0 ) 186 0 186
99 186 ▶ hv_ksplit(dst, HvKEYS(src));
Branch: 1 branch
BranchTrueFalseTotal
hv_ksplit(dst, HvKEYS(src)); 0 186 186
100  
101 186 hv_iterinit(src);
102 1612 ▶ while( ( entry = hv_iternext(src) ) )
Branch: 1 branch
BranchTrueFalseTotal
while( ( entry = hv_iternext(src) ) ) 1426 186 1612
103 {
104 1426 I32 klen = HeKLEN(entry);
105 1426 char *kpv = HeKEY(entry);
106 1426 SV *val = HeVAL(entry);
107  
108 /* Negate klen for UTF-8 keys (Perl API convention) */
109 1426 ▶ if( HeKUTF8(entry) )
Branch: 1 branch
BranchTrueFalseTotal
if( HeKUTF8(entry) ) 0 1426 1426
110 0 klen = -klen;
111  
112 1426 hv_store(dst, kpv, klen, newSVsv(val), HeHASH(entry));
113 }
114  
115 186 return dst;
116 }
117  
118 MODULE = DateTime::Lite PACKAGE = DateTime::Lite
119  
120 PROTOTYPES: ENABLE
121  
122 # Rata Die (RD) <-> Calendar conversions
123 void
124 _rd2ymd(self, d, extra = 0)
125 IV d;
126 IV extra;
127  
128 PREINIT:
129 IV y, m;
130 IV c;
131 IV quarter;
132 283 ▶ IV yadj = 0;
Branch: 1 branch
BranchTrueFalseTotal
IV yadj = 0; 59 224 283
133 IV dow, doy, doq;
134 IV rd_days;
135  
136 PPCODE:
137 283 rd_days = d;
138  
139 283 d += MARCH_1;
140  
141 283 ▶ if( d <= 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( d <= 0 ) 3 280 283
142 {
143 3 yadj = -1 * (((-1 * d) / DAYS_PER_400_YEARS) + 1);
144 3 d -= yadj * DAYS_PER_400_YEARS;
145 }
146  
147 /* c is century */
148 283 c = ((d * 4) - 1) / DAYS_PER_400_YEARS;
149 283 d -= c * DAYS_PER_400_YEARS / 4;
150 283 y = ((d * 4) - 1) / DAYS_PER_4_YEARS;
151 283 d -= y * DAYS_PER_4_YEARS / 4;
152 283 m = ((d * 12) + 1093) / 367;
153 283 d -= ((m * 367) - 1094) / 12;
154 283 y += (c * 100) + (yadj * 400);
155  
156 283 ▶ if( m > 12 )
Branch: 1 branch
BranchTrueFalseTotal
if( m > 12 ) 81 202 283
157 {
158 81 ++y;
159 81 m -= 12;
160 }
161  
162 283 ▶ EXTEND(SP, extra ? 7 : 3);
Branch: 3 branches
BranchTrueFalseTotal
EXTEND(SP, extra ? 7 : 3); 224 59 283
EXTEND(SP, extra ? 7 : 3); 0 283 283
EXTEND(SP, extra ? 7 : 3); 0 0 0
163 283 mPUSHi(y);
164 283 mPUSHi(m);
165 283 mPUSHi(d);
166  
167 283 ▶ if( extra )
Branch: 1 branch
BranchTrueFalseTotal
if( extra ) 224 59 283
168 {
169 224 quarter = ( ( 1.0 / 3.1 ) * m ) + 1;
170  
171 224 dow = rd_days % 7;
172 224 ▶ if( dow <= 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( dow <= 0 ) 21 203 224
173 {
174 21 dow += 7;
175 }
176  
177 224 mPUSHi(dow);
178  
179 224 ▶ if(_real_is_leap_year(y) )
Branch: 1 branch
BranchTrueFalseTotal
if(_real_is_leap_year(y) ) 22 202 224
180 {
181 22 doy = PREVIOUS_MONTH_DOLY[m - 1] + d;
182 22 doq = doy - PREVIOUS_MONTH_DOLY[ (3 * quarter) - 3 ];
183 }
184 else
185 {
186 202 doy = PREVIOUS_MONTH_DOY[m - 1] + d;
187 202 doq = doy - PREVIOUS_MONTH_DOY[ (3 * quarter ) - 3 ];
188 }
189  
190 224 mPUSHi(doy);
191 224 mPUSHi(quarter);
192 224 mPUSHi(doq);
193 }
194  
195 void
196 _ymd2rd(self, y, m, d)
197 IV y;
198 IV m;
199 IV d;
200  
201 PREINIT:
202 IV adj;
203  
204 PPCODE:
205 220 ▶ if( m <= 2 )
Branch: 1 branch
BranchTrueFalseTotal
if( m <= 2 ) 65 155 220
206 {
207 65 adj = (14 - m) / 12;
208 65 y -= adj;
209 65 m += 12 * adj;
210 }
211 155 ▶ else if( m > 14 )
Branch: 1 branch
BranchTrueFalseTotal
else if( m > 14 ) 2 153 155
212 {
213 2 adj = (m - 3) / 12;
214 2 y += adj;
215 2 m -= 12 * adj;
216 }
217  
218 220 ▶ if( y < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( y < 0 ) 2 218 220
219 {
220 2 adj = (399 - y) / 400;
221 2 d -= DAYS_PER_400_YEARS * adj;
222 2 y += 400 * adj;
223 }
224  
225 220 d += (m * 367 - 1094) /
226 220 12 + y % 100 * DAYS_PER_4_YEARS /
227 220 4 + (y / 100 * 36524 + y / 400) - MARCH_1;
228  
229 220 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 220 220
230 220 mPUSHi(d);
231  
232 # Time component decomposition
233 void
234 _seconds_as_components(self, secs, utc_secs = 0, secs_modifier = 0)
235 IV secs;
236 IV utc_secs;
237 IV secs_modifier;
238  
239 PREINIT:
240 IV h, m, s;
241  
242 PPCODE:
243 272 secs -= secs_modifier;
244  
245 272 h = secs / 3600;
246 272 secs -= h * 3600;
247  
248 272 m = secs / 60;
249  
250 272 s = secs - (m * 60);
251  
252 272 ▶ if( utc_secs >= SECONDS_PER_DAY )
Branch: 1 branch
BranchTrueFalseTotal
if( utc_secs >= SECONDS_PER_DAY ) 0 272 272
253 {
254 0 ▶ if( utc_secs >= SECONDS_PER_DAY + 1 )
Branch: 1 branch
BranchTrueFalseTotal
if( utc_secs >= SECONDS_PER_DAY + 1 ) 0 0 0
255 {
256 0 croak("Invalid UTC RD seconds value: %s",
257 SvPV_nolen(newSViv(utc_secs)));
258 }
259  
260 0 s += (utc_secs - SECONDS_PER_DAY) + 60;
261 0 m = 59;
262 0 h--;
263  
264 0 ▶ if( h < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( h < 0 ) 0 0 0
265 {
266 0 h = 23;
267 }
268 }
269  
270 272 ▶ EXTEND(SP, 3);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 3); 0 272 272
271 272 mPUSHi(h);
272 272 mPUSHi(m);
273 272 mPUSHi(s);
274  
275 void
276 _time_as_seconds(self, h, m, s)
277 IV h;
278 IV m;
279 IV s;
280  
281 PPCODE:
282 209 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 209 209
283 209 mPUSHi(h * 3600 + m * 60 + s);
284  
285 # Leap year / leap second helpers
286 void
287 _is_leap_year(self, y)
288 IV y;
289  
290 PPCODE:
291 50 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 50 50
292 50 mPUSHi(_real_is_leap_year(y));
293  
294 void
295 _day_length(self, utc_rd)
296 IV utc_rd;
297  
298 PPCODE:
299 IV day_length;
300 23 SET_DAY_LENGTH(utc_rd, day_length);
301  
302 23 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 23 23
303 23 mPUSHi(day_length);
304  
305 void
306 _day_has_leap_second(self, utc_rd)
307 IV utc_rd;
308  
309 PPCODE:
310 IV day_length;
311 0 SET_DAY_LENGTH(utc_rd, day_length);
312  
313 0 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 0 0
314 0 ▶ mPUSHi(day_length > SECONDS_PER_DAY ? 1 : 0);
Branch: 1 branch
BranchTrueFalseTotal
mPUSHi(day_length > SECONDS_PER_DAY ? 1 : 0); 0 0 0
315  
316 void
317 _accumulated_leap_seconds(self, utc_rd)
318 IV utc_rd;
319  
320 PPCODE:
321 IV leap_seconds;
322 3 ▶ SET_LEAP_SECONDS(utc_rd, leap_seconds);
Branch: 26 branches
BranchTrueFalseTotal
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 3 3
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
SET_LEAP_SECONDS(utc_rd, leap_seconds); 0 0 0
323  
324 3 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 3 3
325 3 mPUSHi(leap_seconds);
326  
327 #ifdef dtl_isfinite
328  
329 # Normalisation (TAI / leap-second-aware)
330 void
331 _normalize_tai_seconds(self, days, secs)
332 SV* days;
333 SV* secs;
334  
335 PPCODE:
336 280 ▶ if( dtl_isfinite(SvNV(days)) && dtl_isfinite(SvNV(secs)) )
Branch: 2 branches
BranchTrueFalseTotal
if( dtl_isfinite(SvNV(days)) && dtl_isfinite(SvNV(secs)) ) 278 2 280
if( dtl_isfinite(SvNV(days)) && dtl_isfinite(SvNV(secs)) ) 278 0 278
337 {
338 278 IV d = SvIV(days);
339 278 IV s = SvIV(secs);
340 IV adj;
341  
342 278 ▶ if( s < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( s < 0 ) 21 257 278
343 {
344 21 adj = (s - (SECONDS_PER_DAY - 1)) / SECONDS_PER_DAY;
345 }
346 else
347 {
348 257 adj = s / SECONDS_PER_DAY;
349 }
350  
351 278 d += adj;
352 278 s -= adj * SECONDS_PER_DAY;
353  
354 278 sv_setiv(days, (IV) d);
355 278 sv_setiv(secs, (IV) s);
356 }
357  
358 void
359 _normalize_leap_seconds(self, days, secs)
360 SV* days;
361 SV* secs;
362  
363 PPCODE:
364 14 ▶ if( dtl_isfinite(SvNV(days)) && dtl_isfinite(SvNV(secs)) )
Branch: 2 branches
BranchTrueFalseTotal
if( dtl_isfinite(SvNV(days)) && dtl_isfinite(SvNV(secs)) ) 14 0 14
if( dtl_isfinite(SvNV(days)) && dtl_isfinite(SvNV(secs)) ) 14 0 14
365 {
366 14 IV d = SvIV(days);
367 14 IV s = SvIV(secs);
368 14 IV old_d = d;
369 IV day_length;
370 IV adj;
371 IV new_leaps;
372 IV old_leaps;
373 IV leap_delta;
374  
375 /* Step 1: fast constant-time normalisation, ignoring leap seconds.
376 * This handles large |s| values in O(1) via integer division, mirroring what
377 * _normalize_tai_seconds does. Previously, this method was looping one day at a
378 * time, which allowed a caller who controls s (for example using
379 * $dt->add(seconds => N) on a non-floating timezone) to hold a worker
380 * process for O(|N|/86400) iterations. This is an inefficient-algorithmic-
381 * complexity issue (CWE-407).
382 *
383 * For negative values, subtracting 86399 before dividing floors the quotient
384 * toward negative infinity under C99 truncation-toward-zero division.
385 */
386 14 ▶ if( s < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( s < 0 ) 10 4 14
387 {
388 10 adj = ( s - 86399 ) / 86400;
389 10 d += adj;
390 10 s -= adj * 86400;
391 }
392 4 ▶ else if( s >= 86400 )
Branch: 1 branch
BranchTrueFalseTotal
else if( s >= 86400 ) 4 0 4
393 {
394 4 adj = s / 86400;
395 4 d += adj;
396 4 s -= adj * 86400;
397 }
398  
399 /* Step 2: correct for leap seconds in the crossed interval.
400 * SET_LEAP_SECONDS returns cumulative leap seconds up to utc_rd, so the
401 * difference gives leap seconds in the interval in O(1).
402 */
403 14 ▶ if( d > old_d )
Branch: 1 branch
BranchTrueFalseTotal
if( d > old_d ) 4 10 14
404 {
405 4 ▶ SET_LEAP_SECONDS( d - 1, new_leaps );
Branch: 26 branches
BranchTrueFalseTotal
SET_LEAP_SECONDS( d - 1, new_leaps ); 1 3 4
SET_LEAP_SECONDS( d - 1, new_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 1 1
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( d - 1, new_leaps ); 0 0 0
406 4 ▶ SET_LEAP_SECONDS( old_d - 1, old_leaps );
Branch: 26 branches
BranchTrueFalseTotal
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 2 2 4
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 2 0 2
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 2 0 2
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 2 0 2
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 2 0 2
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 1 2
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 0 1 1
SET_LEAP_SECONDS( old_d - 1, old_leaps ); 0 0 0
407 4 leap_delta = new_leaps - old_leaps;
408 4 s -= leap_delta;
409 }
410 10 ▶ else if( d < old_d )
Branch: 1 branch
BranchTrueFalseTotal
else if( d < old_d ) 10 0 10
411 {
412 10 ▶ SET_LEAP_SECONDS( old_d - 1, new_leaps );
Branch: 26 branches
BranchTrueFalseTotal
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 10 10
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
SET_LEAP_SECONDS( old_d - 1, new_leaps ); 0 0 0
413 10 ▶ SET_LEAP_SECONDS( d - 1, old_leaps );
Branch: 26 branches
BranchTrueFalseTotal
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 9 10
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
SET_LEAP_SECONDS( d - 1, old_leaps ); 1 0 1
414 10 leap_delta = new_leaps - old_leaps;
415 10 s += leap_delta;
416 }
417  
418 /* Step 3: residual normalisation. Bounded by the total leap seconds in the
419 * crossed interval (at most 27 across all IANA history), in practice a
420 * handful of iterations.
421 */
422 15 ▶ while( s < 0 )
Branch: 1 branch
BranchTrueFalseTotal
while( s < 0 ) 1 14 15
423 {
424 1 SET_DAY_LENGTH( d - 1, day_length );
425 1 s += day_length;
426 1 d--;
427 }
428  
429 14 SET_DAY_LENGTH( d, day_length );
430  
431 14 ▶ while( s > day_length - 1 )
Branch: 1 branch
BranchTrueFalseTotal
while( s > day_length - 1 ) 0 14 14
432 {
433 0 s -= day_length;
434 0 d++;
435 0 SET_DAY_LENGTH( d, day_length );
436 }
437  
438 14 sv_setiv( days, (IV) d );
439 14 sv_setiv( secs, (IV) s );
440 }
441  
442 # Additional XS functions (not in original DateTime)
443  
444 # Compute Unix epoch from utc_rd_days + utc_rd_secs directly in C.
445 # Returns IV (integer seconds). Caller adds nanoseconds if needed.
446 IV
447 _rd_to_epoch(self, rd_days, rd_secs)
448 IV rd_days;
449 IV rd_secs;
450  
451 CODE:
452 18 ▶ RETVAL = (rd_days - UNIX_EPOCH_RD_DAYS) * SECONDS_PER_DAY + rd_secs;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = (rd_days - UNIX_EPOCH_RD_DAYS) * SECONDS_PER_DAY + rd_secs; 11 7 18
453  
454 OUTPUT:
455 RETVAL
456  
457 # Compute utc_rd_days and utc_rd_secs from a Unix epoch integer.
458 # Returns a 2-element list: (rd_days, rd_secs).
459 void
460 _epoch_to_rd(self, epoch)
461 IV epoch;
462  
463 PREINIT:
464 IV d, s;
465  
466 PPCODE:
467 0 d = epoch / SECONDS_PER_DAY;
468 0 s = epoch - d * SECONDS_PER_DAY;
469  
470 0 ▶ if( s < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( s < 0 ) 0 0 0
471 {
472 0 d--;
473 0 s += SECONDS_PER_DAY;
474 }
475  
476 0 d += UNIX_EPOCH_RD_DAYS;
477  
478 0 ▶ EXTEND(SP, 2);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 2); 0 0 0
479 0 mPUSHi(d);
480 0 mPUSHi(s);
481  
482 # In-place nanosecond normalisation.
483 # Modifies the two SV* scalars passed in (seconds, nanoseconds), carrying over-/underflow
484 # between them.
485 void
486 _normalize_nanoseconds(self, secs, nanosecs)
487 SV* secs;
488 SV* nanosecs;
489  
490 PPCODE:
491 {
492 221 IV s = SvIV(secs);
493 221 IV ns = SvIV(nanosecs);
494 IV overflow;
495  
496 221 ▶ if( ns < 0 )
Branch: 1 branch
BranchTrueFalseTotal
if( ns < 0 ) 0 221 221
497 {
498 0 overflow = 1 + (-ns - 1) / MAX_NANOSECONDS;
499 0 ns += overflow * MAX_NANOSECONDS;
500 0 s -= overflow;
501 }
502 221 ▶ else if( ns >= MAX_NANOSECONDS )
Branch: 1 branch
BranchTrueFalseTotal
else if( ns >= MAX_NANOSECONDS ) 0 221 221
503 {
504 0 overflow = ns / MAX_NANOSECONDS;
505 0 ns -= overflow * MAX_NANOSECONDS;
506 0 s += overflow;
507 }
508  
509 221 sv_setiv(secs, (IV) s);
510 221 sv_setiv(nanosecs, (IV) ns);
511 }
512  
513 # Fast three-way UTC comparison: returns -1, 0, or 1.
514 # Compares (rd_days1, rd_secs1, rd_ns1) vs (rd_days2, rd_secs2, rd_ns2).
515 IV
516 _compare_rd(self, rd_days1, rd_secs1, rd_ns1, rd_days2, rd_secs2, rd_ns2)
517 IV rd_days1;
518 IV rd_secs1;
519 IV rd_ns1;
520 IV rd_days2;
521 IV rd_secs2;
522 IV rd_ns2;
523  
524 CODE:
525 22 ▶ if( rd_days1 != rd_days2 )
Branch: 1 branch
BranchTrueFalseTotal
if( rd_days1 != rd_days2 ) 16 6 22
526 {
527 16 ▶ RETVAL = (rd_days1 > rd_days2) ? 1 : -1;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = (rd_days1 > rd_days2) ? 1 : -1; 8 8 16
528 }
529 6 ▶ else if( rd_secs1 != rd_secs2 )
Branch: 1 branch
BranchTrueFalseTotal
else if( rd_secs1 != rd_secs2 ) 0 6 6
530 {
531 0 ▶ RETVAL = (rd_secs1 > rd_secs2) ? 1 : -1;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = (rd_secs1 > rd_secs2) ? 1 : -1; 0 0 0
532 }
533 6 ▶ else if( rd_ns1 != rd_ns2 )
Branch: 1 branch
BranchTrueFalseTotal
else if( rd_ns1 != rd_ns2 ) 1 5 6
534 {
535 1 ▶ RETVAL = (rd_ns1 > rd_ns2) ? 1 : -1;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = (rd_ns1 > rd_ns2) ? 1 : -1; 0 1 1
536 }
537 else
538 {
539 5 RETVAL = 0;
540 }
541  
542 OUTPUT:
543 RETVAL
544  
545 #endif /* ifdef dtl_isfinite */
546  
547 #-------------------------------------------------------------------
548 # clone()
549 #
550 # Returns a two-level deep copy of the DateTime::Lite object.
551 #
552 # The object is a blessed hashref whose values are:
553 # - Scalars (utc_rd_days, utc_rd_secs, rd_nanosecs, etc.)
554 # -> newSVsv() produces an independent copy
555 # - Blessed hashrefs with scalar-only values (tz, locale)
556 # -> dtl_clone_flat_hv() + bless into the same stash
557 # - A plain hashref with scalar-only values (local_c, the calculated
558 # component cache)
559 # -> dtl_clone_flat_hv()
560 # - undef or a formatter object (rare, effectively immutable)
561 # -> newSVsv() for undef; SvREFCNT_inc for non-HV references
562 #
563 # Two levels of depth cover the entire object graph.
564 # Circular refs, threads::shared, COW strings are not needed for this
565 # well-defined, bounded structure.
566 #-------------------------------------------------------------------
567 SV *
568 clone(self)
569 SV *self;
570  
571 PREINIT:
572 HV *src_hv;
573 HV *dst_hv;
574 HE *entry;
575  
576 CODE:
577 61 ▶ if( !SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV )
Branch: 2 branches
BranchTrueFalseTotal
if( !SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV ) 61 0 61
if( !SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV ) 0 61 61
578 0 croak("clone() requires a blessed hashref");
579  
580 61 src_hv = (HV *) SvRV(self);
581 61 dst_hv = newHV();
582  
583 61 ▶ if( HvKEYS(src_hv) > 0 )
Branch: 2 branches
BranchTrueFalseTotal
if( HvKEYS(src_hv) > 0 ) 0 61 61
if( HvKEYS(src_hv) > 0 ) 61 0 61
584 61 ▶ hv_ksplit(dst_hv, HvKEYS(src_hv));
Branch: 1 branch
BranchTrueFalseTotal
hv_ksplit(dst_hv, HvKEYS(src_hv)); 0 61 61
585  
586 61 hv_iterinit(src_hv);
587 735 ▶ while( ( entry = hv_iternext(src_hv) ) )
Branch: 1 branch
BranchTrueFalseTotal
while( ( entry = hv_iternext(src_hv) ) ) 674 61 735
588 {
589 674 I32 klen = HeKLEN(entry);
590 674 char *kpv = HeKEY(entry);
591 674 SV *val = HeVAL(entry);
592 SV *copy;
593  
594 674 ▶ if( HeKUTF8(entry) )
Branch: 1 branch
BranchTrueFalseTotal
if( HeKUTF8(entry) ) 0 674 674
595 0 klen = -klen;
596  
597 674 ▶ if( SvROK(val) && SvTYPE(SvRV(val)) == SVt_PVHV )
Branch: 2 branches
BranchTrueFalseTotal
if( SvROK(val) && SvTYPE(SvRV(val)) == SVt_PVHV ) 186 488 674
if( SvROK(val) && SvTYPE(SvRV(val)) == SVt_PVHV ) 186 0 186
598 186 {
599 /* Nested hashref: clone all entries with dtl_clone_flat_hv(),
600 * then re-bless if the source was a blessed object. */
601 186 HV *inner_src = (HV *) SvRV(val);
602 186 HV *inner_dst = dtl_clone_flat_hv(inner_src);
603  
604 /* Create the RV first, then bless it; sv_bless requires an
605 * RV, not a raw HV pointer. */
606 186 copy = newRV_noinc((SV *) inner_dst);
607 186 ▶ if( SvOBJECT(inner_src) )
Branch: 1 branch
BranchTrueFalseTotal
if( SvOBJECT(inner_src) ) 122 64 186
608 122 sv_bless(copy, SvSTASH(inner_src));
609 }
610 else
611 {
612 /* Scalar, undef, or non-HV reference (e.g. a formatter
613 * object). newSVsv() handles scalars and undef; for RVs
614 * it produces a shallow copy, acceptable here since
615 * formatter objects are treated as immutable in normal use. */
616 488 copy = newSVsv(val);
617 }
618  
619 674 hv_store(dst_hv, kpv, klen, copy, HeHASH(entry));
620 }
621  
622 /* Bless the new hashref into the same class as the source */
623 61 RETVAL = sv_bless(newRV_noinc((SV *) dst_hv), SvSTASH(src_hv));
624  
625 OUTPUT:
626 RETVAL
627  
628 # -------------------------------------------------------------------
629 # posix_tz_lookup( class_or_self, unix_secs, tz_string )
630 #
631 # Parses a POSIX TZ footer string (e.g. "EST5EDT,M3.2.0,M11.1.0")
632 # and resolves the UTC offset, DST flag, and time-zone abbreviation
633 # for the given Unix timestamp.
634 #
635 # Implemented in C via dtl_posix.h, which is derived from IANA tzcode
636 # (public domain). Handles all rule forms (Jn, n, Mm.w.d), quoted
637 # abbreviations (<+0545>), fractional offsets, negative and >24 h
638 # transition times (RFC 9636 s3.3.2), and southern-hemisphere DST.
639 #
640 # Returns a hashref { offset => IV, is_dst => IV, short_name => PV }
641 # on success, or undef on parse error.
642 # -------------------------------------------------------------------
643 SV *
644 posix_tz_lookup(self, unix_secs, tz_string)
645 SV *self;
646 IV unix_secs;
647 const char *tz_string;
648  
649 PREINIT:
650 dtl_posix_tz_result res;
651 HV *hv;
652  
653 CODE:
654 (void)self; /* accept both class and instance calls */
655  
656 229 dtl_posix_tz_lookup( (int_fast64_t)unix_secs, tz_string, &res );
657  
658 229 ▶ if( !res.valid )
Branch: 1 branch
BranchTrueFalseTotal
if( !res.valid ) 0 229 229
659 {
660 0 RETVAL = &PL_sv_undef;
661 }
662 else
663 {
664 229 hv = newHV();
665 229 hv_store( hv, "offset", 6, newSViv( res.offset ), 0 );
666 229 hv_store( hv, "is_dst", 6, newSViv( res.is_dst ), 0 );
667 229 hv_store( hv, "short_name", 10, newSVpv( res.abbr, 0 ), 0 );
668 229 RETVAL = newRV_noinc( (SV *)hv );
669 }
670  
671 OUTPUT:
672 RETVAL
« lib/DateTime/Lite/Infinite.pm ↑ Summary dtl_posix.h »