features_by_desc( text_pattern(s, true) );
    for (int i = 0, size = feats.size(); i < size; ++i)
        list.push_back( feature_spec(feats[i], weight) );

        features_by_desc( glob_pattern(s, true) );
    if (!feats.empty())
        list.push_back( feature_spec(feats[0], weight) );

// Globs are always available.
void *compile_glob_pattern(const char *pattern, bool ignore_case = false);
void free_compiled_glob_pattern(void *cp);
bool glob_pattern_match(void *compiled_pattern, const char *text, int length);

typedef void *(*p_compile)(const char *pattern, bool ignore_case);
typedef void (*p_free)(void *cp);
typedef bool (*p_match)(void *compiled_pattern, const char *text, int length);

class text_pattern : public base_pattern

template <p_compile pcomp, p_free pfree, p_match pmatch>
class basic_text_pattern : public base_pattern

    text_pattern(const std::string &s, bool icase = false) 

    basic_text_pattern(const std::string &s, bool icase = false) 

    text_pattern()

    basic_text_pattern()

    text_pattern(const text_pattern &tp)

    basic_text_pattern(const basic_text_pattern &tp)

    ~text_pattern()

    ~basic_text_pattern()

            free_compiled_pattern(compiled_pattern);

            pfree(compiled_pattern);

    const text_pattern &operator= (const text_pattern &tp)

    const basic_text_pattern &operator= (const basic_text_pattern &tp)

            free_compiled_pattern(compiled_pattern);

            pfree(compiled_pattern);

    const text_pattern &operator= (const std::string &spattern)

    const basic_text_pattern &operator= (const std::string &spattern)

            free_compiled_pattern(compiled_pattern);

            pfree(compiled_pattern);

            !!(compiled_pattern = compile_pattern(pattern.c_str(), ignore_case))

            !!(compiled_pattern = pcomp(pattern.c_str(), ignore_case))

        return valid() && pattern_match(compiled_pattern, s, length);

        return valid() && pmatch(compiled_pattern, s, length);

typedef
basic_text_pattern<compile_pattern,
                   free_compiled_pattern, pattern_match> text_pattern;

typedef
basic_text_pattern<compile_glob_pattern,
                   free_compiled_glob_pattern,
                   glob_pattern_match> glob_pattern;

}
////////////////////////////////////////////////////////////////////
// Basic glob (always available)
struct glob_info
{
    std::string s;
    bool ignore_case;
};
void *compile_glob_pattern(const char *pattern, bool icase) 
{
    // If we're using simple globs, we need to box the pattern with '*'
    std::string s = std::string("*") + pattern + "*";
    glob_info *gi = new glob_info;
    if (gi)
    {
        gi->s = s;
        gi->ignore_case = icase;
    }
    return gi;
}
void free_compiled_glob_pattern(void *compiled_pattern)
{
    delete static_cast<glob_info *>( compiled_pattern );
}
bool glob_pattern_match(void *compiled_pattern, const char *text, int length)
{
    glob_info *gi = static_cast<glob_info *>( compiled_pattern );
    return glob_match(gi->s.c_str(), text, gi->ignore_case);

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
// Basic glob
struct glob_info
{
    std::string s;
    bool ignore_case;
};

void *compile_pattern(const char *pattern, bool icase) 

void *compile_pattern(const char *pattern, bool icase)

    // If we're using simple globs, we need to box the pattern with '*'
    std::string s = std::string("*") + pattern + "*";
    glob_info *gi = new glob_info;
    if (gi)
    {
        gi->s = s;
        gi->ignore_case = icase;
    }
    return gi;

    return compile_glob_pattern(pattern, icase);

void free_compiled_pattern(void *compiled_pattern)

void free_compiled_pattern(void *cp)

    delete static_cast<glob_info *>( compiled_pattern );

    free_compiled_glob_pattern(cp);

    glob_info *gi = static_cast<glob_info *>( compiled_pattern );
    return glob_match(gi->s.c_str(), text, gi->ignore_case);

    return glob_pattern_match(compiled_pattern, text, length);

////////////////////////////////////////////////////////////////////

    std::vector<dungeon_feature_type> feats = features_by_desc(fname);

    std::vector<dungeon_feature_type> feats =
        features_by_desc(text_pattern(fname));

std::vector<dungeon_feature_type> features_by_desc(const text_pattern &pattern);

std::vector<dungeon_feature_type> features_by_desc(const base_pattern &pattern);

std::vector<dungeon_feature_type> features_by_desc(const text_pattern &pattern)

std::vector<dungeon_feature_type> features_by_desc(const base_pattern &pattern)