time.cpp@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 60.9 KB

Line
1	/* $Id: time.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* IPRT - Time.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_TIME
32	#include <iprt/time.h>
33	#include "internal/iprt.h"
34
35	#include <iprt/assert.h>
36	#include <iprt/ctype.h>
37	#include <iprt/errcore.h>
38	#include <iprt/string.h>
39	#include "internal/time.h"
40
41
42	/*********************************************************************************************************************************
43	* Defined Constants And Macros *
44	*********************************************************************************************************************************/
45	/** The max year we possibly could implode. */
46	#define RTTIME_MAX_YEAR (292 + 1970)
47	/** The min year we possibly could implode. */
48	#define RTTIME_MIN_YEAR (-293 + 1970)
49
50	/** The max day supported by our time representation. (2262-04-11T23-47-16.854775807) */
51	#define RTTIME_MAX_DAY (365*292+71 + 101-1)
52	/** The min day supported by our time representation. (1677-09-21T00-12-43.145224192) */
53	#define RTTIME_MIN_DAY (365*-293-70 + 264-1)
54
55	/** The max nano second into the max day. (2262-04-11T23-47-16.854775807) */
56	#define RTTIME_MAX_DAY_NANO ( INT64_C(1000000000) * (233600 + 4760 + 16) + 854775807 )
57	/** The min nano second into the min day. (1677-09-21T00-12-43.145224192) */
58	#define RTTIME_MIN_DAY_NANO ( INT64_C(1000000000) * (003600 + 1260 + 43) + 145224192 )
59
60	/**
61	* Asserts that a_pTime is normalized.
62	*/
63	#define RTTIME_ASSERT_NORMALIZED(a_pTime) \
64	do \
65	{ \
66	Assert(RT_ABS((a_pTime)->offUTC) <= 840); \
67	Assert((a_pTime)->u32Nanosecond < 1000000000); \
68	Assert((a_pTime)->u8Second < 60); \
69	Assert((a_pTime)->u8Minute < 60); \
70	Assert((a_pTime)->u8Hour < 24); \
71	Assert((a_pTime)->u8Month >= 1 && (a_pTime)->u8Month <= 12); \
72	Assert((a_pTime)->u8WeekDay < 7); \
73	Assert((a_pTime)->u16YearDay >= 1); \
74	Assert((a_pTime)->u16YearDay <= (rtTimeIsLeapYear((a_pTime)->i32Year) ? 366 : 365)); \
75	Assert((a_pTime)->u8MonthDay >= 1 && (a_pTime)->u8MonthDay <= 31); \
76	} while (0)
77
78
79	/*********************************************************************************************************************************
80	* Global Variables *
81	*********************************************************************************************************************************/
82	/**
83	* Days per month in a common year.
84	*/
85	static const uint8_t g_acDaysInMonths[12] =
86	{
87	/Jan Feb Mar Arp May Jun Jul Aug Sep Oct Nov Dec /
88	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
89	};
90
91	/**
92	* Days per month in a leap year.
93	*/
94	static const uint8_t g_acDaysInMonthsLeap[12] =
95	{
96	/Jan Feb Mar Arp May Jun Jul Aug Sep Oct Nov Dec /
97	31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
98	};
99
100	/**
101	* The day of year for each month in a common year.
102	*/
103	static const uint16_t g_aiDayOfYear[12 + 1] =
104	{
105	1, /* Jan */
106	1+31, /* Feb */
107	1+31+28, /* Mar */
108	1+31+28+31, /* Apr */
109	1+31+28+31+30, /* May */
110	1+31+28+31+30+31, /* Jun */
111	1+31+28+31+30+31+30, /* Jul */
112	1+31+28+31+30+31+30+31, /* Aug */
113	1+31+28+31+30+31+30+31+31, /* Sep */
114	1+31+28+31+30+31+30+31+31+30, /* Oct */
115	1+31+28+31+30+31+30+31+31+30+31, /* Nov */
116	1+31+28+31+30+31+30+31+31+30+31+30, /* Dec */
117	1+31+28+31+30+31+30+31+31+30+31+30+31
118	};
119
120	/**
121	* The day of year for each month in a leap year.
122	*/
123	static const uint16_t g_aiDayOfYearLeap[12 + 1] =
124	{
125	1, /* Jan */
126	1+31, /* Feb */
127	1+31+29, /* Mar */
128	1+31+29+31, /* Apr */
129	1+31+29+31+30, /* May */
130	1+31+29+31+30+31, /* Jun */
131	1+31+29+31+30+31+30, /* Jul */
132	1+31+29+31+30+31+30+31, /* Aug */
133	1+31+29+31+30+31+30+31+31, /* Sep */
134	1+31+29+31+30+31+30+31+31+30, /* Oct */
135	1+31+29+31+30+31+30+31+31+30+31, /* Nov */
136	1+31+29+31+30+31+30+31+31+30+31+30, /* Dec */
137	1+31+29+31+30+31+30+31+31+30+31+30+31
138	};
139
140	/** The index of 1970 in g_aoffYear */
141	#define OFF_YEAR_IDX_EPOCH 300
142	/** The year of the first index. */
143	#define OFF_YEAR_IDX_0_YEAR 1670
144
145	/**
146	* The number of days the 1st of January a year is offseted from 1970-01-01.
147	*/
148	static const int32_t g_aoffYear[] =
149	{
150	/1670:/ 365-300+-72, 365-299+-72, 365-298+-72, 365-297+-71, 365-296+-71, 365-295+-71, 365-294+-71, 365-293+-70, 365-292+-70, 365-291+-70,
151	/1680:/ 365-290+-70, 365-289+-69, 365-288+-69, 365-287+-69, 365-286+-69, 365-285+-68, 365-284+-68, 365-283+-68, 365-282+-68, 365-281+-67,
152	/1690:/ 365-280+-67, 365-279+-67, 365-278+-67, 365-277+-66, 365-276+-66, 365-275+-66, 365-274+-66, 365-273+-65, 365-272+-65, 365-271+-65,
153	/1700:/ 365-270+-65, 365-269+-65, 365-268+-65, 365-267+-65, 365-266+-65, 365-265+-64, 365-264+-64, 365-263+-64, 365-262+-64, 365-261+-63,
154	/1710:/ 365-260+-63, 365-259+-63, 365-258+-63, 365-257+-62, 365-256+-62, 365-255+-62, 365-254+-62, 365-253+-61, 365-252+-61, 365-251+-61,
155	/1720:/ 365-250+-61, 365-249+-60, 365-248+-60, 365-247+-60, 365-246+-60, 365-245+-59, 365-244+-59, 365-243+-59, 365-242+-59, 365-241+-58,
156	/1730:/ 365-240+-58, 365-239+-58, 365-238+-58, 365-237+-57, 365-236+-57, 365-235+-57, 365-234+-57, 365-233+-56, 365-232+-56, 365-231+-56,
157	/1740:/ 365-230+-56, 365-229+-55, 365-228+-55, 365-227+-55, 365-226+-55, 365-225+-54, 365-224+-54, 365-223+-54, 365-222+-54, 365-221+-53,
158	/1750:/ 365-220+-53, 365-219+-53, 365-218+-53, 365-217+-52, 365-216+-52, 365-215+-52, 365-214+-52, 365-213+-51, 365-212+-51, 365-211+-51,
159	/1760:/ 365-210+-51, 365-209+-50, 365-208+-50, 365-207+-50, 365-206+-50, 365-205+-49, 365-204+-49, 365-203+-49, 365-202+-49, 365-201+-48,
160	/1770:/ 365-200+-48, 365-199+-48, 365-198+-48, 365-197+-47, 365-196+-47, 365-195+-47, 365-194+-47, 365-193+-46, 365-192+-46, 365-191+-46,
161	/1780:/ 365-190+-46, 365-189+-45, 365-188+-45, 365-187+-45, 365-186+-45, 365-185+-44, 365-184+-44, 365-183+-44, 365-182+-44, 365-181+-43,
162	/1790:/ 365-180+-43, 365-179+-43, 365-178+-43, 365-177+-42, 365-176+-42, 365-175+-42, 365-174+-42, 365-173+-41, 365-172+-41, 365-171+-41,
163	/1800:/ 365-170+-41, 365-169+-41, 365-168+-41, 365-167+-41, 365-166+-41, 365-165+-40, 365-164+-40, 365-163+-40, 365-162+-40, 365-161+-39,
164	/1810:/ 365-160+-39, 365-159+-39, 365-158+-39, 365-157+-38, 365-156+-38, 365-155+-38, 365-154+-38, 365-153+-37, 365-152+-37, 365-151+-37,
165	/1820:/ 365-150+-37, 365-149+-36, 365-148+-36, 365-147+-36, 365-146+-36, 365-145+-35, 365-144+-35, 365-143+-35, 365-142+-35, 365-141+-34,
166	/1830:/ 365-140+-34, 365-139+-34, 365-138+-34, 365-137+-33, 365-136+-33, 365-135+-33, 365-134+-33, 365-133+-32, 365-132+-32, 365-131+-32,
167	/1840:/ 365-130+-32, 365-129+-31, 365-128+-31, 365-127+-31, 365-126+-31, 365-125+-30, 365-124+-30, 365-123+-30, 365-122+-30, 365-121+-29,
168	/1850:/ 365-120+-29, 365-119+-29, 365-118+-29, 365-117+-28, 365-116+-28, 365-115+-28, 365-114+-28, 365-113+-27, 365-112+-27, 365-111+-27,
169	/1860:/ 365-110+-27, 365-109+-26, 365-108+-26, 365-107+-26, 365-106+-26, 365-105+-25, 365-104+-25, 365-103+-25, 365-102+-25, 365-101+-24,
170	/1870:/ 365-100+-24, 365 -99+-24, 365* -98+-24, 365* -97+-23, 365* -96+-23, 365* -95+-23, 365* -94+-23, 365* -93+-22, 365* -92+-22, 365* -91+-22,
171	/1880:/ 365* -90+-22, 365* -89+-21, 365* -88+-21, 365* -87+-21, 365* -86+-21, 365* -85+-20, 365* -84+-20, 365* -83+-20, 365* -82+-20, 365* -81+-19,
172	/1890:/ 365* -80+-19, 365* -79+-19, 365* -78+-19, 365* -77+-18, 365* -76+-18, 365* -75+-18, 365* -74+-18, 365* -73+-17, 365* -72+-17, 365* -71+-17,
173	/1900:/ 365* -70+-17, 365* -69+-17, 365* -68+-17, 365* -67+-17, 365* -66+-17, 365* -65+-16, 365* -64+-16, 365* -63+-16, 365* -62+-16, 365* -61+-15,
174	/1910:/ 365* -60+-15, 365* -59+-15, 365* -58+-15, 365* -57+-14, 365* -56+-14, 365* -55+-14, 365* -54+-14, 365* -53+-13, 365* -52+-13, 365* -51+-13,
175	/1920:/ 365* -50+-13, 365* -49+-12, 365* -48+-12, 365* -47+-12, 365* -46+-12, 365* -45+-11, 365* -44+-11, 365* -43+-11, 365* -42+-11, 365* -41+-10,
176	/1930:/ 365* -40+-10, 365* -39+-10, 365* -38+-10, 365* -37+-9 , 365* -36+-9 , 365* -35+-9 , 365* -34+-9 , 365* -33+-8 , 365* -32+-8 , 365* -31+-8 ,
177	/1940:/ 365* -30+-8 , 365* -29+-7 , 365* -28+-7 , 365* -27+-7 , 365* -26+-7 , 365* -25+-6 , 365* -24+-6 , 365* -23+-6 , 365* -22+-6 , 365* -21+-5 ,
178	/1950:/ 365* -20+-5 , 365* -19+-5 , 365* -18+-5 , 365* -17+-4 , 365* -16+-4 , 365* -15+-4 , 365* -14+-4 , 365* -13+-3 , 365* -12+-3 , 365* -11+-3 ,
179	/1960:/ 365* -10+-3 , 365* -9+-2 , 365* -8+-2 , 365* -7+-2 , 365* -6+-2 , 365* -5+-1 , 365* -4+-1 , 365* -3+-1 , 365* -2+-1 , 365* -1+0 ,
180	/1970:/ 365* 0+0 , 365* 1+0 , 365* 2+0 , 365* 3+1 , 365* 4+1 , 365* 5+1 , 365* 6+1 , 365* 7+2 , 365* 8+2 , 365* 9+2 ,
181	/1980:/ 365* 10+2 , 365* 11+3 , 365* 12+3 , 365* 13+3 , 365* 14+3 , 365* 15+4 , 365* 16+4 , 365* 17+4 , 365* 18+4 , 365* 19+5 ,
182	/1990:/ 365* 20+5 , 365* 21+5 , 365* 22+5 , 365* 23+6 , 365* 24+6 , 365* 25+6 , 365* 26+6 , 365* 27+7 , 365* 28+7 , 365* 29+7 ,
183	/2000:/ 365* 30+7 , 365* 31+8 , 365* 32+8 , 365* 33+8 , 365* 34+8 , 365* 35+9 , 365* 36+9 , 365* 37+9 , 365* 38+9 , 365* 39+10 ,
184	/2010:/ 365* 40+10 , 365* 41+10 , 365* 42+10 , 365* 43+11 , 365* 44+11 , 365* 45+11 , 365* 46+11 , 365* 47+12 , 365* 48+12 , 365* 49+12 ,
185	/2020:/ 365* 50+12 , 365* 51+13 , 365* 52+13 , 365* 53+13 , 365* 54+13 , 365* 55+14 , 365* 56+14 , 365* 57+14 , 365* 58+14 , 365* 59+15 ,
186	/2030:/ 365* 60+15 , 365* 61+15 , 365* 62+15 , 365* 63+16 , 365* 64+16 , 365* 65+16 , 365* 66+16 , 365* 67+17 , 365* 68+17 , 365* 69+17 ,
187	/2040:/ 365* 70+17 , 365* 71+18 , 365* 72+18 , 365* 73+18 , 365* 74+18 , 365* 75+19 , 365* 76+19 , 365* 77+19 , 365* 78+19 , 365* 79+20 ,
188	/2050:/ 365* 80+20 , 365* 81+20 , 365* 82+20 , 365* 83+21 , 365* 84+21 , 365* 85+21 , 365* 86+21 , 365* 87+22 , 365* 88+22 , 365* 89+22 ,
189	/2060:/ 365* 90+22 , 365* 91+23 , 365* 92+23 , 365* 93+23 , 365* 94+23 , 365* 95+24 , 365* 96+24 , 365* 97+24 , 365* 98+24 , 365* 99+25 ,
190	/2070:/ 365* 100+25 , 365* 101+25 , 365* 102+25 , 365* 103+26 , 365* 104+26 , 365* 105+26 , 365* 106+26 , 365* 107+27 , 365* 108+27 , 365* 109+27 ,
191	/2080:/ 365* 110+27 , 365* 111+28 , 365* 112+28 , 365* 113+28 , 365* 114+28 , 365* 115+29 , 365* 116+29 , 365* 117+29 , 365* 118+29 , 365* 119+30 ,
192	/2090:/ 365* 120+30 , 365* 121+30 , 365* 122+30 , 365* 123+31 , 365* 124+31 , 365* 125+31 , 365* 126+31 , 365* 127+32 , 365* 128+32 , 365* 129+32 ,
193	/2100:/ 365* 130+32 , 365* 131+32 , 365* 132+32 , 365* 133+32 , 365* 134+32 , 365* 135+33 , 365* 136+33 , 365* 137+33 , 365* 138+33 , 365* 139+34 ,
194	/2110:/ 365* 140+34 , 365* 141+34 , 365* 142+34 , 365* 143+35 , 365* 144+35 , 365* 145+35 , 365* 146+35 , 365* 147+36 , 365* 148+36 , 365* 149+36 ,
195	/2120:/ 365* 150+36 , 365* 151+37 , 365* 152+37 , 365* 153+37 , 365* 154+37 , 365* 155+38 , 365* 156+38 , 365* 157+38 , 365* 158+38 , 365* 159+39 ,
196	/2130:/ 365* 160+39 , 365* 161+39 , 365* 162+39 , 365* 163+40 , 365* 164+40 , 365* 165+40 , 365* 166+40 , 365* 167+41 , 365* 168+41 , 365* 169+41 ,
197	/2140:/ 365* 170+41 , 365* 171+42 , 365* 172+42 , 365* 173+42 , 365* 174+42 , 365* 175+43 , 365* 176+43 , 365* 177+43 , 365* 178+43 , 365* 179+44 ,
198	/2150:/ 365* 180+44 , 365* 181+44 , 365* 182+44 , 365* 183+45 , 365* 184+45 , 365* 185+45 , 365* 186+45 , 365* 187+46 , 365* 188+46 , 365* 189+46 ,
199	/2160:/ 365* 190+46 , 365* 191+47 , 365* 192+47 , 365* 193+47 , 365* 194+47 , 365* 195+48 , 365* 196+48 , 365* 197+48 , 365* 198+48 , 365* 199+49 ,
200	/2170:/ 365* 200+49 , 365* 201+49 , 365* 202+49 , 365* 203+50 , 365* 204+50 , 365* 205+50 , 365* 206+50 , 365* 207+51 , 365* 208+51 , 365* 209+51 ,
201	/2180:/ 365* 210+51 , 365* 211+52 , 365* 212+52 , 365* 213+52 , 365* 214+52 , 365* 215+53 , 365* 216+53 , 365* 217+53 , 365* 218+53 , 365* 219+54 ,
202	/2190:/ 365* 220+54 , 365* 221+54 , 365* 222+54 , 365* 223+55 , 365* 224+55 , 365* 225+55 , 365* 226+55 , 365* 227+56 , 365* 228+56 , 365* 229+56 ,
203	/2200:/ 365* 230+56 , 365* 231+56 , 365* 232+56 , 365* 233+56 , 365* 234+56 , 365* 235+57 , 365* 236+57 , 365* 237+57 , 365* 238+57 , 365* 239+58 ,
204	/2210:/ 365* 240+58 , 365* 241+58 , 365* 242+58 , 365* 243+59 , 365* 244+59 , 365* 245+59 , 365* 246+59 , 365* 247+60 , 365* 248+60 , 365* 249+60 ,
205	/2220:/ 365* 250+60 , 365* 251+61 , 365* 252+61 , 365* 253+61 , 365* 254+61 , 365* 255+62 , 365* 256+62 , 365* 257+62 , 365* 258+62 , 365* 259+63 ,
206	/2230:/ 365* 260+63 , 365* 261+63 , 365* 262+63 , 365* 263+64 , 365* 264+64 , 365* 265+64 , 365* 266+64 , 365* 267+65 , 365* 268+65 , 365* 269+65 ,
207	/2240:/ 365* 270+65 , 365* 271+66 , 365* 272+66 , 365* 273+66 , 365* 274+66 , 365* 275+67 , 365* 276+67 , 365* 277+67 , 365* 278+67 , 365* 279+68 ,
208	/2250:/ 365* 280+68 , 365* 281+68 , 365* 282+68 , 365* 283+69 , 365* 284+69 , 365* 285+69 , 365* 286+69 , 365* 287+70 , 365* 288+70 , 365* 289+70 ,
209	/2260:/ 365* 290+70 , 365* 291+71 , 365* 292+71 , 365* 293+71 , 365* 294+71 , 365* 295+72 , 365* 296+72 , 365* 297+72 , 365* 298+72 , 365* 299+73
210	};
211
212	/* generator code:
213	#include <stdio.h>
214	bool isLeapYear(int iYear)
215	{
216	return iYear % 4 == 0 && (iYear % 100 != 0 \|\| iYear % 400 == 0);
217	}
218	void printYear(int iYear, int iLeap)
219	{
220	if (!(iYear % 10))
221	printf("\n/" "%d:" "/", iYear + 1970);
222	printf(" 365*%4d+%-3d,", iYear, iLeap);
223	}
224	int main()
225	{
226	int iYear = 0;
227	int iLeap = 0;
228	while (iYear > -300)
229	iLeap -= isLeapYear(1970 + --iYear);
230	while (iYear < 300)
231	{
232	printYear(iYear, iLeap);
233	iLeap += isLeapYear(1970 + iYear++);
234	}
235	printf("\n");
236	return 0;
237	}
238	*/
239
240	/** RFC-1123 week day names. */
241	static const char * const g_apszWeekDays[7] =
242	{
243	"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
244	};
245	/** RFC-1123 month of the year names. */
246	static const char * const g_apszMonths[1+12] =
247	{
248	"000", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
249	};
250
251
252	/**
253	* Checks if a year is a leap year or not.
254	*
255	* @returns true if it's a leap year.
256	* @returns false if it's a common year.
257	* @param i32Year The year in question.
258	*/
259	DECLINLINE(bool) rtTimeIsLeapYear(int32_t i32Year)
260	{
261	return i32Year % 4 == 0
262	&& ( i32Year % 100 != 0
263	\|\| i32Year % 400 == 0);
264	}
265
266
267	/**
268	* Checks if a year is a leap year or not.
269	*
270	* @returns true if it's a leap year.
271	* @returns false if it's a common year.
272	* @param i32Year The year in question.
273	*/
274	RTDECL(bool) RTTimeIsLeapYear(int32_t i32Year)
275	{
276	return rtTimeIsLeapYear(i32Year);
277	}
278	RT_EXPORT_SYMBOL(RTTimeIsLeapYear);
279
280
281	/**
282	* Explodes a time spec (UTC).
283	*
284	* @returns pTime.
285	* @param pTime Where to store the exploded time.
286	* @param pTimeSpec The time spec to exploded.
287	*/
288	RTDECL(PRTTIME) RTTimeExplode(PRTTIME pTime, PCRTTIMESPEC pTimeSpec)
289	{
290	int64_t i64Div;
291	int32_t i32Div;
292	int32_t i32Rem;
293	unsigned iYear;
294	const uint16_t *paiDayOfYear;
295	int iMonth;
296
297	AssertMsg(VALID_PTR(pTime), ("%p\n", pTime));
298	AssertMsg(VALID_PTR(pTimeSpec), ("%p\n", pTime));
299
300	/*
301	* The simple stuff first.
302	*/
303	pTime->fFlags = RTTIME_FLAGS_TYPE_UTC;
304	i64Div = pTimeSpec->i64NanosecondsRelativeToUnixEpoch;
305	i32Rem = (int32_t)(i64Div % 1000000000);
306	i64Div /= 1000000000;
307	if (i32Rem < 0)
308	{
309	i32Rem += 1000000000;
310	i64Div--;
311	}
312	pTime->u32Nanosecond = i32Rem;
313
314	/* second */
315	i32Rem = (int32_t)(i64Div % 60);
316	i64Div /= 60;
317	if (i32Rem < 0)
318	{
319	i32Rem += 60;
320	i64Div--;
321	}
322	pTime->u8Second = i32Rem;
323
324	/* minute */
325	i32Div = (int32_t)i64Div; /* 60,000,000,000 > 33bit, so 31bit suffices. */
326	i32Rem = i32Div % 60;
327	i32Div /= 60;
328	if (i32Rem < 0)
329	{
330	i32Rem += 60;
331	i32Div--;
332	}
333	pTime->u8Minute = i32Rem;
334
335	/* hour */
336	i32Rem = i32Div % 24;
337	i32Div /= 24; /* days relative to 1970-01-01 */
338	if (i32Rem < 0)
339	{
340	i32Rem += 24;
341	i32Div--;
342	}
343	pTime->u8Hour = i32Rem;
344
345	/* weekday - 1970-01-01 was a Thursday (3) */
346	pTime->u8WeekDay = ((int)(i32Div % 7) + 3 + 7) % 7;
347
348	/*
349	* We've now got a number of days relative to 1970-01-01.
350	* To get the correct year number we have to mess with leap years. Fortunately,
351	* the representation we've got only supports a few hundred years, so we can
352	* generate a table and perform a simple two way search from the modulus 365 derived.
353	*/
354	iYear = OFF_YEAR_IDX_EPOCH + i32Div / 365;
355	while (g_aoffYear[iYear + 1] <= i32Div)
356	iYear++;
357	while (g_aoffYear[iYear] > i32Div)
358	iYear--;
359	pTime->i32Year = iYear + OFF_YEAR_IDX_0_YEAR;
360	i32Div -= g_aoffYear[iYear];
361	pTime->u16YearDay = i32Div + 1;
362
363	/*
364	* Figuring out the month is done in a manner similar to the year, only here we
365	* ensure that the index is matching or too small.
366	*/
367	if (rtTimeIsLeapYear(pTime->i32Year))
368	{
369	pTime->fFlags \|= RTTIME_FLAGS_LEAP_YEAR;
370	paiDayOfYear = &g_aiDayOfYearLeap[0];
371	}
372	else
373	{
374	pTime->fFlags \|= RTTIME_FLAGS_COMMON_YEAR;
375	paiDayOfYear = &g_aiDayOfYear[0];
376	}
377	iMonth = i32Div / 32;
378	i32Div++;
379	while (paiDayOfYear[iMonth + 1] <= i32Div)
380	iMonth++;
381	pTime->u8Month = iMonth + 1;
382	i32Div -= paiDayOfYear[iMonth];
383	pTime->u8MonthDay = i32Div + 1;
384
385	/* This is for UTC timespecs, so, no offset. */
386	pTime->offUTC = 0;
387
388	return pTime;
389	}
390	RT_EXPORT_SYMBOL(RTTimeExplode);
391
392
393	/**
394	* Implodes exploded time to a time spec (UTC).
395	*
396	* @returns pTime on success.
397	* @returns NULL if the pTime data is invalid.
398	* @param pTimeSpec Where to store the imploded UTC time.
399	* If pTime specifies a time which outside the range, maximum or
400	* minimum values will be returned.
401	* @param pTime Pointer to the exploded time to implode.
402	* The fields u8Month, u8WeekDay and u8MonthDay are not used,
403	* and all the other fields are expected to be within their
404	* bounds. Use RTTimeNormalize() or RTTimeLocalNormalize() to
405	* calculate u16YearDay and normalize the ranges of the fields.
406	*/
407	RTDECL(PRTTIMESPEC) RTTimeImplode(PRTTIMESPEC pTimeSpec, PCRTTIME pTime)
408	{
409	int32_t i32Days;
410	uint32_t u32Secs;
411	int64_t i64Nanos;
412
413	/*
414	* Validate input.
415	*/
416	AssertReturn(VALID_PTR(pTimeSpec), NULL);
417	AssertReturn(VALID_PTR(pTime), NULL);
418	AssertReturn(pTime->u32Nanosecond < 1000000000, NULL);
419	AssertReturn(pTime->u8Second < 60, NULL);
420	AssertReturn(pTime->u8Minute < 60, NULL);
421	AssertReturn(pTime->u8Hour < 24, NULL);
422	AssertReturn(pTime->u16YearDay >= 1, NULL);
423	AssertReturn(pTime->u16YearDay <= (rtTimeIsLeapYear(pTime->i32Year) ? 366 : 365), NULL);
424	AssertMsgReturn(pTime->i32Year <= RTTIME_MAX_YEAR && pTime->i32Year >= RTTIME_MIN_YEAR, ("%RI32\n", pTime->i32Year), NULL);
425	Assert(pTime->offUTC >= -840 && pTime->offUTC <= 840);
426
427	/*
428	* Do the conversion to nanoseconds.
429	*/
430	i32Days = g_aoffYear[pTime->i32Year - OFF_YEAR_IDX_0_YEAR]
431	+ pTime->u16YearDay - 1;
432	AssertMsgReturn(i32Days <= RTTIME_MAX_DAY && i32Days >= RTTIME_MIN_DAY, ("%RI32\n", i32Days), NULL);
433
434	u32Secs = pTime->u8Second
435	+ pTime->u8Minute * 60
436	+ pTime->u8Hour * 3600;
437	i64Nanos = (uint64_t)pTime->u32Nanosecond
438	+ u32Secs * UINT64_C(1000000000);
439	AssertMsgReturn(i32Days != RTTIME_MAX_DAY \|\| i64Nanos <= RTTIME_MAX_DAY_NANO, ("%RI64\n", i64Nanos), NULL);
440	AssertMsgReturn(i32Days != RTTIME_MIN_DAY \|\| i64Nanos >= RTTIME_MIN_DAY_NANO, ("%RI64\n", i64Nanos), NULL);
441
442	i64Nanos += i32Days * UINT64_C(86400000000000);
443	if ((pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) == RTTIME_FLAGS_TYPE_LOCAL)
444	i64Nanos -= pTime->offUTC * RT_NS_1MIN;
445
446	pTimeSpec->i64NanosecondsRelativeToUnixEpoch = i64Nanos;
447	return pTimeSpec;
448	}
449	RT_EXPORT_SYMBOL(RTTimeImplode);
450
451
452	/**
453	* Internal worker for RTTimeNormalize and RTTimeLocalNormalize.
454	*/
455	static PRTTIME rtTimeNormalizeInternal(PRTTIME pTime)
456	{
457	unsigned uSecond;
458	unsigned uMinute;
459	unsigned uHour;
460	bool fLeapYear;
461
462	/*
463	* Fix the YearDay and Month/MonthDay.
464	*/
465	fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
466	if (!pTime->u16YearDay)
467	{
468	/*
469	* The Month+MonthDay must present, overflow adjust them and calc the year day.
470	*/
471	AssertMsgReturn( pTime->u8Month
472	&& pTime->u8MonthDay,
473	("date=%d-%d-%d\n", pTime->i32Year, pTime->u8Month, pTime->u8MonthDay),
474	NULL);
475	while (pTime->u8Month > 12)
476	{
477	pTime->u8Month -= 12;
478	pTime->i32Year++;
479	fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
480	pTime->fFlags &= ~(RTTIME_FLAGS_COMMON_YEAR \| RTTIME_FLAGS_LEAP_YEAR);
481	}
482
483	for (;;)
484	{
485	unsigned cDaysInMonth = fLeapYear
486	? g_acDaysInMonthsLeap[pTime->u8Month - 1]
487	: g_acDaysInMonths[pTime->u8Month - 1];
488	if (pTime->u8MonthDay <= cDaysInMonth)
489	break;
490	pTime->u8MonthDay -= cDaysInMonth;
491	if (pTime->u8Month != 12)
492	pTime->u8Month++;
493	else
494	{
495	pTime->u8Month = 1;
496	pTime->i32Year++;
497	fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
498	pTime->fFlags &= ~(RTTIME_FLAGS_COMMON_YEAR \| RTTIME_FLAGS_LEAP_YEAR);
499	}
500	}
501
502	pTime->u16YearDay = pTime->u8MonthDay - 1
503	+ (fLeapYear
504	? g_aiDayOfYearLeap[pTime->u8Month - 1]
505	: g_aiDayOfYear[pTime->u8Month - 1]);
506	}
507	else
508	{
509	/*
510	* Are both YearDay and Month/MonthDay valid?
511	* Check that they don't overflow and match, if not use YearDay (simpler).
512	*/
513	bool fRecalc = true;
514	if ( pTime->u8Month
515	&& pTime->u8MonthDay)
516	{
517	do
518	{
519	uint16_t u16YearDay;
520
521	/* If you change one, zero the other to make clear what you mean. */
522	AssertBreak(pTime->u8Month <= 12);
523	AssertBreak(pTime->u8MonthDay <= (fLeapYear
524	? g_acDaysInMonthsLeap[pTime->u8Month - 1]
525	: g_acDaysInMonths[pTime->u8Month - 1]));
526	u16YearDay = pTime->u8MonthDay - 1
527	+ (fLeapYear
528	? g_aiDayOfYearLeap[pTime->u8Month - 1]
529	: g_aiDayOfYear[pTime->u8Month - 1]);
530	AssertBreak(u16YearDay == pTime->u16YearDay);
531	fRecalc = false;
532	} while (0);
533	}
534	if (fRecalc)
535	{
536	const uint16_t *paiDayOfYear;
537
538	/* overflow adjust YearDay */
539	while (pTime->u16YearDay > (fLeapYear ? 366 : 365))
540	{
541	pTime->u16YearDay -= fLeapYear ? 366 : 365;
542	pTime->i32Year++;
543	fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
544	pTime->fFlags &= ~(RTTIME_FLAGS_COMMON_YEAR \| RTTIME_FLAGS_LEAP_YEAR);
545	}
546
547	/* calc Month and MonthDay */
548	paiDayOfYear = fLeapYear
549	? &g_aiDayOfYearLeap[0]
550	: &g_aiDayOfYear[0];
551	pTime->u8Month = 1;
552	while (pTime->u16YearDay >= paiDayOfYear[pTime->u8Month])
553	pTime->u8Month++;
554	Assert(pTime->u8Month >= 1 && pTime->u8Month <= 12);
555	pTime->u8MonthDay = pTime->u16YearDay - paiDayOfYear[pTime->u8Month - 1] + 1;
556	}
557	}
558
559	/*
560	* Fixup time overflows.
561	* Use unsigned int values internally to avoid overflows.
562	*/
563	uSecond = pTime->u8Second;
564	uMinute = pTime->u8Minute;
565	uHour = pTime->u8Hour;
566
567	while (pTime->u32Nanosecond >= 1000000000)
568	{
569	pTime->u32Nanosecond -= 1000000000;
570	uSecond++;
571	}
572
573	while (uSecond >= 60)
574	{
575	uSecond -= 60;
576	uMinute++;
577	}
578
579	while (uMinute >= 60)
580	{
581	uMinute -= 60;
582	uHour++;
583	}
584
585	while (uHour >= 24)
586	{
587	uHour -= 24;
588
589	/* This is really a RTTimeIncDay kind of thing... */
590	if (pTime->u16YearDay + 1 != (fLeapYear ? g_aiDayOfYearLeap[pTime->u8Month] : g_aiDayOfYear[pTime->u8Month]))
591	{
592	pTime->u16YearDay++;
593	pTime->u8MonthDay++;
594	}
595	else if (pTime->u8Month != 12)
596	{
597	pTime->u16YearDay++;
598	pTime->u8Month++;
599	pTime->u8MonthDay = 1;
600	}
601	else
602	{
603	pTime->i32Year++;
604	fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
605	pTime->fFlags &= ~(RTTIME_FLAGS_COMMON_YEAR \| RTTIME_FLAGS_LEAP_YEAR);
606	pTime->u16YearDay = 1;
607	pTime->u8Month = 1;
608	pTime->u8MonthDay = 1;
609	}
610	}
611
612	pTime->u8Second = uSecond;
613	pTime->u8Minute = uMinute;
614	pTime->u8Hour = uHour;
615
616	/*
617	* Correct the leap year flag.
618	* Assert if it's wrong, but ignore if unset.
619	*/
620	if (fLeapYear)
621	{
622	Assert(!(pTime->fFlags & RTTIME_FLAGS_COMMON_YEAR));
623	pTime->fFlags &= ~RTTIME_FLAGS_COMMON_YEAR;
624	pTime->fFlags \|= RTTIME_FLAGS_LEAP_YEAR;
625	}
626	else
627	{
628	Assert(!(pTime->fFlags & RTTIME_FLAGS_LEAP_YEAR));
629	pTime->fFlags &= ~RTTIME_FLAGS_LEAP_YEAR;
630	pTime->fFlags \|= RTTIME_FLAGS_COMMON_YEAR;
631	}
632
633
634	/*
635	* Calc week day.
636	*
637	* 1970-01-01 was a Thursday (3), so find the number of days relative to
638	* that point. We use the table when possible and a slow+stupid+brute-force
639	* algorithm for points outside it. Feel free to optimize the latter by
640	* using some clever formula.
641	*/
642	if ( pTime->i32Year >= OFF_YEAR_IDX_0_YEAR
643	&& pTime->i32Year < OFF_YEAR_IDX_0_YEAR + (int32_t)RT_ELEMENTS(g_aoffYear))
644	{
645	int32_t offDays = g_aoffYear[pTime->i32Year - OFF_YEAR_IDX_0_YEAR]
646	+ pTime->u16YearDay -1;
647	pTime->u8WeekDay = ((offDays % 7) + 3 + 7) % 7;
648	}
649	else
650	{
651	int32_t i32Year = pTime->i32Year;
652	if (i32Year >= 1970)
653	{
654	uint64_t offDays = pTime->u16YearDay - 1;
655	while (--i32Year >= 1970)
656	offDays += rtTimeIsLeapYear(i32Year) ? 366 : 365;
657	pTime->u8WeekDay = (uint8_t)((offDays + 3) % 7);
658	}
659	else
660	{
661	int64_t offDays = (fLeapYear ? -366 - 1 : -365 - 1) + pTime->u16YearDay;
662	while (++i32Year < 1970)
663	offDays -= rtTimeIsLeapYear(i32Year) ? 366 : 365;
664	pTime->u8WeekDay = ((int)(offDays % 7) + 3 + 7) % 7;
665	}
666	}
667	return pTime;
668	}
669
670
671	/**
672	* Normalizes the fields of a time structure.
673	*
674	* It is possible to calculate year-day from month/day and vice
675	* versa. If you adjust any of these, make sure to zero the
676	* other so you make it clear which of the fields to use. If
677	* it's ambiguous, the year-day field is used (and you get
678	* assertions in debug builds).
679	*
680	* All the time fields and the year-day or month/day fields will
681	* be adjusted for overflows. (Since all fields are unsigned, there
682	* is no underflows.) It is possible to exploit this for simple
683	* date math, though the recommended way of doing that to implode
684	* the time into a timespec and do the math on that.
685	*
686	* @returns pTime on success.
687	* @returns NULL if the data is invalid.
688	*
689	* @param pTime The time structure to normalize.
690	*
691	* @remarks This function doesn't work with local time, only with UTC time.
692	*/
693	RTDECL(PRTTIME) RTTimeNormalize(PRTTIME pTime)
694	{
695	/*
696	* Validate that we've got the minimum of stuff handy.
697	*/
698	AssertReturn(VALID_PTR(pTime), NULL);
699	AssertMsgReturn(!(pTime->fFlags & ~RTTIME_FLAGS_MASK), ("%#x\n", pTime->fFlags), NULL);
700	AssertMsgReturn((pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) != RTTIME_FLAGS_TYPE_LOCAL, ("Use RTTimeLocalNormalize!\n"), NULL);
701	AssertMsgReturn(pTime->offUTC == 0, ("%d; Use RTTimeLocalNormalize!\n", pTime->offUTC), NULL);
702
703	pTime = rtTimeNormalizeInternal(pTime);
704	if (pTime)
705	pTime->fFlags \|= RTTIME_FLAGS_TYPE_UTC;
706	return pTime;
707	}
708	RT_EXPORT_SYMBOL(RTTimeNormalize);
709
710
711	/**
712	* Normalizes the fields of a time structure, assuming local time.
713	*
714	* It is possible to calculate year-day from month/day and vice
715	* versa. If you adjust any of these, make sure to zero the
716	* other so you make it clear which of the fields to use. If
717	* it's ambiguous, the year-day field is used (and you get
718	* assertions in debug builds).
719	*
720	* All the time fields and the year-day or month/day fields will
721	* be adjusted for overflows. (Since all fields are unsigned, there
722	* is no underflows.) It is possible to exploit this for simple
723	* date math, though the recommended way of doing that to implode
724	* the time into a timespec and do the math on that.
725	*
726	* @returns pTime on success.
727	* @returns NULL if the data is invalid.
728	*
729	* @param pTime The time structure to normalize.
730	*
731	* @remarks This function doesn't work with UTC time, only with local time.
732	*/
733	RTDECL(PRTTIME) RTTimeLocalNormalize(PRTTIME pTime)
734	{
735	/*
736	* Validate that we've got the minimum of stuff handy.
737	*/
738	AssertReturn(VALID_PTR(pTime), NULL);
739	AssertMsgReturn(!(pTime->fFlags & ~RTTIME_FLAGS_MASK), ("%#x\n", pTime->fFlags), NULL);
740	AssertMsgReturn((pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) != RTTIME_FLAGS_TYPE_UTC, ("Use RTTimeNormalize!\n"), NULL);
741
742	pTime = rtTimeNormalizeInternal(pTime);
743	if (pTime)
744	pTime->fFlags \|= RTTIME_FLAGS_TYPE_LOCAL;
745	return pTime;
746	}
747	RT_EXPORT_SYMBOL(RTTimeLocalNormalize);
748
749
750	/**
751	* Converts a time spec to a ISO date string.
752	*
753	* @returns psz on success.
754	* @returns NULL on buffer underflow.
755	* @param pTime The time. Caller should've normalized this.
756	* @param psz Where to store the string.
757	* @param cb The size of the buffer.
758	*/
759	RTDECL(char ) RTTimeToString(PCRTTIME pTime, char psz, size_t cb)
760	{
761	size_t cch;
762
763	/* (Default to UTC if not specified) */
764	if ( (pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) == RTTIME_FLAGS_TYPE_LOCAL
765	&& pTime->offUTC)
766	{
767	int32_t offUTC = pTime->offUTC;
768	Assert(offUTC <= 840 && offUTC >= -840);
769	char chSign;
770	if (offUTC >= 0)
771	chSign = '+';
772	else
773	{
774	chSign = '-';
775	offUTC = -offUTC;
776	}
777	uint32_t offUTCHour = (uint32_t)offUTC / 60;
778	uint32_t offUTCMinute = (uint32_t)offUTC % 60;
779	cch = RTStrPrintf(psz, cb,
780	"%RI32-%02u-%02uT%02u:%02u:%02u.%09RU32%c%02d%:02d",
781	pTime->i32Year, pTime->u8Month, pTime->u8MonthDay,
782	pTime->u8Hour, pTime->u8Minute, pTime->u8Second, pTime->u32Nanosecond,
783	chSign, offUTCHour, offUTCMinute);
784	if ( cch <= 15
785	\|\| psz[cch - 6] != chSign)
786	return NULL;
787	}
788	else
789	{
790	cch = RTStrPrintf(psz, cb, "%RI32-%02u-%02uT%02u:%02u:%02u.%09RU32Z",
791	pTime->i32Year, pTime->u8Month, pTime->u8MonthDay,
792	pTime->u8Hour, pTime->u8Minute, pTime->u8Second, pTime->u32Nanosecond);
793	if ( cch <= 15
794	\|\| psz[cch - 1] != 'Z')
795	return NULL;
796	}
797	return psz;
798	}
799	RT_EXPORT_SYMBOL(RTTimeToString);
800
801
802	/**
803	* Converts a time spec to a ISO date string, extended version.
804	*
805	* @returns Output string length on success (positive), VERR_BUFFER_OVERFLOW
806	* (negative) or VERR_OUT_OF_RANGE (negative) on failure.
807	* @param pTime The time. Caller should've normalized this.
808	* @param psz Where to store the string.
809	* @param cb The size of the buffer.
810	* @param cFractionDigits Number of digits in the fraction. Max is 9.
811	*/
812	RTDECL(ssize_t) RTTimeToStringEx(PCRTTIME pTime, char *psz, size_t cb, unsigned cFractionDigits)
813	{
814	size_t cch;
815
816	/* Format the fraction. */
817	char szFraction[16];
818	if (!cFractionDigits)
819	szFraction[0] = '\0';
820	else
821	{
822	AssertReturn(cFractionDigits <= 9, VERR_OUT_OF_RANGE);
823	Assert(pTime->u32Nanosecond <= 999999999);
824	RTStrPrintf(szFraction, sizeof(szFraction), ".%09RU32", pTime->u32Nanosecond);
825	szFraction[cFractionDigits + 1] = '\0';
826	}
827
828	/* (Default to UTC if not specified) */
829	if ( (pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) == RTTIME_FLAGS_TYPE_LOCAL
830	&& pTime->offUTC)
831	{
832	int32_t offUTC = pTime->offUTC;
833	Assert(offUTC <= 840 && offUTC >= -840);
834	char chSign;
835	if (offUTC >= 0)
836	chSign = '+';
837	else
838	{
839	chSign = '-';
840	offUTC = -offUTC;
841	}
842	uint32_t offUTCHour = (uint32_t)offUTC / 60;
843	uint32_t offUTCMinute = (uint32_t)offUTC % 60;
844
845	/* Examples: 2018-09-07T16:12:00+02:00 2018-09-07T16:12:00.123456789+02:00 */
846	cch = RTStrPrintf(psz, cb,
847	"%04RI32-%02u-%02uT%02u:%02u:%02u%s%c%02d%:02d",
848	pTime->i32Year, pTime->u8Month, pTime->u8MonthDay,
849	pTime->u8Hour, pTime->u8Minute, pTime->u8Second, szFraction,
850	chSign, offUTCHour, offUTCMinute);
851	if ( cch >= 24
852	&& psz[cch - 6] == chSign)
853	return cch;
854	}
855	else
856	{
857	/* Examples: 2018-09-07T16:12:00Z 2018-09-07T16:12:00.123456789Z */
858	cch = RTStrPrintf(psz, cb, "%04RI32-%02u-%02uT%02u:%02u:%02u%sZ",
859	pTime->i32Year, pTime->u8Month, pTime->u8MonthDay,
860	pTime->u8Hour, pTime->u8Minute, pTime->u8Second, szFraction);
861	if ( cch >= 19
862	&& psz[cch - 1] == 'Z')
863	return cch;
864	}
865	return VERR_BUFFER_OVERFLOW;
866	}
867	RT_EXPORT_SYMBOL(RTTimeToStringEx);
868
869
870	/**
871	* Converts a time spec to a ISO date string.
872	*
873	* @returns psz on success.
874	* @returns NULL on buffer underflow.
875	* @param pTime The time spec.
876	* @param psz Where to store the string.
877	* @param cb The size of the buffer.
878	*/
879	RTDECL(char ) RTTimeSpecToString(PCRTTIMESPEC pTime, char psz, size_t cb)
880	{
881	RTTIME Time;
882	return RTTimeToString(RTTimeExplode(&Time, pTime), psz, cb);
883	}
884	RT_EXPORT_SYMBOL(RTTimeSpecToString);
885
886
887
888	/**
889	* Attempts to convert an ISO date string to a time structure.
890	*
891	* We're a little forgiving with zero padding, unspecified parts, and leading
892	* and trailing spaces.
893	*
894	* @retval pTime on success,
895	* @retval NULL on failure.
896	* @param pTime Where to store the time on success.
897	* @param pszString The ISO date string to convert.
898	*/
899	RTDECL(PRTTIME) RTTimeFromString(PRTTIME pTime, const char *pszString)
900	{
901	/* Ignore leading spaces. */
902	while (RT_C_IS_SPACE(*pszString))
903	pszString++;
904
905	/*
906	* Init non date & time parts.
907	*/
908	pTime->fFlags = RTTIME_FLAGS_TYPE_LOCAL;
909	pTime->offUTC = 0;
910
911	/*
912	* The date part.
913	*/
914
915	/* Year */
916	int rc = RTStrToInt32Ex(pszString, (char **)&pszString, 10, &pTime->i32Year);
917	if (rc != VWRN_TRAILING_CHARS)
918	return NULL;
919
920	bool const fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
921	if (fLeapYear)
922	pTime->fFlags \|= RTTIME_FLAGS_LEAP_YEAR;
923
924	if (*pszString++ != '-')
925	return NULL;
926
927	/* Month of the year. */
928	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Month);
929	if (rc != VWRN_TRAILING_CHARS)
930	return NULL;
931	if (pTime->u8Month == 0 \|\| pTime->u8Month > 12)
932	return NULL;
933	if (*pszString++ != '-')
934	return NULL;
935
936	/* Day of month.*/
937	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8MonthDay);
938	if (rc != VWRN_TRAILING_CHARS && rc != VINF_SUCCESS)
939	return NULL;
940	unsigned const cDaysInMonth = fLeapYear
941	? g_acDaysInMonthsLeap[pTime->u8Month - 1]
942	: g_acDaysInMonths[pTime->u8Month - 1];
943	if (pTime->u8MonthDay == 0 \|\| pTime->u8MonthDay > cDaysInMonth)
944	return NULL;
945
946	/* Calculate year day. */
947	pTime->u16YearDay = pTime->u8MonthDay - 1
948	+ (fLeapYear
949	? g_aiDayOfYearLeap[pTime->u8Month - 1]
950	: g_aiDayOfYear[pTime->u8Month - 1]);
951
952	pTime->u8WeekDay = UINT8_MAX; /* later */
953
954	/*
955	* The time part.
956	*/
957	if (*pszString++ != 'T')
958	return NULL;
959
960	/* Hour. */
961	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Hour);
962	if (rc != VWRN_TRAILING_CHARS)
963	return NULL;
964	if (pTime->u8Hour > 23)
965	return NULL;
966	if (*pszString++ != ':')
967	return NULL;
968
969	/* Minute. */
970	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Minute);
971	if (rc != VWRN_TRAILING_CHARS)
972	return NULL;
973	if (pTime->u8Minute > 59)
974	return NULL;
975	if (*pszString++ != ':')
976	return NULL;
977
978	/* Second. */
979	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Second);
980	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS && rc != VWRN_TRAILING_SPACES)
981	return NULL;
982	if (pTime->u8Second > 59)
983	return NULL;
984
985	/* We generally put a 9 digit fraction here, but it's entirely optional. */
986	if (*pszString == '.')
987	{
988	const char * const pszStart = ++pszString;
989	rc = RTStrToUInt32Ex(pszString, (char **)&pszString, 10, &pTime->u32Nanosecond);
990	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS && rc != VWRN_TRAILING_SPACES)
991	return NULL;
992	if (pTime->u32Nanosecond >= 1000000000)
993	return NULL;
994	switch (pszString - pszStart)
995	{
996	case 1: pTime->u32Nanosecond *= 100000000; break;
997	case 2: pTime->u32Nanosecond *= 10000000; break;
998	case 3: pTime->u32Nanosecond *= 1000000; break;
999	case 4: pTime->u32Nanosecond *= 100000; break;
1000	case 5: pTime->u32Nanosecond *= 10000; break;
1001	case 6: pTime->u32Nanosecond *= 1000; break;
1002	case 7: pTime->u32Nanosecond *= 100; break;
1003	case 8: pTime->u32Nanosecond *= 10; break;
1004	case 9: break;
1005	default:
1006	return NULL;
1007	}
1008	if (pTime->u32Nanosecond >= 1000000000)
1009	return NULL;
1010	}
1011	else
1012	pTime->u32Nanosecond = 0;
1013
1014	/*
1015	* Time zone.
1016	*/
1017	if (*pszString == 'Z')
1018	{
1019	pszString++;
1020	pTime->fFlags &= ~RTTIME_FLAGS_TYPE_MASK;
1021	pTime->fFlags \|= RTTIME_FLAGS_TYPE_UTC;
1022	pTime->offUTC = 0;
1023	}
1024	else if ( *pszString == '+'
1025	\|\| *pszString == '-')
1026	{
1027	int8_t cUtcHours = 0;
1028	rc = RTStrToInt8Ex(pszString, (char **)&pszString, 10, &cUtcHours);
1029	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS && rc != VWRN_TRAILING_SPACES)
1030	return NULL;
1031	uint8_t cUtcMin = 0;
1032	if (*pszString == ':')
1033	{
1034	rc = RTStrToUInt8Ex(pszString + 1, (char **)&pszString, 10, &cUtcMin);
1035	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES)
1036	return NULL;
1037	}
1038	else if (pszString && !RT_C_IS_BLANK(pszString))
1039	return NULL;
1040	if (cUtcHours >= 0)
1041	pTime->offUTC = cUtcHours * 60 + cUtcMin;
1042	else
1043	pTime->offUTC = cUtcHours * 60 - cUtcMin;
1044	if (RT_ABS(pTime->offUTC) > 840)
1045	return NULL;
1046	}
1047	/* else: No time zone given, local with offUTC = 0. */
1048
1049	/*
1050	* The rest of the string should be blanks.
1051	*/
1052	char ch;
1053	while ((ch = *pszString++) != '\0')
1054	if (!RT_C_IS_BLANK(ch))
1055	return NULL;
1056
1057	/* Calc week day. */
1058	rtTimeNormalizeInternal(pTime);
1059	return pTime;
1060	}
1061	RT_EXPORT_SYMBOL(RTTimeFromString);
1062
1063
1064	/**
1065	* Attempts to convert an ISO date string to a time structure.
1066	*
1067	* We're a little forgiving with zero padding, unspecified parts, and leading
1068	* and trailing spaces.
1069	*
1070	* @retval pTime on success,
1071	* @retval NULL on failure.
1072	* @param pTime The time spec.
1073	* @param pszString The ISO date string to convert.
1074	*/
1075	RTDECL(PRTTIMESPEC) RTTimeSpecFromString(PRTTIMESPEC pTime, const char *pszString)
1076	{
1077	RTTIME Time;
1078	if (RTTimeFromString(&Time, pszString))
1079	return RTTimeImplode(pTime, &Time);
1080	return NULL;
1081	}
1082	RT_EXPORT_SYMBOL(RTTimeSpecFromString);
1083
1084
1085	/**
1086	* Formats the given time on a RTC-2822 compliant format.
1087	*
1088	* @returns Output string length on success (positive), VERR_BUFFER_OVERFLOW
1089	* (negative) on failure.
1090	* @param pTime The time. Caller should've normalized this.
1091	* @param psz Where to store the string.
1092	* @param cb The size of the buffer.
1093	*/
1094	RTDECL(ssize_t) RTTimeToRfc2822(PRTTIME pTime, char *psz, size_t cb, uint32_t fFlags)
1095	{
1096	Assert(pTime->u8Month > 0 && pTime->u8Month <= 12);
1097	Assert(pTime->u8WeekDay < 7);
1098	Assert(!(fFlags & ~RTTIME_RFC2822_F_GMT));
1099
1100	/* (Default to UTC if not specified) */
1101	if ( (pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) == RTTIME_FLAGS_TYPE_LOCAL
1102	&& pTime->offUTC)
1103	{
1104	Assert(!(fFlags & RTTIME_RFC2822_F_GMT) /* don't call with local time. duh! */ );
1105
1106	/* Calc the UTC offset part. */
1107	int32_t offUtc = pTime->offUTC;
1108	Assert(offUtc <= 840 && offUtc >= -840);
1109	char chSign;
1110	if (offUtc >= 0)
1111	chSign = '+';
1112	else
1113	{
1114	chSign = '-';
1115	offUtc = -offUtc;
1116	}
1117	uint32_t offUtcHour = (uint32_t)offUtc / 60;
1118	uint32_t offUtcMinute = (uint32_t)offUtc % 60;
1119
1120	/* Example: "Mon, 31 Aug 2018 00:00:00 +0200" */
1121	size_t cch = RTStrPrintf(psz, cb, "%s, %u %s %04RI32 %02u:%02u:%02u %c%02u%02u", g_apszWeekDays[pTime->u8WeekDay],
1122	pTime->u8MonthDay, g_apszMonths[pTime->u8Month], pTime->i32Year,
1123	pTime->u8Hour, pTime->u8Minute, pTime->u8Second, chSign, offUtcHour, offUtcMinute);
1124	if ( cch >= 27
1125	&& psz[cch - 5] == chSign)
1126	return cch;
1127	}
1128	else if (fFlags & RTTIME_RFC2822_F_GMT)
1129	{
1130	/* Example: "Mon, 1 Jan 1971 23:55:59 GMT" */
1131	size_t cch = RTStrPrintf(psz, cb, "%s, %u %s %04RI32 %02u:%02u:%02u GMT", g_apszWeekDays[pTime->u8WeekDay],
1132	pTime->u8MonthDay, g_apszMonths[pTime->u8Month], pTime->i32Year,
1133	pTime->u8Hour, pTime->u8Minute, pTime->u8Second);
1134	if ( cch >= 27
1135	&& psz[cch - 1] == 'T')
1136	return cch;
1137	}
1138	else
1139	{
1140	/* Example: "Mon, 1 Jan 1971 00:00:00 -0000" */
1141	size_t cch = RTStrPrintf(psz, cb, "%s, %u %s %04RI32 %02u:%02u:%02u -0000", g_apszWeekDays[pTime->u8WeekDay],
1142	pTime->u8MonthDay, g_apszMonths[pTime->u8Month], pTime->i32Year,
1143	pTime->u8Hour, pTime->u8Minute, pTime->u8Second);
1144	if ( cch >= 27
1145	&& psz[cch - 5] == '-')
1146	return cch;
1147	}
1148	return VERR_BUFFER_OVERFLOW;
1149	}
1150	RT_EXPORT_SYMBOL(RTTimeToRfc2822);
1151
1152
1153	/**
1154	* Attempts to convert an RFC-2822 date string to a time structure.
1155	*
1156	* We're a little forgiving with zero padding, unspecified parts, and leading
1157	* and trailing spaces.
1158	*
1159	* @retval pTime on success,
1160	* @retval NULL on failure.
1161	* @param pTime Where to store the time on success.
1162	* @param pszString The ISO date string to convert.
1163	*/
1164	RTDECL(PRTTIME) RTTimeFromRfc2822(PRTTIME pTime, const char *pszString)
1165	{
1166	/*
1167	* Fri, 31 Aug 2018 00:00:00 +0200
1168	* Mon, 3 Sep 2018 00:00:00 GMT
1169	* Mon, 3 Sep 2018 00:00:00 -0000
1170	* 3 Sep 2018 00:00:00 -0000 (?)
1171	* 3 Sep 2018 00:00:00 GMT (?)
1172	*
1173	*/
1174
1175	/* Ignore leading spaces. */
1176	while (RT_C_IS_SPACE(*pszString))
1177	pszString++;
1178
1179	/*
1180	* Init non date & time parts.
1181	*/
1182	pTime->fFlags = RTTIME_FLAGS_TYPE_LOCAL;
1183	pTime->offUTC = 0;
1184
1185	/*
1186	* The date part.
1187	*/
1188
1189	/* Optional day of week: */
1190	if (RT_C_IS_ALPHA(pszString[0]) && pszString[1] != '\0')
1191	{
1192	uint32_t uWeekDay = RT_MAKE_U32_FROM_U8(RT_C_TO_LOWER(pszString[0]), RT_C_TO_LOWER(pszString[1]),
1193	RT_C_TO_LOWER(pszString[2]), 0);
1194	if ( uWeekDay == RT_MAKE_U32_FROM_U8('m', 'o', 'n', 0)) pTime->u8WeekDay = 0;
1195	else if (uWeekDay == RT_MAKE_U32_FROM_U8('t', 'u', 'e', 0)) pTime->u8WeekDay = 1;
1196	else if (uWeekDay == RT_MAKE_U32_FROM_U8('w', 'e', 'd', 0)) pTime->u8WeekDay = 2;
1197	else if (uWeekDay == RT_MAKE_U32_FROM_U8('t', 'h', 'u', 0)) pTime->u8WeekDay = 3;
1198	else if (uWeekDay == RT_MAKE_U32_FROM_U8('f', 'r', 'i', 0)) pTime->u8WeekDay = 4;
1199	else if (uWeekDay == RT_MAKE_U32_FROM_U8('s', 'a', 't', 0)) pTime->u8WeekDay = 5;
1200	else if (uWeekDay == RT_MAKE_U32_FROM_U8('s', 'u', 'n', 0)) pTime->u8WeekDay = 6;
1201	else
1202	return NULL;
1203	pszString += 3;
1204	while (RT_C_IS_ALPHA(*pszString))
1205	pszString++;
1206	if (*pszString == ',')
1207	pszString++;
1208	while (RT_C_IS_SPACE(*pszString))
1209	pszString++;
1210	if (!RT_C_IS_DIGIT(pszString[0]))
1211	return NULL;
1212	}
1213	else if (RT_C_IS_DIGIT(pszString[0]))
1214	pTime->u8WeekDay = UINT8_MAX;
1215	else
1216	return NULL;
1217
1218	/* Day of month.*/
1219	int rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8MonthDay);
1220	if (rc != VWRN_TRAILING_CHARS && rc != VINF_SUCCESS)
1221	return NULL;
1222	while (RT_C_IS_SPACE(*pszString))
1223	pszString++;
1224
1225	/* Month of the year. */
1226	if (pszString[0] == '\0' \|\| pszString[1] == '\0' \|\| pszString[2] == '\0')
1227	return NULL;
1228	uint32_t uMonth = RT_MAKE_U32_FROM_U8(RT_C_TO_LOWER(pszString[0]), RT_C_TO_LOWER(pszString[1]),
1229	RT_C_TO_LOWER(pszString[2]), 0);
1230	if ( uMonth == RT_MAKE_U32_FROM_U8('j', 'a', 'n', 0)) pTime->u8Month = 1;
1231	else if (uMonth == RT_MAKE_U32_FROM_U8('f', 'e', 'b', 0)) pTime->u8Month = 2;
1232	else if (uMonth == RT_MAKE_U32_FROM_U8('m', 'a', 'r', 0)) pTime->u8Month = 3;
1233	else if (uMonth == RT_MAKE_U32_FROM_U8('a', 'p', 'r', 0)) pTime->u8Month = 4;
1234	else if (uMonth == RT_MAKE_U32_FROM_U8('m', 'a', 'y', 0)) pTime->u8Month = 5;
1235	else if (uMonth == RT_MAKE_U32_FROM_U8('j', 'u', 'n', 0)) pTime->u8Month = 6;
1236	else if (uMonth == RT_MAKE_U32_FROM_U8('j', 'u', 'l', 0)) pTime->u8Month = 7;
1237	else if (uMonth == RT_MAKE_U32_FROM_U8('a', 'u', 'g', 0)) pTime->u8Month = 8;
1238	else if (uMonth == RT_MAKE_U32_FROM_U8('s', 'e', 'p', 0)) pTime->u8Month = 9;
1239	else if (uMonth == RT_MAKE_U32_FROM_U8('o', 'c', 't', 0)) pTime->u8Month = 10;
1240	else if (uMonth == RT_MAKE_U32_FROM_U8('n', 'o', 'v', 0)) pTime->u8Month = 11;
1241	else if (uMonth == RT_MAKE_U32_FROM_U8('d', 'e', 'c', 0)) pTime->u8Month = 12;
1242	else
1243	return NULL;
1244	pszString += 3;
1245	while (RT_C_IS_ALPHA(*pszString))
1246	pszString++;
1247	while (RT_C_IS_SPACE(*pszString))
1248	pszString++;
1249
1250	/* Year */
1251	const char * const pszStartYear = pszString;
1252	rc = RTStrToInt32Ex(pszString, (char **)&pszString, 10, &pTime->i32Year);
1253	if (rc != VWRN_TRAILING_CHARS)
1254	return NULL;
1255	if (pszString - pszStartYear >= 4 )
1256	{ /* likely */ }
1257	else if (pszString - pszStartYear == 3)
1258	pTime->i32Year += 1900;
1259	else if (pszString - pszStartYear == 2)
1260	pTime->i32Year += pTime->i32Year >= 50 ? 1900 : 2000;
1261	else
1262	return NULL;
1263
1264	bool const fLeapYear = rtTimeIsLeapYear(pTime->i32Year);
1265	if (fLeapYear)
1266	pTime->fFlags \|= RTTIME_FLAGS_LEAP_YEAR;
1267
1268	while (RT_C_IS_SPACE(*pszString))
1269	pszString++;
1270
1271
1272	/* Calculate year day. */
1273	unsigned const cDaysInMonth = fLeapYear
1274	? g_acDaysInMonthsLeap[pTime->u8Month - 1]
1275	: g_acDaysInMonths[pTime->u8Month - 1];
1276	if (pTime->u8MonthDay == 0 \|\| pTime->u8MonthDay > cDaysInMonth)
1277	return NULL;
1278
1279	pTime->u16YearDay = pTime->u8MonthDay - 1
1280	+ (fLeapYear
1281	? g_aiDayOfYearLeap[pTime->u8Month - 1]
1282	: g_aiDayOfYear[pTime->u8Month - 1]);
1283
1284	/*
1285	* The time part.
1286	*/
1287	/* Hour. */
1288	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Hour);
1289	if (rc != VWRN_TRAILING_CHARS)
1290	return NULL;
1291	if (pTime->u8Hour > 23)
1292	return NULL;
1293	if (*pszString++ != ':')
1294	return NULL;
1295
1296	/* Minute. */
1297	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Minute);
1298	if (rc != VWRN_TRAILING_CHARS)
1299	return NULL;
1300	if (pTime->u8Minute > 59)
1301	return NULL;
1302	if (*pszString++ != ':')
1303	return NULL;
1304
1305	/* Second. */
1306	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &pTime->u8Second);
1307	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS && rc != VWRN_TRAILING_SPACES)
1308	return NULL;
1309	if (pTime->u8Second > 59)
1310	return NULL;
1311
1312	/* Non-standard fraction. Handy for testing, though. */
1313	if (*pszString == '.')
1314	{
1315	const char * const pszStart = ++pszString;
1316	rc = RTStrToUInt32Ex(pszString, (char **)&pszString, 10, &pTime->u32Nanosecond);
1317	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS && rc != VWRN_TRAILING_SPACES)
1318	return NULL;
1319	if (pTime->u32Nanosecond >= 1000000000)
1320	return NULL;
1321	switch (pszString - pszStart)
1322	{
1323	case 1: pTime->u32Nanosecond *= 100000000; break;
1324	case 2: pTime->u32Nanosecond *= 10000000; break;
1325	case 3: pTime->u32Nanosecond *= 1000000; break;
1326	case 4: pTime->u32Nanosecond *= 100000; break;
1327	case 5: pTime->u32Nanosecond *= 10000; break;
1328	case 6: pTime->u32Nanosecond *= 1000; break;
1329	case 7: pTime->u32Nanosecond *= 100; break;
1330	case 8: pTime->u32Nanosecond *= 10; break;
1331	case 9: break;
1332	default:
1333	return NULL;
1334	}
1335	if (pTime->u32Nanosecond >= 1000000000)
1336	return NULL;
1337	}
1338	else
1339	pTime->u32Nanosecond = 0;
1340	while (RT_C_IS_SPACE(*pszString))
1341	pszString++;
1342
1343	/*
1344	* Time zone.
1345	*/
1346	if ( *pszString == '+'
1347	\|\| *pszString == '-')
1348	{
1349	if ( !RT_C_IS_DIGIT(pszString[1])
1350	\|\| !RT_C_IS_DIGIT(pszString[2]))
1351	return NULL;
1352	int8_t cUtcHours = (pszString[1] - '0') * 10 + (pszString[2] - '0');
1353	char chSign = *pszString;
1354	if (chSign == '-')
1355	cUtcHours = -cUtcHours;
1356	pszString += 3;
1357
1358	uint8_t cUtcMin = 0;
1359	if (RT_C_IS_DIGIT(pszString[0]))
1360	{
1361	rc = RTStrToUInt8Ex(pszString, (char **)&pszString, 10, &cUtcMin);
1362	if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES)
1363	return NULL;
1364	}
1365	else if (pszString && !RT_C_IS_BLANK(pszString))
1366	return NULL;
1367	if (cUtcHours >= 0)
1368	pTime->offUTC = cUtcHours * 60 + cUtcMin;
1369	else
1370	pTime->offUTC = cUtcHours * 60 - cUtcMin;
1371	if (RT_ABS(pTime->offUTC) > 840)
1372	return NULL;
1373
1374	/* -0000: GMT isn't necessarily the local time zone, so change flags from local to UTC. */
1375	if (pTime->offUTC == 0 && chSign == '-')
1376	{
1377	pTime->fFlags &= ~RTTIME_FLAGS_TYPE_MASK;
1378	pTime->fFlags \|= RTTIME_FLAGS_TYPE_UTC;
1379	}
1380	}
1381	else if (RT_C_IS_ALPHA(*pszString))
1382	{
1383	uint32_t uTimeZone = RT_MAKE_U32_FROM_U8(RT_C_TO_LOWER(pszString[0]), RT_C_TO_LOWER(pszString[1]),
1384	RT_C_TO_LOWER(pszString[2]), 0);
1385	if (uTimeZone == RT_MAKE_U32_FROM_U8('g', 'm', 't', 0))
1386	{
1387	pTime->fFlags &= ~RTTIME_FLAGS_TYPE_MASK;
1388	pTime->fFlags \|= RTTIME_FLAGS_TYPE_UTC;
1389	pTime->offUTC = 0;
1390	pszString += 3;
1391	}
1392	else if ((uint16_t)uTimeZone == RT_MAKE_U16('u', 't'))
1393	{
1394	pTime->fFlags &= ~RTTIME_FLAGS_TYPE_MASK;
1395	pTime->fFlags \|= RTTIME_FLAGS_TYPE_UTC;
1396	pTime->offUTC = 0;
1397	pszString += 2;
1398	}
1399	else
1400	{
1401	static const struct { uint32_t uTimeZone; int32_t offUtc; } s_aLegacyTimeZones[] =
1402	{
1403	{ RT_MAKE_U32_FROM_U8('e', 'd', 't', 0), -4*60 },
1404	{ RT_MAKE_U32_FROM_U8('e', 's', 't', 0), -5*60 },
1405	{ RT_MAKE_U32_FROM_U8('c', 'd', 't', 0), -5*60 },
1406	{ RT_MAKE_U32_FROM_U8('c', 's', 't', 0), -6*60 },
1407	{ RT_MAKE_U32_FROM_U8('m', 'd', 't', 0), -6*60 },
1408	{ RT_MAKE_U32_FROM_U8('m', 's', 't', 0), -7*60 },
1409	{ RT_MAKE_U32_FROM_U8('p', 'd', 't', 0), -7*60 },
1410	{ RT_MAKE_U32_FROM_U8('p', 's', 't', 0), -8*60 },
1411	};
1412	size_t i = RT_ELEMENTS(s_aLegacyTimeZones);
1413	while (i-- > 0)
1414	if (s_aLegacyTimeZones[i].uTimeZone == uTimeZone)
1415	{
1416	pTime->fFlags &= ~RTTIME_FLAGS_TYPE_MASK;
1417	pTime->fFlags \|= RTTIME_FLAGS_TYPE_LOCAL;
1418	pTime->offUTC = s_aLegacyTimeZones[i].offUtc;
1419	pszString += 3;
1420	break;
1421	}
1422	}
1423
1424	}
1425	/* else: No time zone given, local with offUTC = 0. */
1426
1427	/*
1428	* The rest of the string should be blanks.
1429	*/
1430	char ch;
1431	while ((ch = *pszString++) != '\0')
1432	if (!RT_C_IS_BLANK(ch))
1433	return NULL;
1434
1435	rtTimeNormalizeInternal(pTime);
1436	return pTime;
1437	}
1438	RT_EXPORT_SYMBOL(RTTimeFromRfc2822);
1439
1440
1441	/**
1442	* Adds one day to @a pTime.
1443	*
1444	* ASSUMES it is zulu time so DST can be ignored.
1445	*/
1446	static PRTTIME rtTimeAdd1Day(PRTTIME pTime)
1447	{
1448	Assert(!pTime->offUTC);
1449	rtTimeNormalizeInternal(pTime);
1450	pTime->u8MonthDay += 1;
1451	pTime->u16YearDay = 0;
1452	return rtTimeNormalizeInternal(pTime);
1453	}
1454
1455
1456	/**
1457	* Subtracts one day from @a pTime.
1458	*
1459	* ASSUMES it is zulu time so DST can be ignored.
1460	*/
1461	static PRTTIME rtTimeSub1Day(PRTTIME pTime)
1462	{
1463	Assert(!pTime->offUTC);
1464	rtTimeNormalizeInternal(pTime);
1465	if (pTime->u16YearDay > 1)
1466	{
1467	pTime->u16YearDay -= 1;
1468	pTime->u8Month = 0;
1469	pTime->u8MonthDay = 0;
1470	}
1471	else
1472	{
1473	pTime->i32Year -= 1;
1474	pTime->u16YearDay = rtTimeIsLeapYear(pTime->i32Year) ? 366 : 365;
1475	pTime->u8MonthDay = 31;
1476	pTime->u8Month = 12;
1477	pTime->fFlags &= ~(RTTIME_FLAGS_COMMON_YEAR \| RTTIME_FLAGS_LEAP_YEAR);
1478	}
1479	return rtTimeNormalizeInternal(pTime);
1480	}
1481
1482
1483	/**
1484	* Adds a signed number of minutes to @a pTime.
1485	*
1486	* ASSUMES it is zulu time so DST can be ignored.
1487	*
1488	* @param pTime The time structure to work on.
1489	* @param cAddend Number of minutes to add.
1490	* ASSUMES the value isn't all that high!
1491	*/
1492	static PRTTIME rtTimeAddMinutes(PRTTIME pTime, int32_t cAddend)
1493	{
1494	Assert(RT_ABS(cAddend) < 31 * 24 * 60);
1495
1496	/*
1497	* Work on minutes of the day.
1498	*/
1499	int32_t const cMinutesInDay = 24 * 60;
1500	int32_t iDayMinute = (unsigned)pTime->u8Hour * 60 + pTime->u8Minute;
1501	iDayMinute += cAddend;
1502
1503	while (iDayMinute >= cMinutesInDay)
1504	{
1505	rtTimeAdd1Day(pTime);
1506	iDayMinute -= cMinutesInDay;
1507	}
1508
1509	while (iDayMinute < 0)
1510	{
1511	rtTimeSub1Day(pTime);
1512	iDayMinute += cMinutesInDay;
1513	}
1514
1515	pTime->u8Hour = iDayMinute / 60;
1516	pTime->u8Minute = iDayMinute % 60;
1517
1518	return pTime;
1519	}
1520
1521
1522	/**
1523	* Converts @a pTime to zulu time (UTC) if needed.
1524	*
1525	* @returns pTime.
1526	* @param pTime What to convert (in/out).
1527	*/
1528	static PRTTIME rtTimeConvertToZulu(PRTTIME pTime)
1529	{
1530	RTTIME_ASSERT_NORMALIZED(pTime);
1531	if ((pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) != RTTIME_FLAGS_TYPE_UTC)
1532	{
1533	int32_t offUTC = pTime->offUTC;
1534	pTime->offUTC = 0;
1535	pTime->fFlags &= ~RTTIME_FLAGS_TYPE_MASK;
1536	pTime->fFlags \|= RTTIME_FLAGS_TYPE_UTC;
1537	if (offUTC != 0)
1538	rtTimeAddMinutes(pTime, -offUTC);
1539	}
1540	return pTime;
1541	}
1542
1543
1544	/**
1545	* Converts a time structure to UTC, relying on UTC offset information if it contains local time.
1546	*
1547	* @returns pTime on success.
1548	* @returns NULL if the data is invalid.
1549	* @param pTime The time structure to convert.
1550	*/
1551	RTDECL(PRTTIME) RTTimeConvertToZulu(PRTTIME pTime)
1552	{
1553	/*
1554	* Validate that we've got the minimum of stuff handy.
1555	*/
1556	AssertReturn(VALID_PTR(pTime), NULL);
1557	AssertMsgReturn(!(pTime->fFlags & ~RTTIME_FLAGS_MASK), ("%#x\n", pTime->fFlags), NULL);
1558
1559	return rtTimeConvertToZulu(rtTimeNormalizeInternal(pTime));
1560	}
1561	RT_EXPORT_SYMBOL(RTTimeConvertToZulu);
1562
1563
1564	/**
1565	* Compares two normalized time structures.
1566	*
1567	* @retval 0 if equal.
1568	* @retval -1 if @a pLeft is earlier than @a pRight.
1569	* @retval 1 if @a pRight is earlier than @a pLeft.
1570	*
1571	* @param pLeft The left side time. NULL is accepted.
1572	* @param pRight The right side time. NULL is accepted.
1573	*
1574	* @note A NULL time is considered smaller than anything else. If both are
1575	* NULL, they are considered equal.
1576	*/
1577	RTDECL(int) RTTimeCompare(PCRTTIME pLeft, PCRTTIME pRight)
1578	{
1579	#ifdef RT_STRICT
1580	if (pLeft)
1581	RTTIME_ASSERT_NORMALIZED(pLeft);
1582	if (pRight)
1583	RTTIME_ASSERT_NORMALIZED(pRight);
1584	#endif
1585
1586	int iRet;
1587	if (pLeft)
1588	{
1589	if (pRight)
1590	{
1591	/*
1592	* Only work with normalized zulu time.
1593	*/
1594	RTTIME TmpLeft;
1595	if ( pLeft->offUTC != 0
1596	\|\| pLeft->u16YearDay == 0
1597	\|\| pLeft->u16YearDay > 366
1598	\|\| pLeft->u8Hour >= 60
1599	\|\| pLeft->u8Minute >= 60
1600	\|\| pLeft->u8Second >= 60)
1601	{
1602	TmpLeft = *pLeft;
1603	pLeft = rtTimeConvertToZulu(rtTimeNormalizeInternal(&TmpLeft));
1604	}
1605
1606	RTTIME TmpRight;
1607	if ( pRight->offUTC != 0
1608	\|\| pRight->u16YearDay == 0
1609	\|\| pRight->u16YearDay > 366
1610	\|\| pRight->u8Hour >= 60
1611	\|\| pRight->u8Minute >= 60
1612	\|\| pRight->u8Second >= 60)
1613	{
1614	TmpRight = *pRight;
1615	pRight = rtTimeConvertToZulu(rtTimeNormalizeInternal(&TmpRight));
1616	}
1617
1618	/*
1619	* Do the comparison.
1620	*/
1621	if ( pLeft->i32Year != pRight->i32Year)
1622	iRet = pLeft->i32Year < pRight->i32Year ? -1 : 1;
1623	else if ( pLeft->u16YearDay != pRight->u16YearDay)
1624	iRet = pLeft->u16YearDay < pRight->u16YearDay ? -1 : 1;
1625	else if ( pLeft->u8Hour != pRight->u8Hour)
1626	iRet = pLeft->u8Hour < pRight->u8Hour ? -1 : 1;
1627	else if ( pLeft->u8Minute != pRight->u8Minute)
1628	iRet = pLeft->u8Minute < pRight->u8Minute ? -1 : 1;
1629	else if ( pLeft->u8Second != pRight->u8Second)
1630	iRet = pLeft->u8Second < pRight->u8Second ? -1 : 1;
1631	else if ( pLeft->u32Nanosecond != pRight->u32Nanosecond)
1632	iRet = pLeft->u32Nanosecond < pRight->u32Nanosecond ? -1 : 1;
1633	else
1634	iRet = 0;
1635	}
1636	else
1637	iRet = 1;
1638	}
1639	else
1640	iRet = pRight ? -1 : 0;
1641	return iRet;
1642	}
1643	RT_EXPORT_SYMBOL(RTTimeCompare);
1644

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/time/time.cpp@ 76553

Download in other formats: