extern std::string init_file_location;

extern std::string init_file_error;

    const bool init_found =
        (init_file_location.find("not found") == std::string::npos);

    const bool init_found = init_file_error.empty();

        msg += "<lightred>Init file ";

        msg += "<lightred>No init file ";

        msg += "<lightgrey>Init file read: ";

        msg += "<lightgrey>(Read options from ";

    msg += init_file_location;

    if (init_found)
    {
#ifdef DGAMELAUNCH
        // For dgl installs, show only the last segment of the .crawlrc
        // file name so that we don't leak details of the directory
        // structure to (untrusted) users.
        msg += get_base_filename(Options.filename);
#else
        msg += Options.filename;
#endif
        msg += ".)";
    }
    else
    {
        msg += init_file_error;
        msg += ", using defaults.";
    }

        UNUSED(cooky);

// [ds] Will the owner of this unused function step up and end its
// suffering? :P
#if 0

#endif

public:

    std::vector<std::string> rcdirs;   // Directories to search for includes.

public:
    void add_rcdir(const std::string &dir);

    // Forget any files we remembered as included.
    included.clear();

// returns where the init file was read from
std::string read_init_file(bool runscript)

static std::string _find_crawlrc()

        { SysEnv.crawl_rc.c_str(), "" },

        { SysEnv.home.c_str(), "/.crawlrc" },

        { SysEnv.home.c_str(), ".crawlrc" },

#ifndef DATA_DIR_PATH

#ifdef WIN32CONSOLE
        { "", ".crawlrc" },
        { "", "_crawlrc" },

        { "..", "init.txt" },

    Options.reset_options();

    // We'll look for these files in any supplied -rcdirs.
    static const char *rc_dir_filenames[] = {
        ".crawlrc", "init.txt"
    };

    FILE* f = NULL;
    char name_buff[kPathLen];

    // -rc option always wins.
    if (!SysEnv.crawl_rc.empty())
        return (SysEnv.crawl_rc);
    // If we have any rcdirs, look in them for files from the
    // rc_dir_names list.
    for (int i = 0, size = SysEnv.rcdirs.size(); i < size; ++i)
    {
        for (unsigned n = 0; n < ARRAYSZ(rc_dir_filenames); ++n)
        {
            const std::string rc(
                catpath(SysEnv.rcdirs[i], rc_dir_filenames[n]));
            if (file_exists(rc))
                return (rc);
        }
    }

    for ( int i = 0; f == NULL && locations_data[i][1] != NULL; ++i )

    for ( int i = 0; locations_data[i][1] != NULL; ++i )

            snprintf( name_buff, sizeof name_buff, "%s%s",
                      locations_data[i][0], locations_data[i][1] );
            f = fopen( name_buff, "r" );

            const std::string rc =
                catpath(locations_data[i][0], locations_data[i][1]);
            if (file_exists(rc))
                return (rc);

    return ("");
}
// Returns an error message if the init.txt was not found.
std::string read_init_file(bool runscript)
{
    Options.reset_options();
    const std::string init_file_name( _find_crawlrc() );

    FILE* f = fopen(init_file_name.c_str(), "r");

        if (!init_file_name.empty())
            return make_stringf("(\"%s\" is not readable)",
                                init_file_name.c_str());

        return "not found (~/.crawlrc missing)";

        return "(~/.crawlrc missing)";

        return "not found (init.txt missing from current directory)";

        return "(no init.txt in current directory)";

    Options.filename = init_file_name;

    return std::string(name_buff);
}                               // end read_init_file()

    return ("");
}

    }
}
bool game_options::include_file_directive(const std::string &line,
                                          bool runscript)
{
    const std::string prefix = "include ";
    if (line.find(prefix) == std::string::npos)
        return (false);
    std::string include_line = trimmed_string(line);
    if (include_line.find(prefix) == 0)
    {
        include(trimmed_string(include_line.substr(prefix.length())),
                true, runscript);
        return (true);

    return (false);

    // If the user asked us to include a file, don't try to process the line
    // as an option.
    if (include_file_directive(str, runscript))
        return;

    // If DATA_DIR_PATH is set, don't set crawl_dir from .crawlrc.
#ifndef DATA_DIR_PATH

#endif

        additional_macro_files.push_back(orig_field);

        const std::string resolved = resolve_include(orig_field, "macro ");
        if (!resolved.empty())
            additional_macro_files.push_back(resolved);

// Checks an include file name for safety and resolves it to a readable path.
// If safety check fails, throws a string with the reason for failure.
// If file cannot be resolved, returns the empty string (this does not throw!)
// If file can be resolved, returns the resolved path.
std::string game_options::resolve_include(
    std::string parent_file,
    std::string included_file,
    const std::vector<std::string> *rcdirs)
    throw (std::string)
{
    // Before we start, make sure we convert forward slashes to the platform's
    // favoured file separator.
    parent_file   = canonicalise_file_separator(parent_file);
    included_file = canonicalise_file_separator(included_file);
    // How we resolve include paths:
    // 1. If it's an absolute path, use it directly.
    // 2. Try the name relative to the parent filename, if supplied.
    // 3. Try the name relative to any of the provided rcdirs.
    // 4. Try locating the name as a regular data file (also checks for the
    //    file name relative to the current directory).
    // 5. Fail, and return empty string.
    assert_read_safe_path(included_file);

    // There's only so much you can do with an absolute path.
    // Note: absolute paths can only get here if we're not on a
    // multiuser system. On multiuser systems assert_read_safe_path()
    // will throw an exception if it sees absolute paths.
    if (is_absolute_path(included_file))
        return (file_exists(included_file)? included_file : "");
    if (!parent_file.empty())
    {
        const std::string candidate =
            get_path_relative_to(parent_file, included_file);
        if (file_exists(candidate))
            return (candidate);
    }
    if (rcdirs)
    {
        const std::vector<std::string> &dirs(*rcdirs);
        for (int i = 0, size = dirs.size(); i < size; ++i)
        {
            const std::string candidate( catpath(dirs[i], included_file) );
            if (file_exists(candidate))
                return (candidate);
        }
    }
    return datafile_path(included_file, false, true);
}
std::string game_options::resolve_include(
    const std::string &file,
    const char *type)
{
    try
    {
        const std::string resolved =
            resolve_include(this->filename, file, &SysEnv.rcdirs);
        if (resolved.empty())
            report_error(
                make_stringf("Cannot find %sfile \"%s\".",
                             type, file.c_str()));
        return (resolved);
    }
    catch (const std::string &err)
    {
        report_error(
            make_stringf("Cannot include %sfile: %s", type, err.c_str()));
        return "";
    }
}
bool game_options::was_included(const std::string &file) const
{
    return (included.find(file) != included.end());
}
void game_options::include(const std::string &rawfilename,
                           bool resolve,
                           bool runscript)
{
    const std::string include_file =
        resolve ? resolve_include(rawfilename) : rawfilename;
    if (was_included(include_file))
    {
        // Report error with rawfilename, not the resolved file name - we
        // don't want to leak file paths in dgamelaunch installs.
        report_error(make_stringf("Skipping previously included file: \"%s\".",
                                  rawfilename.c_str()));
        return;
    }
    included.insert(include_file);
    // Change this->filename to the included filename while we're reading it.
    unwind_var<std::string> optfile(this->filename, include_file);
    FILE* f = fopen( include_file.c_str(), "r" );
    if (f)
    {
        FileLineInput fl(f);
        read_options(fl, runscript);
        fclose(f);
    }
}
void game_options::report_error(const std::string &error)
{
    // If called before game starts, log a startup error,
    // otherwise spam the warning channel.
    if (crawl_state.need_save)
        mprf(MSGCH_WARN, "Warning: %s", error.c_str());
    else
        crawl_state.add_startup_error(error);
}

    CLO_RCDIR,

static const char *cmd_ops[] = { "scores", "name", "race", "class",
                                 "pizza", "plain", "dir", "rc", "tscores",
                                 "vscores", "scorefile", "morgue",
                                 "macro", "mapstat" };

static const char *cmd_ops[] = {
    "scores", "name", "race", "class", "pizza", "plain", "dir", "rc",
    "rcdir", "tscores", "vscores", "scorefile", "morgue", "macro",
    "mapstat"
};

    SysEnv.rcdirs.clear();

        case CLO_RCDIR:
            // Always parse
            if (!next_is_param)
                return (false);

            SysEnv.add_rcdir(next_arg);
            nextUsed = true;
            break;

// system_environment
void system_environment::add_rcdir(const std::string &dir)
{
    std::string cdir = canonicalise_file_separator(dir);
    if (dir_exists(cdir))
        rcdirs.push_back(cdir);
    else
        end(1, false, "Cannot find -rcdir \"%s\"", cdir.c_str());
}
///////////////////////////////////////////////////////////////////////

bool file_exists(const std::string &name);
bool dir_exists(const std::string &dir);
bool is_absolute_path(const std::string &path);
bool is_read_safe_path(const std::string &path);
void assert_read_safe_path(const std::string &path) throw (std::string);

std::string get_path_relative_to(const std::string &referencefile,
                                 const std::string &relativepath);
std::string catpath(const std::string &first, const std::string &second);
std::string canonicalise_file_separator(const std::string &path);

}
bool is_absolute_path(const std::string &path)
{
    return (!path.empty()
            && (path[0] == FILE_SEPARATOR
#if defined(WIN32CONSOLE) || defined(WIN32TILES)
                || path.find(':') != std::string::npos
#endif
                ));
}
// Concatenates two paths, separating them with FILE_SEPARATOR if necessary.
// Assumes that the second path is not absolute.
//
// If the first path is empty, returns the second unchanged. The second path
// may be absolute in this case.
std::string catpath(const std::string &first, const std::string &second)
{
    if (first.empty())
        return (second);
    std::string directory = first;
    if (directory[directory.length() - 1] != FILE_SEPARATOR)
        directory += FILE_SEPARATOR;
    directory += second;
    return (directory);
}
// Given a relative path and a reference file name, returns the relative path
// suffixed to the directory containing the reference file name. Assumes that
// the second path is not absolute.
std::string get_path_relative_to(const std::string &referencefile,
                                 const std::string &relativepath)
{
    return catpath(get_parent_directory(referencefile),
                   relativepath);

static bool file_exists(const std::string &name)

bool file_exists(const std::string &name)

static bool dir_exists(const std::string &dir)

bool dir_exists(const std::string &dir)

#elif defined(HAVE_STAT)
    struct stat st;
    const int err = ::stat(dir.c_str(), &st);
    return (!err && S_ISDIR(st.st_mode));

    }
    return (true);
}
// Checks whether the given path is safe to read from. A path is safe if:
// 1. If Unix: It contains no shell metacharacters.
// 2. If DATA_DIR_PATH is set: the path is not an absolute path.
// 3. If DATA_DIR_PATH is set: the path contains no ".." sequence.
void assert_read_safe_path(const std::string &path) throw (std::string)
{
    // Check for rank tomfoolery first:
    if (path.empty())
        throw "Empty file name.";
#ifdef UNIX
    if (!shell_safe(path.c_str()))
        throw make_stringf("\"%s\" contains bad characters.",
                           path.c_str());
#endif
#ifdef DATA_DIR_PATH
    if (is_absolute_path(path))
        throw make_stringf("\"%s\" is an absolute path.", path.c_str());
    if (path.find("..") != std::string::npos)
        throw make_stringf("\"%s\" contains \"..\" sequences.",
                           path.c_str());
#endif
    // Path is okay.
}
bool is_read_safe_path(const std::string &path)
{
    try
    {
        assert_read_safe_path(path);

    catch (const std::string &err)
    {
        return (false);
    }

std::string canonicalise_file_separator(const std::string &path)
{
#if FILE_SEPARATOR != '/'
    return (replace_all_of(path, "/", std::string(1, FILE_SEPARATOR)));
#else
    // No action needed here.
    return (path);
#endif
}

#if FILE_SEPARATOR != '/'
    basename = replace_all_of(basename, "/", std::string(1, FILE_SEPARATOR));
#endif

    basename = canonicalise_file_separator(basename);

    std::string cdir = !SysEnv.crawl_dir.empty()? SysEnv.crawl_dir : "";

        cdir,

        !SysEnv.crawl_dir.empty()? SysEnv.crawl_dir : "",

        std::string("settings") + FILE_SEPARATOR,

        std::string("..") + FILE_SEPARATOR + "settings" + FILE_SEPARATOR,

        std::string(".") + FILE_SEPARATOR,

    void include(const std::string &file, bool resolve, bool runscript);
    void report_error(const std::string &error);
    std::string resolve_include(const std::string &file,
                                const char *type = "");
    bool was_included(const std::string &file) const;
    static std::string resolve_include(
        std::string including_file,
        std::string included_file,
        const std::vector<std::string> *rcdirs = NULL)
               throw (std::string);

    std::string filename;  // The name of the file containing options.

    std::set<std::string>    included; // Files we've included already.

    bool include_file_directive(const std::string &line, bool runscript);

    FILE* f = fopen( filename, "r" );
    if (f)
    {
        FileLineInput fl(f);
        Options.read_options(fl, true);
        fclose(f);
    }
    else
    {
        mprf(MSGCH_WARN, "Warning: could not read options file '%s'", filename);
    }

    Options.include(filename, true, true);

std::string init_file_location; // externed in newgame.cc

std::string init_file_error;    // externed in newgame.cc

    init_file_location = read_init_file();

    init_file_error = read_init_file();

    puts("  -rcdir <dir>     directory that contains (included) rc files");

# : crawl.read_options('docs/034_monster_glyphs.txt')

# include                   docs/034_monster_glyphs.txt

# You can use the travel_stop_message for making autotravel better behaved.
# The following file contains a list of such options, with explanations.
: crawl.read_options('docs/travel_stoppers.txt')

# You can use travel_stop_message to make autotravel stop for situations that
# warrant your attention. This file (travel_stoppers.txt) contains a list of
# travel_stop_message settings, with brief descriptions of what they do.
include docs/travel_stoppers.txt

#
# Set the monster glyphs back to the way they were in 0.3.4
# : crawl.read_options('docs/monster_glyphs.txt')

saves/
morgue/

saves
morgue