1 /* $NetBSD: ntp_calendar.h,v 1.8 2020/05/25 20:47:19 christos Exp $ */ 2 3 /* 4 * ntp_calendar.h - definitions for the calendar time-of-day routine 5 */ 6 #ifndef NTP_CALENDAR_H 7 #define NTP_CALENDAR_H 8 9 #include <time.h> 10 11 #include "ntp_types.h" 12 13 /* gregorian calendar date */ 14 struct calendar { 15 uint16_t year; /* year (A.D.) */ 16 uint16_t yearday; /* day of year, 1 = January 1 */ 17 uint8_t month; /* month, 1 = January */ 18 uint8_t monthday; /* day of month */ 19 uint8_t hour; /* hour of day, midnight = 0 */ 20 uint8_t minute; /* minute of hour */ 21 uint8_t second; /* second of minute */ 22 uint8_t weekday; /* 0..7, 0=Sunday */ 23 }; 24 typedef struct calendar TCivilDate; 25 typedef struct calendar const TcCivilDate; 26 27 /* ISO week calendar date */ 28 struct isodate { 29 uint16_t year; /* year (A.D.) */ 30 uint8_t week; /* 1..53, week in year */ 31 uint8_t weekday; /* 1..7, 1=Monday */ 32 uint8_t hour; /* hour of day, midnight = 0 */ 33 uint8_t minute; /* minute of hour */ 34 uint8_t second; /* second of minute */ 35 }; 36 typedef struct isodate TIsoDate; 37 typedef struct isodate const TcIsoDate; 38 39 /* general split representation */ 40 typedef struct { 41 int32_t hi; 42 int32_t lo; 43 } ntpcal_split; 44 45 typedef time_t (*systime_func_ptr)(time_t *); 46 47 /* 48 * set the function for getting the system time. This is mostly used for 49 * unit testing to provide a fixed / shifted time stamp. Setting the 50 * value to NULL restores the original function, that is, 'time()', 51 * which is also the automatic default. 52 */ 53 extern systime_func_ptr ntpcal_set_timefunc(systime_func_ptr); 54 55 /* 56 * days-of-week 57 */ 58 #define CAL_SUNDAY 0 59 #define CAL_MONDAY 1 60 #define CAL_TUESDAY 2 61 #define CAL_WEDNESDAY 3 62 #define CAL_THURSDAY 4 63 #define CAL_FRIDAY 5 64 #define CAL_SATURDAY 6 65 #define CAL_SUNDAY7 7 /* also sunday */ 66 67 /* 68 * Days in each month. 30 days hath September... 69 */ 70 #define JAN 31 71 #define FEB 28 72 #define FEBLEAP 29 73 #define MAR 31 74 #define APR 30 75 #define MAY 31 76 #define JUN 30 77 #define JUL 31 78 #define AUG 31 79 #define SEP 30 80 #define OCT 31 81 #define NOV 30 82 #define DEC 31 83 84 /* 85 * We deal in a 4 year cycle starting at March 1, 1900. We assume 86 * we will only want to deal with dates since then, and not to exceed 87 * the rollover day in 2036. 88 */ 89 #define SECSPERMIN (60) /* seconds per minute */ 90 #define MINSPERHR (60) /* minutes per hour */ 91 #define HRSPERDAY (24) /* hours per day */ 92 #define DAYSPERWEEK (7) /* days per week */ 93 #define DAYSPERYEAR (365) /* days per year */ 94 95 #define SECSPERHR (SECSPERMIN * MINSPERHR) 96 #define SECSPERDAY (SECSPERHR * HRSPERDAY) 97 #define SECSPERWEEK (DAYSPERWEEK * SECSPERDAY) 98 #define SECSPERYEAR (365 * SECSPERDAY) /* regular year */ 99 #define SECSPERLEAPYEAR (366 * SECSPERDAY) /* leap year */ 100 #define SECSPERAVGYEAR 31556952 /* mean year length over 400yrs */ 101 102 #define GPSWEEKS 1024 /* GPS week cycle */ 103 /* 104 * Gross hacks. I have illicit knowlege that there won't be overflows 105 * here, the compiler often can't tell this. 106 */ 107 #define TIMES60(val) ((((val)<<4) - (val))<<2) /* *(16 - 1) * 4 */ 108 #define TIMES24(val) (((val)<<4) + ((val)<<3)) /* *16 + *8 */ 109 #define TIMES7(val) (((val)<<3) - (val)) /* *8 - *1 */ 110 #define TIMESDPERC(val) (((val)<<10) + ((val)<<8) \ 111 + ((val)<<7) + ((val)<<5) \ 112 + ((val)<<4) + ((val)<<2) + (val)) /* *big* hack */ 113 114 115 extern const char * const months[12]; 116 extern const char * const daynames[7]; 117 118 extern char * ntpcal_iso8601std(char*, size_t, struct calendar const*); 119 extern void caljulian (uint32_t, struct calendar *); 120 extern uint32_t caltontp (const struct calendar *); 121 122 /* 123 * Convert between 'time_t' and 'vint64' 124 */ 125 extern vint64 time_to_vint64(const time_t *); 126 extern time_t vint64_to_time(const vint64 *); 127 128 /* 129 * Get the build date & time. ATTENTION: The time zone is not specified! 130 * This depends entirely on the C compilers' capabilities to properly 131 * expand the '__TIME__' and '__DATE__' macros, as required by the C 132 * standard. 133 */ 134 extern int 135 ntpcal_get_build_date(struct calendar * /* jd */); 136 137 /* 138 * Convert a timestamp in NTP scale to a time_t value in the UN*X 139 * scale with proper epoch unfolding around a given pivot or the 140 * current system time. 141 */ 142 extern vint64 143 ntpcal_ntp_to_time(uint32_t /* ntp */, const time_t * /* pivot */); 144 145 /* 146 * Convert a timestamp in NTP scale to a 64bit seconds value in the NTP 147 * scale with proper epoch unfolding around a given pivot or the current 148 * system time. 149 * Note: The pivot must be given in UN*X time scale! 150 */ 151 extern vint64 152 ntpcal_ntp_to_ntp(uint32_t /* ntp */, const time_t * /* pivot */); 153 154 /* 155 * Split a time stamp in seconds into elapsed days and elapsed seconds 156 * since midnight. 157 */ 158 extern ntpcal_split 159 ntpcal_daysplit(const vint64 *); 160 161 /* 162 * Split a time stamp in seconds into elapsed weeks and elapsed seconds 163 * since start of week. 164 */ 165 extern ntpcal_split 166 ntpcal_weeksplit(const vint64 *); 167 168 /* 169 * Merge a number of days and a number of seconds into seconds, 170 * expressed in 64 bits to avoid overflow. 171 */ 172 extern vint64 173 ntpcal_dayjoin(int32_t /* days */, int32_t /* seconds */); 174 175 /* 176 * Merge a number of weeks and a number of seconds into seconds, 177 * expressed in 64 bits to avoid overflow. 178 */ 179 extern vint64 180 ntpcal_weekjoin(int32_t /* weeks */, int32_t /* seconds */); 181 182 /* Get the number of leap years since epoch for the number of elapsed 183 * full years 184 */ 185 extern int32_t 186 ntpcal_leapyears_in_years(int32_t /* years */); 187 188 /* 189 * Convert elapsed years in Era into elapsed days in Era. 190 */ 191 extern int32_t 192 ntpcal_days_in_years(int32_t /* years */); 193 194 /* 195 * Convert a number of elapsed month in a year into elapsed days 196 * in year. 197 * 198 * The month will be normalized, and 'res.hi' will contain the 199 * excessive years that must be considered when converting the years, 200 * while 'res.lo' will contain the days since start of the 201 * year. (Expect the resulting days to be negative, with a positive 202 * excess! But then, we need no leap year flag, either...) 203 */ 204 extern ntpcal_split 205 ntpcal_days_in_months(int32_t /* months */); 206 207 /* 208 * Convert ELAPSED years/months/days of gregorian calendar to elapsed 209 * days in Gregorian epoch. No range checks done here! 210 */ 211 extern int32_t 212 ntpcal_edate_to_eradays(int32_t /* years */, int32_t /* months */, int32_t /* mdays */); 213 214 /* 215 * Convert a time spec to seconds. No range checks done here! 216 */ 217 extern int32_t 218 ntpcal_etime_to_seconds(int32_t /* hours */, int32_t /* minutes */, int32_t /* seconds */); 219 220 /* 221 * Convert ELAPSED years/months/days of gregorian calendar to elapsed 222 * days in year. 223 * 224 * Note: This will give the true difference to the start of the given year, 225 * even if months & days are off-scale. 226 */ 227 extern int32_t 228 ntpcal_edate_to_yeardays(int32_t /* years */, int32_t /* months */, int32_t /* mdays */); 229 230 /* 231 * Convert the date part of a 'struct tm' (that is, year, month, 232 * day-of-month) into the RataDie of that day. 233 */ 234 extern int32_t 235 ntpcal_tm_to_rd(const struct tm * /* utm */); 236 237 /* 238 * Convert the date part of a 'struct calendar' (that is, year, month, 239 * day-of-month) into the RataDie of that day. 240 */ 241 extern int32_t 242 ntpcal_date_to_rd(const struct calendar * /* jt */); 243 244 /* 245 * Given the number of elapsed days in the calendar era, split this 246 * number into the number of elapsed years in 'res.quot' and the 247 * number of elapsed days of that year in 'res.rem'. 248 * 249 * if 'isleapyear' is not NULL, it will receive an integer that is 0 250 * for regular years and a non-zero value for leap years. 251 * 252 * The input is limited to [-2^30, 2^30-1]. If the days exceed this 253 * range, errno is set to EDOM and the result is saturated. 254 */ 255 extern ntpcal_split 256 ntpcal_split_eradays(int32_t /* days */, int/*BOOL*/ * /* isleapyear */); 257 258 /* 259 * Given a number of elapsed days in a year and a leap year indicator, 260 * split the number of elapsed days into the number of elapsed months 261 * in 'res.quot' and the number of elapsed days of that month in 262 * 'res.rem'. 263 */ 264 extern ntpcal_split 265 ntpcal_split_yeardays(int32_t /* eyd */, int/*BOOL*/ /* isleapyear */); 266 267 /* 268 * Convert a RataDie number into the date part of a 'struct 269 * calendar'. Return 0 if the year is regular year, !0 if the year is 270 * a leap year. 271 */ 272 extern int/*BOOL*/ 273 ntpcal_rd_to_date(struct calendar * /* jt */, int32_t /* rd */); 274 275 /* 276 * Convert a RataDie number into the date part of a 'struct 277 * tm'. Return 0 if the year is regular year, !0 if the year is a leap 278 * year. 279 */ 280 extern int/*BOOL*/ 281 ntpcal_rd_to_tm(struct tm * /* utm */, int32_t /* rd */); 282 283 /* 284 * Take a value of seconds since midnight and split it into hhmmss in 285 * a 'struct calendar'. Return excessive days. 286 */ 287 extern int32_t 288 ntpcal_daysec_to_date(struct calendar * /* jt */, int32_t /* secs */); 289 290 /* 291 * Take the time part of a 'struct calendar' and return the seconds 292 * since midnight. 293 */ 294 extern int32_t 295 ntpcal_date_to_daysec(const struct calendar *); 296 297 /* 298 * Take a value of seconds since midnight and split it into hhmmss in 299 * a 'struct tm'. Return excessive days. 300 */ 301 extern int32_t 302 ntpcal_daysec_to_tm(struct tm * /* utm */, int32_t /* secs */); 303 304 extern int32_t 305 ntpcal_tm_to_daysec(const struct tm * /* utm */); 306 307 /* 308 * convert a year number to rata die of year start 309 */ 310 extern int32_t 311 ntpcal_year_to_ystart(int32_t /* year */); 312 313 /* 314 * For a given RataDie, get the RataDie of the associated year start, 315 * that is, the RataDie of the last January,1st on or before that day. 316 */ 317 extern int32_t 318 ntpcal_rd_to_ystart(int32_t /* rd */); 319 320 /* 321 * convert a RataDie to the RataDie of start of the calendar month. 322 */ 323 extern int32_t 324 ntpcal_rd_to_mstart(int32_t /* year */); 325 326 327 extern int 328 ntpcal_daysplit_to_date(struct calendar * /* jt */, 329 const ntpcal_split * /* ds */, int32_t /* dof */); 330 331 extern int 332 ntpcal_daysplit_to_tm(struct tm * /* utm */, const ntpcal_split * /* ds */, 333 int32_t /* dof */); 334 335 extern int 336 ntpcal_time_to_date(struct calendar * /* jd */, const vint64 * /* ts */); 337 338 extern int32_t 339 ntpcal_periodic_extend(int32_t /* pivot */, int32_t /* value */, 340 int32_t /* cycle */); 341 342 extern int 343 ntpcal_ntp64_to_date(struct calendar * /* jd */, const vint64 * /* ntp */); 344 345 extern int 346 ntpcal_ntp_to_date(struct calendar * /* jd */, uint32_t /* ntp */, 347 const time_t * /* pivot */); 348 349 extern vint64 350 ntpcal_date_to_ntp64(const struct calendar * /* jd */); 351 352 extern uint32_t 353 ntpcal_date_to_ntp(const struct calendar * /* jd */); 354 355 extern time_t 356 ntpcal_date_to_time(const struct calendar * /* jd */); 357 358 /* 359 * ISO week-calendar conversions 360 */ 361 extern int32_t 362 isocal_weeks_in_years(int32_t /* years */); 363 364 /* 365 * The input is limited to [-2^30, 2^30-1]. If the weeks exceed this 366 * range, errno is set to EDOM and the result is saturated. 367 */ 368 extern ntpcal_split 369 isocal_split_eraweeks(int32_t /* weeks */); 370 371 extern int 372 isocal_ntp64_to_date(struct isodate * /* id */, const vint64 * /* ntp */); 373 374 extern int 375 isocal_ntp_to_date(struct isodate * /* id */, uint32_t /* ntp */, 376 const time_t * /* pivot */); 377 378 extern vint64 379 isocal_date_to_ntp64(const struct isodate * /* id */); 380 381 extern uint32_t 382 isocal_date_to_ntp(const struct isodate * /* id */); 383 384 385 /* 386 * day-of-week calculations 387 * 388 * Given a RataDie and a day-of-week, calculate a RDN that is reater-than, 389 * greater-or equal, closest, less-or-equal or less-than the given RDN 390 * and denotes the given day-of-week 391 */ 392 extern int32_t 393 ntpcal_weekday_gt(int32_t /* rdn */, int32_t /* dow */); 394 395 extern int32_t 396 ntpcal_weekday_ge(int32_t /* rdn */, int32_t /* dow */); 397 398 extern int32_t 399 ntpcal_weekday_close(int32_t /* rdn */, int32_t /* dow */); 400 401 extern int32_t 402 ntpcal_weekday_le(int32_t /* rdn */, int32_t /* dow */); 403 404 extern int32_t 405 ntpcal_weekday_lt(int32_t /* rdn */, int32_t /* dow */); 406 407 408 /* 409 * handling of base date spec 410 */ 411 extern int32_t 412 basedate_eval_buildstamp(void); 413 414 extern int32_t 415 basedate_eval_string(const char *str); 416 417 extern int32_t 418 basedate_set_day(int32_t dayno); 419 420 extern uint32_t 421 basedate_get_day(void); 422 423 extern time_t 424 basedate_get_eracenter(void); 425 426 extern time_t 427 basedate_get_erabase(void); 428 429 extern uint32_t 430 basedate_get_gpsweek(void); 431 432 extern uint32_t 433 basedate_expand_gpsweek(unsigned short weekno); 434 435 /* 436 * Additional support stuff for Ed Rheingold's calendrical calculations 437 */ 438 439 /* 440 * Start day of NTP time as days past 0000-12-31 in the proleptic 441 * Gregorian calendar. (So 0001-01-01 is day number 1; this is the Rata 442 * Die counting scheme used by Ed Rheingold in his book "Calendrical 443 * Calculations".) 444 */ 445 #define DAY_NTP_STARTS 693596 446 447 /* 448 * Start day of the UNIX epoch. This is the Rata Die of 1970-01-01. 449 */ 450 #define DAY_UNIX_STARTS 719163 451 452 /* 453 * Start day of the GPS epoch. This is the Rata Die of 1980-01-06 454 */ 455 #define DAY_GPS_STARTS 722820 456 457 /* 458 * Difference between UN*X and NTP epoch (25567). 459 */ 460 #define NTP_TO_UNIX_DAYS (DAY_UNIX_STARTS - DAY_NTP_STARTS) 461 462 /* 463 * Difference between GPS and NTP epoch (29224) 464 */ 465 #define NTP_TO_GPS_DAYS (DAY_GPS_STARTS - DAY_NTP_STARTS) 466 467 /* 468 * Days in a normal 4 year leap year calendar cycle (1461). 469 */ 470 #define GREGORIAN_NORMAL_LEAP_CYCLE_DAYS (4 * 365 + 1) 471 472 /* 473 * Days in a normal 100 year leap year calendar (36524). We lose a 474 * leap day in years evenly divisible by 100 but not by 400. 475 */ 476 #define GREGORIAN_NORMAL_CENTURY_DAYS \ 477 (25 * GREGORIAN_NORMAL_LEAP_CYCLE_DAYS - 1) 478 479 /* 480 * The Gregorian calendar is based on a 400 year cycle. This is the 481 * number of days in each cycle (146097). We gain a leap day in years 482 * divisible by 400 relative to the "normal" century. 483 */ 484 #define GREGORIAN_CYCLE_DAYS (4 * GREGORIAN_NORMAL_CENTURY_DAYS + 1) 485 486 /* 487 * Number of weeks in 400 years (20871). 488 */ 489 #define GREGORIAN_CYCLE_WEEKS (GREGORIAN_CYCLE_DAYS / 7) 490 491 /* 492 * Is a Greogorian calendar year a leap year? The obvious solution is to 493 * test the expression 494 * 495 * (y % 4 == 0) && ((y % 100 != 0) || (y % 400 == 0)) 496 * 497 * This needs (in theory) 2 true divisions -- most compilers check the 498 * (mod 4) condition by doing a bit test. Some compilers have been 499 * even observed to partially fuse the (mod 100) and (mod 400) test, 500 * but there is an alternative formula that gives the compiler even 501 * better chances: 502 * 503 * (y % 4 == 0) && ((y % 16 == 0) || (y % 25 != 0)) 504 * 505 * The order of checks is chosen so that the shorcut evaluation can fix 506 * the result as soon as possible. And the compiler has to do only one 507 * true division here -- the (mod 4) and (mod 16) can be done with 508 * direct bit tests. *If* the compiler chooses to do so. 509 * 510 * The deduction is as follows: rewrite the standard formula as 511 * (y % 4 == 0) && ((y % 4*25 != 0) || (y % 16*25 == 0)) 512 * 513 * then split the congruences: 514 * (y % 4 == 0) && ((y % 4 != 0 || y % 25 != 0) || (y % 16 == 0 && y % 25 == 0)) 515 * 516 * eliminate the 1st inner term, as it is provably false: 517 * (y % 4 == 0) && (y % 25 != 0 || (y % 16 == 0 && y % 25 == 0)) 518 * 519 * Use the distributive laws on the second major group: 520 * (y % 4 == 0) && ((y % 25 != 0 || y % 16 == 0) && (y % 25 != 0 || y % 25 == 0)) 521 * 522 * Eliminate the constant term, reorder, and voila: 523 */ 524 525 static inline int 526 is_leapyear(int32_t y) { 527 return !(y % 4) && (!(y % 16) || (y % 25)); 528 } 529 /* The (mod 4) test eliminates 3/4 (or 12/16) of all values. 530 * The (mod 16) test eliminates another 1/16 of all values. 531 * 3/16 of all values reach the final division. 532 * Assuming that the true division is the most costly operation, this 533 * sequence should give most bang for the buck. 534 */ 535 536 /* misc */ 537 extern int u32mod7(uint32_t x); 538 extern int i32mod7(int32_t x); 539 extern uint32_t i32fmod(int32_t x, uint32_t d); 540 541 extern int32_t ntpcal_expand_century(uint32_t y, uint32_t m, uint32_t d, uint32_t wd); 542 543 #endif 544
Indexes created Wed Jun 10 00:26:05 UTC 2026