Time.c@ 77599

最後變更在這個檔案從77599是 48674,由 vboxsync 提交於 11 年前
EFI: Export newly imported tinaocore UEFI sources to OSE.
屬性 svn:eol-style 設為 `native`
檔案大小: 22.2 KB

行
1	/**
2	Definitions and Implementation for <time.h>.
3
4	Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
5	This program and the accompanying materials are licensed and made available under
6	the terms and conditions of the BSD License that accompanies this distribution.
7	The full text of the license may be found at
8	http://opensource.org/licenses/bsd-license.php.
9
10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13	Portions derived from the NIH time zone package file, localtime.c,
14	which contains the following notice:
15
16	This file is in the public domain, so clarified as of
17	1996-06-05 by Arthur David Olson ([email protected]).
18
19	NetBSD: localtime.c,v 1.39 2006/03/22 14:01:30 christos Exp
20	**/
21	#include <Uefi.h>
22	#include <Library/UefiLib.h>
23	#include <Library/TimerLib.h>
24	#include <Library/BaseLib.h>
25	#include <Library/UefiRuntimeServicesTableLib.h>
26	//#include <Library/UefiRuntimeLib.h>
27
28	#include <LibConfig.h>
29
30	#include <errno.h>
31	#include <limits.h>
32	#include <time.h>
33	#include <reentrant.h>
34	#include "tzfile.h"
35	#include "TimeVals.h"
36	#include <MainData.h>
37	#include <extern.h> // Library/include/extern.h: Private to implementation
38
39	#if defined(_MSC_VER) /* Handle Microsoft VC++ compiler specifics. */
40	// Keep compiler quiet about casting from function to data pointers
41	#pragma warning ( disable : 4054 )
42	#endif /* defined(_MSC_VER) */
43
44	/* ####################### Private Data ################################# */
45
46	#if 0
47	static EFI_TIME TimeBuffer;
48
49	static UINT16 MonthOffs[12] = {
50	00,
51	31, 59, 90, 120,
52	151, 181, 212, 243,
53	273, 304, 334
54	};
55	static clock_t y2kOffs = 730485;
56	#endif
57
58	const int mon_lengths[2][MONSPERYEAR] = {
59	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
60	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
61	};
62
63	const int year_lengths[2] = {
64	DAYSPERNYEAR, DAYSPERLYEAR
65	};
66
67
68	static const char *wday_name[7] = {
69	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
70	};
71
72	static const char *mon_name[12] = {
73	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
74	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
75	};
76
77	static int gmt_is_set;
78
79	/* ############### Implementation Functions ############################ */
80	// Forward reference
81	static void
82	localsub(const time_t * const timep, const long offset, struct tm * const tmp);
83
84	clock_t
85	__getCPS(void)
86	{
87	return gMD->ClocksPerSecond;
88	}
89
90	static void
91	timesub(
92	const time_t * const timep,
93	const long offset,
94	const struct state * const sp,
95	struct tm * const tmp
96	)
97	{
98	const struct lsinfo * lp;
99	time_t /INTN/ days;
100	time_t /INTN/ rem;
101	time_t /INTN/ y;
102	int yleap;
103	const int * ip;
104	time_t /INTN/ corr;
105	int hit;
106	int i;
107
108	corr = 0;
109	hit = 0;
110	#ifdef ALL_STATE
111	i = (sp == NULL) ? 0 : sp->leapcnt;
112	#endif /* defined ALL_STATE */
113	#ifndef ALL_STATE
114	i = sp->leapcnt;
115	#endif /* State Farm */
116	while (--i >= 0) {
117	lp = &sp->lsis[i];
118	if (*timep >= lp->ls_trans) {
119	if (*timep == lp->ls_trans) {
120	hit = ((i == 0 && lp->ls_corr > 0) \|\|
121	lp->ls_corr > sp->lsis[i - 1].ls_corr);
122	if (hit)
123	while (i > 0 &&
124	sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&
125	sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1 )
126	{
127	++hit;
128	--i;
129	}
130	}
131	corr = lp->ls_corr;
132	break;
133	}
134	}
135	days = *timep / SECSPERDAY;
136	rem = *timep % SECSPERDAY;
137	rem += (offset - corr);
138	while (rem < 0) {
139	rem += SECSPERDAY;
140	--days;
141	}
142	while (rem >= SECSPERDAY) {
143	rem -= SECSPERDAY;
144	++days;
145	}
146	tmp->tm_hour = (int) (rem / SECSPERHOUR);
147	rem = rem % SECSPERHOUR;
148	tmp->tm_min = (int) (rem / SECSPERMIN);
149	/*
150	** A positive leap second requires a special
151	** representation. This uses "... ??:59:60" et seq.
152	*/
153	tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
154	tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
155	if (tmp->tm_wday < 0)
156	tmp->tm_wday += DAYSPERWEEK;
157	y = EPOCH_YEAR;
158	while (days < 0 \|\| days >= (LONG32) year_lengths[yleap = isleap(y)]) {
159	time_t /INTN/ newy;
160
161	newy = (y + days / DAYSPERNYEAR);
162	if (days < 0)
163	--newy;
164	days -= (newy - y) * DAYSPERNYEAR +
165	LEAPS_THRU_END_OF(newy - 1) -
166	LEAPS_THRU_END_OF(y - 1);
167	y = newy;
168	}
169	tmp->tm_year = (int)(y - TM_YEAR_BASE);
170	tmp->tm_yday = (int) days;
171	ip = mon_lengths[yleap];
172	for (tmp->tm_mon = 0; days >= (LONG32) ip[tmp->tm_mon]; ++(tmp->tm_mon))
173	days = days - (LONG32) ip[tmp->tm_mon];
174	tmp->tm_mday = (int) (days + 1);
175	tmp->tm_isdst = 0;
176	#ifdef TM_GMTOFF
177	tmp->TM_GMTOFF = offset;
178	#endif /* defined TM_GMTOFF */
179	}
180
181	/* ############### Time Manipulation Functions ########################## */
182
183	/**
184	**/
185	double
186	difftime(time_t time1, time_t time0)
187	{
188	return (double)(time1 - time0);
189	}
190
191	/*
192	** Adapted from code provided by Robert Elz, who writes:
193	** The "best" way to do mktime I think is based on an idea of Bob
194	** Kridle's (so its said...) from a long time ago.
195	** [[email protected] as of 1996-01-16.]
196	** It does a binary search of the time_t space. Since time_t's are
197	** just 32 bits, its a max of 32 iterations (even at 64 bits it
198	** would still be very reasonable).
199	*/
200
201	#ifndef WRONG
202	#define WRONG (-1)
203	#endif /* !defined WRONG */
204
205	/*
206	** Simplified normalize logic courtesy Paul Eggert ([email protected]).
207	*/
208
209	static int
210	increment_overflow(int * number, int delta)
211	{
212	int number0;
213
214	number0 = *number;
215	*number += delta;
216	return (*number < number0) != (delta < 0);
217	}
218
219	static int
220	normalize_overflow(int * const tensptr, int * const unitsptr, const int base)
221	{
222	register int tensdelta;
223
224	tensdelta = (*unitsptr >= 0) ?
225	(unitsptr / base) : (-1 - (-1 - unitsptr) / base);
226	unitsptr -= tensdelta base;
227	return increment_overflow(tensptr, tensdelta);
228	}
229
230	static int
231	tmcomp(const struct tm * const atmp, const struct tm * const btmp)
232	{
233	register int result;
234
235	if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
236	(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
237	(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
238	(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
239	(result = (atmp->tm_min - btmp->tm_min)) == 0)
240	result = atmp->tm_sec - btmp->tm_sec;
241	return result;
242	}
243
244	static time_t
245	time2sub(
246	struct tm * const tmp,
247	void (* const funcp)(const time_t, long, struct tm),
248	const long offset,
249	int * const okayp,
250	const int do_norm_secs
251	)
252	{
253	register const struct state * sp;
254	register int dir;
255	register int bits;
256	register int i, j ;
257	register int saved_seconds;
258	time_t newt;
259	time_t t;
260	struct tm yourtm, mytm;
261
262	*okayp = FALSE;
263	yourtm = *tmp; // Create a copy of tmp
264	if (do_norm_secs) {
265	if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,
266	SECSPERMIN))
267	return WRONG;
268	}
269	if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
270	return WRONG;
271	if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
272	return WRONG;
273	if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR))
274	return WRONG;
275	/*
276	** Turn yourtm.tm_year into an actual year number for now.
277	** It is converted back to an offset from TM_YEAR_BASE later.
278	*/
279	if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE))
280	return WRONG;
281	while (yourtm.tm_mday <= 0) {
282	if (increment_overflow(&yourtm.tm_year, -1))
283	return WRONG;
284	i = yourtm.tm_year + (1 < yourtm.tm_mon);
285	yourtm.tm_mday += year_lengths[isleap(i)];
286	}
287	while (yourtm.tm_mday > DAYSPERLYEAR) {
288	i = yourtm.tm_year + (1 < yourtm.tm_mon);
289	yourtm.tm_mday -= year_lengths[isleap(i)];
290	if (increment_overflow(&yourtm.tm_year, 1))
291	return WRONG;
292	}
293	for ( ; ; ) {
294	i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon];
295	if (yourtm.tm_mday <= i)
296	break;
297	yourtm.tm_mday -= i;
298	if (++yourtm.tm_mon >= MONSPERYEAR) {
299	yourtm.tm_mon = 0;
300	if (increment_overflow(&yourtm.tm_year, 1))
301	return WRONG;
302	}
303	}
304	if (increment_overflow(&yourtm.tm_year, -TM_YEAR_BASE))
305	return WRONG;
306	if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
307	saved_seconds = 0;
308	else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) {
309	/*
310	** We can't set tm_sec to 0, because that might push the
311	** time below the minimum representable time.
312	** Set tm_sec to 59 instead.
313	** This assumes that the minimum representable time is
314	** not in the same minute that a leap second was deleted from,
315	** which is a safer assumption than using 58 would be.
316	*/
317	if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
318	return WRONG;
319	saved_seconds = yourtm.tm_sec;
320	yourtm.tm_sec = SECSPERMIN - 1;
321	} else {
322	saved_seconds = yourtm.tm_sec;
323	yourtm.tm_sec = 0;
324	}
325	/*
326	** Divide the search space in half
327	** (this works whether time_t is signed or unsigned).
328	*/
329	bits = TYPE_BIT(time_t) - 1;
330	/*
331	** Set t to the midpoint of our binary search.
332	**
333	** If time_t is signed, then 0 is just above the median,
334	** assuming two's complement arithmetic.
335	** If time_t is unsigned, then (1 << bits) is just above the median.
336	*/
337	t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits);
338	for ( ; ; ) {
339	(*funcp)(&t, offset, &mytm); // Convert t to broken-down time in mytm
340	dir = tmcomp(&mytm, &yourtm); // Is mytm larger, equal, or less than yourtm?
341	if (dir != 0) { // If mytm != yourtm...
342	if (bits-- < 0) // If we have exhausted all the bits..
343	return WRONG; // Return that we failed
344	if (bits < 0) // If on the last bit...
345	--t; /* may be needed if new t is minimal */
346	else if (dir > 0) // else if mytm > yourtm...
347	t -= ((time_t) 1) << bits; // subtract half the remaining time-space
348	else t += ((time_t) 1) << bits; // otherwise add half the remaining time-space
349	continue; // Repeat for the next half
350	}
351	if (yourtm.tm_isdst < 0 \|\| mytm.tm_isdst == yourtm.tm_isdst)
352	break;
353	/*
354	** Right time, wrong type.
355	** Hunt for right time, right type.
356	** It's okay to guess wrong since the guess
357	** gets checked.
358	*/
359	/*
360	** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
361	*/
362	sp = (const struct state *)
363	(((void ) funcp == (void ) localsub) ?
364	lclptr : gmtptr);
365	#ifdef ALL_STATE
366	if (sp == NULL)
367	return WRONG;
368	#endif /* defined ALL_STATE */
369	for (i = sp->typecnt - 1; i >= 0; --i) {
370	if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
371	continue;
372	for (j = sp->typecnt - 1; j >= 0; --j) {
373	if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
374	continue;
375	newt = t + sp->ttis[j].tt_gmtoff -
376	sp->ttis[i].tt_gmtoff;
377	(*funcp)(&newt, offset, &mytm);
378	if (tmcomp(&mytm, &yourtm) != 0)
379	continue;
380	if (mytm.tm_isdst != yourtm.tm_isdst)
381	continue;
382	/*
383	** We have a match.
384	*/
385	t = newt;
386	goto label;
387	}
388	}
389	return WRONG;
390	}
391	label:
392	newt = t + saved_seconds;
393	if ((newt < t) != (saved_seconds < 0))
394	return WRONG;
395	t = newt;
396	(*funcp)(&t, offset, tmp);
397	*okayp = TRUE;
398	return t;
399	}
400
401	time_t
402	time2(struct tm * const tmp, void (* const funcp)(const time_t, long, struct tm),
403	const long offset, int * const okayp)
404	{
405	time_t t;
406
407	/*
408	** First try without normalization of seconds
409	** (in case tm_sec contains a value associated with a leap second).
410	** If that fails, try with normalization of seconds.
411	*/
412	t = time2sub(tmp, funcp, offset, okayp, FALSE);
413	return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE);
414	}
415
416	static time_t
417	time1(
418	struct tm * const tmp,
419	void (* const funcp)(const time_t , long, struct tm ),
420	const long offset
421	)
422	{
423	register time_t t;
424	register const struct state * sp;
425	register int samei, otheri;
426	register int sameind, otherind;
427	register int i;
428	register int nseen;
429	int seen[TZ_MAX_TYPES];
430	int types[TZ_MAX_TYPES];
431	int okay;
432
433	if (tmp->tm_isdst > 1)
434	tmp->tm_isdst = 1;
435	t = time2(tmp, funcp, offset, &okay);
436	#ifdef PCTS
437	/*
438	** PCTS code courtesy Grant Sullivan ([email protected]).
439	*/
440	if (okay)
441	return t;
442	if (tmp->tm_isdst < 0)
443	tmp->tm_isdst = 0; /* reset to std and try again */
444	#endif /* defined PCTS */
445	#ifndef PCTS
446	if (okay \|\| tmp->tm_isdst < 0)
447	return t;
448	#endif /* !defined PCTS */
449	/*
450	** We're supposed to assume that somebody took a time of one type
451	** and did some math on it that yielded a "struct tm" that's bad.
452	** We try to divine the type they started from and adjust to the
453	** type they need.
454	*/
455	/*
456	** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
457	*/
458	sp = (const struct state ) (((void ) funcp == (void *) localsub) ?
459	lclptr : gmtptr);
460	#ifdef ALL_STATE
461	if (sp == NULL)
462	return WRONG;
463	#endif /* defined ALL_STATE */
464	for (i = 0; i < sp->typecnt; ++i)
465	seen[i] = FALSE;
466	nseen = 0;
467	for (i = sp->timecnt - 1; i >= 0; --i)
468	if (!seen[sp->types[i]]) {
469	seen[sp->types[i]] = TRUE;
470	types[nseen++] = sp->types[i];
471	}
472	for (sameind = 0; sameind < nseen; ++sameind) {
473	samei = types[sameind];
474	if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
475	continue;
476	for (otherind = 0; otherind < nseen; ++otherind) {
477	otheri = types[otherind];
478	if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
479	continue;
480	tmp->tm_sec += (int)(sp->ttis[otheri].tt_gmtoff -
481	sp->ttis[samei].tt_gmtoff);
482	tmp->tm_isdst = !tmp->tm_isdst;
483	t = time2(tmp, funcp, offset, &okay);
484	if (okay)
485	return t;
486	tmp->tm_sec -= (int)(sp->ttis[otheri].tt_gmtoff -
487	sp->ttis[samei].tt_gmtoff);
488	tmp->tm_isdst = !tmp->tm_isdst;
489	}
490	}
491	return WRONG;
492	}
493
494	/** The mktime function converts the broken-down time, expressed as local time,
495	in the structure pointed to by timeptr into a calendar time value with the
496	same encoding as that of the values returned by the time function. The
497	original values of the tm_wday and tm_yday components of the structure are
498	ignored, and the original values of the other components are not restricted
499	to the ranges indicated above. Thus, a positive or zero value for tm_isdst
500	causes the mktime function to presume initially that Daylight Saving Time,
501	respectively, is or is not in effect for the specified time. A negative
502	value causes it to attempt to determine whether Daylight Saving Time is in
503	effect for the specified time. On successful completion, the values of the
504	tm_wday and tm_yday components of the structure are set appropriately, and
505	the other components are set to represent the specified calendar time, but
506	with their values forced to the ranges indicated above; the final value of
507	tm_mday is not set until tm_mon and tm_year are determined.
508
509	@return The mktime function returns the specified calendar time encoded
510	as a value of type time_t. If the calendar time cannot be
511	represented, the function returns the value (time_t)(-1).
512	**/
513	time_t
514	mktime(struct tm *timeptr)
515	{
516	/* From NetBSD */
517	time_t result;
518
519	rwlock_wrlock(&lcl_lock);
520	tzset();
521	result = time1(timeptr, &localsub, 0L);
522	rwlock_unlock(&lcl_lock);
523	return (result);
524	}
525
526	/** The time function determines the current calendar time. The encoding of
527	the value is unspecified.
528
529	@return The time function returns the implementation's best approximation
530	to the current calendar time. The value (time_t)(-1) is returned
531	if the calendar time is not available. If timer is not a null
532	pointer, the return value is also assigned to the object it
533	points to.
534	**/
535	time_t
536	time(time_t *timer)
537	{
538	time_t CalTime;
539	EFI_STATUS Status;
540	EFI_TIME *ET;
541	struct tm *BT;
542
543	ET = &gMD->TimeBuffer;
544	BT = &gMD->BDTime;
545
546	// Get EFI Time
547	Status = gRT->GetTime( ET, NULL);
548	// Status = EfiGetTime( ET, NULL);
549	EFIerrno = Status;
550	if( Status != RETURN_SUCCESS) {
551	return (time_t)-1;
552	}
553
554	// Convert EFI time to broken-down time.
555	Efi2Tm( ET, BT);
556
557	// Convert to time_t
558	CalTime = mktime(&gMD->BDTime);
559
560	if( timer != NULL) {
561	*timer = CalTime;
562	}
563	return CalTime; // Return calendar time in microseconds
564	}
565
566	/** The clock function determines the processor time used.
567
568	@return The clock function returns the implementation's best
569	approximation to the processor time used by the program since the
570	beginning of an implementation-defined era related only to the
571	program invocation. To determine the time in seconds, the value
572	returned by the clock function should be divided by the value of
573	the macro CLOCKS_PER_SEC. If the processor time used is not
574	available or its value cannot be represented, the function
575	returns the value (clock_t)(-1).
576	**/
577	clock_t
578	clock(void)
579	{
580	clock_t retval;
581	time_t temp;
582
583	temp = time(NULL);
584	retval = ((clock_t)((UINT32)temp)) - gMD->AppStartTime;
585	return retval;
586	}
587
588	/* ################# Time Conversion Functions ########################## */
589	/*
590	Except for the strftime function, these functions each return a pointer to
591	one of two types of static objects: a broken-down time structure or an
592	array of char. Execution of any of the functions that return a pointer to
593	one of these object types may overwrite the information in any object of
594	the same type pointed to by the value returned from any previous call to
595	any of them. The implementation shall behave as if no other library
596	functions call these functions.
597	*/
598
599	/** The asctime function converts the broken-down time in the structure pointed
600	to by timeptr into a string in the form
601	Sun Sep 16 01:03:52 1973\n\0
602	using the equivalent of the following algorithm.
603
604	char asctime(const struct tm timeptr)
605	{
606	static const char wday_name[7][3] = {
607	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
608	};
609	static const char mon_name[12][3] = {
610	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
611	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
612	};
613	static char result[26];
614	sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
615	wday_name[timeptr->tm_wday],
616	mon_name[timeptr->tm_mon],
617	timeptr->tm_mday, timeptr->tm_hour,
618	timeptr->tm_min, timeptr->tm_sec,
619	1900 + timeptr->tm_year);
620	return result;
621	}
622	@return The asctime function returns a pointer to the string.
623	**/
624	char *
625	asctime(const struct tm *timeptr)
626	{
627	register const char * wn;
628	register const char * mn;
629
630	if (timeptr->tm_wday < 0 \|\| timeptr->tm_wday >= DAYSPERWEEK)
631	wn = "???";
632	else wn = wday_name[timeptr->tm_wday];
633	if (timeptr->tm_mon < 0 \|\| timeptr->tm_mon >= MONSPERYEAR)
634	mn = "???";
635	else mn = mon_name[timeptr->tm_mon];
636	/*
637	** The X3J11-suggested format is
638	** "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %d\n"
639	** Since the .2 in 02.2d is ignored, we drop it.
640	*/
641	(void)snprintf(gMD->ASasctime,
642	sizeof (char[ASCTIME_BUFLEN]),
643	"%.3s %.3s%3d %02d:%02d:%02d %d\r\n", // explicit CRLF for EFI
644	wn, mn,
645	timeptr->tm_mday, timeptr->tm_hour,
646	timeptr->tm_min, timeptr->tm_sec,
647	TM_YEAR_BASE + timeptr->tm_year);
648	return gMD->ASasctime;
649	}
650
651	/**
652	**/
653	char *
654	ctime(const time_t *timer)
655	{
656	return asctime(localtime(timer));
657	}
658
659	/*
660	** gmtsub is to gmtime as localsub is to localtime.
661	*/
662	void
663	gmtsub(
664	const time_t * const timep,
665	const long offset,
666	struct tm * const tmp
667	)
668	{
669	#ifdef _REENTRANT
670	static mutex_t gmt_mutex = MUTEX_INITIALIZER;
671	#endif
672
673	mutex_lock(&gmt_mutex);
674	if (!gmt_is_set) {
675	gmt_is_set = TRUE;
676	#ifdef ALL_STATE
677	gmtptr = (struct state ) malloc(sizeof gmtptr);
678	if (gmtptr != NULL)
679	#endif /* defined ALL_STATE */
680	gmtload(gmtptr);
681	}
682	mutex_unlock(&gmt_mutex);
683	timesub(timep, offset, gmtptr, tmp);
684	#ifdef TM_ZONE
685	/*
686	** Could get fancy here and deliver something such as
687	** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
688	** but this is no time for a treasure hunt.
689	*/
690	if (offset != 0)
691	tmp->TM_ZONE = (__aconst char *)__UNCONST(wildabbr);
692	else {
693	#ifdef ALL_STATE
694	if (gmtptr == NULL)
695	tmp->TM_ZONE = (__aconst char *)__UNCONST(gmt);
696	else tmp->TM_ZONE = gmtptr->chars;
697	#endif /* defined ALL_STATE */
698	#ifndef ALL_STATE
699	tmp->TM_ZONE = gmtptr->chars;
700	#endif /* State Farm */
701	}
702	#endif /* defined TM_ZONE */
703	}
704
705	/**
706	**/
707	struct tm *
708	gmtime(const time_t *timer)
709	{
710	gmtsub(timer, 0L, &gMD->BDTime);
711	return &gMD->BDTime;
712	}
713
714	static void
715	localsub(const time_t * const timep, const long offset, struct tm * const tmp)
716	{
717	register struct state * sp;
718	register const struct ttinfo * ttisp;
719	register int i;
720	const time_t t = *timep;
721
722	sp = lclptr;
723	#ifdef ALL_STATE
724	if (sp == NULL) {
725	gmtsub(timep, offset, tmp);
726	return;
727	}
728	#endif /* defined ALL_STATE */
729	if (sp->timecnt == 0 \|\| t < sp->ats[0]) {
730	i = 0;
731	while (sp->ttis[i].tt_isdst)
732	if (++i >= sp->typecnt) {
733	i = 0;
734	break;
735	}
736	} else {
737	for (i = 1; i < sp->timecnt; ++i)
738	if (t < sp->ats[i])
739	break;
740	i = sp->types[i - 1];
741	}
742	ttisp = &sp->ttis[i];
743	/*
744	** To get (wrong) behavior that's compatible with System V Release 2.0
745	** you'd replace the statement below with
746	** t += ttisp->tt_gmtoff;
747	** timesub(&t, 0L, sp, tmp);
748	*/
749	timesub(&t, ttisp->tt_gmtoff, sp, tmp);
750	tmp->tm_isdst = ttisp->tt_isdst;
751	tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
752	#ifdef TM_ZONE
753	tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
754	#endif /* defined TM_ZONE */
755	}
756
757	/**
758	**/
759	struct tm *
760	localtime(const time_t *timer)
761	{
762	tzset();
763	localsub(timer, 0L, &gMD->BDTime);
764	return &gMD->BDTime;
765	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/StdLib/LibC/Time/Time.c@ 77599

以其他格式下載: