src/misc/dbg_helpers.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file dbg_helpers.cpp Helpers for outputting debug information. */
  11
  12 #include "../stdafx.h"
  13 #include "dbg_helpers.h"
  14
  15 /** Trackdir & TrackdirBits short names. */
  16 static const char * const trackdir_names[] = {
  17         "NE", "SE", "UE", "LE", "LS", "RS", "rne", "rse",
  18         "SW", "NW", "UW", "LW", "LN", "RN", "rsw", "rnw",
  19 };
  20
  21 /** Return name of given Trackdir. */
  22 CStrA ValueStr(Trackdir td)
  23 {
  24         CStrA out;
  25         out.Format("%d (%s)", td, ItemAtT(td, trackdir_names, "UNK", INVALID_TRACKDIR, "INV"));
  26         return out.Transfer();
  27 }
  28
  29 /** Return composed name of given TrackdirBits. */
  30 CStrA ValueStr(TrackdirBits td_bits)
  31 {
  32         CStrA out;
  33         out.Format("%d (%s)", td_bits, ComposeNameT(td_bits, trackdir_names, "UNK", INVALID_TRACKDIR_BIT, "INV").Data());
  34         return out.Transfer();
  35 }
  36
  37
  38 /** DiagDirection short names. */
  39 static const char * const diagdir_names[] = {
  40         "NE", "SE", "SW", "NW",
  41 };
  42
  43 /** Return name of given DiagDirection. */
  44 CStrA ValueStr(DiagDirection dd)
  45 {
  46         CStrA out;
  47         out.Format("%d (%s)", dd, ItemAtT(dd, diagdir_names, "UNK", INVALID_DIAGDIR, "INV"));
  48         return out.Transfer();
  49 }
  50
  51
  52 /** SignalType short names. */
  53 static const char * const signal_type_names[] = {
  54         "NORMAL", "ENTRY", "EXIT", "COMBO", "PBS", "NOENTRY",
  55 };
  56
  57 /** Return name of given SignalType. */
  58 CStrA ValueStr(SignalType t)
  59 {
  60         CStrA out;
  61         out.Format("%d (%s)", t, ItemAtT(t, signal_type_names, "UNK"));
  62         return out.Transfer();
  63 }
  64
  65
  66 /** Translate TileIndex into string. */
  67 CStrA TileStr(TileIndex tile)
  68 {
  69         CStrA out;
  70         out.Format("0x%04X (%d, %d)", tile, TileX(tile), TileY(tile));
  71         return out.Transfer();
  72 }
  73
  74 /**
  75  * Keep track of the last assigned type_id. Used for anti-recursion.
  76  *static*/ size_t& DumpTarget::LastTypeId()
  77 {
  78         static size_t last_type_id = 0;
  79         return last_type_id;
  80 }
  81
  82 /** Return structured name of the current class/structure. */
  83 CStrA DumpTarget::GetCurrentStructName()
  84 {
  85         CStrA out;
  86         if (!m_cur_struct.empty()) {
  87                 /* we are inside some named struct, return its name */
  88                 out = m_cur_struct.top();
  89         }
  90         return out.Transfer();
  91 }
  92
  93 /**
  94  * Find the given instance in our anti-recursion repository.
  95  * Return true and set name when object was found.
  96  */
  97 bool DumpTarget::FindKnownName(size_t type_id, const void *ptr, CStrA &name)
  98 {
  99         KNOWN_NAMES::const_iterator it = m_known_names.find(KnownStructKey(type_id, ptr));
 100         if (it != m_known_names.end()) {
 101                 /* we have found it */
 102                 name = (*it).second;
 103                 return true;
 104         }
 105         return false;
 106 }
 107
 108 /** Write some leading spaces into the output. */
 109 void DumpTarget::WriteIndent()
 110 {
 111         int num_spaces = 2 * m_indent;
 112         if (num_spaces > 0) {
 113                 memset(m_out.GrowSizeNC(num_spaces), ' ', num_spaces);
 114         }
 115 }
 116
 117 /** Write a line with indent at the beginning and <LF> at the end. */
 118 void DumpTarget::WriteLine(const char *format, ...)
 119 {
 120         WriteIndent();
 121         va_list args;
 122         va_start(args, format);
 123         m_out.AddFormatL(format, args);
 124         va_end(args);
 125         m_out.AppendStr("\n");
 126 }
 127
 128 /** Write 'name = value' with indent and new-line. */
 129 void DumpTarget::WriteValue(const char *name, const char *value_str)
 130 {
 131         WriteIndent();
 132         m_out.AddFormat("%s = %s\n", name, value_str);
 133 }
 134
 135 /** Write name & TileIndex to the output. */
 136 void DumpTarget::WriteTile(const char *name, TileIndex tile)
 137 {
 138         WriteIndent();
 139         m_out.AddFormat("%s = %s\n", name, TileStr(tile).Data());
 140 }
 141
 142 /**
 143  * Open new structure (one level deeper than the current one) 'name = {<LF>'.
 144  */
 145 void DumpTarget::BeginStruct(size_t type_id, const char *name, const void *ptr)
 146 {
 147         /* make composite name */
 148         CStrA cur_name = GetCurrentStructName().Transfer();
 149         if (cur_name.Size() > 0) {
 150                 /* add name delimiter (we use structured names) */
 151                 cur_name.AppendStr(".");
 152         }
 153         cur_name.AppendStr(name);
 154
 155         /* put the name onto stack (as current struct name) */
 156         m_cur_struct.push(cur_name);
 157
 158         /* put it also to the map of known structures */
 159         m_known_names.insert(KNOWN_NAMES::value_type(KnownStructKey(type_id, ptr), cur_name));
 160
 161         WriteIndent();
 162         m_out.AddFormat("%s = {\n", name);
 163         m_indent++;
 164 }
 165
 166 /**
 167  * Close structure '}<LF>'.
 168  */
 169 void DumpTarget::EndStruct()
 170 {
 171         m_indent--;
 172         WriteIndent();
 173         m_out.AddFormat("}\n");
 174
 175         /* remove current struct name from the stack */
 176         m_cur_struct.pop();
 177 }
 178
 179 /** Just to silence an unsilencable GCC 4.4+ warning */
 180 /* static */ ByteBlob::BlobHeader ByteBlob::hdrEmpty[] = {{0, 0}, {0, 0}};