src/time/mktime.cpp - llvm-project/libc - Git at Google

 //===-- Implementation of mktime function ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "src/time/mktime.h"
 #include "src/__support/common.h"
 #include "src/time/time_utils.h"

 #include <limits.h>

 namespace __llvm_libc {

 using __llvm_libc::time_utils::TimeConstants;

 // Returns number of years from (1, year).
 static constexpr int64_t getNumOfLeapYearsBefore(int64_t year) {
   return (year / 4) - (year / 100) + (year / 400);
 }

 // Returns True if year is a leap year.
 static constexpr bool isLeapYear(const int64_t year) {
   return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
 }

 static int64_t computeRemainingYears(int64_t daysPerYears,
                                      int64_t quotientYears,
                                      int64_t *remainingDays) {
   int64_t years = *remainingDays / daysPerYears;
   if (years == quotientYears)
     years--;
   *remainingDays -= years * daysPerYears;
   return years;
 }

 // Update the "tm" structure's year, month, etc. members from seconds.
 // "total_seconds" is the number of seconds since January 1st, 1970.
 //
 // First, divide "total_seconds" by the number of seconds in a day to get the
 // number of days since Jan 1 1970. The remainder will be used to calculate the
 // number of Hours, Minutes and Seconds.
 //
 // Then, adjust that number of days by a constant to be the number of days
 // since Mar 1 2000. Year 2000 is a multiple of 400, the leap year cycle. This
 // makes it easier to count how many leap years have passed using division.
 //
 // While calculating numbers of years in the days, the following algorithm
 // subdivides the days into the number of 400 years, the number of 100 years and
 // the number of 4 years. These numbers of cycle years are used in calculating
 // leap day. This is similar to the algorithm used in  getNumOfLeapYearsBefore()
 // and isLeapYear(). Then compute the total number of years in days from these
 // subdivided units.
 //
 // Compute the number of months from the remaining days. Finally, adjust years
 // to be 1900 and months to be from January.
 static int64_t updateFromSeconds(int64_t total_seconds, struct tm *tm) {
   // Days in month starting from March in the year 2000.
   static const char daysInMonth[] = {31 /* Mar */, 30, 31, 30, 31, 31,
                                      30,           31, 30, 31, 31, 29};

   if (sizeof(time_t) == 4) {
     if (total_seconds < 0x80000000)
       return time_utils::OutOfRange();
     if (total_seconds > 0x7FFFFFFF)
       return time_utils::OutOfRange();
   } else {
     if (total_seconds <
             INT_MIN * static_cast<int64_t>(
                           TimeConstants::NumberOfSecondsInLeapYear) ||
         total_seconds > INT_MAX * static_cast<int64_t>(
                                       TimeConstants::NumberOfSecondsInLeapYear))
       return time_utils::OutOfRange();
   }

   int64_t seconds = total_seconds - TimeConstants::SecondsUntil2000MarchFirst;
   int64_t days = seconds / TimeConstants::SecondsPerDay;
   int64_t remainingSeconds = seconds % TimeConstants::SecondsPerDay;
   if (remainingSeconds < 0) {
     remainingSeconds += TimeConstants::SecondsPerDay;
     days--;
   }

   int64_t wday = (TimeConstants::WeekDayOf2000MarchFirst + days) %
                  TimeConstants::DaysPerWeek;
   if (wday < 0)
     wday += TimeConstants::DaysPerWeek;

   // Compute the number of 400 year cycles.
   int64_t numOfFourHundredYearCycles = days / TimeConstants::DaysPer400Years;
   int64_t remainingDays = days % TimeConstants::DaysPer400Years;
   if (remainingDays < 0) {
     remainingDays += TimeConstants::DaysPer400Years;
     numOfFourHundredYearCycles--;
   }

   // The reminder number of years after computing number of
   // "four hundred year cycles" will be 4 hundred year cycles or less in 400
   // years.
   int64_t numOfHundredYearCycles =
       computeRemainingYears(TimeConstants::DaysPer100Years, 4, &remainingDays);

   // The reminder number of years after computing number of
   // "hundred year cycles" will be 25 four year cycles or less in 100 years.
   int64_t numOfFourYearCycles =
       computeRemainingYears(TimeConstants::DaysPer4Years, 25, &remainingDays);

   // The reminder number of years after computing number of "four year cycles"
   // will be 4 one year cycles or less in 4 years.
   int64_t remainingYears = computeRemainingYears(
       TimeConstants::DaysPerNonLeapYear, 4, &remainingDays);

   // Calculate number of years from year 2000.
   int64_t years = remainingYears + 4 * numOfFourYearCycles +
                   100 * numOfHundredYearCycles +
                   400LL * numOfFourHundredYearCycles;

   int leapDay =
       !remainingYears && (numOfFourYearCycles || !numOfHundredYearCycles);

   int64_t yday = remainingDays + 31 + 28 + leapDay;
   if (yday >= TimeConstants::DaysPerNonLeapYear + leapDay)
     yday -= TimeConstants::DaysPerNonLeapYear + leapDay;

   int64_t months = 0;
   while (daysInMonth[months] <= remainingDays) {
     remainingDays -= daysInMonth[months];
     months++;
   }

   if (months >= TimeConstants::MonthsPerYear - 2) {
     months -= TimeConstants::MonthsPerYear;
     years++;
   }

   if (years > INT_MAX || years < INT_MIN)
     return time_utils::OutOfRange();

   // All the data (years, month and remaining days) was calculated from
   // March, 2000. Thus adjust the data to be from January, 1900.
   tm->tm_year = years + 2000 - TimeConstants::TimeYearBase;
   tm->tm_mon = months + 2;
   tm->tm_mday = remainingDays + 1;
   tm->tm_wday = wday;
   tm->tm_yday = yday;

   tm->tm_hour = remainingSeconds / TimeConstants::SecondsPerHour;
   tm->tm_min = remainingSeconds / TimeConstants::SecondsPerMin %
                TimeConstants::SecondsPerMin;
   tm->tm_sec = remainingSeconds % TimeConstants::SecondsPerMin;

   return 0;
 }

 LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
   // Unlike most C Library functions, mktime doesn't just die on bad input.
   // TODO(rtenneti); Handle leap seconds.
   int64_t tmYearFromBase = tm_out->tm_year + TimeConstants::TimeYearBase;

   // 32-bit end-of-the-world is 03:14:07 UTC on 19 January 2038.
   if (sizeof(time_t) == 4 &&
       tmYearFromBase >= TimeConstants::EndOf32BitEpochYear) {
     if (tmYearFromBase > TimeConstants::EndOf32BitEpochYear)
       return time_utils::OutOfRange();
     if (tm_out->tm_mon > 0)
       return time_utils::OutOfRange();
     if (tm_out->tm_mday > 19)
       return time_utils::OutOfRange();
     if (tm_out->tm_hour > 3)
       return time_utils::OutOfRange();
     if (tm_out->tm_min > 14)
       return time_utils::OutOfRange();
     if (tm_out->tm_sec > 7)
       return time_utils::OutOfRange();
   }

   // Years are ints.  A 32-bit year will fit into a 64-bit time_t.
   // A 64-bit year will not.
   static_assert(sizeof(int) == 4,
                 "ILP64 is unimplemented.  This implementation requires "
                 "32-bit integers.");

   // Calculate number of months and years from tm_mon.
   int64_t month = tm_out->tm_mon;
   if (month < 0 || month >= TimeConstants::MonthsPerYear - 1) {
     int64_t years = month / 12;
     month %= 12;
     if (month < 0) {
       years--;
       month += 12;
     }
     tmYearFromBase += years;
   }
   bool tmYearIsLeap = isLeapYear(tmYearFromBase);

   // Calculate total number of days based on the month and the day (tm_mday).
   int64_t totalDays = tm_out->tm_mday - 1;
   for (int64_t i = 0; i < month; ++i)
     totalDays += TimeConstants::NonLeapYearDaysInMonth[i];
   // Add one day if it is a leap year and the month is after February.
   if (tmYearIsLeap && month > 1)
     totalDays++;

   // Calculate total numbers of days based on the year.
   totalDays += (tmYearFromBase - TimeConstants::EpochYear) *
                TimeConstants::DaysPerNonLeapYear;
   if (tmYearFromBase >= TimeConstants::EpochYear) {
     totalDays += getNumOfLeapYearsBefore(tmYearFromBase - 1) -
                  getNumOfLeapYearsBefore(TimeConstants::EpochYear);
   } else if (tmYearFromBase >= 1) {
     totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
                  getNumOfLeapYearsBefore(tmYearFromBase - 1);
   } else {
     // Calculate number of leap years until 0th year.
     totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
                  getNumOfLeapYearsBefore(0);
     if (tmYearFromBase <= 0) {
       totalDays -= 1; // Subtract 1 for 0th year.
       // Calculate number of leap years until -1 year
       if (tmYearFromBase < 0) {
         totalDays -= getNumOfLeapYearsBefore(-tmYearFromBase) -
                      getNumOfLeapYearsBefore(1);
       }
     }
   }

   // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
   int64_t seconds = tm_out->tm_sec +
                     tm_out->tm_min * TimeConstants::SecondsPerMin +
                     tm_out->tm_hour * TimeConstants::SecondsPerHour +
                     totalDays * TimeConstants::SecondsPerDay;

   // Update the tm structure's year, month, day, etc. from seconds.
   if (updateFromSeconds(seconds, tm_out) < 0)
     return time_utils::OutOfRange();

   return static_cast<time_t>(seconds);
 }

 } // namespace __llvm_libc
	//===-- Implementation of mktime function ---------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "src/time/mktime.h"
	#include "src/__support/common.h"
	#include "src/time/time_utils.h"

	#include <limits.h>

	namespace __llvm_libc {

	using __llvm_libc::time_utils::TimeConstants;

	// Returns number of years from (1, year).
	static constexpr int64_t getNumOfLeapYearsBefore(int64_t year) {
	return (year / 4) - (year / 100) + (year / 400);
	}

	// Returns True if year is a leap year.
	static constexpr bool isLeapYear(const int64_t year) {
	return (((year) % 4) == 0 && (((year) % 100) != 0 \|\| ((year) % 400) == 0));
	}

	static int64_t computeRemainingYears(int64_t daysPerYears,
	int64_t quotientYears,
	int64_t *remainingDays) {
	int64_t years = *remainingDays / daysPerYears;
	if (years == quotientYears)
	years--;
	remainingDays -= years daysPerYears;
	return years;
	}

	// Update the "tm" structure's year, month, etc. members from seconds.
	// "total_seconds" is the number of seconds since January 1st, 1970.
	//
	// First, divide "total_seconds" by the number of seconds in a day to get the
	// number of days since Jan 1 1970. The remainder will be used to calculate the
	// number of Hours, Minutes and Seconds.
	//
	// Then, adjust that number of days by a constant to be the number of days
	// since Mar 1 2000. Year 2000 is a multiple of 400, the leap year cycle. This
	// makes it easier to count how many leap years have passed using division.
	//
	// While calculating numbers of years in the days, the following algorithm
	// subdivides the days into the number of 400 years, the number of 100 years and
	// the number of 4 years. These numbers of cycle years are used in calculating
	// leap day. This is similar to the algorithm used in getNumOfLeapYearsBefore()
	// and isLeapYear(). Then compute the total number of years in days from these
	// subdivided units.
	//
	// Compute the number of months from the remaining days. Finally, adjust years
	// to be 1900 and months to be from January.
	static int64_t updateFromSeconds(int64_t total_seconds, struct tm *tm) {
	// Days in month starting from March in the year 2000.
	static const char daysInMonth[] = {31 /* Mar */, 30, 31, 30, 31, 31,
	30, 31, 30, 31, 31, 29};

	if (sizeof(time_t) == 4) {
	if (total_seconds < 0x80000000)
	return time_utils::OutOfRange();
	if (total_seconds > 0x7FFFFFFF)
	return time_utils::OutOfRange();
	} else {
	if (total_seconds <
	INT_MIN * static_cast<int64_t>(
	TimeConstants::NumberOfSecondsInLeapYear) \|\|
	total_seconds > INT_MAX * static_cast<int64_t>(
	TimeConstants::NumberOfSecondsInLeapYear))
	return time_utils::OutOfRange();
	}

	int64_t seconds = total_seconds - TimeConstants::SecondsUntil2000MarchFirst;
	int64_t days = seconds / TimeConstants::SecondsPerDay;
	int64_t remainingSeconds = seconds % TimeConstants::SecondsPerDay;
	if (remainingSeconds < 0) {
	remainingSeconds += TimeConstants::SecondsPerDay;
	days--;
	}

	int64_t wday = (TimeConstants::WeekDayOf2000MarchFirst + days) %
	TimeConstants::DaysPerWeek;
	if (wday < 0)
	wday += TimeConstants::DaysPerWeek;

	// Compute the number of 400 year cycles.
	int64_t numOfFourHundredYearCycles = days / TimeConstants::DaysPer400Years;
	int64_t remainingDays = days % TimeConstants::DaysPer400Years;
	if (remainingDays < 0) {
	remainingDays += TimeConstants::DaysPer400Years;
	numOfFourHundredYearCycles--;
	}

	// The reminder number of years after computing number of
	// "four hundred year cycles" will be 4 hundred year cycles or less in 400
	// years.
	int64_t numOfHundredYearCycles =
	computeRemainingYears(TimeConstants::DaysPer100Years, 4, &remainingDays);

	// The reminder number of years after computing number of
	// "hundred year cycles" will be 25 four year cycles or less in 100 years.
	int64_t numOfFourYearCycles =
	computeRemainingYears(TimeConstants::DaysPer4Years, 25, &remainingDays);

	// The reminder number of years after computing number of "four year cycles"
	// will be 4 one year cycles or less in 4 years.
	int64_t remainingYears = computeRemainingYears(
	TimeConstants::DaysPerNonLeapYear, 4, &remainingDays);

	// Calculate number of years from year 2000.
	int64_t years = remainingYears + 4 * numOfFourYearCycles +
	100 * numOfHundredYearCycles +
	400LL * numOfFourHundredYearCycles;

	int leapDay =
	!remainingYears && (numOfFourYearCycles \|\| !numOfHundredYearCycles);

	int64_t yday = remainingDays + 31 + 28 + leapDay;
	if (yday >= TimeConstants::DaysPerNonLeapYear + leapDay)
	yday -= TimeConstants::DaysPerNonLeapYear + leapDay;

	int64_t months = 0;
	while (daysInMonth[months] <= remainingDays) {
	remainingDays -= daysInMonth[months];
	months++;
	}

	if (months >= TimeConstants::MonthsPerYear - 2) {
	months -= TimeConstants::MonthsPerYear;
	years++;
	}

	if (years > INT_MAX \|\| years < INT_MIN)
	return time_utils::OutOfRange();

	// All the data (years, month and remaining days) was calculated from
	// March, 2000. Thus adjust the data to be from January, 1900.
	tm->tm_year = years + 2000 - TimeConstants::TimeYearBase;
	tm->tm_mon = months + 2;
	tm->tm_mday = remainingDays + 1;
	tm->tm_wday = wday;
	tm->tm_yday = yday;

	tm->tm_hour = remainingSeconds / TimeConstants::SecondsPerHour;
	tm->tm_min = remainingSeconds / TimeConstants::SecondsPerMin %
	TimeConstants::SecondsPerMin;
	tm->tm_sec = remainingSeconds % TimeConstants::SecondsPerMin;

	return 0;
	}

	LLVM_LIBC_FUNCTION(time_t, mktime, (struct tm * tm_out)) {
	// Unlike most C Library functions, mktime doesn't just die on bad input.
	// TODO(rtenneti); Handle leap seconds.
	int64_t tmYearFromBase = tm_out->tm_year + TimeConstants::TimeYearBase;

	// 32-bit end-of-the-world is 03:14:07 UTC on 19 January 2038.
	if (sizeof(time_t) == 4 &&
	tmYearFromBase >= TimeConstants::EndOf32BitEpochYear) {
	if (tmYearFromBase > TimeConstants::EndOf32BitEpochYear)
	return time_utils::OutOfRange();
	if (tm_out->tm_mon > 0)
	return time_utils::OutOfRange();
	if (tm_out->tm_mday > 19)
	return time_utils::OutOfRange();
	if (tm_out->tm_hour > 3)
	return time_utils::OutOfRange();
	if (tm_out->tm_min > 14)
	return time_utils::OutOfRange();
	if (tm_out->tm_sec > 7)
	return time_utils::OutOfRange();
	}

	// Years are ints. A 32-bit year will fit into a 64-bit time_t.
	// A 64-bit year will not.
	static_assert(sizeof(int) == 4,
	"ILP64 is unimplemented. This implementation requires "
	"32-bit integers.");

	// Calculate number of months and years from tm_mon.
	int64_t month = tm_out->tm_mon;
	if (month < 0 \|\| month >= TimeConstants::MonthsPerYear - 1) {
	int64_t years = month / 12;
	month %= 12;
	if (month < 0) {
	years--;
	month += 12;
	}
	tmYearFromBase += years;
	}
	bool tmYearIsLeap = isLeapYear(tmYearFromBase);

	// Calculate total number of days based on the month and the day (tm_mday).
	int64_t totalDays = tm_out->tm_mday - 1;
	for (int64_t i = 0; i < month; ++i)
	totalDays += TimeConstants::NonLeapYearDaysInMonth[i];
	// Add one day if it is a leap year and the month is after February.
	if (tmYearIsLeap && month > 1)
	totalDays++;

	// Calculate total numbers of days based on the year.
	totalDays += (tmYearFromBase - TimeConstants::EpochYear) *
	TimeConstants::DaysPerNonLeapYear;
	if (tmYearFromBase >= TimeConstants::EpochYear) {
	totalDays += getNumOfLeapYearsBefore(tmYearFromBase - 1) -
	getNumOfLeapYearsBefore(TimeConstants::EpochYear);
	} else if (tmYearFromBase >= 1) {
	totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
	getNumOfLeapYearsBefore(tmYearFromBase - 1);
	} else {
	// Calculate number of leap years until 0th year.
	totalDays -= getNumOfLeapYearsBefore(TimeConstants::EpochYear) -
	getNumOfLeapYearsBefore(0);
	if (tmYearFromBase <= 0) {
	totalDays -= 1; // Subtract 1 for 0th year.
	// Calculate number of leap years until -1 year
	if (tmYearFromBase < 0) {
	totalDays -= getNumOfLeapYearsBefore(-tmYearFromBase) -
	getNumOfLeapYearsBefore(1);
	}
	}
	}

	// TODO(rtenneti): Need to handle timezone and update of tm_isdst.
	int64_t seconds = tm_out->tm_sec +
	tm_out->tm_min * TimeConstants::SecondsPerMin +
	tm_out->tm_hour * TimeConstants::SecondsPerHour +
	totalDays * TimeConstants::SecondsPerDay;

	// Update the tm structure's year, month, day, etc. from seconds.
	if (updateFromSeconds(seconds, tm_out) < 0)
	return time_utils::OutOfRange();

	return static_cast<time_t>(seconds);
	}

	} // namespace __llvm_libc