time_t mktime (struct tm *tim_p) // from newlib
{
time_t tim = 0;
long days = 0;
int year;
/* validate structure */
validate_structure (tim_p);
/* compute hours, minutes, seconds */
tim += tim_p->tm_sec + (tim_p->tm_min * _SEC_IN_MINUTE) +
(tim_p->tm_hour * _SEC_IN_HOUR);
/* compute days in year */
days += tim_p->tm_mday - 1;
days += _DAYS_BEFORE_MONTH[tim_p->tm_mon];
if (tim_p->tm_mon > 1 && _DAYS_IN_YEAR (tim_p->tm_year) == 366)
days++;
/* compute day of the year */
tim_p->tm_yday = days;
if (tim_p->tm_year > 10000
|| tim_p->tm_year < -10000)
{
return (time_t) -1;
}
/* compute days in other years */
if (tim_p->tm_year > 70)
{
for (year = 70; year < tim_p->tm_year; year++)
days += _DAYS_IN_YEAR (year);
}
else if (tim_p->tm_year < 70)
{
for (year = 69; year > tim_p->tm_year; year--)
days -= _DAYS_IN_YEAR (year);
days -= _DAYS_IN_YEAR (year);
}
/* compute day of the week */
if ((tim_p->tm_wday = (days + 4) % 7) < 0)
tim_p->tm_wday += 7;
/* compute total seconds */
tim += (days * _SEC_IN_DAY);
return tim;
}
time_t
mktime(
_In_ struct tm *TimePointer)
{
time_t Result = 0;
long Days = 0;
int Year = TimePointer->tm_year;
int Leap = isleap(Year);
validate_structure(TimePointer);
if (TimePointer->tm_year > 10000 || TimePointer->tm_year < -10000) {
return (time_t)-1;
}
// compute hours, minutes, seconds
Result += TimePointer->tm_sec + (TimePointer->tm_min * SECSPERMIN) + (TimePointer->tm_hour * SECSPERHOUR);
// compute days in year, get how many days untill now, and how many days has passed this year
Days += __days_before_month[Leap][TimePointer->tm_mon];
Days += TimePointer->tm_mday - 1;
// Update the time structure to include this information
TimePointer->tm_yday = Days;
// compute days in other years
if (Year > 70) {
for (Year = 70; Year < TimePointer->tm_year; Year++) {
Days += DAYSPERYEAR(Year);
}
}
else if (Year < 70) {
for (Year = 69; Year > TimePointer->tm_year; Year--) {
Days -= DAYSPERYEAR(Year);
}
Days -= DAYSPERYEAR(Year);
}
return handle_daylight_savings(TimePointer, Year, Days, Result + (Days * SECSPERDAY));
}
time_t mkgmtime(tm *tim_p)
{
time_t tim = 0;
long days = 0;
int year, isdst, tm_isdst;
/* validate structure */
validate_structure (tim_p);
/* compute hours, minutes, seconds */
tim += tim_p->tm_sec + (tim_p->tm_min * _SEC_IN_MINUTE) +
(tim_p->tm_hour * _SEC_IN_HOUR);
/* compute days in year */
days += tim_p->tm_mday - 1;
days += _DAYS_BEFORE_MONTH[tim_p->tm_mon];
if (tim_p->tm_mon > 1 && _DAYS_IN_YEAR (tim_p->tm_year) == 366)
days++;
/* compute day of the year */
tim_p->tm_yday = days;
if (tim_p->tm_year > 10000
|| tim_p->tm_year < -10000)
{
return (time_t) -1;
}
/* compute days in other years */
if (tim_p->tm_year > 70)
{
for (year = 70; year < tim_p->tm_year; year++)
days += _DAYS_IN_YEAR (year);
}
else if (tim_p->tm_year < 70)
{
for (year = 69; year > tim_p->tm_year; year--)
days -= _DAYS_IN_YEAR (year);
days -= _DAYS_IN_YEAR (year);
}
/* compute day of the week */
if ((tim_p->tm_wday = (days + 4) % 7) < 0)
tim_p->tm_wday += 7;
/* compute total seconds */
tim += (days * _SEC_IN_DAY);
/* Convert user positive into 1 */
tm_isdst = tim_p->tm_isdst > 0 ? 1 : tim_p->tm_isdst;
isdst = tm_isdst;
//screw this!
// if (_daylight)
// {
// int y = tim_p->tm_year + YEAR_BASE;
// if (y == tz->__tzyear || __tzcalc_limits (y))
//{
// /* calculate start of dst in dst local time and
// start of std in both std local time and dst local time */
// time_t startdst_dst = tz->__tzrule[0].change
// - (time_t) tz->__tzrule[1].offset;
// time_t startstd_dst = tz->__tzrule[1].change
// - (time_t) tz->__tzrule[1].offset;
// time_t startstd_std = tz->__tzrule[1].change
// - (time_t) tz->__tzrule[0].offset;
// /* if the time is in the overlap between dst and std local times */
// if (tim >= startstd_std && tim < startstd_dst)
// ; /* we let user decide or leave as -1 */
// else
// {
// isdst = (tz->__tznorth
// ? (tim >= startdst_dst && tim < startstd_std)
// : (tim >= startdst_dst || tim < startstd_std));
// /* if user committed and was wrong, perform correction, but not
// * if the user has given a negative value (which
// * asks mktime() to determine if DST is in effect or not) */
// if (tm_isdst >= 0 && (isdst ^ tm_isdst) == 1)
// {
// /* we either subtract or add the difference between
// time zone offsets, depending on which way the user got it
// wrong. The diff is typically one hour, or 3600 seconds,
// and should fit in a 16-bit int, even though offset
// is a long to accomodate 12 hours. */
// int diff = (int) (tz->__tzrule[0].offset
// - tz->__tzrule[1].offset);
// if (!isdst)
// diff = -diff;
// tim_p->tm_sec += diff;
// validate_structure (tim_p);
// tim += diff; /* we also need to correct our current time calculation */
// }
// }
//}
// }
//screw this also
/* add appropriate offset to put time in gmt format */
//if (isdst == 1)
// tim += (time_t) tz->__tzrule[1].offset;
//else /* otherwise assume std time */
// tim += (time_t) tz->__tzrule[0].offset;
//and screw this too
/* reset isdst flag to what we have calculated */
tim_p->tm_isdst = isdst;
return tim;
}
time_t
handle_daylight_savings(
_In_ struct tm* TimePointer,
_In_ int Year,
_In_ int DayCount,
_In_ time_t LinearTime)
{
__tzinfo_type* tz = __gettzinfo();
int isdst = 0;
TZ_LOCK;
_tzset_unlocked();
if (__daylight) {
int tm_isdst;
int y = TimePointer->tm_year + YEAR_BASE;
/* Convert user positive into 1 */
tm_isdst = TimePointer->tm_isdst > 0 ? 1 : TimePointer->tm_isdst;
isdst = tm_isdst;
if (y == tz->__tzyear || __tzcalc_limits (y)) {
/* calculate start of dst in dst local time and
start of std in both std local time and dst local time */
time_t startdst_dst = tz->__tzrule[0].change - (time_t) tz->__tzrule[1].offset;
time_t startstd_dst = tz->__tzrule[1].change - (time_t) tz->__tzrule[1].offset;
time_t startstd_std = tz->__tzrule[1].change - (time_t) tz->__tzrule[0].offset;
/* if the time is in the overlap between dst and std local times */
if (LinearTime >= startstd_std && LinearTime < startstd_dst)
; /* we let user decide or leave as -1 */
else
{
isdst = (tz->__tznorth
? (LinearTime >= startdst_dst && LinearTime < startstd_std)
: (LinearTime >= startdst_dst || LinearTime < startstd_std));
/* if user committed and was wrong, perform correction, but not
* if the user has given a negative value (which
* asks mktime() to determine if DST is in effect or not) */
if (tm_isdst >= 0 && (isdst ^ tm_isdst) == 1)
{
/* we either subtract or add the difference between
time zone offsets, depending on which way the user got it
wrong. The diff is typically one hour, or 3600 seconds,
and should fit in a 16-bit int, even though offset
is a long to accomodate 12 hours. */
int diff = (int) (tz->__tzrule[0].offset
- tz->__tzrule[1].offset);
if (!isdst)
diff = -diff;
TimePointer->tm_sec += diff;
LinearTime += diff; /* we also need to correct our current time calculation */
int mday = TimePointer->tm_mday;
validate_structure (TimePointer);
mday = TimePointer->tm_mday - mday;
/* roll over occurred */
if (mday) {
/* compensate for month roll overs */
if (mday > 1)
mday = -1;
else if (mday < -1)
mday = 1;
/* update days for wday calculation */
DayCount += mday;
/* handle yday */
if ((TimePointer->tm_yday += mday) < 0) {
--Year;
TimePointer->tm_yday = DAYSPERYEAR(Year) - 1;
} else {
mday = DAYSPERYEAR(Year);
if (TimePointer->tm_yday > (mday - 1))
TimePointer->tm_yday -= mday;
}
}
}
}
}
}
// add appropriate offset to put time in gmt format
if (isdst == 1) {
LinearTime += (time_t) tz->__tzrule[1].offset;
}
else {
// otherwise assume std time
LinearTime += (time_t) tz->__tzrule[0].offset;
}
TZ_UNLOCK;
// Update the daylight savings result
TimePointer->tm_isdst = isdst;
TimePointer->tm_wday = (DayCount + 4) % 7;
if (TimePointer->tm_wday < 0) {
TimePointer->tm_wday += 7;
}
return LinearTime;
}
AP_Logger::log_write_fmt *AP_Logger::msg_fmt_for_name(const char *name, const char *labels, const char *units, const char *mults, const char *fmt)
{
struct log_write_fmt *f;
for (f = log_write_fmts; f; f=f->next) {
if (f->name == name) { // ptr comparison
// already have an ID for this name:
#if CONFIG_HAL_BOARD == HAL_BOARD_SITL
assert_same_fmt_for_name(f, name, labels, units, mults, fmt);
#endif
return f;
}
}
f = (struct log_write_fmt *)calloc(1, sizeof(*f));
if (f == nullptr) {
// out of memory
return nullptr;
}
// no message type allocated for this name. Try to allocate one:
int16_t msg_type = find_free_msg_type();
if (msg_type == -1) {
free(f);
return nullptr;
}
f->msg_type = msg_type;
f->name = name;
f->fmt = fmt;
f->labels = labels;
f->units = units;
f->mults = mults;
int16_t tmp = Write_calc_msg_len(fmt);
if (tmp == -1) {
free(f);
return nullptr;
}
f->msg_len = tmp;
// add to front of list
f->next = log_write_fmts;
log_write_fmts = f;
#if CONFIG_HAL_BOARD == HAL_BOARD_SITL
char ls_name[LS_NAME_SIZE] = {};
char ls_format[LS_FORMAT_SIZE] = {};
char ls_labels[LS_LABELS_SIZE] = {};
char ls_units[LS_UNITS_SIZE] = {};
char ls_multipliers[LS_MULTIPLIERS_SIZE] = {};
struct LogStructure ls = {
f->msg_type,
f->msg_len,
ls_name,
ls_format,
ls_labels,
ls_units,
ls_multipliers
};
memcpy((char*)ls_name, f->name, MIN(sizeof(ls_name), strlen(f->name)));
memcpy((char*)ls_format, f->fmt, MIN(sizeof(ls_format), strlen(f->fmt)));
memcpy((char*)ls_labels, f->labels, MIN(sizeof(ls_labels), strlen(f->labels)));
if (f->units != nullptr) {
memcpy((char*)ls_units, f->units, MIN(sizeof(ls_units), strlen(f->units)));
} else {
memset((char*)ls_units, '?', MIN(sizeof(ls_format), strlen(f->fmt)));
}
if (f->mults != nullptr) {
memcpy((char*)ls_multipliers, f->mults, MIN(sizeof(ls_multipliers), strlen(f->mults)));
} else {
memset((char*)ls_multipliers, '?', MIN(sizeof(ls_format), strlen(f->fmt)));
}
validate_structure(&ls, (int16_t)-1);
#endif
return f;
}
