1

/* $Id$ */

     2

     3

/** @file dbg_helpers.h Functions to be used for debug printings. */

     4

     5

#ifndef DBG_HELPERS

     6

#define DBG_HELPERS

     7

     8

#include <new>

     9

#include <map>

    10

#include <stack>

    11

    12

#include "blob.hpp"

    13

#include "str.hpp"

    14

    15

/** Helper template class that provides C array length and item type */

    16

template <typename T> struct ArrayT;

    17

    18

/** Helper template class that provides C array length and item type */

    19

template <typename T, size_t N> struct ArrayT<T[N]> {

    20

	static const size_t length = N;

    21

	typedef T item_t;

    22

};

    23

    24

    25

/**

    26

* Helper template function that returns item of array at given index

    27

* or t_unk when index is out of bounds.

    28

*/

    29

template <typename E, typename T>

    30

inline typename ArrayT<T>::item_t ItemAtT(E idx, T &t, typename ArrayT<T>::item_t t_unk)

    31

{

    32

	if ((size_t)idx >= ArrayT<T>::length) {

    33

		return t_unk;

    34

	}

    35

	return t[idx];

    36

}

    37

    38

/**

    39

* Helper template function that returns item of array at given index

    40

* or t_inv when index == idx_inv

    41

* or t_unk when index is out of bounds.

    42

*/

    43

template <typename E, typename T>

    44

inline typename ArrayT<T>::item_t ItemAtT(E idx, T &t, typename ArrayT<T>::item_t t_unk, E idx_inv, typename ArrayT<T>::item_t t_inv)

    45

{

    46

	if ((size_t)idx < ArrayT<T>::length) {

    47

		return t[idx];

    48

	}

    49

	if (idx == idx_inv) {

    50

		return t_inv;

    51

	}

    52

	return t_unk;

    53

}

    54

    55

/**

    56

* Helper template function that returns compound bitfield name that is

    57

* concatenation of names of each set bit in the given value

    58

* or t_inv when index == idx_inv

    59

* or t_unk when index is out of bounds.

    60

*/

    61

template <typename E, typename T>

    62

inline CStrA ComposeNameT(E value, T &t, const char* t_unk, E val_inv, const char* name_inv)

    63

{

    64

	CStrA out;

    65

	if (value == val_inv) {

    66

		out = name_inv;

    67

	} else if (value == 0) {

    68

		out = "<none>";

    69

	} else {

    70

		for (size_t i = 0; i < ArrayT<T>::length; i++) {

    71

			if ((value & (1 << i)) == 0) continue;

    72

			out.AddFormat("%s%s", (out.Size() > 0 ? "+" : ""), t[i]);

    73

			value &= ~(E)(1 << i);

    74

		}

    75

		if (value != 0) out.AddFormat("%s%s", (out.Size() > 0 ? "+" : ""), t_unk);

    76

	}

    77

	return out.Transfer();

    78

}

    79

    80

CStrA ValueStr(Trackdir td);

    81

CStrA ValueStr(TrackdirBits td_bits);

    82

CStrA ValueStr(DiagDirection dd);

    83

CStrA ValueStr(SignalType t);

    84

    85

/** Class that represents the dump-into-string target. */

    86

struct DumpTarget {

    87

    88

	/** Used as a key into map of known object instances. */

    89

	struct KnownStructKey {

    90

		size_t      m_type_id;

    91

		const void *m_ptr;

    92

    93

		KnownStructKey(size_t type_id, const void *ptr)

    94

			: m_type_id(type_id)

    95

			, m_ptr(ptr)

    96

		{}

    97

    98

		KnownStructKey(const KnownStructKey &src)

    99

		{

   100

			m_type_id = src.m_type_id;

   101

			m_ptr = src.m_ptr;

   102

		}

   103

   104

		bool operator < (const KnownStructKey &other) const

   105

		{

   106

			if ((size_t)m_ptr < (size_t)other.m_ptr) return true;

   107

			if ((size_t)m_ptr > (size_t)other.m_ptr) return false;

   108

			if (m_type_id < other.m_type_id) return true;

   109

			return false;

   110

		}

   111

	};

   112

   113

	typedef std::map<KnownStructKey, CStrA> KNOWN_NAMES;

   114

   115

	CStrA              m_out;         ///< the output string

   116

	int                m_indent;      ///< current indent/nesting level

   117

	std::stack<CStrA>  m_cur_struct;  ///< here we will track the current structure name

   118

	KNOWN_NAMES        m_known_names; ///< map of known object instances and their structured names

   119

   120

	DumpTarget()

   121

		: m_indent(0)

   122

	{}

   123

   124

	static size_t& LastTypeId();

   125

	CStrA GetCurrentStructName();

   126

	bool FindKnownName(size_t type_id, const void* ptr, CStrA &name);

   127

   128

	void WriteIndent();

   129

   130

	void WriteLine(const char *format, ...);

   131

	void WriteValue(const char *name, const char *value_str);

   132

	void WriteTile(const char *name, TileIndex t);

   133

   134

	/** Dump given enum value (as a number and as named value) */

   135

	template <typename E> void WriteEnumT(const char *name, E e)

   136

	{

   137

		WriteValue(name, ValueStr(e).Data());

   138

	}

   139

   140

	void BeginStruct(size_t type_id, const char *name, const void *ptr);

   141

	void EndStruct();

   142

   143

	/** Dump nested object (or only its name if this instance is already known). */

   144

	template <typename S> void WriteStructT(const char *name, const S *s)

   145

	{

   146

		static size_t type_id = ++LastTypeId();

   147

   148

		if (s == NULL) {

   149

			/* No need to dump NULL struct. */

   150

			WriteLine("%s = <null>", name);

   151

			return;

   152

		}

   153

		CStrA known_as;

   154

		if (FindKnownName(type_id, s, known_as)) {

   155

			/* We already know this one, no need to dump it. */

   156

			WriteLine("%s = known_as.%s", name, known_as.Data());

   157

		} else {

   158

			/* Still unknown, dump it */

   159

			BeginStruct(type_id, name, s);

   160

			s->Dump(*this);

   161

			EndStruct();

   162

		}

   163

	}

   164

};

   165

   166

#endif /* DBG_HELPERS */