1

/* $Id$ */

     2

     3

/** @file dbg_helpers.cpp Helpers for outputting debug information. */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../direction_type.h"

     8

#include "../strings_type.h"

     9

#include "../rail.h"

    10

#include "../rail_map.h"

    11

#include "dbg_helpers.h"

    12

    13

/** Trackdir & TrackdirBits short names. */

    14

static const char* trackdir_names[] = {

    15

	"NE", "SE", "UE", "LE", "LS", "RS", "rne", "rse",

    16

	"SW", "NW", "UW", "LW", "LN", "RN", "rsw", "rnw",

    17

};

    18

    19

/** Return name of given Trackdir. */

    20

CStrA ValueStr(Trackdir td)

    21

{

    22

	CStrA out;

    23

	out.Format("%d (%s)", td, ItemAtT(td, trackdir_names, "UNK", INVALID_TRACKDIR, "INV"));

    24

	return out.Transfer();

    25

}

    26

    27

/** Return composed name of given TrackdirBits. */

    28

CStrA ValueStr(TrackdirBits td_bits)

    29

{

    30

	CStrA out;

    31

	out.Format("%d (%s)", td_bits, ComposeNameT(td_bits, trackdir_names, "UNK", INVALID_TRACKDIR_BIT, "INV").Data());

    32

	return out.Transfer();

    33

}

    34

    35

    36

/** DiagDirection short names. */

    37

static const char* diagdir_names[] = {

    38

	"NE", "SE", "SW", "NW",

    39

};

    40

    41

/** Return name of given DiagDirection. */

    42

CStrA ValueStr(DiagDirection dd)

    43

{

    44

	CStrA out;

    45

	out.Format("%d (%s)", dd, ItemAtT(dd, diagdir_names, "UNK", INVALID_DIAGDIR, "INV"));

    46

	return out.Transfer();

    47

}

    48

    49

    50

/** SignalType short names. */

    51

static const char* signal_type_names[] = {

    52

	"NORMAL", "ENTRY", "EXIT", "COMBO", "PBS", "NOENTRY",

    53

};

    54

    55

/** Return name of given SignalType. */

    56

CStrA ValueStr(SignalType t)

    57

{

    58

	CStrA out;

    59

	out.Format("%d (%s)", t, ItemAtT(t, signal_type_names, "UNK"));

    60

	return out.Transfer();

    61

}

    62

    63

    64

/** Translate TileIndex into string. */

    65

CStrA TileStr(TileIndex tile)

    66

{

    67

	CStrA out;

    68

	out.Format("0x%04X (%d, %d)", tile, TileX(tile), TileY(tile));

    69

	return out.Transfer();

    70

}

    71

    72

/** Keep track of the last assigned type_id. Used for anti-recursion. */

    73

/*static*/ size_t& DumpTarget::LastTypeId()

    74

{

    75

	static size_t last_type_id = 0;

    76

	return last_type_id;

    77

}

    78

    79

/** Return structured name of the current class/structure. */

    80

CStrA DumpTarget::GetCurrentStructName()

    81

{

    82

	CStrA out;

    83

	if (!m_cur_struct.empty()) {

    84

		// we are inside some named struct, return its name

    85

		out = m_cur_struct.top();

    86

	}

    87

	return out.Transfer();

    88

}

    89

    90

/**

    91

 * Find the given instance in our anti-recursion repository.

    92

 * Return true and set name when object was found.

    93

 */

    94

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

    95

{

    96

	KNOWN_NAMES::const_iterator it = m_known_names.find(KnownStructKey(type_id, ptr));

    97

	if (it != m_known_names.end()) {

    98

		/* we have found it */

    99

		name = (*it).second;

   100

		return true;

   101

	}

   102

	return false;

   103

}

   104

   105

/** Write some leading spaces into the output. */

   106

void DumpTarget::WriteIndent()

   107

{

   108

	int num_spaces = 2 * m_indent;

   109

	memset(m_out.GrowSizeNC(num_spaces), ' ', num_spaces);

   110

}

   111

   112

/** Write a line with indent at the beginning and <LF> at the end. */

   113

void DumpTarget::WriteLine(const char *format, ...)

   114

{

   115

	WriteIndent();

   116

	va_list args;

   117

	va_start(args, format);

   118

	m_out.AddFormatL(format, args);

   119

	va_end(args);

   120

	m_out.AppendStr("\n");

   121

}

   122

   123

/** Write 'name = value' with indent and new-line. */

   124

void DumpTarget::WriteValue(const char *name, const char *value_str)

   125

{

   126

	WriteIndent();

   127

	m_out.AddFormat("%s = %s\n", name, value_str);

   128

}

   129

   130

/** Write name & TileIndex to the output. */

   131

void DumpTarget::WriteTile(const char *name, TileIndex tile)

   132

{

   133

	WriteIndent();

   134

	m_out.AddFormat("%s = %s\n", name, TileStr(tile).Data());

   135

}

   136

   137

/**

   138

 * Open new structure (one level deeper than the current one) 'name = {<LF>'.

   139

 */

   140

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

   141

{

   142

	/* make composite name */

   143

	CStrA cur_name = GetCurrentStructName().Transfer();

   144

	if (cur_name.Size() > 0) {

   145

		/* add name delimiter (we use structured names) */

   146

		cur_name.AppendStr(".");

   147

	}

   148

	cur_name.AppendStr(name);

   149

   150

	/* put the name onto stack (as current struct name) */

   151

	m_cur_struct.push(cur_name);

   152

   153

	/* put it also to the map of known structures */

   154

	m_known_names.insert(KNOWN_NAMES::value_type(KnownStructKey(type_id, ptr), cur_name));

   155

   156

	WriteIndent();

   157

	m_out.AddFormat("%s = {\n", name);

   158

	m_indent++;

   159

}

   160

   161

/**

   162

 * Close structure '}<LF>'.

   163

 */

   164

void DumpTarget::EndStruct()

   165

{

   166

	m_indent--;

   167

	WriteIndent();

   168

	m_out.AddFormat("}\n");

   169

   170

	/* remove current struct name from the stack */

   171

	m_cur_struct.pop();

   172

}

   173