progmem.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <new>
#include <string>
 
#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)
 
#ifdef USE_ESP8266
// ESP8266 uses Arduino macros
#define ESPHOME_F(string_literal) F(string_literal)
#define ESPHOME_PGM_P PGM_P
#define ESPHOME_PSTR(s) PSTR(s)
#define ESPHOME_strncpy_P strncpy_P
#define ESPHOME_strncat_P strncat_P
#define ESPHOME_snprintf_P snprintf_P
#define ESPHOME_strcmp_P strcmp_P
#define ESPHOME_strcasecmp_P strcasecmp_P
#define ESPHOME_strncmp_P strncmp_P
#define ESPHOME_strncasecmp_P strncasecmp_P
#define ESPHOME_strlen_P strlen_P
#define ESPHOME_strstr_P strstr_P
// Type for pointers to PROGMEM strings (for use with ESPHOME_F return values)
using ProgmemStr = const __FlashStringHelper *;
// Storage class for PROGMEM_STRING_TABLE data; LOG_STR_ARG treats a LogString as PGM_P
// on ESP8266, so the table data must be in flash to match.
#define ESPHOME_PROGMEM_STRING_TABLE_STORAGE PROGMEM
#else
#define ESPHOME_F(string_literal) (string_literal)
#define ESPHOME_PGM_P const char *
#define ESPHOME_PSTR(s) (s)
#define ESPHOME_strncpy_P strncpy
#define ESPHOME_strncat_P strncat
#define ESPHOME_snprintf_P snprintf
#define ESPHOME_strcmp_P strcmp
#define ESPHOME_strcasecmp_P strcasecmp
#define ESPHOME_strncmp_P strncmp
#define ESPHOME_strncasecmp_P strncasecmp
#define ESPHOME_strlen_P strlen
#define ESPHOME_strstr_P strstr
// Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
using ProgmemStr = const char *;
// No-op on non-ESP8266 platforms where PROGMEM itself is a no-op.
#define ESPHOME_PROGMEM_STRING_TABLE_STORAGE
#endif
 
namespace esphome {
 
#ifdef USE_ESP8266
std::string progmem_string(ProgmemStr str);
#else
inline std::string progmem_string(ProgmemStr str) { return std::string(str); }
#endif
 
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
};
 
template<FixedString... Strs> struct ProgmemStringTable {
  static constexpr size_t COUNT = sizeof...(Strs);
  static constexpr size_t BLOB_SIZE = (0 + ... + (Strs.size() + 1));
  static constexpr size_t MAX_LENGTH = std::max({Strs.size()...});
  static constexpr bool INDEXED = BLOB_SIZE <= UINT8_MAX;
 
  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;
  }
 
  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");
    if constexpr (INDEXED) {
      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;
    } else {
      return std::array<uint8_t, 0>{};
    }
  }
};
 
inline const char *progmem_skip_strings(const char *blob, uint8_t idx) {
  while (idx-- > 0)
    blob += ESPHOME_strlen_P(blob) + 1;
  return blob;
}
 
// Forward declaration for LogString (defined in log.h)
struct LogString;
 
#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 size_t MAX_LENGTH = Table::MAX_LENGTH; \
    static constexpr auto BLOB ESPHOME_PROGMEM_STRING_TABLE_STORAGE = Table::make_blob(); \
    static constexpr auto OFFSETS ESPHOME_PROGMEM_STRING_TABLE_STORAGE = Table::make_offsets(); \
    static const char *get_(uint8_t idx, uint8_t fallback) { \
      if (idx >= COUNT) \
        idx = fallback; \
      /* std::launder is used here to prevent the inter-procedural analysis that */ \
      /* causes the false positive that the string is not null terminated */ \
      if constexpr (Table::INDEXED) \
        return std::launder(&BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]); \
      else \
        return std::launder(::esphome::progmem_skip_strings(BLOB.data(), 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