[esp32_hosted] Replace sscanf with strtol for version parsing

esphome/components/cover/cover.cpp

@@ -22,11 +22,17 @@ const LogString *cover_command_to_str(float pos) {
     return LOG_STR("UNKNOWN");
   }
 }
-// Cover operation strings indexed by CoverOperation enum (0-2): IDLE, OPENING, CLOSING, plus UNKNOWN
-PROGMEM_STRING_TABLE(CoverOperationStrings, "IDLE", "OPENING", "CLOSING", "UNKNOWN");
-
 const LogString *cover_operation_to_str(CoverOperation op) {
-  return CoverOperationStrings::get_log_str(static_cast<uint8_t>(op), CoverOperationStrings::LAST_INDEX);
+  switch (op) {
+    case COVER_OPERATION_IDLE:
+      return LOG_STR("IDLE");
+    case COVER_OPERATION_OPENING:
+      return LOG_STR("OPENING");
+    case COVER_OPERATION_CLOSING:
+      return LOG_STR("CLOSING");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 Cover::Cover() : position{COVER_OPEN} {}

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -34,14 +34,29 @@ static const char *const ESP_HOSTED_VERSION_STR = STRINGIFY(ESP_HOSTED_VERSION_M
     ESP_HOSTED_VERSION_MINOR_1) "." STRINGIFY(ESP_HOSTED_VERSION_PATCH_1);
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
+// Parse an integer from str, advancing ptr past the number
+// Returns false if no digits were parsed
+static bool parse_int(const char *&ptr, int &value) {
+  char *end;
+  value = static_cast<int>(strtol(ptr, &end, 10));
+  if (end == ptr)
+    return false;
+  ptr = end;
+  return true;
+}
+
 // Parse version string "major.minor.patch" into components
-// Returns true if parsing succeeded
+// Returns true if at least major.minor was parsed
 static bool parse_version(const std::string &version_str, int &major, int &minor, int &patch) {
   major = minor = patch = 0;
-  if (sscanf(version_str.c_str(), "%d.%d.%d", &major, &minor, &patch) >= 2) {
-    return true;
-  }
-  return false;
+  const char *ptr = version_str.c_str();
+
+  if (!parse_int(ptr, major) || *ptr++ != '.' || !parse_int(ptr, minor))
+    return false;
+  if (*ptr == '.')
+    parse_int(++ptr, patch);
+
+  return true;
 }
 
 // Compare two versions, returns:

esphome/components/light/light_json_schema.cpp

@@ -9,19 +9,32 @@ namespace esphome::light {
 
 // See https://www.home-assistant.io/integrations/light.mqtt/#json-schema for documentation on the schema
 
-// Color mode JSON strings - packed into flash with compile-time generated offsets.
-// Indexed by ColorModeBitPolicy bit index (1-9), so index 0 maps to bit 1 ("onoff").
-PROGMEM_STRING_TABLE(ColorModeStrings, "onoff", "brightness", "white", "color_temp", "cwww", "rgb", "rgbw", "rgbct",
-                     "rgbww");
-
-// Get JSON string for color mode. Returns nullptr for UNKNOWN (bit 0).
-// Returns ProgmemStr so ArduinoJson knows to handle PROGMEM strings on ESP8266.
+// Get JSON string for color mode.
+// ColorMode enum values are sparse bitmasks (0, 1, 3, 7, 11, 19, 35, 39, 47, 51) which would
+// generate a large jump table. Converting to bit index (0-9) allows a compact switch.
 static ProgmemStr get_color_mode_json_str(ColorMode mode) {
-  unsigned bit = ColorModeBitPolicy::to_bit(mode);
-  if (bit == 0)
-    return nullptr;
-  // bit is 1-9 for valid modes, so bit-1 is always valid (0-8). LAST_INDEX fallback never used.
-  return ColorModeStrings::get_progmem_str(bit - 1, ColorModeStrings::LAST_INDEX);
+  switch (ColorModeBitPolicy::to_bit(mode)) {
+    case 1:
+      return ESPHOME_F("onoff");
+    case 2:
+      return ESPHOME_F("brightness");
+    case 3:
+      return ESPHOME_F("white");
+    case 4:
+      return ESPHOME_F("color_temp");
+    case 5:
+      return ESPHOME_F("cwww");
+    case 6:
+      return ESPHOME_F("rgb");
+    case 7:
+      return ESPHOME_F("rgbw");
+    case 8:
+      return ESPHOME_F("rgbct");
+    case 9:
+      return ESPHOME_F("rgbww");
+    default:
+      return nullptr;
+  }
 }
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {

esphome/components/logger/logger.cpp

@@ -4,7 +4,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome::logger {
 
@@ -292,20 +291,34 @@ UARTSelection Logger::get_uart() const { return this->uart_; }
 
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
 
-// Log level strings - packed into flash on ESP8266, indexed by log level (0-7)
-PROGMEM_STRING_TABLE(LogLevelStrings, "NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE");
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+// ESP8266: PSTR() cannot be used in array initializers, so we need to declare
+// each string separately as a global constant first
+static const char LOG_LEVEL_NONE[] PROGMEM = "NONE";
+static const char LOG_LEVEL_ERROR[] PROGMEM = "ERROR";
+static const char LOG_LEVEL_WARN[] PROGMEM = "WARN";
+static const char LOG_LEVEL_INFO[] PROGMEM = "INFO";
+static const char LOG_LEVEL_CONFIG[] PROGMEM = "CONFIG";
+static const char LOG_LEVEL_DEBUG[] PROGMEM = "DEBUG";
+static const char LOG_LEVEL_VERBOSE[] PROGMEM = "VERBOSE";
+static const char LOG_LEVEL_VERY_VERBOSE[] PROGMEM = "VERY_VERBOSE";
 
-static const LogString *get_log_level_str(uint8_t level) {
-  return LogLevelStrings::get_log_str(level, LogLevelStrings::LAST_INDEX);
-}
+static const LogString *const LOG_LEVELS[] = {
+    reinterpret_cast<const LogString *>(LOG_LEVEL_NONE),    reinterpret_cast<const LogString *>(LOG_LEVEL_ERROR),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_WARN),    reinterpret_cast<const LogString *>(LOG_LEVEL_INFO),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_CONFIG),  reinterpret_cast<const LogString *>(LOG_LEVEL_DEBUG),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_VERBOSE), reinterpret_cast<const LogString *>(LOG_LEVEL_VERY_VERBOSE),
+};
+#else
+static const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
+#endif
 
 void Logger::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Logger:\n"
                 "  Max Level: %s\n"
                 "  Initial Level: %s",
-                LOG_STR_ARG(get_log_level_str(ESPHOME_LOG_LEVEL)),
-                LOG_STR_ARG(get_log_level_str(this->current_level_)));
+                LOG_STR_ARG(LOG_LEVELS[ESPHOME_LOG_LEVEL]), LOG_STR_ARG(LOG_LEVELS[this->current_level_]));
 #ifndef USE_HOST
   ESP_LOGCONFIG(TAG,
                 "  Log Baud Rate: %" PRIu32 "\n"
@@ -324,7 +337,7 @@ void Logger::dump_config() {
 
 #ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
   for (auto &it : this->log_levels_) {
-    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first, LOG_STR_ARG(get_log_level_str(it.second)));
+    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first, LOG_STR_ARG(LOG_LEVELS[it.second]));
   }
 #endif
 }
@@ -332,8 +345,7 @@ void Logger::dump_config() {
 void Logger::set_log_level(uint8_t level) {
   if (level > ESPHOME_LOG_LEVEL) {
     level = ESPHOME_LOG_LEVEL;
-    ESP_LOGW(TAG, "Cannot set log level higher than pre-compiled %s",
-             LOG_STR_ARG(get_log_level_str(ESPHOME_LOG_LEVEL)));
+    ESP_LOGW(TAG, "Cannot set log level higher than pre-compiled %s", LOG_STR_ARG(LOG_LEVELS[ESPHOME_LOG_LEVEL]));
   }
   this->current_level_ = level;
 #ifdef USE_LOGGER_LEVEL_LISTENERS

esphome/components/sensor/sensor.cpp

@@ -2,7 +2,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome::sensor {
 
@@ -31,13 +30,20 @@ void log_sensor(const char *tag, const char *prefix, const char *type, Sensor *o
   }
 }
 
-// State class strings indexed by StateClass enum (0-4): NONE, MEASUREMENT, TOTAL_INCREASING, TOTAL, MEASUREMENT_ANGLE
-PROGMEM_STRING_TABLE(StateClassStrings, "", "measurement", "total_increasing", "total", "measurement_angle");
-static_assert(StateClassStrings::COUNT == STATE_CLASS_LAST + 1, "StateClassStrings must match StateClass enum");
-
 const LogString *state_class_to_string(StateClass state_class) {
-  // Fallback to index 0 (empty string for STATE_CLASS_NONE) if out of range
-  return StateClassStrings::get_log_str(static_cast<uint8_t>(state_class), 0);
+  switch (state_class) {
+    case STATE_CLASS_MEASUREMENT:
+      return LOG_STR("measurement");
+    case STATE_CLASS_TOTAL_INCREASING:
+      return LOG_STR("total_increasing");
+    case STATE_CLASS_TOTAL:
+      return LOG_STR("total");
+    case STATE_CLASS_MEASUREMENT_ANGLE:
+      return LOG_STR("measurement_angle");
+    case STATE_CLASS_NONE:
+    default:
+      return LOG_STR("");
+  }
 }
 
 Sensor::Sensor() : state(NAN), raw_state(NAN) {}

esphome/components/sensor/sensor.h

@@ -32,7 +32,6 @@ enum StateClass : uint8_t {
   STATE_CLASS_TOTAL = 3,
   STATE_CLASS_MEASUREMENT_ANGLE = 4
 };
-constexpr uint8_t STATE_CLASS_LAST = static_cast<uint8_t>(STATE_CLASS_MEASUREMENT_ANGLE);
 
 const LogString *state_class_to_string(StateClass state_class);
 

esphome/components/valve/valve.cpp

@@ -23,11 +23,17 @@ const LogString *valve_command_to_str(float pos) {
     return LOG_STR("UNKNOWN");
   }
 }
-// Valve operation strings indexed by ValveOperation enum (0-2): IDLE, OPENING, CLOSING, plus UNKNOWN
-PROGMEM_STRING_TABLE(ValveOperationStrings, "IDLE", "OPENING", "CLOSING", "UNKNOWN");
-
 const LogString *valve_operation_to_str(ValveOperation op) {
-  return ValveOperationStrings::get_log_str(static_cast<uint8_t>(op), ValveOperationStrings::LAST_INDEX);
+  switch (op) {
+    case VALVE_OPERATION_IDLE:
+      return LOG_STR("IDLE");
+    case VALVE_OPERATION_OPENING:
+      return LOG_STR("OPENING");
+    case VALVE_OPERATION_CLOSING:
+      return LOG_STR("CLOSING");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 Valve::Valve() : position{VALVE_OPEN} {}

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -36,7 +36,6 @@ extern "C" {
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include "esphome/core/util.h"
 
 namespace esphome::wifi {
@@ -399,22 +398,36 @@ class WiFiMockClass : public ESP8266WiFiGenericClass {
   static void _event_callback(void *event) { ESP8266WiFiGenericClass::_eventCallback(event); }  // NOLINT
 };
 
-// Auth mode strings indexed by AUTH_* constants (0-4), with UNKNOWN at last index
-// Static asserts verify the SDK constants are contiguous as expected
-static_assert(AUTH_OPEN == 0 && AUTH_WEP == 1 && AUTH_WPA_PSK == 2 && AUTH_WPA2_PSK == 3 && AUTH_WPA_WPA2_PSK == 4,
-              "AUTH_* constants are not contiguous");
-PROGMEM_STRING_TABLE(AuthModeStrings, "OPEN", "WEP", "WPA PSK", "WPA2 PSK", "WPA/WPA2 PSK", "UNKNOWN");
-
 const LogString *get_auth_mode_str(uint8_t mode) {
-  return AuthModeStrings::get_log_str(mode, AuthModeStrings::LAST_INDEX);
+  switch (mode) {
+    case AUTH_OPEN:
+      return LOG_STR("OPEN");
+    case AUTH_WEP:
+      return LOG_STR("WEP");
+    case AUTH_WPA_PSK:
+      return LOG_STR("WPA PSK");
+    case AUTH_WPA2_PSK:
+      return LOG_STR("WPA2 PSK");
+    case AUTH_WPA_WPA2_PSK:
+      return LOG_STR("WPA/WPA2 PSK");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
+const LogString *get_op_mode_str(uint8_t mode) {
+  switch (mode) {
+    case WIFI_OFF:
+      return LOG_STR("OFF");
+    case WIFI_STA:
+      return LOG_STR("STA");
+    case WIFI_AP:
+      return LOG_STR("AP");
+    case WIFI_AP_STA:
+      return LOG_STR("AP+STA");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
-
-// WiFi op mode strings indexed by WIFI_* constants (0-3), with UNKNOWN at last index
-static_assert(WIFI_OFF == 0 && WIFI_STA == 1 && WIFI_AP == 2 && WIFI_AP_STA == 3,
-              "WIFI_* op mode constants are not contiguous");
-PROGMEM_STRING_TABLE(OpModeStrings, "OFF", "STA", "AP", "AP+STA", "UNKNOWN");
-
-const LogString *get_op_mode_str(uint8_t mode) { return OpModeStrings::get_log_str(mode, OpModeStrings::LAST_INDEX); }
 
 const LogString *get_disconnect_reason_str(uint8_t reason) {
   /* If this were one big switch statement, GCC would generate a lookup table for it. However, the values of the

esphome/core/progmem.h

@@ -1,11 +1,5 @@
 #pragma once
 
-#include <array>
-#include <cstddef>
-#include <cstdint>
-
-#include "esphome/core/hal.h"  // For PROGMEM definition
-
 // Platform-agnostic macros for PROGMEM string handling
 // On ESP8266/Arduino: Use Arduino's F() macro for PROGMEM strings
 // On other platforms: Use plain strings (no PROGMEM)
@@ -38,80 +32,3 @@ using ProgmemStr = const __FlashStringHelper *;
 // Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
 using ProgmemStr = const char *;
 #endif
-
-namespace esphome {
-
-/// Helper for C++20 string literal template arguments
-template<size_t N> struct FixedString {
-  char data[N]{};
-  constexpr FixedString(const char (&str)[N]) {
-    for (size_t i = 0; i < N; ++i)
-      data[i] = str[i];
-  }
-  constexpr size_t size() const { return N - 1; }  // exclude null terminator
-};
-
-/// Compile-time string table that packs strings into a single blob with offset lookup.
-/// Use PROGMEM_STRING_TABLE macro to instantiate with proper flash placement on ESP8266.
-///
-/// Example:
-///   PROGMEM_STRING_TABLE(MyStrings, "foo", "bar", "baz");
-///   ProgmemStr str = MyStrings::get_progmem_str(idx, MyStrings::LAST_INDEX);  // For ArduinoJson
-///   const LogString *log_str = MyStrings::get_log_str(idx, MyStrings::LAST_INDEX);  // For logging
-///
-template<FixedString... Strs> struct ProgmemStringTable {
-  static constexpr size_t COUNT = sizeof...(Strs);
-  static constexpr size_t BLOB_SIZE = (0 + ... + (Strs.size() + 1));
-
-  /// Generate packed string blob at compile time
-  static constexpr auto make_blob() {
-    std::array<char, BLOB_SIZE> result{};
-    size_t pos = 0;
-    auto copy = [&](const auto &str) {
-      for (size_t i = 0; i <= str.size(); ++i)
-        result[pos++] = str.data[i];
-    };
-    (copy(Strs), ...);
-    return result;
-  }
-
-  /// Generate offset table at compile time (uint8_t limits blob to 255 bytes)
-  static constexpr auto make_offsets() {
-    static_assert(COUNT > 0, "PROGMEM_STRING_TABLE must contain at least one string");
-    static_assert(COUNT <= 255, "PROGMEM_STRING_TABLE supports at most 255 strings with uint8_t indices");
-    static_assert(BLOB_SIZE <= 255, "PROGMEM_STRING_TABLE blob exceeds 255 bytes; use fewer/shorter strings");
-    std::array<uint8_t, COUNT> result{};
-    size_t pos = 0, idx = 0;
-    ((result[idx++] = static_cast<uint8_t>(pos), pos += Strs.size() + 1), ...);
-    return result;
-  }
-};
-
-// Forward declaration for LogString (defined in log.h)
-struct LogString;
-
-/// Instantiate a ProgmemStringTable with PROGMEM storage.
-/// Creates: Name::get_progmem_str(idx, fallback), Name::get_log_str(idx, fallback)
-/// If idx >= COUNT, returns string at fallback. Use LAST_INDEX for common patterns.
-#define PROGMEM_STRING_TABLE(Name, ...) \
-  struct Name { \
-    using Table = ::esphome::ProgmemStringTable<__VA_ARGS__>; \
-    static constexpr size_t COUNT = Table::COUNT; \
-    static constexpr uint8_t LAST_INDEX = COUNT - 1; \
-    static constexpr size_t BLOB_SIZE = Table::BLOB_SIZE; \
-    static constexpr auto BLOB PROGMEM = Table::make_blob(); \
-    static constexpr auto OFFSETS PROGMEM = Table::make_offsets(); \
-    static const char *get_(uint8_t idx, uint8_t fallback) { \
-      if (idx >= COUNT) \
-        idx = fallback; \
-      return &BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]; \
-    } \
-    static ::ProgmemStr get_progmem_str(uint8_t idx, uint8_t fallback) { \
-      return reinterpret_cast<::ProgmemStr>(get_(idx, fallback)); \
-    } \
-    static const ::esphome::LogString *get_log_str(uint8_t idx, uint8_t fallback) { \
-      return reinterpret_cast<const ::esphome::LogString *>(get_(idx, fallback)); \
-    } \
-  }
-
-}  // namespace esphome