fiddlerwoaroof/crawl - Change 52J7CYVAW3QCUEWA5OKWPDGOP6JZR5NJSE3JDLZFBCR7B6LH5ASAC

Cleanup/refactoring of tags.cc. No functional changes. I've been

running with and without this patch applied for about a week, and none of my saves have broken, so I'm ready to commit it.

Tag system no longer uses one big (shared!) global buffer. This was the original impetus behind the change…
Change every use of tagHeader into reader or writer (touches a lot).
Split tagHeader into two classes: reader and writer. Turns out every place that used tagHeader only cared about reading or writing and not about tags at all. There was nothing left in tagHeader, so it disappeared along with a bunch of grotty special-case code.
Not done: merge the files.cc read/writeThing code with the tags.cc marshall/unmarshallThing code. This patch is big enough already.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@3685 c06c8d41-db1a-0410-9941-cceddc491573

Created by pauldubois on March 17, 2008

52J7CYVAW3QCUEWA5OKWPDGOP6JZR5NJSE3JDLZFBCR7B6LH5ASAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/tags.h at line 21 [5.161012]

B:BD[4.41771] → [4.41771:41839]

    TAG_VERSION = 0,                    // should NEVER be read in!

[4.41771]

[4.41839]

    TAG_NO_TAG = 0,                     // should NEVER be read in!

Replacement in crawl-ref/source/tags.h at line 44 [5.161012]

B:BD[4.42679] → [4.42679:42733]

struct tagHeader 
{
    short tagID;
    long offset;

[4.42679]

[6.138]

/* ***********************************************************************
 * writer API
 * *********************************************************************** */

Replacement in crawl-ref/source/tags.h at line 48 [5.161012]

B:BD[6.139] → [6.139:198]

    // File handle for direct file writes.
    FILE *file;

[6.139]

[6.198]

class writer
{
public:
    writer(FILE* output)
        : _file(output), _pbuf(0) {}
    writer(std::vector<unsigned char>* poutput)
        : _file(0), _pbuf(poutput) {}

Deletion in crawl-ref/source/tags.h at line 56 [5.161012]

B:BD[6.199] → [6.199:343]

    tagHeader() : tagID(0), offset(0L), file(NULL) { }
    tagHeader(FILE *f) : tagID(0), offset(0L), file(f) { }
    unsigned char readByte();

Replacement in crawl-ref/source/tags.h at line 58 [5.161012]

B:BD[6.430] → [6.430:498]

    void read(void *data, size_t size);
    void advance(int skip);

[6.430]

[4.42733]


private:
    FILE* _file;
    std::vector<unsigned char>* _pbuf;

Replacement in crawl-ref/source/tags.h at line 64 [5.161012]

∅:D[4.42737] → [5.161308:161520]

B:BD[5.161308] → [5.161308:161520]

B:BD[5.161520] → [7.130965:131030]

// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: files tags
 * *********************************************************************** */
int write2(FILE * file, const char *buffer, unsigned int count);

[4.42737]

[5.161579]

void marshallByte    (writer &, char );
void marshallShort   (writer &, short );
void marshallLong    (writer &, long );
void marshallFloat   (writer &, float );
void marshallBoolean (writer &, bool );
void marshallString  (writer &, const std::string &, int maxSize = 0);
void marshallCoord   (writer &, const coord_def &);
void marshallItem    (writer &, const item_def &);

Deletion in crawl-ref/source/tags.h at line 73 [5.161012]
B:BD[5.161580] → [5.161580:161613]
```
// last updated 22jan2001 {gdl}
```
Replacement in crawl-ref/source/tags.h at line 74 [5.161012]
B:BD[5.161688] → [5.161688:161715]
```
 * called from: files tags
```
[5.161688]
[5.161715]
```
 * reader API
```
Deletion in crawl-ref/source/tags.h at line 76 [5.161012]
B:BD[5.161793] → [5.161793:161851]
```
int read2(FILE * file, char *buffer, unsigned int count);
```

Insertion in crawl-ref/source/tags.h at line 77 [5.161012]

[5.161852]

class reader
{
public:
    reader(FILE* input)
        : _file(input), _pbuf(0), _read_offset(0) {}
    reader(const std::vector<unsigned char>& input)
        : _file(0), _pbuf(&input), _read_offset(0) {}

Replacement in crawl-ref/source/tags.h at line 85 [5.161012]

B:BD[5.161853] → [5.161853:162065]

B:BD[5.162065] → [6.499:791]

∅:D[6.791] → [8.199:237]

B:BD[8.199] → [8.199:237]

∅:D[8.237] → [9.824:879]

B:BD[10.98852] → [9.824:879]

B:BD[9.879] → [11.138:194]

// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: files tags
 * *********************************************************************** */
void marshallByte(tagHeader &th, char data);
void marshallShort(tagHeader &th, short data);
void marshallLong(tagHeader &th, long data);
void marshallFloat(tagHeader &th, float data);
void marshallBoolean(tagHeader &th, bool data);
void marshallString(tagHeader &th, const std::string &data,
                    int maxSize = 0);
void marshallCoord(tagHeader &th, const coord_def &c);
void marshallItem(tagHeader &th, const item_def &item);

[5.161853]

[5.162404]

    unsigned char readByte();
    void read(void *data, size_t size);

Replacement in crawl-ref/source/tags.h at line 88 [5.161012]

B:BD[5.162405] → [5.162405:162617]

B:BD[5.162617] → [6.792:1042]

∅:D[6.1042] → [8.309:374]

∅:D[12.1663] → [8.309:374]

B:BD[8.309] → [8.309:374]

∅:D[8.374] → [9.880:931]

B:BD[13.77] → [9.880:931]

B:BD[9.931] → [11.195:247]

∅:D[13.77] → [5.162909:162910]

∅:D[11.247] → [5.162909:162910]

∅:D[9.931] → [5.162909:162910]

B:BD[5.162909] → [5.162909:162910]

B:BD[5.162910] → [14.382:430]

∅:D[14.430] → [5.162966:163210]

B:BD[5.162966] → [5.162966:163210]

B:BD[5.163210] → [15.2343:2385]

// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: tags files
 * *********************************************************************** */
char unmarshallByte(tagHeader &th);
short unmarshallShort(tagHeader &th);
long unmarshallLong(tagHeader &th);
float unmarshallFloat(tagHeader &th);
bool unmarshallBoolean(tagHeader &th);
int unmarshallCString(tagHeader &th, char *data, int maxSize);
std::string unmarshallString(tagHeader &th, int maxSize = 1000);
void unmarshallCoord(tagHeader &th, coord_def &c);
void unmarshallItem(tagHeader &th, item_def &item);
std::string make_date_string( time_t in_date );
time_t parse_date_string( char[20] );
// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: acr
 * *********************************************************************** */
void tag_init(long largest_tag = 100000);

[5.162405]

[5.163251]

private:
    FILE* _file;
    const std::vector<unsigned char>* _pbuf;
    unsigned int _read_offset;
};

Replacement in crawl-ref/source/tags.h at line 94 [5.161012]

B:BD[5.163252] → [5.163252:163460]

B:BD[5.163460] → [6.1043:1085]

∅:D[6.1085] → [5.163509:163510]

B:BD[5.163509] → [5.163509:163510]


// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: files
 * *********************************************************************** */
void tag_construct(tagHeader &th, int i);

[5.163252]

[5.163510]

char        unmarshallByte    (reader &);
short       unmarshallShort   (reader &);
long        unmarshallLong    (reader &);
float       unmarshallFloat   (reader &);
bool        unmarshallBoolean (reader &);
int         unmarshallCString (reader &, char *data, int maxSize);
std::string unmarshallString  (reader &, int maxSize = 1000);
void        unmarshallCoord   (reader &, coord_def &c);
void        unmarshallItem    (reader &, item_def &item);

Deletion in crawl-ref/source/tags.h at line 104 [5.161012]
B:BD[5.163511] → [5.163511:163543]
```
// last updated 22jan2001 {gdl}
```
Replacement in crawl-ref/source/tags.h at line 105 [5.161012]
B:BD[5.163618] → [5.163618:163640]
```
 * called from: files
```
[5.163618]
[5.163640]
```
 * Tag interface
```
Deletion in crawl-ref/source/tags.h at line 107 [5.161012]
B:BD[5.163718] → [6.1086:1133]
∅:D[6.1133] → [5.163772:163773]
B:BD[5.163772] → [5.163772:163773]
```
void tag_write(tagHeader &th, FILE *saveFile);
```

Replacement in crawl-ref/source/tags.h at line 108 [5.161012]

B:BD[5.163774] → [5.163774:163981]

// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: files
 * *********************************************************************** */

[5.163774]

[5.163981]

tag_type tag_read(FILE* inf, char minorVersion);
void tag_write(tag_type tagID, FILE* outf);

Insertion in crawl-ref/source/tags.h at line 111 [5.161012]
[5.164031]
[5.164031]
```
void tag_missing(int tag, char minorVersion);
```
Deletion in crawl-ref/source/tags.h at line 113 [5.161012]
B:BD[5.164032] → [5.164032:164065]
```
// last updated 22jan2001 {gdl}
```
Replacement in crawl-ref/source/tags.h at line 114 [5.161012]
B:BD[5.164140] → [5.164140:164162]
```
 * called from: files
```
[5.164140]
[5.164162]
```
 * misc
```
Deletion in crawl-ref/source/tags.h at line 116 [5.161012]
B:BD[5.164240] → [5.164240:164286]
```
void tag_missing(int tag, char minorVersion);
```

Replacement in crawl-ref/source/tags.h at line 117 [5.161012]

B:BD[5.164287] → [5.164287:164538]


// last updated 22jan2001 {gdl}
/* ***********************************************************************
 * called from: files
 * *********************************************************************** */
int tag_read(FILE *fp, char minorVersion);

[5.164287]

[5.164538]

int write2(FILE * file, const void *buffer, unsigned int count);
int read2(FILE * file, void *buffer, unsigned int count);
std::string make_date_string( time_t in_date );
time_t parse_date_string( char[20] );

Replacement in crawl-ref/source/tags.cc at line 16 [5.164589]

B:BD[5.164953] → [16.138:214]

∅:D[16.214] → [5.165029:165158]

B:BD[5.165029] → [5.165029:165158]

1. Tag types are enumerated in tags.h, from TAG_VERSION (more a placeholder
   than anything else, it is not actually saved as a tag) to TAG_XXX. NUM_TAGS
   is equal to the actual number of defined tags.

[5.164953]

[5.165158]

1. Tag types are enumerated in tags.h.

Replacement in crawl-ref/source/tags.cc at line 18 [5.164589]

B:BD[5.165159] → [10.98854:98928]

∅:D[10.98928] → [5.165234:165328]

B:BD[5.165234] → [5.165234:165328]

2. Tags are created with tag_construct(), which forwards the construction
   request appropriately.   tag_write() is then used to write the tag to an
   output stream.

[5.165159]

[5.165328]

2. Tags are written to a FILE* using tag_write(tag_type t).  The serialization
   request is forwarded appropriately.

Replacement in crawl-ref/source/tags.cc at line 21 [5.164589]

B:BD[5.165329] → [5.165329:165516]

3. Tags are parsed with tag_read(), which tries to read a tag header and then
   forwards the request appropriately, returning the ID of the tag it found,
   or zero if no tag was found.

[5.165329]

[5.165516]

3. Tags are read from a FILE* with tag_read(), which does not need a tag_type
   argument.  A header is read, which tells tag_read what to construct.

Deletion in crawl-ref/source/tags.cc at line 89 [5.164589]
∅:D[17.1580] → [5.167647:167730]
B:BD[5.167647] → [5.167647:167730]
```
// THE BIG IMPORTANT TAG CONSTRUCTION/PARSE BUFFER
static char *tagBuffer = NULL;
```

Replacement in crawl-ref/source/tags.cc at line 100 [5.164589]

B:BD[5.168194] → [5.168194:168212]

B:BD[5.168212] → [6.1135:1287]

∅:D[6.1287] → [18.276:332]

B:BD[5.168385] → [18.276:332]

B:BD[18.332] → [19.2210:2263]

B:BD[19.2263] → [6.1288:1463]

∅:D[6.1463] → [18.333:402]

B:BD[5.168581] → [18.333:402]

B:BD[18.402] → [19.2264:2330]

∅:D[18.402] → [5.168581:168582]

∅:D[19.2330] → [5.168581:168582]

B:BD[5.168581] → [5.168581:168582]

B:BD[5.168582] → [6.1464:1680]

B:BD[6.1680] → [20.228594:228655]

∅:D[20.228655] → [6.1680:1933]

B:BD[6.1680] → [6.1680:1933]

∅:D[6.1933] → [5.169107:169149]

B:BD[5.169107] → [5.169107:169149]

B:BD[5.169149] → [20.228656:228751]

∅:D[20.228751] → [5.169149:169150]

B:BD[5.169149] → [5.169149:169150]

B:BD[5.169150] → [6.1934:2044]

∅:D[6.2044] → [13.79:201]

B:BD[5.169274] → [13.79:201]

B:BD[13.201] → [21.245:502]

∅:D[21.502] → [18.403:527]

B:BD[13.201] → [18.403:527]

∅:D[13.201] → [5.169274:169275]

∅:D[18.651] → [5.169274:169275]

B:BD[5.169274] → [5.169274:169275]

B:BD[5.169275] → [8.376:434]

B:BD[8.434] → [6.2045:2114]

∅:D[6.2114] → [8.435:485]

B:BD[22.270] → [8.435:485]

∅:D[8.485] → [22.350:371]

B:BD[22.350] → [22.350:371]

B:BD[22.371] → [6.2115:2365]

// static helpers
static void tag_construct_you(tagHeader &th);
static void tag_construct_you_items(tagHeader &th);
static void tag_construct_you_dungeon(tagHeader &th);
static void tag_construct_lost_monsters(tagHeader &th);
static void tag_construct_lost_items(tagHeader &th);
static void tag_read_you(tagHeader &th, char minorVersion);
static void tag_read_you_items(tagHeader &th, char minorVersion);
static void tag_read_you_dungeon(tagHeader &th);
static void tag_read_lost_monsters(tagHeader &th, int minorVersion);
static void tag_read_lost_items(tagHeader &th, int minorVersion);
static void tag_construct_level(tagHeader &th);
static void tag_construct_level_items(tagHeader &th);
static void tag_construct_level_monsters(tagHeader &th);
static void tag_construct_level_attitude(tagHeader &th);
static void tag_construct_level_tiles(struct tagHeader &th);
static void tag_read_level(tagHeader &th, char minorVersion);
static void tag_read_level_items(tagHeader &th, char minorVersion);
static void tag_read_level_monsters(tagHeader &th, char minorVersion);
static void tag_read_level_attitude(tagHeader &th);
static void tag_missing_level_attitude();
static void tag_read_level_tiles(struct tagHeader &th);
static void tag_missing_level_tiles();
static void tag_construct_ghost(tagHeader &th);
static void tag_read_ghost(tagHeader &th, char minorVersion);
static void marshallGhost(tagHeader &th, const ghost_demon &ghost);
static ghost_demon unmarshallGhost( tagHeader &th );
static void marshallResists(tagHeader &, const mon_resist_def &);
static void unmarshallResists(tagHeader &, mon_resist_def &);
static void marshallSpells(tagHeader &, const monster_spells &);
static void unmarshallSpells(tagHeader &, monster_spells &);
static void marshall_monster(tagHeader &th, const monsters &m);
static void unmarshall_monster(tagHeader &th, monsters &m);
template<typename T, typename T_iter, typename T_marshal>
static void marshall_iterator(tagHeader &th, T_iter beg, T_iter end,
                              T_marshal marshal);
template<typename T>
static void unmarshall_vector(tagHeader& th, std::vector<T>& vec,
                              T (*T_unmarshall)(tagHeader&));
//////////////////////////////////////////////////////////////////////
// tagHeader
unsigned char tagHeader::readByte()

[5.168193]

[6.2365]

// Reads input in network byte order, from a file or buffer.
unsigned char reader::readByte()

Replacement in crawl-ref/source/tags.cc at line 103 [5.164589]

B:BD[6.2367] → [6.2367:2437]

    if (file)
        return static_cast<unsigned char>(fgetc(file));

[6.2367]

[6.2437]

    if (_file)
        return static_cast<unsigned char>(fgetc(_file));

Replacement in crawl-ref/source/tags.cc at line 106 [5.164589]
B:BD[6.2446] → [6.2446:2482]
```
        return tagBuffer[offset++];
```
[6.2446]
[6.2482]
```
        return (*_pbuf)[_read_offset++];
```
Replacement in crawl-ref/source/tags.cc at line 109 [5.164589]
B:BD[6.2485] → [6.2485:2529]
```
void tagHeader::writeByte(unsigned char ch)
```
[6.2485]
[6.2529]
```
void reader::read(void *data, size_t size)
```

Replacement in crawl-ref/source/tags.cc at line 111 [5.164589]

B:BD[6.2531] → [6.2531:2570]

    if (file)
        fputc(ch, file);

[6.2531]

[6.2570]

    if (_file)
    {
        if (data)
            fread(data, 1, size, _file);
        else
            fseek(_file, (long)size, SEEK_CUR);
    }

Replacement in crawl-ref/source/tags.cc at line 119 [5.164589]

B:BD[6.2579] → [6.2579:2613]

        tagBuffer[offset++] = ch;

[6.2579]

[6.2613]

    {
        ASSERT(_read_offset+size <= _pbuf->size());
        if (data) memcpy(data, &(*_pbuf)[_read_offset], size);
        _read_offset += size;
    }

Replacement in crawl-ref/source/tags.cc at line 126 [5.164589]
B:BD[6.2616] → [6.2616:2669]
```
void tagHeader::write(const void *data, size_t size)
```
[6.2616]
[6.2669]
```
void writer::writeByte(unsigned char ch)
```

Replacement in crawl-ref/source/tags.cc at line 128 [5.164589]

B:BD[6.2671] → [6.2671:2809]

    if (file)
        fwrite(data, 1, size, file);
    else
    {
        memcpy(tagBuffer + offset, data, size);
        offset += size;

[6.2671]

[6.2809]

    if (_file)
        fputc(ch, _file);
    else {
        _pbuf->push_back(ch);

Replacement in crawl-ref/source/tags.cc at line 135 [5.164589]
B:BD[22.514] → [6.2818:2864]
```
void tagHeader::read(void *data, size_t size)
```
[22.514]
[6.2864]
```
void writer::write(const void *data, size_t size)
```

Replacement in crawl-ref/source/tags.cc at line 137 [5.164589]

B:BD[6.2866] → [6.2866:2916]

    if (file)
        fread(data, 1, size, file);

[6.2866]

[6.2916]

    if (_file)
    {
        fwrite(data, 1, size, _file);
    }

Replacement in crawl-ref/source/tags.cc at line 143 [5.164589]

B:BD[6.2931] → [6.2931:3003]

        memcpy(data, tagBuffer + offset, size);
        offset += size;

[6.2931]

[6.3003]

        const unsigned char* cdata = static_cast<const unsigned char*>(data);
        _pbuf->insert(_pbuf->end(), cdata, cdata+size);

Insertion in crawl-ref/source/tags.cc at line 147 [5.164589]

[6.3011]


// static helpers
static void tag_construct_you(writer &th);
static void tag_construct_you_items(writer &th);
static void tag_construct_you_dungeon(writer &th);
static void tag_construct_lost_monsters(writer &th);
static void tag_construct_lost_items(writer &th);
static void tag_read_you(reader &th, char minorVersion);
static void tag_read_you_items(reader &th, char minorVersion);
static void tag_read_you_dungeon(reader &th);
static void tag_read_lost_monsters(reader &th, int minorVersion);
static void tag_read_lost_items(reader &th, int minorVersion);
static void tag_construct_level(writer &th);
static void tag_construct_level_items(writer &th);
static void tag_construct_level_monsters(writer &th);
static void tag_construct_level_attitude(writer &th);
static void tag_construct_level_tiles(writer &th);
static void tag_read_level(reader &th, char minorVersion);
static void tag_read_level_items(reader &th, char minorVersion);
static void tag_read_level_monsters(reader &th, char minorVersion);
static void tag_read_level_attitude(reader &th);
static void tag_missing_level_attitude();
static void tag_read_level_tiles(struct reader &th);
static void tag_missing_level_tiles();

Replacement in crawl-ref/source/tags.cc at line 174 [5.164589]

B:BD[6.3012] → [6.3012:3134]

void tagHeader::advance(int skip)
{
    if (file)
        fseek(file, skip, SEEK_CUR);
    else
        offset += skip;
}

[6.3012]

[6.3134]

static void tag_construct_ghost(writer &th);
static void tag_read_ghost(reader &th, char minorVersion);
static void marshallGhost(writer &th, const ghost_demon &ghost);
static ghost_demon unmarshallGhost( reader &th );
static void marshallResists(writer &, const mon_resist_def &);
static void unmarshallResists(reader &, mon_resist_def &);
static void marshallSpells(writer &, const monster_spells &);
static void unmarshallSpells(reader &, monster_spells &);
static void marshall_monster(writer &th, const monsters &m);
static void unmarshall_monster(reader &th, monsters &m);
template<typename T, typename T_iter, typename T_marshal>
static void marshall_iterator(writer &th, T_iter beg, T_iter end,
                              T_marshal marshal);
template<typename T>
static void unmarshall_vector(reader& th, std::vector<T>& vec,
                              T (*T_unmarshall)(reader&));

Deletion in crawl-ref/source/tags.cc at line 196 [5.164589]
B:BD[6.3135] → [6.3135:3206]
```
//////////////////////////////////////////////////////////////////////
```

Replacement in crawl-ref/source/tags.cc at line 198 [5.164589]

B:BD[5.169328] → [7.131032:131096]

int write2(FILE * file, const char *buffer, unsigned int count)

[5.169328]

[5.169386]

int write2(FILE * file, const void *buffer, unsigned int count)

Replacement in crawl-ref/source/tags.cc at line 204 [5.164589]
B:BD[5.169487] → [5.169487:169544]
```
int read2(FILE * file, char *buffer, unsigned int count)
```
[5.169487]
[5.169544]
```
int read2(FILE * file, void *buffer, unsigned int count)
```
Replacement in crawl-ref/source/tags.cc at line 209 [5.164589]
B:BD[5.169591] → [6.3208:3252]
```
void marshallByte(tagHeader &th, char data)
```
[5.169591]
[5.169642]
```
void marshallByte(writer &th, char data)
```
Replacement in crawl-ref/source/tags.cc at line 214 [5.164589]
B:BD[5.169700] → [6.3278:3313]
```
char unmarshallByte(tagHeader &th)
```
[5.169700]
[5.169742]
```
char unmarshallByte(reader &th)
```

Insertion in crawl-ref/source/tags.cc at line 219 [5.164589]

[5.169822]

void marshallShort(std::vector<unsigned char>& buf, short data)
{
    COMPILE_CHECK(sizeof(data)==2, c1);
    buf.push_back((unsigned char) ((data & 0xFF00) >> 8));
    buf.push_back((unsigned char) ((data & 0x00FF)     ));
}

Replacement in crawl-ref/source/tags.cc at line 227 [5.164589]
B:BD[5.169864] → [6.3341:3387]
```
void marshallShort(tagHeader &th, short data)
```
[5.169864]
[5.169917]
```
void marshallShort(writer &th, short data)
```
Replacement in crawl-ref/source/tags.cc at line 236 [5.164589]
B:BD[5.170135] → [6.3526:3563]
```
short unmarshallShort(tagHeader &th)
```
[5.170135]
[5.170179]
```
short unmarshallShort(reader &th)
```

Insertion in crawl-ref/source/tags.cc at line 244 [5.164589]

[5.170345]

void marshallLong(std::vector<unsigned char>& buf, long data)
{
    COMPILE_CHECK(sizeof(data)==4, c1);
    buf.push_back((unsigned char) ((data & 0xFF000000) >> 24));
    buf.push_back((unsigned char) ((data & 0x00FF0000) >> 16));
    buf.push_back((unsigned char) ((data & 0x0000FF00) >>  8));
    buf.push_back((unsigned char) ((data & 0x000000FF)      ));
}

Replacement in crawl-ref/source/tags.cc at line 254 [5.164589]
B:BD[5.170385] → [6.3625:3669]
```
void marshallLong(tagHeader &th, long data)
```
[5.170385]
[5.170436]
```
void marshallLong(writer &th, long data)
```
Replacement in crawl-ref/source/tags.cc at line 268 [5.164589]
B:BD[5.170829] → [6.3759:3794]
```
long unmarshallLong(tagHeader &th)
```
[5.170829]
[5.170871]
```
long unmarshallLong(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 281 [5.164589]
B:BD[17.1846] → [6.3912:3961]
```
void marshall_as_long(tagHeader& th, const T& t)
```
[17.1846]
[17.1902]
```
void marshall_as_long(writer& th, const T& t)
```

Replacement in crawl-ref/source/tags.cc at line 287 [5.164589]

B:BD[17.1992] → [6.3962:4157]

void marshallMap(tagHeader &th, const std::map<key,value>& data,
                 void (*key_marshall)(tagHeader&, const key&),
                 void (*value_marshall)(tagHeader&, const value&))

[17.1992]

[17.2208]

void marshallMap(writer &th, const std::map<key,value>& data,
                 void (*key_marshall)(writer&, const key&),
                 void (*value_marshall)(writer&, const value&))

Replacement in crawl-ref/source/tags.cc at line 301 [5.164589]

B:BD[8.535] → [6.4158:4227]

static void marshall_iterator(tagHeader &th, T_iter beg, T_iter end,

[8.535]

[8.536]

static void marshall_iterator(writer &th, T_iter beg, T_iter end,

Replacement in crawl-ref/source/tags.cc at line 313 [5.164589]

B:BD[22.867] → [6.4228:4355]

static void unmarshall_vector(tagHeader& th, std::vector<T>& vec,
                              T (*T_unmarshall)(tagHeader&))

[22.867]

[22.1008]

static void unmarshall_vector(reader& th, std::vector<T>& vec,
                              T (*T_unmarshall)(reader&))

Replacement in crawl-ref/source/tags.cc at line 323 [5.164589]

B:BD[8.671] → [8.671:743]

static void unmarshall_container(tagHeader &th, T_container &container,

[8.671]

[8.743]

static void unmarshall_container(reader &th, T_container &container,

Replacement in crawl-ref/source/tags.cc at line 332 [5.164589]

B:BD[17.2446] → [18.652:712]

void marshall_level_id( tagHeader& th, const level_id& id )

[17.2446]

[17.2513]

void marshall_level_id( writer& th, const level_id& id )

Replacement in crawl-ref/source/tags.cc at line 339 [5.164589]

B:BD[17.2585] → [6.4356:4420]

void marshall_level_pos( tagHeader& th, const level_pos& lpos )

[17.2585]

[17.2656]

void marshall_level_pos( writer& th, const level_pos& lpos )

Replacement in crawl-ref/source/tags.cc at line 347 [5.164589]

B:BD[9.1008] → [6.4421:4466]

∅:D[9.1060] → [18.751:868]

∅:D[6.4466] → [18.751:868]

B:BD[17.2872] → [18.751:868]

void unmarshallMap(tagHeader& th, map& data,
                   key   (*key_unmarshall)  (tagHeader&),
                   value (*value_unmarshall)(tagHeader&) )

[9.1008]

[17.3003]

void unmarshallMap(reader& th, map& data,
                   key   (*key_unmarshall)  (reader&),
                   value (*value_unmarshall)(reader&) )

Replacement in crawl-ref/source/tags.cc at line 362 [5.164589]
B:BD[17.3222] → [6.4467:4505]
```
T unmarshall_long_as( tagHeader& th )
```
[17.3222]
[17.3267]
```
T unmarshall_long_as( reader& th )
```
Replacement in crawl-ref/source/tags.cc at line 367 [5.164589]
B:BD[5.171185] → [18.910:956]
```
level_id unmarshall_level_id( tagHeader& th )
```
[5.171185]
[17.3370]
```
level_id unmarshall_level_id( reader& th )
```
Replacement in crawl-ref/source/tags.cc at line 376 [5.164589]
B:BD[17.3478] → [6.4506:4554]
```
level_pos unmarshall_level_pos( tagHeader& th )
```
[17.3478]
[17.3533]
```
level_pos unmarshall_level_pos( reader& th )
```
Replacement in crawl-ref/source/tags.cc at line 385 [5.164589]
B:BD[9.1147] → [9.1147:1201]
```
void marshallCoord(tagHeader &th, const coord_def &c)
```
[9.1147]
[9.1201]
```
void marshallCoord(writer &th, const coord_def &c)
```
Replacement in crawl-ref/source/tags.cc at line 391 [5.164589]
B:BD[9.1262] → [9.1262:1312]
```
void unmarshallCoord(tagHeader &th, coord_def &c)
```
[9.1262]
[9.1312]
```
void unmarshallCoord(reader &th, coord_def &c)
```

Replacement in crawl-ref/source/tags.cc at line 398 [5.164589]

B:BD[23.1435] → [23.1435:1500]

void run_length_encode(tagHeader &th, marshall m, const grid &g,

[23.1435]

[23.1500]

void run_length_encode(writer &th, marshall m, const grid &g,

Replacement in crawl-ref/source/tags.cc at line 427 [5.164589]

B:BD[23.2080] → [23.2080:2142]

void run_length_decode(tagHeader &th, unmarshall um, grid &g,

[23.2080]

[23.2142]

void run_length_decode(reader &th, unmarshall um, grid &g,

Replacement in crawl-ref/source/tags.cc at line 456 [5.164589]
B:BD[5.171241] → [6.4555:4601]
```
void marshallFloat(tagHeader &th, float data)
```
[5.171241]
[5.171294]
```
void marshallFloat(writer &th, float data)
```
Replacement in crawl-ref/source/tags.cc at line 464 [5.164589]
B:BD[5.171427] → [6.4602:4639]
```
float unmarshallFloat(tagHeader &th)
```
[5.171427]
[5.171471]
```
float unmarshallFloat(reader &th)
```

Replacement in crawl-ref/source/tags.cc at line 472 [5.164589]

B:BD[5.171594] → [6.4640:4713]

void marshallString(tagHeader &th, const std::string &data, int maxSize)

[5.171594]

[5.171661]

void marshallString(writer &th, const std::string &data, int maxSize)

Replacement in crawl-ref/source/tags.cc at line 486 [5.164589]

B:BD[24.1409] → [6.4748:4816]

static void marshall_string(tagHeader &th, const std::string &data)

[24.1409]

[24.1484]

static void marshallStringNoMax(writer &th, const std::string &data)

Replacement in crawl-ref/source/tags.cc at line 492 [5.164589]

B:BD[5.172014] → [6.4817:4879]

int unmarshallCString(tagHeader &th, char *data, int maxSize)

[5.172014]

[5.172083]

int unmarshallCString(reader &th, char *data, int maxSize)

Replacement in crawl-ref/source/tags.cc at line 505 [5.164589]
B:BD[5.172355] → [6.4909:4940]
```
    th.advance(len - copylen);
```
[5.172355]
[12.1736]
```
    th.read(NULL, len - copylen);
```

Replacement in crawl-ref/source/tags.cc at line 509 [5.164589]

B:BD[13.203] → [13.203:260]

std::string unmarshallString(tagHeader &th, int maxSize)

[13.203]

[13.260]

std::string unmarshallString(reader &th, int maxSize)

Replacement in crawl-ref/source/tags.cc at line 524 [5.164589]
B:BD[24.1548] → [6.4963:5015]
```
static std::string unmarshall_string(tagHeader &th)
```
[24.1548]
[24.1607]
```
static std::string unmarshallStringNoMax(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 530 [5.164589]
B:BD[5.172440] → [6.5016:5063]
```
void marshallBoolean(tagHeader &th, bool data)
```
[5.172440]
[5.172494]
```
void marshallBoolean(writer &th, bool data)
```
Replacement in crawl-ref/source/tags.cc at line 540 [5.164589]
B:BD[5.172692] → [6.5092:5130]
```
bool unmarshallBoolean(tagHeader &th)
```
[5.172692]
[5.172737]
```
bool unmarshallBoolean(reader &th)
```

Replacement in crawl-ref/source/tags.cc at line 605 [5.164589]

B:BD[5.174109] → [5.174109:174165]

// PUBLIC TAG FUNCTIONS
void tag_init(long largest_tag)

[5.174109]

[5.174165]

// Write a tagged chunk of data to the FILE*.
// tagId specifies what to write.
void tag_write(tag_type tagID, FILE* outf)

Replacement in crawl-ref/source/tags.cc at line 609 [5.164589]

B:BD[5.174167] → [5.174167:174259]

B:BD[5.174259] → [6.5189:5234]

∅:D[6.5234] → [5.174311:174355]

B:BD[5.174311] → [5.174311:174355]

    if (tagBuffer != NULL)
        return;
    tagBuffer = (char *)malloc(largest_tag);
}
void tag_construct(tagHeader &th, int tagID)
{
    th.offset = 0;
    th.tagID = tagID;

[5.174167]

[5.174355]

    std::vector<unsigned char> buf;
    writer th(&buf);

Deletion in crawl-ref/source/tags.cc at line 648 [5.164589]
B:BD[5.175171] → [5.175171:175174]
B:BD[5.175174] → [6.5235:5281]
∅:D[6.5281] → [5.175227:175306]
B:BD[5.175227] → [5.175227:175306]
```
}
void tag_write(tagHeader &th, FILE *saveFile)
{
    const int tagHdrSize = 6;
    int tagSize=0;
    char swap[tagHdrSize];
```
Replacement in crawl-ref/source/tags.cc at line 650 [5.164589]
B:BD[5.175353] → [5.175353:175377]
```
    if (th.offset == 0)
```
[5.175353]
[5.175377]
```
    if (buf.size() == 0)
```

Replacement in crawl-ref/source/tags.cc at line 653 [5.164589]

B:BD[5.175394] → [5.175394:175479]

    // special case: TAG_VERSION.  Skip tag header.
    if (th.tagID != TAG_VERSION)

[5.175394]

[5.175479]

    // Write tag header.

Replacement in crawl-ref/source/tags.cc at line 655 [5.164589]

B:BD[5.175485] → [5.175485:175956]

        // swap out first few bytes
        memcpy(swap, tagBuffer, tagHdrSize);
        // save tag size
        tagSize = th.offset;
        // swap in the header
        th.offset = 0;
        marshallShort(th, th.tagID);
        marshallLong(th, tagSize);
        // write header
        write2(saveFile, tagBuffer, th.offset);
        // swap real data back in
        memcpy(tagBuffer, swap, tagHdrSize);
        // reset tag size
        th.offset = tagSize;

[5.175485]

[5.175956]

        writer tmp(outf);
        marshallShort(tmp, tagID);
        marshallLong(tmp, buf.size());

Replacement in crawl-ref/source/tags.cc at line 661 [5.164589]
B:BD[5.175985] → [5.175985:176041]
```
    write2(saveFile, tagBuffer, th.offset);
    return;
```
[5.175985]
[5.176041]
```
    write2(outf, &buf[0], buf.size());
```

Insertion in crawl-ref/source/tags.cc at line 664 [5.164589]

[5.176044]

// Read a single tagged chunk of data from fp into memory.
// TAG_NO_TAG is returned if there's nothing left to read in the file
// (or on an error).
//

Replacement in crawl-ref/source/tags.cc at line 670 [5.164589]
B:BD[5.176135] → [5.176135:176177]
```
int tag_read(FILE *fp, char minorVersion)
```
[5.176135]
[5.176177]
```
tag_type tag_read(FILE *fp, char minorVersion)
```

Replacement in crawl-ref/source/tags.cc at line 672 [5.164589]

B:BD[5.176179] → [5.176179:176209]

B:BD[5.176209] → [6.5282:5305]

∅:D[6.5305] → [5.176239:176258]

B:BD[5.176239] → [5.176239:176258]

    const int tagHdrSize = 6;
    tagHeader hdr, th;
    th.offset = 0;

[5.176179]

[5.176258]

    // Read header info and data
    short tag_id;
    std::vector<unsigned char> buf;
    {
        reader tmp(fp);
        tag_id = unmarshallShort(tmp);
        if (tag_id < 0) return TAG_NO_TAG;
        const long data_size = unmarshallLong(tmp);
        if (data_size < 0) return TAG_NO_TAG;

Replacement in crawl-ref/source/tags.cc at line 682 [5.164589]

B:BD[5.176259] → [5.176259:176492]

    // read tag header
    if (read2(fp, tagBuffer, tagHdrSize) != tagHdrSize)
        return 0;
    // unmarshall tag type and length (not including header)
    hdr.tagID = unmarshallShort(th);
    hdr.offset = unmarshallLong(th);

[5.176259]

[5.176492]

        // Fetch data in one go
        buf.resize(data_size);
        if (read2(fp, &buf[0], buf.size()) != (int)buf.size())
            return TAG_NO_TAG;
    }

Deletion in crawl-ref/source/tags.cc at line 688 [5.164589]

B:BD[5.176493] → [5.176493:176710]

    // sanity check
    if (hdr.tagID <= 0 || hdr.offset <= 0)
        return 0;
    // now reset th and read actual data
    th.offset = 0;
    if (read2(fp, tagBuffer, hdr.offset) != hdr.offset)
        return 0;

Replacement in crawl-ref/source/tags.cc at line 689 [5.164589]
B:BD[5.176739] → [5.176739:176761]
```
    switch(hdr.tagID)
```
[5.176739]
[5.176761]
```
    reader th(buf);
    switch (tag_id)
```
Replacement in crawl-ref/source/tags.cc at line 725 [5.164589]
B:BD[5.177578] → [5.177578:177600]
```
            return 0;
```
[5.177578]
[5.177600]
```
            ASSERT(false);
            return TAG_NO_TAG;
```
Replacement in crawl-ref/source/tags.cc at line 729 [5.164589]
B:BD[5.177607] → [5.177607:177629]
```
    return hdr.tagID;
```
[5.177607]
[5.177629]
```
    return (tag_type)tag_id;
```

Replacement in crawl-ref/source/tags.cc at line 755 [5.164589]

∅:D[20.229021] → [5.178210:178294]

B:BD[5.178210] → [5.178210:178294]

        default:
            perror("Tag %d is missing;  file is likely corrupt.");

[20.229021]

[5.178294]

        default: 
            perror("Tag is missing; file is likely corrupt.");

Replacement in crawl-ref/source/tags.cc at line 810 [5.164589]
B:BD[5.179509] → [6.5306:5351]
```
static void tag_construct_you(tagHeader &th)
```
[5.179509]
[5.179561]
```
static void tag_construct_you(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 987 [5.164589]
B:BD[5.184466] → [6.5352:5403]
```
static void tag_construct_you_items(tagHeader &th)
```
[5.184466]
[5.184524]
```
static void tag_construct_you_items(writer &th)
```

Replacement in crawl-ref/source/tags.cc at line 1034 [5.164589]

B:BD[16.218] → [6.5404:5471]

static void marshallPlaceInfo(tagHeader &th, PlaceInfo place_info)

[16.218]

[16.292]

static void marshallPlaceInfo(writer &th, PlaceInfo place_info)

Replacement in crawl-ref/source/tags.cc at line 1063 [5.164589]
B:BD[5.186080] → [6.5472:5525]
```
static void tag_construct_you_dungeon(tagHeader &th)
```
[5.186080]
[5.186140]
```
static void tag_construct_you_dungeon(writer &th)
```

Replacement in crawl-ref/source/tags.cc at line 1094 [5.164589]

B:BD[24.1685] → [24.1685:1738]

                marshall_level_id, marshall_string);

[24.1685]

[16.1266]

                marshall_level_id, marshallStringNoMax);

Replacement in crawl-ref/source/tags.cc at line 1105 [5.164589]

B:BD[8.1400] → [3.250:290]

                      marshall_string);

[8.1400]

[8.1439]

                      marshallStringNoMax);

Replacement in crawl-ref/source/tags.cc at line 1107 [5.164589]

B:BD[8.1519] → [3.291:331]

                      marshall_string);

[8.1519]

[5.186830]

                      marshallStringNoMax);

Replacement in crawl-ref/source/tags.cc at line 1110 [5.164589]

B:BD[5.186833] → [18.1404:1468]

static void marshall_follower(tagHeader &th, const follower &f)

[5.186833]

[18.1468]

static void marshall_follower(writer &th, const follower &f)

Replacement in crawl-ref/source/tags.cc at line 1117 [5.164589]

B:BD[18.1598] → [18.1598:1658]

static void unmarshall_follower(tagHeader &th, follower &f)

[18.1598]

[18.1658]

static void unmarshall_follower(reader &th, follower &f)

Replacement in crawl-ref/source/tags.cc at line 1124 [5.164589]

B:BD[18.1788] → [18.1788:1867]

static void marshall_follower_list(tagHeader &th, const m_transit_list &mlist)

[18.1788]

[18.1867]

static void marshall_follower_list(writer &th, const m_transit_list &mlist)

Replacement in crawl-ref/source/tags.cc at line 1135 [5.164589]

B:BD[18.2060] → [19.2426:2501]

static void marshall_item_list(tagHeader &th, const i_transit_list &ilist)

[18.2060]

[19.2501]

static void marshall_item_list(writer &th, const i_transit_list &ilist)

Replacement in crawl-ref/source/tags.cc at line 1146 [5.164589]
∅:D[19.2689] → [18.2060:2122]
B:BD[18.2060] → [18.2060:2122]
```
static m_transit_list unmarshall_follower_list(tagHeader &th)
```
[19.2689]
[18.2122]
```
static m_transit_list unmarshall_follower_list(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 1162 [5.164589]
B:BD[18.2353] → [19.2690:2748]
```
static i_transit_list unmarshall_item_list(tagHeader &th)
```
[18.2353]
[19.2748]
```
static i_transit_list unmarshall_item_list(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 1178 [5.164589]
∅:D[19.2983] → [18.2353:2408]
B:BD[18.2353] → [18.2353:2408]
```
static void tag_construct_lost_monsters(tagHeader &th)
```
[19.2983]
[18.2408]
```
static void tag_construct_lost_monsters(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 1184 [5.164589]
B:BD[19.2987] → [19.2987:3039]
```
static void tag_construct_lost_items(tagHeader &th)
```
[19.2987]
[19.3039]
```
static void tag_construct_lost_items(writer &th)
```

Replacement in crawl-ref/source/tags.cc at line 1190 [5.164589]

B:BD[18.2511] → [6.5526:5585]

static void tag_read_you(tagHeader &th, char minorVersion)

[18.2511]

[5.186899]

static void tag_read_you(reader &th, char minorVersion)

Replacement in crawl-ref/source/tags.cc at line 1366 [5.164589]

B:BD[5.199470] → [6.5586:5651]

static void tag_read_you_items(tagHeader &th, char minorVersion)

[5.199470]

[5.199542]

static void tag_read_you_items(reader &th, char minorVersion)

Replacement in crawl-ref/source/tags.cc at line 1443 [5.164589]
B:BD[16.1551] → [6.5652:5704]
```
static PlaceInfo unmarshallPlaceInfo(tagHeader &th)
```
[16.1551]
[16.1610]
```
static PlaceInfo unmarshallPlaceInfo(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 1476 [5.164589]
B:BD[16.2891] → [6.5705:5753]
```
static void tag_read_you_dungeon(tagHeader &th)
```
[16.2891]
[5.202829]
```
static void tag_read_you_dungeon(reader &th)
```

Replacement in crawl-ref/source/tags.cc at line 1520 [5.164589]

B:BD[24.1780] → [24.1780:1839]

                  unmarshall_level_id, unmarshall_string);

[24.1780]

[16.2957]

                  unmarshall_level_id, unmarshallStringNoMax);

Replacement in crawl-ref/source/tags.cc at line 1544 [5.164589]

B:BD[8.1966] → [3.332:377]

                         unmarshall_string);

[8.1966]

[8.2010]

                         unmarshallStringNoMax);

Replacement in crawl-ref/source/tags.cc at line 1548 [5.164589]

B:BD[8.2177] → [3.378:423]

                         unmarshall_string);

[8.2177]

[18.2604]

                         unmarshallStringNoMax);

Replacement in crawl-ref/source/tags.cc at line 1551 [5.164589]

B:BD[18.2607] → [18.2607:2675]

static void tag_read_lost_monsters(tagHeader &th, int minorVersion)

[18.2607]

[18.2675]

static void tag_read_lost_monsters(reader &th, int minorVersion)

Replacement in crawl-ref/source/tags.cc at line 1559 [5.164589]

B:BD[5.203569] → [19.3139:3204]

static void tag_read_lost_items(tagHeader &th, int minorVersion)

[5.203569]

[19.3204]

static void tag_read_lost_items(reader &th, int minorVersion)

Replacement in crawl-ref/source/tags.cc at line 1569 [5.164589]
B:BD[5.203648] → [6.5754:5801]
```
static void tag_construct_level(tagHeader &th)
```
[5.203648]
[5.203702]
```
static void tag_construct_level(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 1635 [5.164589]
B:BD[18.2816] → [11.413:468]
```
void marshallItem(tagHeader &th, const item_def &item)
```
[18.2816]
[18.2879]
```
void marshallItem(writer &th, const item_def &item)
```
Replacement in crawl-ref/source/tags.cc at line 1664 [5.164589]
B:BD[5.204996] → [11.647:698]
```
void unmarshallItem(tagHeader &th, item_def &item)
```
[5.204996]
[18.3579]
```
void unmarshallItem(reader &th, item_def &item)
```
Replacement in crawl-ref/source/tags.cc at line 1690 [5.164589]
B:BD[18.4614] → [6.5802:5855]
```
static void tag_construct_level_items(tagHeader &th)
```
[18.4614]
[5.205056]
```
static void tag_construct_level_items(writer &th)
```

Replacement in crawl-ref/source/tags.cc at line 1707 [5.164589]

B:BD[25.76] → [25.76:147]

static void marshall_mon_enchant(tagHeader &th, const mon_enchant &me)

[25.76]

[25.147]

static void marshall_mon_enchant(writer &th, const mon_enchant &me)

Replacement in crawl-ref/source/tags.cc at line 1716 [5.164589]
B:BD[5.205662] → [25.247:304]
```
static mon_enchant unmarshall_mon_enchant(tagHeader &th)
```
[5.205662]
[25.304]
```
static mon_enchant unmarshall_mon_enchant(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 1727 [5.164589]
∅:D[25.516] → [18.4654:4717]
B:BD[5.205662] → [18.4654:4717]
```
static void marshall_monster(tagHeader &th, const monsters &m)
```
[25.516]
[18.4717]
```
static void marshall_monster(writer &th, const monsters &m)
```
Replacement in crawl-ref/source/tags.cc at line 1770 [5.164589]
B:BD[5.205965] → [6.5856:5912]
```
static void tag_construct_level_monsters(tagHeader &th)
```
[5.205965]
[5.206028]
```
static void tag_construct_level_monsters(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 1786 [5.164589]
B:BD[5.207308] → [6.5913:5962]
```
void tag_construct_level_attitude(tagHeader &th)
```
[5.207308]
[5.207364]
```
void tag_construct_level_attitude(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 1800 [5.164589]
B:BD[20.229146] → [20.229146:229199]
```
void tag_construct_level_tiles(struct tagHeader &th)
```
[20.229146]
[20.229199]
```
void tag_construct_level_tiles(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 1892 [5.164589]
∅:D[20.231785] → [6.5963:6026]
B:BD[5.207581] → [6.5963:6026]
```
static void tag_read_level( tagHeader &th, char minorVersion )
```
[20.231785]
[5.207651]
```
static void tag_read_level( reader &th, char minorVersion )
```

Replacement in crawl-ref/source/tags.cc at line 1964 [5.164589]

B:BD[5.209257] → [6.6027:6094]

static void tag_read_level_items(tagHeader &th, char minorVersion)

[5.209257]

[5.209331]

static void tag_read_level_items(reader &th, char minorVersion)

Replacement in crawl-ref/source/tags.cc at line 1983 [5.164589]
B:BD[5.211237] → [18.5895:5954]
```
static void unmarshall_monster(tagHeader &th, monsters &m)
```
[5.211237]
[18.5954]
```
static void unmarshall_monster(reader &th, monsters &m)
```

Replacement in crawl-ref/source/tags.cc at line 2028 [5.164589]

B:BD[5.211371] → [6.6095:6165]

static void tag_read_level_monsters(tagHeader &th, char minorVersion)

[5.211371]

[5.211448]

static void tag_read_level_monsters(reader &th, char minorVersion)

Replacement in crawl-ref/source/tags.cc at line 2053 [5.164589]
B:BD[5.214031] → [6.6166:6210]
```
void tag_read_level_attitude(tagHeader &th)
```
[5.214031]
[5.214082]
```
void tag_read_level_attitude(reader &th)
```
Replacement in crawl-ref/source/tags.cc at line 2118 [5.164589]
B:BD[20.231795] → [20.231795:231843]
```
void tag_read_level_tiles(struct tagHeader &th)
```
[20.231795]
[20.231843]
```
void tag_read_level_tiles(struct reader &th)
```

Replacement in crawl-ref/source/tags.cc at line 2205 [5.164589]

B:BD[5.215856] → [21.575:645]

static void marshallResists(tagHeader &th, const mon_resist_def &res)

[5.215856]

[5.215910]

static void marshallResists(writer &th, const mon_resist_def &res)

Replacement in crawl-ref/source/tags.cc at line 2221 [5.164589]

B:BD[5.215965] → [21.1057:1123]

static void unmarshallResists(tagHeader &th, mon_resist_def &res)

[5.215965]

[21.1123]

static void unmarshallResists(reader &th, mon_resist_def &res)

Replacement in crawl-ref/source/tags.cc at line 2237 [5.164589]

B:BD[5.216022] → [21.1572:1644]

static void marshallSpells(tagHeader &th, const monster_spells &spells)

[5.216022]

[21.1644]

static void marshallSpells(writer &th, const monster_spells &spells)

Replacement in crawl-ref/source/tags.cc at line 2243 [5.164589]

B:BD[5.216100] → [21.1739:1807]

static void unmarshallSpells(tagHeader &th, monster_spells &spells)

[5.216100]

[5.216168]

static void unmarshallSpells(reader &th, monster_spells &spells)

Replacement in crawl-ref/source/tags.cc at line 2249 [5.164589]

B:BD[21.1933] → [21.1933:2000]

static void marshallGhost(tagHeader &th, const ghost_demon &ghost)

[21.1933]

[21.2000]

static void marshallGhost(writer &th, const ghost_demon &ghost)

Replacement in crawl-ref/source/tags.cc at line 2275 [5.164589]
B:BD[5.216191] → [13.2329:2381]
```
static ghost_demon unmarshallGhost( tagHeader &th )
```
[5.216191]
[13.2381]
```
static ghost_demon unmarshallGhost( reader &th )
```
Replacement in crawl-ref/source/tags.cc at line 2305 [5.164589]
B:BD[13.2633] → [21.3529:3576]
```
static void tag_construct_ghost(tagHeader &th)
```
[13.2633]
[21.3576]
```
static void tag_construct_ghost(writer &th)
```
Replacement in crawl-ref/source/tags.cc at line 2314 [5.164589]
∅:D[21.3739] → [6.6259:6320]
B:BD[13.2633] → [6.6259:6320]
```
static void tag_read_ghost(tagHeader &th, char minorVersion)
```
[21.3739]
[13.2701]
```
static void tag_read_ghost(reader &th, char minorVersion)
```
Replacement in crawl-ref/source/store.h at line 22 [26.142]
B:BD[26.553] → [26.553:571]
```
struct tagHeader;
```
[26.553]
[26.571]
```
class  reader;
class  writer;
```

Replacement in crawl-ref/source/store.h at line 232 [26.142]

B:BD[26.6330] → [26.6330:6397]

    void write(tagHeader &th) const;
    void read(tagHeader &th);

[26.6330]

[26.6397]

    void write(writer &) const;
    void read(reader &);

Replacement in crawl-ref/source/store.h at line 275 [26.142]

B:BD[26.7678] → [26.7678:7745]

    void write(tagHeader &th) const;
    void read(tagHeader &th);

[26.7678]

[26.7745]

    void write(writer &) const;
    void read(reader &);

Replacement in crawl-ref/source/store.h at line 341 [26.142]

B:BD[26.9934] → [26.9934:10001]

    void write(tagHeader &th) const;
    void read(tagHeader &th);

[26.9934]

[26.10001]

    void write(writer &) const;
    void read(reader &);

Replacement in crawl-ref/source/store.cc at line 354 [26.12569]
B:BD[26.18715] → [26.18715:18764]
```
void CrawlStoreValue::write(tagHeader &th) const
```
[26.18715]
[26.18764]
```
void CrawlStoreValue::write(writer &th) const
```
Replacement in crawl-ref/source/store.cc at line 426 [26.12569]
B:BD[26.20072] → [26.20072:20114]
```
void CrawlStoreValue::read(tagHeader &th)
```
[26.20072]
[26.20114]
```
void CrawlStoreValue::read(reader &th)
```
Replacement in crawl-ref/source/store.cc at line 1041 [26.12569]
B:BD[26.32290] → [26.32290:32338]
```
void CrawlHashTable::write(tagHeader &th) const
```
[26.32290]
[26.32338]
```
void CrawlHashTable::write(writer &th) const
```
Replacement in crawl-ref/source/store.cc at line 1065 [26.12569]
B:BD[26.32776] → [26.32776:32817]
```
void CrawlHashTable::read(tagHeader &th)
```
[26.32776]
[26.32817]
```
void CrawlHashTable::read(reader &th)
```
Replacement in crawl-ref/source/store.cc at line 1330 [26.12569]
B:BD[26.38277] → [26.38277:38322]
```
void CrawlVector::write(tagHeader &th) const
```
[26.38277]
[26.38322]
```
void CrawlVector::write(writer &th) const
```
Replacement in crawl-ref/source/store.cc at line 1355 [26.12569]
B:BD[26.38816] → [26.38816:38854]
```
void CrawlVector::read(tagHeader &th)
```
[26.38816]
[26.38854]
```
void CrawlVector::read(reader &th)
```

Replacement in crawl-ref/source/stash.cc at line 139 [7.147324]

B:BD[7.150330] → [6.6446:6498]

    tagHeader th(file);
    marshallItem(th, item);

[7.150330]

[7.150609]

    writer outf(file);
    marshallItem(outf, item);

Replacement in crawl-ref/source/stash.cc at line 145 [7.147324]

B:BD[7.150664] → [6.6499:6553]

    tagHeader th(file);
    unmarshallItem(th, item);

[7.150664]

[7.150971]

    reader inf(file);
    unmarshallItem(inf, item);

Replacement in crawl-ref/source/mapmark.h at line 23 [27.10602]
B:BD[4.72640] → [4.72640:72658]
```
struct tagHeader;
```
[4.72640]
[27.10782]
```
class reader;
class writer;
```

Replacement in crawl-ref/source/mapmark.h at line 36 [27.10602]

∅:D[2.928] → [27.11168:11247]

B:BD[27.11168] → [27.11168:11247]

    virtual void write(tagHeader &) const;
    virtual void read(tagHeader &);

[2.928]

[28.2213]

    virtual void write(writer &) const;
    virtual void read(reader &);

Replacement in crawl-ref/source/mapmark.h at line 42 [27.10602]
∅:D[28.2389] → [27.11298:11346]
B:BD[27.11298] → [27.11298:11346]
```
    static map_marker *read_marker(tagHeader&);
```
[28.2389]
[12.5662]
```
    static map_marker *read_marker(reader &);
```

Replacement in crawl-ref/source/mapmark.h at line 53 [27.10602]

B:BD[27.11503] → [27.11503:11575]

    typedef map_marker *(*marker_reader)(tagHeader &, map_marker_type);

[27.11503]

[12.5789]

    typedef map_marker *(*marker_reader)(reader &, map_marker_type);

Replacement in crawl-ref/source/mapmark.h at line 66 [27.10602]

B:BD[27.11994] → [27.11994:12057]

    void write(tagHeader &) const;
    void read(tagHeader &);

[27.11994]

[28.2390]

    void write(writer &) const;
    void read(reader &);

Replacement in crawl-ref/source/mapmark.h at line 70 [27.10602]
∅:D[29.1028] → [27.12091:12150]
∅:D[28.2430] → [27.12091:12150]
B:BD[27.12091] → [27.12091:12150]
```
    static map_marker *read(tagHeader &, map_marker_type);
```
[29.1028]
[12.5915]
```
    static map_marker *read(reader &, map_marker_type);
```

Replacement in crawl-ref/source/mapmark.h at line 84 [27.10602]

B:BD[23.9605] → [23.9605:9668]

    void write(tagHeader &) const;
    void read(tagHeader &);

[23.9605]

[29.1029]

    void write(writer &) const;
    void read(reader &);

Replacement in crawl-ref/source/mapmark.h at line 89 [27.10602]

B:BD[23.9710] → [23.9710:9769]

    static map_marker *read(tagHeader &, map_marker_type);

[23.9710]

[23.9769]

    static map_marker *read(reader &, map_marker_type);

Replacement in crawl-ref/source/mapmark.h at line 106 [27.10602]
∅:D[12.6228] → [27.12568:12631]
B:BD[27.12568] → [27.12568:12631]
```
    void write(tagHeader &) const;
    void read(tagHeader &);
```
[12.6228]
[29.1061]
```
    void write(writer &) const;
    void read(reader &);
```
Replacement in crawl-ref/source/mapmark.h at line 115 [27.10602]
∅:D[29.1098] → [27.12802:12861]
∅:D[12.6236] → [27.12802:12861]
B:BD[27.12802] → [27.12802:12861]
```
    static map_marker *read(tagHeader &, map_marker_type);
```
[29.1098]
[12.6237]
```
    static map_marker *read(reader &, map_marker_type);
```

Replacement in crawl-ref/source/mapmark.h at line 133 [27.10602]

B:BD[30.447] → [30.447:510]

    void write(tagHeader &) const;
    void read(tagHeader &);

[30.447]

[30.510]

    void write(writer &) const;
    void read(reader &);

Replacement in crawl-ref/source/mapmark.h at line 140 [27.10602]

B:BD[30.764] → [30.764:823]

    static map_marker *read(tagHeader &, map_marker_type);

[30.764]

[30.823]

    static map_marker *read(reader &, map_marker_type);

Replacement in crawl-ref/source/mapmark.cc at line 53 [27.13502]
B:BD[27.14384] → [27.14384:14430]
```
void map_marker::write(tagHeader &outf) const
```
[27.14384]
[27.14430]
```
void map_marker::write(writer &outf) const
```
Replacement in crawl-ref/source/mapmark.cc at line 59 [27.13502]
B:BD[27.14496] → [27.14496:14534]
```
void map_marker::read(tagHeader &inf)
```
[27.14496]
[27.14534]
```
void map_marker::read(reader &inf)
```
Replacement in crawl-ref/source/mapmark.cc at line 76 [27.13502]
B:BD[27.14686] → [27.14686:14738]
```
map_marker *map_marker::read_marker(tagHeader &inf)
```
[27.14686]
[27.14738]
```
map_marker *map_marker::read_marker(reader &inf)
```
Replacement in crawl-ref/source/mapmark.cc at line 113 [27.13502]
B:BD[27.15571] → [27.15571:15625]
```
void map_feature_marker::write(tagHeader &outf) const
```
[27.15571]
[27.15625]
```
void map_feature_marker::write(writer &outf) const
```
Replacement in crawl-ref/source/mapmark.cc at line 119 [27.13502]
B:BD[27.15696] → [27.15696:15742]
```
void map_feature_marker::read(tagHeader &inf)
```
[27.15696]
[27.15742]
```
void map_feature_marker::read(reader &inf)
```

Replacement in crawl-ref/source/mapmark.cc at line 130 [27.13502]

B:BD[27.15842] → [27.15842:15912]

map_marker *map_feature_marker::read(tagHeader &inf, map_marker_type)

[27.15842]

[27.15912]

map_marker *map_feature_marker::read(reader &inf, map_marker_type)

Replacement in crawl-ref/source/mapmark.cc at line 234 [27.13502]
B:BD[27.18459] → [12.8370:8418]
```
void map_lua_marker::write(tagHeader &th) const
```
[27.18459]
[27.18526]
```
void map_lua_marker::write(writer &outf) const
```
Replacement in crawl-ref/source/mapmark.cc at line 236 [27.13502]
B:BD[27.18528] → [12.8419:8446]
```
    map_marker::write(th);
```
[27.18528]
[12.8446]
```
    map_marker::write(outf);
```
Replacement in crawl-ref/source/mapmark.cc at line 246 [27.13502]
B:BD[12.8616] → [12.8616:8644]
```
    marshallByte(th, init);
```
[12.8616]
[12.8644]
```
    marshallByte(outf, init);
```
Replacement in crawl-ref/source/mapmark.cc at line 261 [27.13502]
B:BD[12.9109] → [12.9109:9158]
```
    marshallString(th, reader.compiled_chunk());
```
[12.9109]
[12.9158]
```
    marshallString(outf, reader.compiled_chunk());
```
Replacement in crawl-ref/source/mapmark.cc at line 269 [27.13502]
B:BD[12.9401] → [12.9401:9439]
```
    lua_pushlightuserdata(dlua, &th);
```
[12.9401]
[12.9439]
```
    lua_pushlightuserdata(dlua, &outf);
```
Replacement in crawl-ref/source/mapmark.cc at line 275 [27.13502]
B:BD[27.18892] → [12.9562:9603]
```
void map_lua_marker::read(tagHeader &th)
```
[27.18892]
[27.18960]
```
void map_lua_marker::read(reader &inf)
```
Replacement in crawl-ref/source/mapmark.cc at line 277 [27.13502]
B:BD[27.18962] → [12.9604:9630]
```
    map_marker::read(th);
```
[27.18962]
[12.9630]
```
    map_marker::read(inf);
```
Replacement in crawl-ref/source/mapmark.cc at line 279 [27.13502]
B:BD[12.9635] → [12.9635:9680]
```
    if (!(initialised = unmarshallByte(th)))
```
[12.9635]
[27.19018]
```
    if (!(initialised = unmarshallByte(inf)))
```

Replacement in crawl-ref/source/mapmark.cc at line 284 [27.13502]

B:BD[12.9750] → [12.9750:9825]

    const std::string compiled = unmarshallString(th, LUA_CHUNK_MAX_SIZE);

[12.9750]

[27.19173]

    const std::string compiled = unmarshallString(inf, LUA_CHUNK_MAX_SIZE);

Replacement in crawl-ref/source/mapmark.cc at line 290 [27.13502]
B:BD[12.10039] → [12.10039:10077]
```
    lua_pushlightuserdata(dlua, &th);
```
[12.10039]
[12.10077]
```
    lua_pushlightuserdata(dlua, &inf);
```

Replacement in crawl-ref/source/mapmark.cc at line 298 [27.13502]

B:BD[27.19666] → [12.10279:10344]

map_marker *map_lua_marker::read(tagHeader &th, map_marker_type)

[27.19666]

[27.19719]

map_marker *map_lua_marker::read(reader &inf, map_marker_type)

Replacement in crawl-ref/source/mapmark.cc at line 301 [27.13502]
B:BD[12.10390] → [12.10390:10412]
```
    marker->read(th);
```
[12.10390]
[12.10412]
```
    marker->read(inf);
```
Replacement in crawl-ref/source/mapmark.cc at line 415 [27.13502]
B:BD[23.10196] → [23.10196:10252]
```
void map_corruption_marker::write(tagHeader &out) const
```
[23.10196]
[23.10252]
```
void map_corruption_marker::write(writer &out) const
```
Replacement in crawl-ref/source/mapmark.cc at line 422 [27.13502]
B:BD[23.10351] → [23.10351:10399]
```
void map_corruption_marker::read(tagHeader &in)
```
[23.10351]
[23.10399]
```
void map_corruption_marker::read(reader &in)
```

Replacement in crawl-ref/source/mapmark.cc at line 429 [27.13502]

B:BD[23.10502] → [23.10502:10574]

map_marker *map_corruption_marker::read(tagHeader &th, map_marker_type)

[23.10502]

[23.10574]

map_marker *map_corruption_marker::read(reader &in, map_marker_type)

Replacement in crawl-ref/source/mapmark.cc at line 432 [27.13502]
B:BD[23.10637] → [23.10637:10655]
```
    mc->read(th);
```
[23.10637]
[23.10655]
```
    mc->read(in);
```
Replacement in crawl-ref/source/mapmark.cc at line 463 [27.13502]
B:BD[30.1406] → [30.1406:1462]
```
void map_wiz_props_marker::write(tagHeader &outf) const
```
[30.1406]
[30.1462]
```
void map_wiz_props_marker::write(writer &outf) const
```
Replacement in crawl-ref/source/mapmark.cc at line 475 [27.13502]
B:BD[30.1764] → [30.1764:1812]
```
void map_wiz_props_marker::read(tagHeader &inf)
```
[30.1764]
[30.1812]
```
void map_wiz_props_marker::read(reader &inf)
```

Replacement in crawl-ref/source/mapmark.cc at line 518 [27.13502]

B:BD[30.2776] → [30.2776:2848]

map_marker *map_wiz_props_marker::read(tagHeader &inf, map_marker_type)

[30.2776]

[30.2848]

map_marker *map_wiz_props_marker::read(reader &inf, map_marker_type)

Replacement in crawl-ref/source/mapmark.cc at line 721 [27.13502]
B:BD[29.3815] → [29.3815:3860]
```
void map_markers::write(tagHeader &th) const
```
[29.3815]
[29.3860]
```
void map_markers::write(writer &outf) const
```
Replacement in crawl-ref/source/mapmark.cc at line 724 [27.13502]
B:BD[29.3886] → [29.3886:3925]
```
    marshallShort(th, markers.size());
```
[29.3886]
[29.3925]
```
    marshallShort(outf, markers.size());
```
Replacement in crawl-ref/source/mapmark.cc at line 728 [27.13502]
B:BD[29.4026] → [29.4026:4056]
```
        i->second->write(th);
```
[29.4026]
[29.4056]
```
        i->second->write(outf);
```
Replacement in crawl-ref/source/mapmark.cc at line 732 [27.13502]
B:BD[29.4064] → [29.4064:4102]
```
void map_markers::read(tagHeader &th)
```
[29.4064]
[29.4102]
```
void map_markers::read(reader &inf)
```
Replacement in crawl-ref/source/mapmark.cc at line 735 [27.13502]
B:BD[29.4117] → [29.4117:4163]
```
    const int nmarkers = unmarshallShort(th);
```
[29.4117]
[29.4163]
```
    const int nmarkers = unmarshallShort(inf);
```

Replacement in crawl-ref/source/mapmark.cc at line 737 [27.13502]

B:BD[29.4202] → [29.4202:4262]

        if (map_marker *mark = map_marker::read_marker(th))

[29.4202]

[29.4262]

        if (map_marker *mark = map_marker::read_marker(inf))

Replacement in crawl-ref/source/luadgn.cc at line 1738 [31.1232]

B:BD[12.18308] → [12.18308:18378]

    tagHeader &th(*static_cast<tagHeader*>( lua_touserdata(ls, 1) ));

[12.18308]

[12.18378]

    writer &th(*static_cast<writer*>( lua_touserdata(ls, 1) ));

Replacement in crawl-ref/source/luadgn.cc at line 1754 [31.1232]

B:BD[12.18768] → [12.18768:18897]

        luaL_error(ls, "Need tag header as one argument");
    tagHeader &th(*static_cast<tagHeader*>( lua_touserdata(ls, 1) ));

[12.18768]

[12.18897]

        luaL_error(ls, "Need reader as one argument");
    reader &th(*static_cast<reader*>( lua_touserdata(ls, 1) ));

Replacement in crawl-ref/source/luadgn.cc at line 1763 [31.1232]

B:BD[12.19040] → [12.19040:19169]

        luaL_error(ls, "Need tag header as one argument");
    tagHeader &th(*static_cast<tagHeader*>( lua_touserdata(ls, 1) ));

[12.19040]

[12.19169]

        luaL_error(ls, "Need reader as one argument");
    reader &th(*static_cast<reader*>( lua_touserdata(ls, 1) ));

Replacement in crawl-ref/source/luadgn.cc at line 1772 [31.1232]

B:BD[12.19318] → [12.19318:19447]

        luaL_error(ls, "Need tag header as one argument");
    tagHeader &th(*static_cast<tagHeader*>( lua_touserdata(ls, 1) ));

[12.19318]

[12.19447]

        luaL_error(ls, "Need reader as one argument");
    reader &th(*static_cast<reader*>( lua_touserdata(ls, 1) ));

Replacement in crawl-ref/source/luadgn.cc at line 1795 [31.1232]

B:BD[12.19875] → [12.19875:19945]

    tagHeader &th(*static_cast<tagHeader*>( lua_touserdata(ls, 1) ));

[12.19875]

[12.19945]

    writer &th(*static_cast<writer*>( lua_touserdata(ls, 1) ));

Replacement in crawl-ref/source/luadgn.cc at line 1816 [31.1232]

B:BD[12.20376] → [12.20376:20446]

    tagHeader &th(*static_cast<tagHeader*>( lua_touserdata(ls, 1) ));

[12.20376]

[12.20446]

    reader &th(*static_cast<reader*>( lua_touserdata(ls, 1) ));

Replacement in crawl-ref/source/files.cc at line 622 [5.3084589]

B:BD[21.24046] → [21.24046:24135]

    tagHeader versionTag;
    versionTag.offset = 0;
    versionTag.tagID = TAG_VERSION;

[21.24046]

[21.24135]

    writer outf(dataFile);

Replacement in crawl-ref/source/files.cc at line 624 [5.3084589]

B:BD[21.24136] → [21.24136:24224]

    marshallByte(versionTag, majorVersion);
    marshallByte(versionTag, minorVersion);

[21.24136]

[21.24224]

    marshallByte(outf, majorVersion);
    marshallByte(outf, minorVersion);

Replacement in crawl-ref/source/files.cc at line 638 [5.3084589]
B:BD[21.24813] → [21.24813:24865]
```
        marshallShort(versionTag, GHOST_SIGNATURE);
```
[21.24813]
[21.24865]
```
        marshallShort(outf, GHOST_SIGNATURE);
```
Replacement in crawl-ref/source/files.cc at line 642 [5.3084589]
B:BD[21.24972] → [21.24972:25013]
```
            marshallLong(versionTag, 0);
```
[21.24972]
[21.25013]
```
            marshallLong(outf, 0);
```
Deletion in crawl-ref/source/files.cc at line 644 [5.3084589]
B:BD[21.25019] → [21.25019:25057]
```
    tag_write(versionTag, dataFile);
```
Deletion in crawl-ref/source/files.cc at line 650 [5.3084589]
B:BD[5.3090856] → [5.3090856:3090882]
```
    struct tagHeader th;
```

Replacement in crawl-ref/source/files.cc at line 661 [5.3084589]

B:BD[5.3091317] → [5.3091317:3091388]

            tag_construct(th, i);
            tag_write(th, dataFile);

[5.3091317]

[5.3091388]

            tag_write((tag_type)i, dataFile);

Deletion in crawl-ref/source/files.cc at line 1571 [5.3084589]
B:BD[5.3119619] → [5.3119619:3119631]
```
    int i;
```

Replacement in crawl-ref/source/files.cc at line 1576 [5.3084589]

B:BD[5.3119714] → [5.3119714:3119810]

        i = tag_read(restoreFile, minorVersion);
        if (i == 0)                 // no tag!

[5.3119714]

[5.3119810]

        tag_type tt = tag_read(restoreFile, minorVersion);
        if (tt == TAG_NO_TAG)

Replacement in crawl-ref/source/files.cc at line 1579 [5.3084589]
B:BD[5.3119829] → [5.3119829:3119877]
```
        tags[i] = 0;                // tag read
```
[5.3119829]
[10.873360]
```
        tags[tt] = 0;                // tag read
```
Replacement in crawl-ref/source/files.cc at line 1585 [5.3084589]
B:BD[5.3119924] → [5.3119924:3119954]
```
    for(i=0; i<NUM_TAGS; i++)
```
[5.3119924]
[5.3119954]
```
    for (int i=0; i<NUM_TAGS; i++)
```
Replacement in crawl-ref/source/externs.h at line 1296 [5.3270163]
B:BD[29.4801] → [32.5549:5567]
```
struct tagHeader;
```
[29.4801]
[29.4818]
```
class reader;
class writer;
```

Replacement in crawl-ref/source/externs.h at line 1321 [5.3270163]

B:BD[29.5605] → [29.5605:5670]

    void write(tagHeader &th) const;
    void read(tagHeader &);

[29.5605]

[29.5670]

    void write(writer &) const;
    void read(reader &);

Deletion in crawl-ref/source/acr.cc at line 3683 [5.4397395]
B:BD[5.4470016] → [33.478:539]
∅:D[33.539] → [5.4470077:4470094]
B:BD[5.4470077] → [5.4470077:4470094]
```
    // initialise tag system before we try loading anything!
    tag_init();
```

Cleanup/refactoring of tags.cc. No functional changes. I've been

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/tags.h at line 21 [5.161012]

Replacement in crawl-ref/source/tags.h at line 44 [5.161012]

Replacement in crawl-ref/source/tags.h at line 48 [5.161012]

Deletion in crawl-ref/source/tags.h at line 56 [5.161012]

Replacement in crawl-ref/source/tags.h at line 58 [5.161012]

Replacement in crawl-ref/source/tags.h at line 64 [5.161012]

Deletion in crawl-ref/source/tags.h at line 73 [5.161012]

Replacement in crawl-ref/source/tags.h at line 74 [5.161012]

Deletion in crawl-ref/source/tags.h at line 76 [5.161012]

Insertion in crawl-ref/source/tags.h at line 77 [5.161012]

Replacement in crawl-ref/source/tags.h at line 85 [5.161012]

Replacement in crawl-ref/source/tags.h at line 88 [5.161012]

Replacement in crawl-ref/source/tags.h at line 94 [5.161012]

Deletion in crawl-ref/source/tags.h at line 104 [5.161012]

Replacement in crawl-ref/source/tags.h at line 105 [5.161012]

Deletion in crawl-ref/source/tags.h at line 107 [5.161012]

Replacement in crawl-ref/source/tags.h at line 108 [5.161012]

Insertion in crawl-ref/source/tags.h at line 111 [5.161012]

Deletion in crawl-ref/source/tags.h at line 113 [5.161012]

Replacement in crawl-ref/source/tags.h at line 114 [5.161012]

Deletion in crawl-ref/source/tags.h at line 116 [5.161012]

Replacement in crawl-ref/source/tags.h at line 117 [5.161012]

Replacement in crawl-ref/source/tags.cc at line 16 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 18 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 21 [5.164589]

Deletion in crawl-ref/source/tags.cc at line 89 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 100 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 103 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 106 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 109 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 111 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 119 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 126 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 128 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 135 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 137 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 143 [5.164589]

Insertion in crawl-ref/source/tags.cc at line 147 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 174 [5.164589]

Deletion in crawl-ref/source/tags.cc at line 196 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 198 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 204 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 209 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 214 [5.164589]

Insertion in crawl-ref/source/tags.cc at line 219 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 227 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 236 [5.164589]

Insertion in crawl-ref/source/tags.cc at line 244 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 254 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 268 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 281 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 287 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 301 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 313 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 323 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 332 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 339 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 347 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 362 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 367 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 376 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 385 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 391 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 398 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 427 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 456 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 464 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 472 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 486 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 492 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 505 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 509 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 524 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 530 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 540 [5.164589]

Replacement in crawl-ref/source/tags.cc at line 605 [5.164589]