Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/ntos/rtl/stdtimep.h

451 lines
12 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
stdtimep.h
Abstract:
This module contains definitions and function prototypes which are local to
stdime.c and fmttime.c.
Author:
Rob McKaughan (t-robmc) 17-Jul-1991
Revision History:
*/
#ifndef _STD_TIME_P_
#define _STD_TIME_P_
// These are the magic numbers needed to do our extended division. The
// only numbers we ever need to divide by are
// 10,000 = convert 100ns tics to millisecond tics
// 10,000,000 = convert 100ns tics to one second tics
// 86,400,000 = convert Millisecond tics to one day tics
extern LARGE_INTEGER Magic10000;
#define SHIFT10000 13
extern LARGE_INTEGER Magic10000000;
#define SHIFT10000000 23
extern LARGE_INTEGER Magic86400000;
#define SHIFT86400000 26
// To make the code more readable we'll also define some macros to
// do the actual division for use
#define Convert100nsToMilliseconds(LARGE_INTEGER) ( \
RtlExtendedMagicDivide( (LARGE_INTEGER), Magic10000, SHIFT10000 ) \
)
#define ConvertMillisecondsTo100ns(MILLISECONDS) ( \
RtlExtendedIntegerMultiply( (MILLISECONDS), 10000 ) \
)
#define Convert100nsToSeconds(LARGE_INTEGER) ( \
RtlExtendedMagicDivide( (LARGE_INTEGER), Magic10000000, SHIFT10000000 ) \
)
#define ConvertSecondsTo100ns(SECONDS) ( \
RtlExtendedIntegerMultiply( (SECONDS), 10000000L ) \
)
#define ConvertMillisecondsToDays(LARGE_INTEGER) ( \
RtlExtendedMagicDivide( (LARGE_INTEGER), Magic86400000, SHIFT86400000 ) \
)
// //
// Macros for Time Differentials and Time Revisions //
// //
// The following define the minimum and maximum possible values for the Time
// Differential Factor as defined by ISO 4031-1978.
#define MAX_STDTIME_TDF (780)
#define MIN_STDTIME_TDF (-720)
// The revision of this design (will be inserted in the revision field of any
// STANDARD_TIMEs created by this revision).
#define STDTIME_REVISION (4)
// The number of bits we need to shift to get to and from a revision in a
// StdTime.TdfAndRevision field.
#define STDTIME_REVISION_SHIFT 12
// USHORT
// ShiftStandardTimeRevision(
// IN USHORT Rev
// )
// Description:
// This routine shifts the given revision number to its proper place for
// storing in a STANDARD_TIME.TdfAndRevision field.
#define ShiftStandardTimeRevision(Rev) \
((USHORT) ((Rev) << STDTIME_REVISION_SHIFT))
// The pre-shifted value of the current revision
#define SHIFTED_STDTIME_REVISION (ShiftStandardTimeRevision(STDTIME_REVISION))
// The bit mask used to mask a STANDARD_TIME.TdfAndRevision field to retrieve
// the Tdf value.
#define TDF_MASK ((USHORT) 0x0fff)
// USHORT
// MaskStandardTimeTdf(
// IN USHORT Tdf
// )
// Description:
// This routine masks the given tdf field with TDF_MASK and returns the
// result.
// BUG: Byte order dependant
#define MaskStandardTimeTdf(Tdf) ((USHORT) ((Tdf) & TDF_MASK))
// SHORT
// GetStandardTimeTdf(
// IN STANDARD_TIME
// )
// Description:
// This routine gets the Time Differential Factor from a tdf field and
// makes any adjustments necessary to preserve the sign of the TDF.
// The resulting TDF is returned.
// Since the TDF is stored as a signed 12 bit int, it's sign bit is the
// bit 0x0800. To make it a 16 bit negative, we subtract 0x1000 from the
// bottome 12 bits of the TdfAndRevision field.
// BUG: Byte order dependant
#define GetStandardTimeTdf(StdTime) \
((SHORT) \
(((StdTime)->TdfAndRevision) & 0x0800) \
? (MaskStandardTimeTdf((StdTime)->TdfAndRevision) - 0x1000) \
: MaskStandardTimeTdf((StdTime)->TdfAndRevision) \
)
// USHORT
// GetStandardTimeRev(
// IN USHORT Tdf
// )
// Description:
// This routine gets the revision number from a tdf field and returns it
// shifted back down to its place as a SHORT.
#define GetStandardTimeRev(StdTime) \
((USHORT) (((StdTime)->TdfAndRevision) >> STDTIME_REVISION_SHIFT))
// //
// Tests for absolute and delta times //
// //
// BOOLEAN
// IsPositive(
// IN LARGE_INTEGER Time
// )
// Returns:
// TRUE - if the time in Time is positive.
// FALSE - if Time is negative.
#define IsPositive(Time) \
( ((Time).HighPart > 0) || (((Time).HighPart = 0) & ((Time).LowPart > 0)) )
// BOOLEAN
// IsAbsoluteTime(
// IN PSTANDARDTIME Time
// )
// Returns:
// TRUE - if the given time is an absolute time
// FALSE - If the given time is not an absolute time
#define IsAbsoluteTime(Time) \
( IsPositive(Time->SimpleTime) )
// BOOLEAN
// IsDeltaTime(
// IN PSTANDARDTIME Time
// )
// Returns:
// TRUE - if the given time is a delta time
// FALSE - If the given time is not a delta time
#define IsDeltaTime(Time) \
( !IsAbsoluteTime(Time) )
// BOOLEAN
// GreaterThanTime(
// IN PLARGE_INTEGER Time1,
// IN PLARGE_INTEGER Time2
// )
// Returns:
// TRUE - If Time1 is greater (older) than Time2
// FALSE - If not
// BUG: Byte order dependant
// BUG: Only works on absolute times
#define GreaterThanTime(Time1, Time2) \
( \
((Time1).HighPart > (Time2).HighPart) \
|| \
( \
((Time1).HighPart == (Time2).HighPart) \
&& \
((Time1).LowPart > (Time2).LowPart) \
) \
)
// BOOLEAN
// GreaterThanStandardTime(
// IN PSTANDARD_TIME Time1,
// IN PSTANDARD_TIME Time2
// )
// Returns:
// TRUE - If Time1 is greater (older) than Time2
// FALSE - If not
#define GreaterThanStdTime(Time1, Time2) \
GreaterThanTime((Time1).SimpleTime, (Time2).SimpleTime)
// /
// The following definitions and declarations are some important constants /
// used in the time conversion routines /
// /
// This is the week day that January 1st, 1601 fell on (a Monday)
#define WEEKDAY_OF_1601 1
// These are known constants used to convert 1970 and 1980 times to 1601
// times. They are the number of seconds from the 1601 base to the start
// of 1970 and the start of 1980. The number of seconds from 1601 to
// 1970 is 369 years worth, or (369 * 365) + 89 leap days = 134774 days, or
// 134774 * 864000 seconds, which is equal to the large integer defined
// below. The number of seconds from 1601 to 1980 is 379 years worth, or etc.
// These are declared in time.c
extern LARGE_INTEGER SecondsToStartOf1970;
extern LARGE_INTEGER SecondsToStartOf1980;
// ULONG
// ElapsedDaysToYears (
// IN ULONG ElapsedDays
// );
// To be completely true to the Gregorian calendar the equation to
// go from days to years is really
// ElapsedDays / 365.2425
// But because we are doing the computation in ulong integer arithmetic
// and the LARGE_INTEGER variable limits the number of expressible days to around
// 11,000,000 we use the following computation
// (ElapsedDays * 128 + 127) / (365.2425 * 128)
// which will be off from the Gregorian calendar in about 150,000 years
// but that doesn't really matter because LARGE_INTEGER can only express around
// 30,000 years
#define ElapsedDaysToYears(DAYS) ( \
((DAYS) * 128 + 127) / 46751 \
)
// ULONG
// NumberOfLeapYears (
// IN ULONG ElapsedYears
// );
// The number of leap years is simply the number of years divided by 4
// minus years divided by 100 plus years divided by 400. This says
// that every four years is a leap year except centuries, and the
// exception to the exception is the quadricenturies
#define NumberOfLeapYears(YEARS) ( \
((YEARS) / 4) - ((YEARS) / 100) + ((YEARS) / 400) \
)
// ULONG
// ElapsedYearsToDays (
// IN ULONG ElapsedYears
// );
// The number of days contained in elapsed years is simply the number
// of years times 365 (because every year has at least 365 days) plus
// the number of leap years there are (i.e., the number of 366 days years)
#define ElapsedYearsToDays(YEARS) ( \
((YEARS) * 365) + NumberOfLeapYears(YEARS) \
)
// BOOLEAN
// IsLeapYear (
// IN ULONG ElapsedYears
// );
// If it is an even 400 or a non century leapyear then the
// answer is true otherwise it's false
#define IsLeapYear(YEARS) ( \
(((YEARS) % 400 == 0) || \
((YEARS) % 100 != 0) && ((YEARS) % 4 == 0)) ? \
TRUE \
: \
FALSE \
)
// ULONG
// MaxDaysInMonth (
// IN ULONG Year,
// IN ULONG Month
// );
// The maximum number of days in a month depend on the year and month.
// It is the difference between the days to the month and the days
// to the following month
#define MaxDaysInMonth(YEAR,MONTH) ( \
IsLeapYear(YEAR) ? \
LeapYearDaysPrecedingMonth[(MONTH) + 1] - \
LeapYearDaysPrecedingMonth[(MONTH)] \
: \
NormalYearDaysPrecedingMonth[(MONTH) + 1] - \
NormalYearDaysPrecedingMonth[(MONTH)] \
)
// Local utlity function prototypes
VOID
RtlpConvert48To64(
IN PSTDTIME_ERROR num48,
OUT LARGE_INTEGER *num64
);
NTSTATUS
RtlpConvert64To48(
IN LARGE_INTEGER num64,
OUT PSTDTIME_ERROR num48
);
LARGE_INTEGER
RtlpTimeToLargeInt(
IN LARGE_INTEGER Time
);
LARGE_INTEGER
RtlpLargeIntToTime(
IN LARGE_INTEGER Int
);
NTSTATUS
RtlpAdd48Int(
IN PSTDTIME_ERROR First48,
IN PSTDTIME_ERROR Second48,
IN PSTDTIME_ERROR Result48
);
NTSTATUS
RtlpAddTime(
IN LARGE_INTEGER Time1,
IN LARGE_INTEGER Time2,
OUT PLARGE_INTEGER Result
);
NTSTATUS
RtlpSubtractTime(
IN LARGE_INTEGER Time1,
IN LARGE_INTEGER Time2,
OUT PLARGE_INTEGER Result
);
LARGE_INTEGER
RtlpAbsTime(
IN LARGE_INTEGER Time
);
#endif //_STD_TIME_P_
Reference in New Issue Copy Permalink