mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 15:47:44 +00:00
AK: Implement C++ 'Time' type for easier time-calculations
This adds a bunch of code in the hope that other, wrong code can be deleted. Related to #5315.
This commit is contained in:
parent
b374dd03bd
commit
bd6be910e5
4 changed files with 386 additions and 0 deletions
133
AK/Time.cpp
133
AK/Time.cpp
|
@ -25,8 +25,18 @@
|
|||
*/
|
||||
|
||||
#include <AK/Assertions.h>
|
||||
#include <AK/Checked.h>
|
||||
#include <AK/LogStream.h>
|
||||
#include <AK/Time.h>
|
||||
|
||||
// Make a reasonable guess as to which timespec/timeval definition to use.
|
||||
// It doesn't really matter, since both are identical.
|
||||
#ifdef KERNEL
|
||||
# include <Kernel/UnixTypes.h>
|
||||
#else
|
||||
# include <sys/time.h>
|
||||
#endif
|
||||
|
||||
namespace AK {
|
||||
|
||||
int day_of_year(int year, unsigned month, int day)
|
||||
|
@ -61,4 +71,127 @@ unsigned day_of_week(int year, unsigned month, int day)
|
|||
|
||||
return (year + year / 4 - year / 100 + year / 400 + seek_table[month - 1] + day) % 7;
|
||||
}
|
||||
|
||||
ALWAYS_INLINE static i32 sane_mod(i32& numerator, i32 denominator)
|
||||
{
|
||||
VERIFY(2 <= denominator && denominator <= 1'000'000'000);
|
||||
// '%' in C/C++ does not work in the obvious way:
|
||||
// For example, -9 % 7 is -2, not +5.
|
||||
// However, we want a representation like "(-2)*7 + (+5)".
|
||||
i32 dividend = numerator / denominator;
|
||||
numerator %= denominator;
|
||||
if (numerator < 0) {
|
||||
// Does not overflow: different signs.
|
||||
numerator += denominator;
|
||||
// Does not underflow: denominator >= 2.
|
||||
dividend -= 1;
|
||||
}
|
||||
return dividend;
|
||||
}
|
||||
Time Time::from_timespec(const struct timespec& ts)
|
||||
{
|
||||
i32 nsecs = ts.tv_nsec;
|
||||
i32 extra_secs = sane_mod(nsecs, 1'000'000'000);
|
||||
return Time::from_half_sanitized(ts.tv_sec, extra_secs, nsecs);
|
||||
}
|
||||
Time Time::from_timeval(const struct timeval& tv)
|
||||
{
|
||||
i32 usecs = tv.tv_usec;
|
||||
i32 extra_secs = sane_mod(usecs, 1'000'000);
|
||||
VERIFY(0 <= usecs && usecs < 1'000'000);
|
||||
return Time::from_half_sanitized(tv.tv_sec, extra_secs, usecs * 1'000);
|
||||
}
|
||||
|
||||
timespec Time::to_timespec() const
|
||||
{
|
||||
VERIFY(m_nanoseconds < 1'000'000'000);
|
||||
return { static_cast<i64>(m_seconds), static_cast<i32>(m_nanoseconds) };
|
||||
}
|
||||
timeval Time::to_timeval() const
|
||||
{
|
||||
VERIFY(m_nanoseconds < 1'000'000'000);
|
||||
return { static_cast<i64>(m_seconds), static_cast<i32>(m_nanoseconds) / 1000 };
|
||||
}
|
||||
|
||||
Time Time::operator+(const Time& other) const
|
||||
{
|
||||
VERIFY(m_nanoseconds < 1'000'000'000);
|
||||
VERIFY(other.m_nanoseconds < 1'000'000'000);
|
||||
|
||||
u32 new_nsecs = m_nanoseconds + other.m_nanoseconds;
|
||||
u32 extra_secs = new_nsecs / 1'000'000'000;
|
||||
new_nsecs %= 1'000'000'000;
|
||||
|
||||
i64 this_secs = m_seconds;
|
||||
i64 other_secs = other.m_seconds;
|
||||
// We would like to just add "this_secs + other_secs + extra_secs".
|
||||
// However, computing this naively may overflow even though the result is in-bounds.
|
||||
// Example in 8-bit: (-127) + (-2) + (+1) = (-128), which fits in an i8.
|
||||
// Example in 8-bit, the other way around: (-2) + (127) + (+1) = 126.
|
||||
// So we do something more sophisticated:
|
||||
if (extra_secs) {
|
||||
VERIFY(extra_secs == 1);
|
||||
if (this_secs != 0x7fff'ffff'ffff'ffff) {
|
||||
this_secs += 1;
|
||||
} else if (other_secs != 0x7fff'ffff'ffff'ffff) {
|
||||
other_secs += 1;
|
||||
} else {
|
||||
/* If *both* are INT64_MAX, then adding them will overflow in any case. */
|
||||
return Time::max();
|
||||
}
|
||||
extra_secs = 0;
|
||||
}
|
||||
|
||||
Checked<i64> new_secs { this_secs };
|
||||
new_secs += other_secs;
|
||||
if (new_secs.has_overflow()) {
|
||||
if (other_secs > 0)
|
||||
return Time::max();
|
||||
else
|
||||
return Time::min();
|
||||
}
|
||||
|
||||
return Time { new_secs.value(), new_nsecs };
|
||||
}
|
||||
Time Time::operator-(const Time& other) const
|
||||
{
|
||||
VERIFY(m_nanoseconds < 1'000'000'000);
|
||||
VERIFY(other.m_nanoseconds < 1'000'000'000);
|
||||
|
||||
if (other.m_nanoseconds)
|
||||
return *this + Time((i64) ~(u64)other.m_seconds, 1'000'000'000 - other.m_nanoseconds);
|
||||
|
||||
if (other.m_seconds != (i64)-0x8000'0000'0000'0000)
|
||||
return *this + Time(-other.m_seconds, 0);
|
||||
|
||||
// Only remaining case: We want to subtract -0x8000'0000'0000'0000 seconds,
|
||||
// i.e. add a very large number.
|
||||
|
||||
if (m_seconds >= 0)
|
||||
return Time::max();
|
||||
return Time { (m_seconds + 0x4000'0000'0000'0000) + 0x4000'0000'0000'0000, m_nanoseconds };
|
||||
}
|
||||
|
||||
Time Time::from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds)
|
||||
{
|
||||
VERIFY(nanoseconds < 1'000'000'000);
|
||||
|
||||
if ((seconds <= 0 && extra_seconds > 0) || (seconds >= 0 && extra_seconds < 0)) {
|
||||
// Opposite signs mean that we can definitely add them together without fear of overflowing i64:
|
||||
seconds += extra_seconds;
|
||||
extra_seconds = 0;
|
||||
}
|
||||
|
||||
// Now the only possible way to become invalid is overflowing i64 towards positive infinity:
|
||||
if (Checked<i64>::addition_would_overflow<i64, i64>(seconds, extra_seconds)) {
|
||||
if (seconds < 0) {
|
||||
return Time::min();
|
||||
} else {
|
||||
return Time::max();
|
||||
}
|
||||
}
|
||||
|
||||
return Time { seconds + extra_seconds, nanoseconds };
|
||||
}
|
||||
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue