gdb_packet_recognizer.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../microfmt.hpp"
#include "gdb_packet_types.hpp" // Contains packet_type enum
#include <cstddef>
#include <cstdint>
 
namespace microfmt::gdb {
 
class MICROFMT_API_CLASS packet_recognizer {
public:
  struct RELOCO_POINTER packet_entry {
    // Aggregate used by the enclosing class's constexpr tables: a default member initializer cannot be used there.
    microfmt::string_view prefix;
    packet_type type; // NOLINT(reloco-member-init)
 
    constexpr bool operator<(const packet_entry &other) const noexcept { return prefix < other.prefix; }
  };
 
  static constexpr size_t k_count_multichar = []() -> size_t {
    size_t count = 0;
#define __INSPECTOR_GDB_PACKET_TYPE_X(name, str)                                                                       \
  if constexpr (sizeof(str) > 2) {                                                                                     \
    ++count;                                                                                                           \
  }
    INSPECTOR_GDB_PACKET_LIST(__INSPECTOR_GDB_PACKET_TYPE_X)
#undef __INSPECTOR_GDB_PACKET_TYPE_X
    return count;
  }();
 
  static constexpr auto k_multi_char_table = []() {
    reloco::array<packet_entry, k_count_multichar> sub{};
    size_t idx = 0;
#define __INSPECTOR_GDB_PACKET_TYPE_X(name, str)                                                                       \
  if constexpr (sizeof(str) > 2) {                                                                                     \
    sub[idx++] = packet_entry{str, packet_type::name};                                                                 \
  }
    INSPECTOR_GDB_PACKET_LIST(__INSPECTOR_GDB_PACKET_TYPE_X)
#undef __INSPECTOR_GDB_PACKET_TYPE_X
 
    return sub;
  }();
 
  struct dispatch_entry {
    packet_type type;   // NOLINT(reloco-member-init)
    bool is_multi_char; // NOLINT(reloco-member-init)
  };
 
  static constexpr auto k_first_byte_table = []() {
    reloco::array<packet_type, 128> table{};
    for (size_t i = 0; i < 128; ++i) {
      table[i] = packet_type::unknown;
    }
 
#define __INSPECTOR_GDB_PACKET_TYPE_X(name, str)                                                                       \
  if constexpr (sizeof(str) > 2) {                                                                                     \
    const unsigned char c = static_cast<unsigned char>((str)[0]);                                                      \
    if (c < 128) {                                                                                                     \
      table[c] = packet_type::_multi_char_marker;                                                                      \
    }                                                                                                                  \
  } else if constexpr (sizeof(str) == 2) {                                                                             \
    const unsigned char c = static_cast<unsigned char>((str)[0]);                                                      \
    if (c < 128) {                                                                                                     \
      table[c] = packet_type::name;                                                                                    \
    }                                                                                                                  \
  }
    INSPECTOR_GDB_PACKET_LIST(__INSPECTOR_GDB_PACKET_TYPE_X)
#undef __INSPECTOR_GDB_PACKET_TYPE_X
 
    return table;
  }();
 
  [[nodiscard]] static constexpr packet_type recognize(string_view payload) noexcept {
    if (payload.empty()) {
      return packet_type::unknown;
    }
 
    const unsigned char first_char = static_cast<unsigned char>(payload[0]);
    if (first_char >= 128) {
      return packet_type::unknown;
    }
 
    const packet_type match = k_first_byte_table[first_char];
 
    // Level 1: O(1) Direct match for single-character commands
    if (match != packet_type::_multi_char_marker) {
      return match;
    }
 
    // Level 2: Linear search over the small unified multi-character table (~23 entries)
    for (const auto &entry : k_multi_char_table) {
      if (payload.substr(0, entry.prefix.size()) == entry.prefix) {
        return entry.type;
      }
    }
 
    return packet_type::unknown;
  }
};
 
} // namespace microfmt::gdb