[time] Eliminate libc timezone bloat (~9.5KB flash ESP32, ~2% RAM on ESP8266) (#13635)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

esphome/core/time.cpp

@@ -2,7 +2,6 @@
 #include "helpers.h"
 
 #include <algorithm>
-#include <cinttypes>
 
 namespace esphome {
 
@@ -67,58 +66,123 @@ std::string ESPTime::strftime(const char *format) {
 
 std::string ESPTime::strftime(const std::string &format) { return this->strftime(format.c_str()); }
 
-bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
-  uint16_t year;
-  uint8_t month;
-  uint8_t day;
-  uint8_t hour;
-  uint8_t minute;
-  uint8_t second;
-  int num;
-  const int ilen = static_cast<int>(len);
-
-  if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-             &hour,                                                                              // NOLINT
-             &minute,                                                                            // NOLINT
-             &second, &num) == 6 &&                                                              // NOLINT
-      num == ilen) {
-    esp_time.year = year;
-    esp_time.month = month;
-    esp_time.day_of_month = day;
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-                    &hour,                                                                       // NOLINT
-                    &minute, &num) == 5 &&                                                       // NOLINT
-             num == ilen) {
-    esp_time.year = year;
-    esp_time.month = month;
-    esp_time.day_of_month = day;
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
-             num == ilen) {
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
-             num == ilen) {
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
-             num == ilen) {
-    esp_time.year = year;
-    esp_time.month = month;
-    esp_time.day_of_month = day;
-  } else {
-    return false;
+// Helper to parse exactly N digits, returns false if not enough digits
+static bool parse_digits(const char *&p, const char *end, int count, uint16_t &value) {
+  value = 0;
+  for (int i = 0; i < count; i++) {
+    if (p >= end || *p < '0' || *p > '9')
+      return false;
+    value = value * 10 + (*p - '0');
+    p++;
   }
   return true;
 }
 
+// Helper to check for expected character
+static bool expect_char(const char *&p, const char *end, char expected) {
+  if (p >= end || *p != expected)
+    return false;
+  p++;
+  return true;
+}
+
+bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
+  // Supported formats:
+  //   YYYY-MM-DD HH:MM:SS (19 chars)
+  //   YYYY-MM-DD HH:MM    (16 chars)
+  //   YYYY-MM-DD          (10 chars)
+  //   HH:MM:SS            (8 chars)
+  //   HH:MM               (5 chars)
+
+  if (time_to_parse == nullptr || len == 0)
+    return false;
+
+  const char *p = time_to_parse;
+  const char *end = time_to_parse + len;
+  uint16_t v1, v2, v3, v4, v5, v6;
+
+  // Try date formats first (start with 4-digit year)
+  if (len >= 10 && time_to_parse[4] == '-') {
+    // YYYY-MM-DD...
+    if (!parse_digits(p, end, 4, v1))
+      return false;
+    if (!expect_char(p, end, '-'))
+      return false;
+    if (!parse_digits(p, end, 2, v2))
+      return false;
+    if (!expect_char(p, end, '-'))
+      return false;
+    if (!parse_digits(p, end, 2, v3))
+      return false;
+
+    esp_time.year = v1;
+    esp_time.month = v2;
+    esp_time.day_of_month = v3;
+
+    if (p == end) {
+      // YYYY-MM-DD (date only)
+      return true;
+    }
+
+    if (!expect_char(p, end, ' '))
+      return false;
+
+    // Continue with time part: HH:MM[:SS]
+    if (!parse_digits(p, end, 2, v4))
+      return false;
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v5))
+      return false;
+
+    esp_time.hour = v4;
+    esp_time.minute = v5;
+
+    if (p == end) {
+      // YYYY-MM-DD HH:MM
+      esp_time.second = 0;
+      return true;
+    }
+
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v6))
+      return false;
+
+    esp_time.second = v6;
+    return p == end;  // YYYY-MM-DD HH:MM:SS
+  }
+
+  // Try time-only formats (HH:MM[:SS])
+  if (len >= 5 && time_to_parse[2] == ':') {
+    if (!parse_digits(p, end, 2, v1))
+      return false;
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v2))
+      return false;
+
+    esp_time.hour = v1;
+    esp_time.minute = v2;
+
+    if (p == end) {
+      // HH:MM
+      esp_time.second = 0;
+      return true;
+    }
+
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v3))
+      return false;
+
+    esp_time.second = v3;
+    return p == end;  // HH:MM:SS
+  }
+
+  return false;
+}
+
 void ESPTime::increment_second() {
   this->timestamp++;
   if (!increment_time_value(this->second, 0, 60))
@@ -193,27 +257,67 @@ void ESPTime::recalc_timestamp_utc(bool use_day_of_year) {
 }
 
 void ESPTime::recalc_timestamp_local() {
-  struct tm tm;
+#ifdef USE_TIME_TIMEZONE
+  // Calculate timestamp as if fields were UTC
+  this->recalc_timestamp_utc(false);
+  if (this->timestamp == -1) {
+    return;  // Invalid time
+  }
 
-  tm.tm_year = this->year - 1900;
-  tm.tm_mon = this->month - 1;
-  tm.tm_mday = this->day_of_month;
-  tm.tm_hour = this->hour;
-  tm.tm_min = this->minute;
-  tm.tm_sec = this->second;
-  tm.tm_isdst = -1;
+  // Now convert from local to UTC by adding the offset
+  // POSIX: local = utc - offset, so utc = local + offset
+  const auto &tz = time::get_global_tz();
 
-  this->timestamp = mktime(&tm);
+  if (!tz.has_dst()) {
+    // No DST - just apply standard offset
+    this->timestamp += tz.std_offset_seconds;
+    return;
+  }
+
+  // Try both interpretations to match libc mktime() with tm_isdst=-1
+  // For ambiguous times (fall-back repeated hour), prefer standard time
+  // For invalid times (spring-forward skipped hour), libc normalizes forward
+  time_t utc_if_dst = this->timestamp + tz.dst_offset_seconds;
+  time_t utc_if_std = this->timestamp + tz.std_offset_seconds;
+
+  bool dst_valid = time::is_in_dst(utc_if_dst, tz);
+  bool std_valid = !time::is_in_dst(utc_if_std, tz);
+
+  if (dst_valid && std_valid) {
+    // Ambiguous time (repeated hour during fall-back) - prefer standard time
+    this->timestamp = utc_if_std;
+  } else if (dst_valid) {
+    // Only DST interpretation is valid
+    this->timestamp = utc_if_dst;
+  } else if (std_valid) {
+    // Only standard interpretation is valid
+    this->timestamp = utc_if_std;
+  } else {
+    // Invalid time (skipped hour during spring-forward)
+    // libc normalizes forward: 02:30 CST -> 08:30 UTC -> 03:30 CDT
+    // Using std offset achieves this since the UTC result falls during DST
+    this->timestamp = utc_if_std;
+  }
+#else
+  // No timezone support - treat as UTC
+  this->recalc_timestamp_utc(false);
+#endif
 }
 
 int32_t ESPTime::timezone_offset() {
+#ifdef USE_TIME_TIMEZONE
   time_t now = ::time(nullptr);
-  struct tm local_tm = *::localtime(&now);
-  local_tm.tm_isdst = 0;  // Cause mktime to ignore daylight saving time because we want to include it in the offset.
-  time_t local_time = mktime(&local_tm);
-  struct tm utc_tm = *::gmtime(&now);
-  time_t utc_time = mktime(&utc_tm);
-  return static_cast<int32_t>(local_time - utc_time);
+  const auto &tz = time::get_global_tz();
+  // POSIX offset is positive west, but we return offset to add to UTC to get local
+  // So we negate the POSIX offset
+  if (time::is_in_dst(now, tz)) {
+    return -tz.dst_offset_seconds;
+  }
+  return -tz.std_offset_seconds;
+#else
+  // No timezone support - no offset
+  return 0;
+#endif
 }
 
 bool ESPTime::operator<(const ESPTime &other) const { return this->timestamp < other.timestamp; }