fiddlerwoaroof/crawl - Change NCDWWDJQLAU5ORSAQGZKJJ5E22VTDGGPJMVVBWQFHQ2B3U3UFHDQC

Implemented .des file caching (speeds startup a fair bit): .des files are

parsed only once (unless they're modified again). Crawl also keeps only map stubs in memory (name, place, orient, tags) and loads the map body only when it is actually selected by the dungeon builder.

This probably breaks the Windows build, will be fixed soonish.

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

Created by dshaligram on June 24, 2007

NCDWWDJQLAU5ORSAQGZKJJ5E22VTDGGPJMVVBWQFHQ2B3U3UFHDQC

Dependencies

In channels

main

Change contents

File deletion: levcomp.h

BF:BFD[5.75590] → [5.85083:85116]

BF:BFD[5.85116] → [5.84834:84834]

B:BD[5.84834] → [5.84835:84986]

∅:D[6.2482] → [5.85024:85082]

B:BD[5.85024] → [5.85024:85082]

B:BD[5.84986] → [6.2443:2482]

#include <cstdio>
#include <string>
#include <vector>
#include "mapdef.h"
#include "maps.h"
extern map_def      lc_map;
extern level_range  lc_range;
extern std::string  lc_desfile;
void reset_map_parser();
extern depth_ranges lc_default_depths;

File deletion: levcomp.cc
BF:BFD[5.75590] → [5.85399:85433]
BF:BFD[5.85433] → [5.85118:85118]
B:BD[5.85118] → [5.85119:85160]
∅:D[6.2502] → [5.85160:85227]
B:BD[5.85160] → [5.85160:85227]
∅:D[6.2535] → [5.85257:85347]
B:BD[5.85257] → [5.85257:85347]
∅:D[6.2567] → [5.85377:85398]
B:BD[5.85377] → [5.85377:85398]
B:BD[5.85347] → [6.2536:2567]
B:BD[5.85227] → [6.2503:2535]
B:BD[5.85160] → [6.2484:2502]
```
#include "AppHdr.h"
#include "levcomp.h"
std::string lc_desfile;
map_def     lc_map;
level_range lc_range;
extern int yylineno;
void reset_map_parser()
{
    lc_map.init();
    lc_range.reset();
    yylineno = 1;
}
    lc_default_depths.clear();
depth_ranges lc_default_depths;
#include <vector>
```
Deletion in crawl-ref/source/util/levcomp.ypp at line 6 [5.75608]
B:BD[5.75654] → [5.75654:75675]
```
#include "levcomp.h"
```
Insertion in crawl-ref/source/util/levcomp.ypp at line 8 [5.75608]
[6.142]
[7.8]
```
#include "maps.h"
```

Replacement in crawl-ref/source/util/levcomp.ypp at line 109 [5.75608]

∅:D[8.1534] → [5.77121:77167]

B:BD[5.77121] → [5.77121:77167]

                    add_parsed_map( lc_map );

[6.900]

[5.77167]

                    lc_map.set_file(lc_desfile);
                    add_parsed_map(lc_map);

Replacement in crawl-ref/source/player.cc at line 5028 [10.962854]
B:BD[9.151] → [4.601:643]
```
    return random2(player_shield_class())
```
[9.151]
[9.324]
```
    return random2(shield_class)
```

Insertion in crawl-ref/source/maps.h at line 50 [10.2007036]

[5.583441]

void run_map_preludes();
void reset_map_parser();
std::string get_descache_path(const std::string &file,
                              const std::string &ext);
extern dlua_chunk map_file_prelude;
extern std::string lc_desfile;
extern map_def     lc_map;
extern level_range lc_range;
extern depth_ranges lc_default_depths;

Deletion in crawl-ref/source/maps.cc at line 29 [10.2007666]
B:BD[10.2008139] → [10.2008139:2008140]
B:BD[10.2008140] → [5.583624:583645]
```
#include "levcomp.h"
```
Replacement in crawl-ref/source/maps.cc at line 30 [10.2007666]
B:BD[10.2008141] → [5.583646:583704]
```
static int write_vault(const map_def &mdef, map_type mt, 
```
[10.2008141]
[11.560]
```
static int write_vault(map_def &mdef, map_type mt, 
```
Replacement in crawl-ref/source/maps.cc at line 81 [10.2007666]
B:BD[10.2139584] → [5.584810:584869]
```
static int write_vault(const map_def &mdef, map_type map, 
```
[10.2139584]
[11.899]
```
static int write_vault(map_def &mdef, map_type map, 
```
Insertion in crawl-ref/source/maps.cc at line 85 [10.2007666]
[10.2142745]
[5.584993]
```
    mdef.load();
    
```

Insertion in crawl-ref/source/maps.cc at line 357 [10.2007666]

[10.2199062]

[5.590570]

dlua_chunk lc_file_prelude;
std::string lc_desfile;
map_def     lc_map;
level_range lc_range;
depth_ranges lc_default_depths;
std::set<std::string> map_files_read;
extern int yylineno;
void reset_map_parser()
{
    lc_map.init();
    lc_range.reset();
    lc_default_depths.clear();
    lc_file_prelude.clear();
    yylineno = 1;
}
////////////////////////////////////////////////////////////////////////////
static bool checked_des_index_dir = false;
#define DESCACHE_VER  1000
static void check_des_index_dir()
{
    if (checked_des_index_dir)
        return;
    
    std::string desdir = get_savedir_path("des");
    if (!check_dir("Data file cache", desdir, true))
        end(1, true, "Can't create data file cache: %s", desdir.c_str());
    checked_des_index_dir = true;
}
std::string get_descache_path(const std::string &file,
                              const std::string &ext)
{
    const std::string basename =
        change_file_extension(get_base_filename(file), ext);
    return get_savedir_path("des/" + basename);
}
static bool verify_file_version(const std::string &file)
{
    FILE *inf = fopen(file.c_str(), "rb");
    if (!inf)
        return (false);
    const long ver = readLong(inf);
    fclose(inf);
    return (ver == DESCACHE_VER);
}
static bool verify_map_index(const std::string &base)
{
    return verify_file_version(base + ".idx");
}
static bool verify_map_full(const std::string &base)
{
    return verify_file_version(base + ".dsc");
}
static bool load_map_index(const std::string &base)
{
    FILE *inf = fopen((base + ".idx").c_str(), "rb");
    // Discard version (it's been checked by verify_map_index).
    readLong(inf);
    const int nmaps = readShort(inf);
    const int nexist = vdefs.size();
    vdefs.resize( nexist + nmaps, map_def() );
    for (int i = 0; i < nmaps; ++i)
    {
        vdefs[nexist + i].read_index(inf);
        vdefs[nexist + i].set_file(base);
    }
    fclose(inf);
    return (true);
}
static bool load_map_cache(const std::string &filename)
{
    check_des_index_dir();
    const std::string descache_base = get_descache_path(filename, "");
    
    file_lock deslock(descache_base + ".lk", "rb", false);
    if (is_newer(filename, descache_base + ".idx")
        || is_newer(filename, descache_base + ".dsc"))
        return (false);
    
    if (!verify_map_index(descache_base) || !verify_map_full(descache_base))
        return (false);
    return load_map_index(descache_base);
}
static void write_map_prelude(const std::string &filebase)
{
    const std::string luafile = filebase + ".lua";
    if (lc_file_prelude.empty())
    {
        unlink(luafile.c_str());
        return;
    }
    FILE *outf = fopen(luafile.c_str(), "w");
    if (!outf)
        end(1, true, "Unable to open %s for writing", luafile.c_str());
    fprintf(outf, "%s", lc_file_prelude.lua_string().c_str());
    fclose(outf);
}
static void write_map_full(const std::string &filebase, size_t vs, size_t ve)
{
    const std::string cfile = filebase + ".dsc";
    FILE *outf = fopen(cfile.c_str(), "wb");
    if (!outf)
        end(1, true, "Unable to open %s for writing", cfile.c_str());
    writeLong(outf, DESCACHE_VER);
    for (size_t i = vs; i < ve; ++i)
        vdefs[i].write_full(outf);
    fclose(outf);
}
static void write_map_index(const std::string &filebase, size_t vs, size_t ve)
{
    const std::string cfile = filebase + ".idx";
    FILE *outf = fopen(cfile.c_str(), "wb");
    if (!outf)
        end(1, true, "Unable to open %s for writing", cfile.c_str());
    writeLong(outf, DESCACHE_VER);
    writeShort(outf, ve > vs? ve - vs : 0);
    for (size_t i = vs; i < ve; ++i)
        vdefs[i].write_index(outf);
    fclose(outf);
}
static void write_map_cache(const std::string &filename, size_t vs, size_t ve)
{
    check_des_index_dir();
    const std::string descache_base = get_descache_path(filename, "");
    
    file_lock deslock(descache_base + ".lk", "wb");
    
    write_map_prelude(descache_base);
    write_map_full(descache_base, vs, ve);
    write_map_index(descache_base, vs, ve);
}

Insertion in crawl-ref/source/maps.cc at line 518 [10.2007666]

[10.2212635]

[5.590616]

    const std::string base = get_base_filename(s);
    if (map_files_read.find(base) != map_files_read.end())
        end(1, false, "Map file %s has already been read.", base.c_str());
    map_files_read.insert(base);
    
    if (load_map_cache(s))
        return;

Insertion in crawl-ref/source/maps.cc at line 537 [10.2007666]
[10.2218330]
[5.590881]
```
    size_t file_start = vdefs.size();
```
Insertion in crawl-ref/source/maps.cc at line 540 [10.2007666]
[5.590913]
[10.2218352]
```
    write_map_cache(s, file_start, vdefs.size());
```

Insertion in crawl-ref/source/maps.cc at line 570 [10.2007666]

[5.591166]

[10.2221735]

}
void run_map_preludes()
{
    for (int i = 0, size = vdefs.size(); i < size; ++i)
    {
        if (!vdefs[i].prelude.empty())
        {
            std::string err = vdefs[i].run_lua(true);
            if (!err.empty())
                mprf(MSGCH_WARN, "Lua error (map %s): %s",
                     vdefs[i].name.c_str(), err.c_str());
        }
    }

Insertion in crawl-ref/source/mapdef.h at line 14 [5.591249]
[5.591552]
[5.591552]
```
#include <cstdio>
```
Insertion in crawl-ref/source/mapdef.h at line 44 [5.591249]
[6.3787]
[5.592062]
```
    void write(FILE *) const;
    void read(FILE *);
```

Insertion in crawl-ref/source/mapdef.h at line 397 [5.591249]

[6.3947]

[12.2196]

// Lua chunks cannot exceed 512K. Which is plenty!
const int LUA_CHUNK_MAX_SIZE = 512 * 1024;

Insertion in crawl-ref/source/mapdef.h at line 423 [5.591249]
[2.7480]
[13.3382]
```
    std::string     file;
```

Insertion in crawl-ref/source/mapdef.h at line 430 [5.591249]

[2.7517]

    void load();
    
    void write_index(FILE *) const;
    void write_full(FILE *);
    void read_index(FILE *);
    void read_full(FILE *);

Replacement in crawl-ref/source/mapdef.h at line 441 [5.591249]
B:BD[2.7629] → [2.7629:7651]
```
    void strip_lua();
```
[2.7629]
[2.7651]
```
    void strip_main();
```

Insertion in crawl-ref/source/mapdef.h at line 482 [5.591249]

[13.3606]

    void write_depth_ranges(FILE *) const;
    void read_depth_ranges(FILE *);

Insertion in crawl-ref/source/mapdef.cc at line 10 [5.594797]
[13.3835]
[7.139355]
```
#include "files.h"
```
Insertion in crawl-ref/source/mapdef.cc at line 15 [5.594797]
[5.594915]
[13.3836]
```
#include "maps.h"
```

Insertion in crawl-ref/source/mapdef.cc at line 138 [5.594797]

[6.4542]

{
}
void level_range::write(FILE *outf) const
{
    writeShort(outf, branch);
    writeShort(outf, shallowest);
    writeShort(outf, deepest);
    writeByte(outf, deny);
}
void level_range::read(FILE *inf)

Insertion in crawl-ref/source/mapdef.cc at line 151 [5.594797]

[6.4544]

    branch     = static_cast<branch_type>( readShort(inf) );
    shallowest = readShort(inf);
    deepest    = readShort(inf);
    deny       = readByte(inf);

Insertion in crawl-ref/source/mapdef.cc at line 845 [5.594797]

[5.598972]

[6.6211]

}
void map_def::write_full(FILE *outf)
{
    cache_offset = ftell(outf);
    writeShort(outf, 0x1eaf);   // Level indicator.
    writeString(outf, name);
    writeString(outf, prelude.lua_string(), LUA_CHUNK_MAX_SIZE);
    writeString(outf, main.lua_string(), LUA_CHUNK_MAX_SIZE);

Insertion in crawl-ref/source/mapdef.cc at line 856 [5.594797]

[6.6214]

[2.12957]

void map_def::read_full(FILE *inf)
{
    // There's a potential race-condition here:
    // - If someone modifies a .des file while there are games in progress,
    // - a new Crawl process will overwrite the .dsc.
    // - older Crawl processes trying to reading the new .dsc will be hosed.
    // We could try to recover from the condition (by locking and
    // reloading the index), but it's easier to save the game at this
    // point and let the player reload.
    if (readShort(inf) != 0x1eaf || readString(inf) != name)
        save_game(true,
                  make_stringf("Level file cache for %s is out-of-sync! "
                               "Please reload your game.",
                               file.c_str()).c_str());
    prelude.set_chunk(readString(inf, LUA_CHUNK_MAX_SIZE));
    main.set_chunk(readString(inf, LUA_CHUNK_MAX_SIZE));
}
void map_def::load()
{
    if (!index_only)
        return;
    
    const std::string loadfile = get_descache_path(file, ".dsc");
    FILE *inf = fopen(loadfile.c_str(), "r");
    fseek(inf, cache_offset, SEEK_SET);
    read_full(inf);
    fclose(inf);
    index_only = false;
}
void map_def::write_index(FILE *outf) const
{
    if (!cache_offset)
        end(1, false, "Map %s: can't write index - cache offset not set!",
            name.c_str());
    writeString(outf, name);
    writeShort(outf, orient);
    writeLong(outf, chance);
    writeLong(outf, cache_offset);
    writeString(outf, tags);
    writeString(outf, place);
    write_depth_ranges(outf);
    writeString(outf, prelude.lua_string(), LUA_CHUNK_MAX_SIZE);
}
void map_def::read_index(FILE *inf)
{
    name         = readString(inf);
    orient       = static_cast<map_section_type>( readShort(inf) );
    chance       = readLong(inf);
    cache_offset = readLong(inf);
    tags         = readString(inf);
    place        = readString(inf);
    read_depth_ranges(inf);
    prelude.set_chunk(readString(inf, LUA_CHUNK_MAX_SIZE));
    index_only   = true;
}
void map_def::write_depth_ranges(FILE *outf) const
{
    writeShort(outf, depths.size());
    for (int i = 0, size = depths.size(); i < size; ++i)
        depths[i].write(outf);
}
void map_def::read_depth_ranges(FILE *inf)
{
    depths.clear();
    const int nranges = readShort(inf);
    for (int i = 0; i < nranges; ++i)
        depths[i].read(inf);
}

Insertion in crawl-ref/source/mapdef.cc at line 937 [5.594797]
[2.13051]
[2.13051]
```
    file = get_base_filename(s);
```
Replacement in crawl-ref/source/mapdef.cc at line 946 [5.594797]
B:BD[2.13134] → [2.13134:13160]
```
void map_def::strip_lua()
```
[2.13134]
[2.13160]
```
void map_def::strip_main()
```
Deletion in crawl-ref/source/mapdef.cc at line 948 [5.594797]
B:BD[2.13162] → [2.13162:13183]
```
    prelude.clear();
```
Insertion in crawl-ref/source/mapdef.cc at line 949 [5.594797]
[2.13201]
[2.13201]
```
    index_only = true;
```

Replacement in crawl-ref/source/makefile.unix at line 133 [5.604320]

B:BD[5.605386] → [5.605386:605471]

OBJECTS := $(UTIL)levcomp.tab.o $(UTIL)levcomp.lex.o $(UTIL)levcomp.o \
		$(OBJECTS)

[5.605386]

[5.605471]

OBJECTS := $(UTIL)levcomp.tab.o $(UTIL)levcomp.lex.o $(OBJECTS)

Replacement in crawl-ref/source/makefile.mgw at line 77 [14.272908]
B:BD[5.610894] → [5.610894:610950]
```
OBJECTS      := levcomp.tab.o levcomp.lex.o levcomp.o \
```
[5.610894]
[5.610950]
```
OBJECTS      := levcomp.tab.o levcomp.lex.o \
```
Insertion in crawl-ref/source/luadgn.h at line 33 [3.228]
[3.820]
[3.820]
```
    void set_chunk(const std::string &s);
```
Insertion in crawl-ref/source/luadgn.cc at line 71 [3.1232]
[3.2673]
[3.2673]
```
}
void dlua_chunk::set_chunk(const std::string &s)
{
    chunk = s;
```

Insertion in crawl-ref/source/luadgn.cc at line 478 [3.1232]

[3.12240]

}
static int dgn_name(lua_State *ls)
{
    MAP(ls, 1, map);
    PLUARET(string, map->name.c_str());

Insertion in crawl-ref/source/luadgn.cc at line 489 [3.1232]
[3.12330]
[3.12330]
```
    { "name", dgn_name },
```

Replacement in crawl-ref/source/files.h at line 33 [10.3082298]

∅:D[15.2013] → [16.1660:1719]

B:BD[5.856639] → [16.1660:1719]

bool check_dir(const std::string &what, std::string &dir);

[15.2013]

[14.431905]

std::string get_base_filename(const std::string &filename);
bool check_dir(const std::string &what, std::string &dir, bool silent = false);

Insertion in crawl-ref/source/files.h at line 46 [10.3082298]

[17.607]

[14.432076]

std::string get_prefs_filename();
std::string change_file_extension(const std::string &file,
                                  const std::string &ext);

Replacement in crawl-ref/source/files.h at line 50 [10.3082298]

B:BD[14.432077] → [14.432077:432111]

std::string get_prefs_filename();

[14.432077]

[10.3083341]

time_t file_modtime(const std::string &file);
bool is_newer(const std::string &a, const std::string &b);
void check_newer(const std::string &target,
                 const std::string &dependency,
                 void (*action)());

Replacement in crawl-ref/source/files.h at line 63 [10.3082298]
B:BD[10.3083691] → [10.3083691:3083724]
```
void save_game(bool leave_game);
```
[10.3083691]
[10.3083724]
```
void save_game(bool leave_game, const char *bye = NULL);
```
Replacement in crawl-ref/source/files.h at line 88 [10.3082298]
B:BD[14.432113] → [14.432113:432151]
```
void writeShort(FILE *file, short s);
```
[10.3084548]
[14.432151]
```
// Default cap on strings marshalled.
#define STR_CAP 1000
```
Insertion in crawl-ref/source/files.h at line 91 [10.3082298]
[14.432152]
[14.432152]
```
void writeShort(FILE *file, short s);
```
Deletion in crawl-ref/source/files.h at line 93 [10.3082298]
B:BD[14.432181] → [14.432181:432182]
Deletion in crawl-ref/source/files.h at line 94 [10.3082298]
B:BD[14.432230] → [14.432230:432231]
Replacement in crawl-ref/source/files.h at line 95 [10.3082298]
B:BD[14.432267] → [14.432267:432268]
B:BD[14.432268] → [18.513:580]
∅:D[18.580] → [14.432320:432358]
B:BD[14.432320] → [14.432320:432358]
```
void writeString(FILE* file, const std::string &s, int cap = 200);
std::string readString(FILE *file);
```
[14.432267]
[14.432358]
```
void writeString(FILE* file, const std::string &s, int cap = STR_CAP);
std::string readString(FILE *file, int cap = STR_CAP);
```
Deletion in crawl-ref/source/files.h at line 98 [10.3082298]
B:BD[14.432396] → [14.432396:432397]

Insertion in crawl-ref/source/files.cc at line 227 [10.3084589]

[15.2396]

}
std::string get_base_filename(const std::string &filename)
{
    std::string::size_type pos = filename.rfind(FILE_SEPARATOR);
    if (pos != std::string::npos)
        return filename.substr(pos + 1);
#ifdef ALT_FILE_SEPARATOR
    pos = filename.rfind(ALT_FILE_SEPARATOR);
    if (pos != std::string::npos)
        return filename.substr(pos + 1);
#endif
    return (filename);
}
std::string change_file_extension(const std::string &filename,
                                  const std::string &ext)
{
    const std::string::size_type pos = filename.rfind('.');
    return ((pos == std::string::npos? filename : filename.substr(0, pos))
            + ext);
}
time_t file_modtime(const std::string &file)
{
    struct stat filestat;
    if (stat(file.c_str(), &filestat))
        return (0);
    return (filestat.st_mtime);
}
// Returns true if file a is newer than file b.
bool is_newer(const std::string &a, const std::string &b)
{
    return (file_modtime(a) > file_modtime(b));
}
void check_newer(const std::string &target,
                 const std::string &dependency,
                 void (*action)())
{
    if (is_newer(dependency, target))
        action();

Replacement in crawl-ref/source/files.cc at line 398 [10.3084589]

B:BD[5.862025] → [16.1721:1782]

bool check_dir(const std::string &whatdir, std::string &dir)

[5.862025]

[5.862062]

bool check_dir(const std::string &whatdir, std::string &dir, bool silent)

Replacement in crawl-ref/source/files.cc at line 403 [10.3084589]
B:BD[5.862102] → [5.862102:862158]
```
    std::string sep = " ";
    sep[0] = FILE_SEPARATOR;
```
[5.862102]
[5.862158]
```
    const std::string sep(1, FILE_SEPARATOR);
```

Replacement in crawl-ref/source/files.cc at line 414 [10.3084589]

B:BD[5.862412] → [16.1807:1859]

∅:D[16.1859] → [5.862476:862528]

B:BD[5.862476] → [5.862476:862528]

B:BD[5.862528] → [16.1860:1907]

        fprintf(stderr, "%s \"%s\" does not exist "
                        "and I can't create it.\n",
                whatdir.c_str(), dir.c_str());

[5.862412]

[16.1907]

        if (!silent)
            fprintf(stderr, "%s \"%s\" does not exist "
                    "and I can't create it.\n",
                    whatdir.c_str(), dir.c_str());

Replacement in crawl-ref/source/files.cc at line 425 [10.3084589]

B:BD[5.862664] → [5.862664:862706]

// the file in the Crawl saves directory.

[5.862664]

[5.862706]

// the file in the Crawl saves directory. You can use path segments in
// shortpath (separated by /) and get_savedir_path will canonicalise them
// to the platform's native file separator.

Replacement in crawl-ref/source/files.cc at line 430 [10.3084589]

B:BD[5.862767] → [5.862767:862810]

    return (Options.save_dir + shortpath);

[5.862767]

[10.3090720]

    const std::string file = Options.save_dir + shortpath;
#if FILE_SEPARATOR != '/'
    return (replace_all(file, "/", std::string(1, FILE_SEPARATOR)));
#else
    return (file);
#endif

Replacement in crawl-ref/source/files.cc at line 1144 [10.3084589]
B:BD[10.3112435] → [10.3112435:3112467]
```
void save_game(bool leave_game)
```
[10.3112435]
[10.3112467]
```
void save_game(bool leave_game, const char *farewellmsg)
```
Deletion in crawl-ref/source/files.cc at line 1235 [10.3084589]
B:BD[10.3114252] → [10.3114252:3114308]
```
    cprintf( "See you soon, %s!" EOL , you.your_name );
```
Replacement in crawl-ref/source/files.cc at line 1238 [10.3084589]
∅:D[19.1450] → [10.3114309:3114321]
B:BD[10.3114309] → [10.3114309:3114321]
```
    end(0);
```
[19.1450]
[10.3114321]
```
    end(0, false, farewellmsg? "%s" : "See you soon, %s!",
        farewellmsg? farewellmsg : you.your_name);
```
Deletion in crawl-ref/source/files.cc at line 1597 [10.3084589]
B:BD[14.437316] → [14.437316:437366]
B:BD[14.437386] → [14.437386:437387]
```
// Largest string we'll save
#define STR_CAP 1000
```
Replacement in crawl-ref/source/files.cc at line 1637 [10.3084589]
B:BD[14.438187] → [5.874851:874886]
```
std::string readString(FILE *file)
```
[14.438187]
[14.438217]
```
std::string readString(FILE *file, int cap)
```
Replacement in crawl-ref/source/files.cc at line 1642 [10.3084589]
B:BD[18.714] → [18.714:745]
```
        if (length <= STR_CAP)
```
[18.714]
[18.745]
```
        if (length <= cap)
```
Replacement in crawl-ref/source/files.cc at line 1644 [10.3084589]
B:BD[18.755] → [18.755:790]
```
            char buf[STR_CAP + 1];
```
[18.755]
[18.790]
```
            char *buf = new char[length + 1];
```

Replacement in crawl-ref/source/files.cc at line 1647 [10.3084589]

B:BD[18.857] → [18.857:883]

            return (buf);

[18.857]

[18.883]

            const std::string s = buf;
            delete [] buf;
            return (s);

Deletion in crawl-ref/source/database.cc at line 33 [20.13932]
∅:D[17.2275] → [20.14522:14523]
B:BD[20.14522] → [20.14522:14523]
B:BD[20.14523] → [17.2276:2408]
∅:D[17.2408] → [20.14523:14524]
B:BD[20.14523] → [20.14523:14524]
B:BD[20.14524] → [17.2409:2443]
```
time_t file_modtime(const std::string &file)
{
    struct stat filestat;
    if (stat(file.c_str(), &filestat))
        return (0);
    return (filestat.st_mtime);
}
```

Deletion in crawl-ref/source/database.cc at line 34 [20.13932]

B:BD[17.2444] → [17.2444:2791]

// Returns true if file a is newer than file b.
bool is_newer(const std::string &a, const std::string &b)
{
    return (file_modtime(a) > file_modtime(b));
}
void check_newer(const std::string &target,
                 const std::string &dependency,
                 void (*action)())
{
    if (is_newer(dependency, target))
        action();
}

Insertion in crawl-ref/source/clua.cc at line 1525 [14.483969]
[14.520551]
[14.520551]
```
    if (!crawl_state.io_inited)
        return (0);
    
```
Insertion in crawl-ref/source/acr.cc at line 3073 [10.4397395]
[5.1280295]
[5.1280295]
```
    run_map_preludes();
    
```

Implemented .des file caching (speeds startup a fair bit): .des files are

Dependencies

In channels

Change contents

File deletion: levcomp.h

File deletion: levcomp.cc

Deletion in crawl-ref/source/util/levcomp.ypp at line 6 [5.75608]

Insertion in crawl-ref/source/util/levcomp.ypp at line 8 [5.75608]

Replacement in crawl-ref/source/util/levcomp.ypp at line 109 [5.75608]

Replacement in crawl-ref/source/player.cc at line 5028 [10.962854]

Insertion in crawl-ref/source/maps.h at line 50 [10.2007036]

Deletion in crawl-ref/source/maps.cc at line 29 [10.2007666]

Replacement in crawl-ref/source/maps.cc at line 30 [10.2007666]

Replacement in crawl-ref/source/maps.cc at line 81 [10.2007666]

Insertion in crawl-ref/source/maps.cc at line 85 [10.2007666]

Insertion in crawl-ref/source/maps.cc at line 357 [10.2007666]

Insertion in crawl-ref/source/maps.cc at line 518 [10.2007666]

Insertion in crawl-ref/source/maps.cc at line 537 [10.2007666]

Insertion in crawl-ref/source/maps.cc at line 540 [10.2007666]

Insertion in crawl-ref/source/maps.cc at line 570 [10.2007666]

Insertion in crawl-ref/source/mapdef.h at line 14 [5.591249]

Insertion in crawl-ref/source/mapdef.h at line 44 [5.591249]

Insertion in crawl-ref/source/mapdef.h at line 397 [5.591249]

Insertion in crawl-ref/source/mapdef.h at line 423 [5.591249]

Insertion in crawl-ref/source/mapdef.h at line 430 [5.591249]

Replacement in crawl-ref/source/mapdef.h at line 441 [5.591249]

Insertion in crawl-ref/source/mapdef.h at line 482 [5.591249]

Insertion in crawl-ref/source/mapdef.cc at line 10 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 15 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 138 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 151 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 845 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 856 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 937 [5.594797]

Replacement in crawl-ref/source/mapdef.cc at line 946 [5.594797]

Deletion in crawl-ref/source/mapdef.cc at line 948 [5.594797]

Insertion in crawl-ref/source/mapdef.cc at line 949 [5.594797]

Replacement in crawl-ref/source/makefile.unix at line 133 [5.604320]

Replacement in crawl-ref/source/makefile.mgw at line 77 [14.272908]

Insertion in crawl-ref/source/luadgn.h at line 33 [3.228]

Insertion in crawl-ref/source/luadgn.cc at line 71 [3.1232]

Insertion in crawl-ref/source/luadgn.cc at line 478 [3.1232]

Insertion in crawl-ref/source/luadgn.cc at line 489 [3.1232]

Replacement in crawl-ref/source/files.h at line 33 [10.3082298]

Insertion in crawl-ref/source/files.h at line 46 [10.3082298]

Replacement in crawl-ref/source/files.h at line 50 [10.3082298]

Replacement in crawl-ref/source/files.h at line 63 [10.3082298]

Replacement in crawl-ref/source/files.h at line 88 [10.3082298]

Insertion in crawl-ref/source/files.h at line 91 [10.3082298]

Deletion in crawl-ref/source/files.h at line 93 [10.3082298]

Deletion in crawl-ref/source/files.h at line 94 [10.3082298]

Replacement in crawl-ref/source/files.h at line 95 [10.3082298]

Deletion in crawl-ref/source/files.h at line 98 [10.3082298]

Insertion in crawl-ref/source/files.cc at line 227 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 398 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 403 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 414 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 425 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 430 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 1144 [10.3084589]

Deletion in crawl-ref/source/files.cc at line 1235 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 1238 [10.3084589]

Deletion in crawl-ref/source/files.cc at line 1597 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 1637 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 1642 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 1644 [10.3084589]

Replacement in crawl-ref/source/files.cc at line 1647 [10.3084589]

Deletion in crawl-ref/source/database.cc at line 33 [20.13932]

Deletion in crawl-ref/source/database.cc at line 34 [20.13932]

Insertion in crawl-ref/source/clua.cc at line 1525 [14.483969]

Insertion in crawl-ref/source/acr.cc at line 3073 [10.4397395]