1

/* $Id:$ */

     2

     3

/** @file dbg_helpers.cpp */

     4

#include "../stdafx.h"

     5

#include "../direction.h"

     6

#include "../rail.h"

     7

#include "../rail_map.h"

     8

#include "dbg_helpers.h"

     9

    10

/** Trackdir & TrackdirBits short names. */

    11

static const char* trackdir_names[] = {

    12

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

    13

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

    14

};

    15

    16

/** Return name of given Trackdir. */

    17

CStrA ValueStr(Trackdir td)

    18

{

    19

	CStrA out;

    20

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

    21

	return out.Transfer();

    22

}

    23

    24

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

    25

CStrA ValueStr(TrackdirBits td_bits)

    26

{

    27

	CStrA out;

    28

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

    29

	return out.Transfer();

    30

}

    31

    32

    33

/** DiagDirection short names. */

    34

static const char* diagdir_names[] = {

    35

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

    36

};

    37

    38

/** Return name of given DiagDirection. */

    39

CStrA ValueStr(DiagDirection dd)

    40

{

    41

	CStrA out;

    42

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

    43

	return out.Transfer();

    44

}

    45

    46

    47

/** SignalType short names. */

    48

static const char* signal_type_names[] = {

    49

	"NORMAL", "ENTRY", "EXIT", "COMBO",

    50

};

    51

    52

/** Return name of given SignalType. */

    53

CStrA ValueStr(SignalType t)

    54

{

    55

	CStrA out;

    56

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

    57

	return out.Transfer();

    58

}

    59

    60

    61

/** Translate TileIndex into string. */

    62

CStrA TileStr(TileIndex tile)

    63

{

    64

	CStrA out;

    65

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

    66

	return out.Transfer();

    67

}

    68

    69

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

    70

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

    71

{

    72

	static size_t last_type_id = 0;

    73

	return last_type_id;

    74

}

    75

    76

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

    77

CStrA DumpTarget::GetCurrentStructName()

    78

{

    79

	CStrA out;

    80

	if (!m_cur_struct.empty()) {

    81

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

    82

		out = m_cur_struct.top();

    83

	}

    84

	return out.Transfer();

    85

}

    86

    87

/**

    88

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

    89

 * Return true and set name when object was found.

    90

 */

    91

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

    92

{

    93

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

    94

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

    95

		/* we have found it */

    96

		name = (*it).second;

    97

		return true;

    98

	}

    99

	return false;

   100

}

   101

   102

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

   103

void DumpTarget::WriteIndent()

   104

{

   105

	int num_spaces = 2 * m_indent;

   106

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

   107

}

   108

   109

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

   110

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

   111

{

   112

	WriteIndent();

   113

	va_list args;

   114

	va_start(args, format);

   115

	m_out.AddFormatL(format, args);

   116

	va_end(args);

   117

	m_out.AppendStr("\n");

   118

}

   119

   120

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

   121

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

   122

{

   123

	WriteIndent();

   124

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

   125

}

   126

   127

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

   128

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

   129

{

   130

	WriteIndent();

   131

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

   132

}

   133

   134

/**

   135

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

   136

 */

   137

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

   138

{

   139

	/* make composite name */

   140

	CStrA cur_name = GetCurrentStructName().Transfer();

   141

	if (cur_name.Size() > 0) {

   142

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

   143

		cur_name.AppendStr(".");

   144

	}

   145

	cur_name.AppendStr(name);

   146

   147

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

   148

	m_cur_struct.push(cur_name);

   149

   150

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

   151

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

   152

   153

	WriteIndent();

   154

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

   155

	m_indent++;

   156

}

   157

   158

/**

   159

 * Close structure '}<LF>'.

   160

 */

   161

void DumpTarget::EndStruct()

   162

{

   163

	m_indent--;

   164

	WriteIndent();

   165

	m_out.AddFormat("}\n");

   166

   167

	/* remove current struct name from the stack */

   168

	m_cur_struct.pop();

   169

}

   170