dbg_helpers.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "../stdafx.h"
#include "../rail_map.h"
#include "dbg_helpers.h"
 
#include "../safeguards.h"
 
static const char * const trackdir_names[] = {
  "NE", "SE", "UE", "LE", "LS", "RS", "rne", "rse",
  "SW", "NW", "UW", "LW", "LN", "RN", "rsw", "rnw",
};
 
std::string ValueStr(Trackdir td)
{
  return std::to_string(td) + " (" + ItemAtT(td, trackdir_names, "UNK", INVALID_TRACKDIR, "INV") + ")";
}
 
std::string ValueStr(TrackdirBits td_bits)
{
  return std::to_string(td_bits) + " (" + ComposeNameT(td_bits, trackdir_names, "UNK", INVALID_TRACKDIR_BIT, "INV") + ")";
}
 
 
static const char * const diagdir_names[] = {
  "NE", "SE", "SW", "NW",
};
 
std::string ValueStr(DiagDirection dd)
{
  return std::to_string(dd) + " (" + ItemAtT(dd, diagdir_names, "UNK", INVALID_DIAGDIR, "INV") + ")";
}
 
 
static const char * const signal_type_names[] = {
  "NORMAL", "ENTRY", "EXIT", "COMBO", "PBS", "NOENTRY",
};
 
std::string ValueStr(SignalType t)
{
  return std::to_string(t) + " (" + ItemAtT(t, signal_type_names, "UNK") + ")";
}
 
 
std::string TileStr(TileIndex tile)
{
  return fmt::format("0x{:04X} ({}, {})", tile.base(), TileX(tile), TileY(tile));
}
 
{
  static size_t last_type_id = 0;
  return last_type_id;
}
 
std::string DumpTarget::GetCurrentStructName()
{
  std::string out;
  if (!m_cur_struct.empty()) {
    /* we are inside some named struct, return its name */
    out = m_cur_struct.top();
  }
  return out;
}
 
bool DumpTarget::FindKnownName(size_t type_id, const void *ptr, std::string &name)
{
  KNOWN_NAMES::const_iterator it = m_known_names.find(KnownStructKey(type_id, ptr));
  if (it != m_known_names.end()) {
    /* we have found it */
    name = (*it).second;
    return true;
  }
  return false;
}
 
void DumpTarget::WriteIndent()
{
  int num_spaces = 2 * m_indent;
  if (num_spaces > 0) {
    m_out += std::string(num_spaces, ' ');
  }
}
 
void DumpTarget::WriteValue(const std::string &name, int value)
{
  WriteIndent();
  m_out += name + " = " + std::to_string(value) + "\n";
}
 
void DumpTarget::WriteValue(const std::string &name, const std::string &value_str)
{
  WriteIndent();
  m_out += name + " = " + value_str + "\n";
}
 
void DumpTarget::WriteTile(const std::string &name, TileIndex tile)
{
  WriteIndent();
  m_out += name + " = " + TileStr(tile) + "\n";
}
 
void DumpTarget::BeginStruct(size_t type_id, const std::string &name, const void *ptr)
{
  /* make composite name */
  std::string cur_name = GetCurrentStructName();
  if (!cur_name.empty()) {
    /* add name delimiter (we use structured names) */
    cur_name += ".";
  }
  cur_name += name;
 
  /* put the name onto stack (as current struct name) */
  m_cur_struct.push(cur_name);
 
  /* put it also to the map of known structures */
  m_known_names.insert(KNOWN_NAMES::value_type(KnownStructKey(type_id, ptr), cur_name));
 
  WriteIndent();
  m_out += name + " = {\n";
  m_indent++;
}
 
void DumpTarget::EndStruct()
{
  m_indent--;
  WriteIndent();
  m_out += "}\n";
 
  /* remove current struct name from the stack */
  m_cur_struct.pop();
}