recoll / Code / Diff of /src/common/rclconfig.cpp

Diff of /src/common/rclconfig.cpp [3c48e8] .. [51aa31]

Switch to unified view


...
      m_mdrstate(this, "metadatacmds")
{
    zeroMe();

    if (o_origcwd.empty()) {
        char buf[MAXPATHLEN];
        if (getcwd(buf, MAXPATHLEN)) {
            o_origcwd = string(buf);
        } else {
            fprintf(stderr, "recollxx: can't retrieve current working "
                    "directory: relative path translations will fail\n");
        }
    }

    // Compute our data dir name, typically /usr/local/share/recoll
    m_datadir = path_pkgdatadir();
    // We only do the automatic configuration creation thing for the default
    // config dir, not if it was specified through -c or RECOLL_CONFDIR
    bool autoconfdir = false;

    // Command line config name overrides environment
    if (argcnf && !argcnf->empty()) {
        m_confdir = path_absolute(*argcnf);
        if (m_confdir.empty()) {
            m_reason = 
                string("Cant turn [") + *argcnf + "] into absolute path";
            return;
        }
    } else {
        const char *cp = getenv("RECOLL_CONFDIR");
        if (cp) {
            m_confdir = path_canon(cp);
        } else {
            autoconfdir = true;
            m_confdir=path_cat(path_homedata(), path_defaultrecollconfsubdir());
        }
    }

    // Note: autoconfdir and isDefaultConfig() are normally the same. We just 
    // want to avoid the imperfect test in isDefaultConfig() if we actually know
    // this is the default conf
    if (!autoconfdir && !isDefaultConfig()) {
        if (!path_exists(m_confdir)) {
            m_reason = "Explicitly specified configuration "
                "directory must exist"
                " (won't be automatically created). Use mkdir first";
            return;
        }
    }

    if (!path_exists(m_confdir)) {
        if (!initUserConfig()) 
            return;
    }

    // This can't change once computed inside a process. It would be
    // nicer to move this to a static class initializer to avoid
    // possible threading issues but this doesn't work (tried) as
    // things would not be ready. In practise we make sure that this
    // is called from the main thread at once, by constructing a config
    // from recollinit
    if (o_localecharset.empty()) {
#ifndef _WIN32
        const char *cp;
        cp = nl_langinfo(CODESET);
        // We don't keep US-ASCII. It's better to use a superset
        // Ie: me have a C locale and some french file names, and I
        // can't imagine a version of iconv that couldn't translate
        // from iso8859?
        // The 646 thing is for solaris. 
        if (cp && *cp && strcmp(cp, "US-ASCII") 
#ifdef sun
            && strcmp(cp, "646")
#endif
            ) {
            o_localecharset = string(cp);
        } else {
            // Use cp1252 instead of iso-8859-1, it's a superset.
            o_localecharset = string(cstr_cp1252);
        }
#else
        o_localecharset = winACPName();
#endif
        LOGDEB1("RclConfig::getDefCharset: localecharset ["  <<
                o_localecharset << "]\n");
    }

    const char *cp;

    // Additional config directory, values override user ones
    if ((cp = getenv("RECOLL_CONFTOP"))) {
        m_cdirs.push_back(cp);
    } 

    // User config
    m_cdirs.push_back(m_confdir);

    // Additional config directory, overrides system's, overridden by user's
    if ((cp = getenv("RECOLL_CONFMID"))) {
        m_cdirs.push_back(cp);
    } 

    // Base/installation config
    m_cdirs.push_back(path_cat(m_datadir, "examples"));

    string cnferrloc;
    for (vector<string>::const_iterator it = m_cdirs.begin();
         it != m_cdirs.end(); it++) {
        if (it != m_cdirs.begin())
            cnferrloc += string(" or ");
        cnferrloc += *it;
    }

    // Read and process "recoll.conf"
    if (!updateMainConfig())
        return;
    // Other files
    mimemap = new ConfStack<ConfTree>("mimemap", m_cdirs, true);
    if (mimemap == 0 || !mimemap->ok()) {
        m_reason = string("No or bad mimemap file in: ") + cnferrloc;
        return;
    }

    // Maybe create the MIME to suffix association reverse map. Do it
    // in file order so that we can control what suffix is used when
    // there are several. This only uses the distributed file, not any
...
        }
    }

    mimeconf = new ConfStack<ConfSimple>("mimeconf", m_cdirs, true);
    if (mimeconf == 0 || !mimeconf->ok()) {
        m_reason = string("No/bad mimeconf in: ") + cnferrloc;
        return;
    }
    mimeview = new ConfStack<ConfSimple>("mimeview", m_cdirs, false);
    if (mimeview == 0)
        mimeview = new ConfStack<ConfSimple>("mimeview", m_cdirs, true);
    if (mimeview == 0 || !mimeview->ok()) {
        m_reason = string("No/bad mimeview in: ") + cnferrloc;
        return;
    }
    if (!readFieldsConfig(cnferrloc))
        return;

    // Default is no threading
    m_thrConf = {{-1, 0}, {-1, 0}, {-1, 0}};

    m_ptrans = new ConfSimple(path_cat(m_confdir, "ptrans").c_str());
...
}

bool RclConfig::updateMainConfig()
{
    ConfStack<ConfTree> *newconf = 
        new ConfStack<ConfTree>("recoll.conf", m_cdirs, true);
    if (newconf == 0 || !newconf->ok()) {
        if (m_conf)
            return false;
        string where;
        stringsToString(m_cdirs, where);
        m_reason = string("No/bad main configuration file in: ") + where;
        m_ok = false;
        initParamStale(0, 0);
        return false;
    }

    delete m_conf;
    m_conf = newconf;

...

    setKeyDir(cstr_null);

    bool bvalue = false;
    if (getConfParam("nocjk", &bvalue) && bvalue == true) {
        TextSplit::cjkProcessing(false);
    } else {
        int ngramlen;
        if (getConfParam("cjkngramlen", &ngramlen)) {
            TextSplit::cjkProcessing(true, (unsigned int)ngramlen);
        } else {
            TextSplit::cjkProcessing(true);
        }
    }

    bvalue = false;
    if (getConfParam("nonumbers", &bvalue) && bvalue == true) {
        TextSplit::noNumbers();
    }

    bvalue = false;
    if (getConfParam("dehyphenate", &bvalue)) {
        TextSplit::deHyphenate(bvalue);
    }

    bvalue = true;
    if (getConfParam("skippedPathsFnmPathname", &bvalue) && bvalue == false) {
        FsTreeWalker::setNoFnmPathname();
    }

    static int m_index_stripchars_init = 0;
    if (!m_index_stripchars_init) {
        getConfParam("indexStripChars", &o_index_stripchars);
        getConfParam("indexStoreDocText", &o_index_storedoctext);
        getConfParam("testmodifusemtime", &o_uptodate_test_use_mtime);
        m_index_stripchars_init = 1;
    }

    if (getConfParam("cachedir", m_cachedir)) {
        m_cachedir = path_canon(path_tildexpand(m_cachedir));
    }
...

ConfNull *RclConfig::cloneMainConfig()
{
    ConfNull *conf = new ConfStack<ConfTree>("recoll.conf", m_cdirs, false);
    if (conf == 0 || !conf->ok()) {
        m_reason = string("Can't read config");
        return 0;
    }
    return conf;
}

// Remember what directory we're under (for further conf->get()s), and 
...
        return;

    m_keydirgen++;
    m_keydir = dir;
    if (m_conf == 0)
        return;

    if (!m_conf->get("defaultcharset", m_defcharset, m_keydir))
        m_defcharset.erase();
}

bool RclConfig::getConfParam(const string &name, int *ivp, bool shallow) const
{
    string value;
    if (!getConfParam(name, value, shallow))
        return false;
    errno = 0;
    long lval = strtol(value.c_str(), 0, 0);
    if (lval == 0 && errno)
        return 0;
    if (ivp)
        *ivp = int(lval);
    return true;
}

bool RclConfig::getConfParam(const string &name, bool *bvp, bool shallow) const
{
    if (!bvp) 
        return false;

    *bvp = false;
    string s;
    if (!getConfParam(name, s, shallow))
        return false;
    *bvp = stringToBool(s);
    return true;
}

bool RclConfig::getConfParam(const string &name, vector<string> *svvp,
                             bool shallow) const
{
    if (!svvp) 
        return false;
    svvp->clear();
    string s;
    if (!getConfParam(name, s, shallow))
        return false;
    return stringToStrings(s, *svvp);
}

bool RclConfig::getConfParam(const string &name, unordered_set<string> *out,
                             bool shallow) const
{
    vector<string> v;
    if (!out || !getConfParam(name, &v, shallow)) {
        return false;
    }
    out->clear();
    out->insert(v.begin(), v.end());
    return true;
}

bool RclConfig::getConfParam(const string &name, vector<int> *vip,
                             bool shallow) const
{
    if (!vip) 
        return false;
    vip->clear();
    vector<string> vs;
    if (!getConfParam(name, &vs, shallow))
        return false;
    vip->reserve(vs.size());
    for (unsigned int i = 0; i < vs.size(); i++) {
        char *ep;
        vip->push_back(strtol(vs[i].c_str(), &ep, 0));
        if (ep == vs[i].c_str()) {
            LOGDEB("RclConfig::getConfParam: bad int value in [" << name <<
                   "]\n");
            return false;
        }
    }
    return true;
}

void RclConfig::initThrConf()
...
    m_thrConf = {{-1, 0}, {-1, 0}, {-1, 0}};

    vector<int> vq;
    vector<int> vt;
    if (!getConfParam("thrQSizes", &vq)) {
        LOGINFO("RclConfig::initThrConf: no thread info (queues)\n");
        goto out;
    }

    // If the first queue size is 0, autoconf is requested.
    if (vq.size() > 0 && vq[0] == 0) {
        CpuConf cpus;
        if (!getCpuConf(cpus) || cpus.ncpus < 1) {
            LOGERR("RclConfig::initThrConf: could not retrieve cpu conf\n");
            cpus.ncpus = 1;
        }
        if (cpus.ncpus != 1) {
            LOGDEB("RclConfig::initThrConf: autoconf requested. " <<
                   cpus.ncpus << " concurrent threads available.\n");
        }

        // Arbitrarily set threads config based on number of CPUS. This also
        // depends on the IO setup actually, so we're bound to be wrong...
        if (cpus.ncpus == 1) {
            // Somewhat counter-intuitively (because of possible IO//)
            // it seems that the best config here is no threading
        } else if (cpus.ncpus < 4) {
            // Untested so let's guess...
            m_thrConf = {{2, 2}, {2, 2}, {2, 1}};
        } else if (cpus.ncpus < 6) {
            m_thrConf = {{2, 4}, {2, 2}, {2, 1}};
        } else {
            m_thrConf = {{2, 5}, {2, 3}, {2, 1}};
        }
        goto out;
    } else if (vq.size() > 0 && vq[0] < 0) {
        // threads disabled by config
        goto out;
    }

    if (!getConfParam("thrTCounts", &vt) ) {
        LOGINFO("RclConfig::initThrConf: no thread info (threads)\n");
        goto out;
    }

    if (vq.size() != 3 || vt.size() != 3) {
        LOGINFO("RclConfig::initThrConf: bad thread info vector sizes\n");
        goto out;
    }

    // Normal case: record info from config
    m_thrConf.clear();
    for (unsigned int i = 0; i < 3; i++) {
        m_thrConf.push_back({vq[i], vt[i]});
    }

out:
    ostringstream sconf;
    for (unsigned int i = 0; i < 3; i++) {
        sconf << "(" << m_thrConf[i].first << ", " << m_thrConf[i].second <<
            ") ";
    }

    LOGDEB("RclConfig::initThrConf: chosen config (ql,nt): " << sconf.str() <<
           "\n");
}

pair<int,int> RclConfig::getThrConf(ThrStage who) const
{
    if (m_thrConf.size() != 3) {
        LOGERR("RclConfig::getThrConf: bad data in rclconfig\n");
        return pair<int,int>(-1,-1);
    }
    return m_thrConf[who];
}

vector<string> RclConfig::getTopdirs(bool formonitor) const
...
        }
    } else {
        getConfParam("topdirs", &tdl);
    }
    if (tdl.empty()) {
        LOGERR("RclConfig::getTopdirs: nothing to index:  topdirs/monitordirs "
               " are not set or have a bad list format\n");
        return tdl;
    }

    for (auto& dir : tdl) {
        dir = path_canon(path_tildexpand(dir));
    }
    return tdl;
}

const string& RclConfig::getLocaleCharset()
...
// For filenames, same thing except that we do not use the config file value
// (only the locale).
const string& RclConfig::getDefCharset(bool filename) const
{
    if (filename) {
        return o_localecharset;
    } else {
        return m_defcharset.empty() ? o_localecharset : m_defcharset;
    }
}

// Get all known document mime values. We get them from the mimeconf
// 'index' submap.
...
// comparison with suffix-only sensitivity
class SfString {
public:
    SfString(const string& s) : m_str(s) {}
    bool operator==(const SfString& s2) {
        string::const_reverse_iterator r1 = m_str.rbegin(), re1 = m_str.rend(),
            r2 = s2.m_str.rbegin(), re2 = s2.m_str.rend();
        while (r1 != re1 && r2 != re2) {
            if (*r1 != *r2) {
                return 0;
            }
            ++r1; ++r2;
        }
        return 1;
    }
    string m_str;
};

class SuffCmp {
public:
    int operator()(const SfString& s1, const SfString& s2) {
        //cout << "Comparing " << s1.m_str << " and " << s2.m_str << endl;
        string::const_reverse_iterator 
            r1 = s1.m_str.rbegin(), re1 = s1.m_str.rend(),
            r2 = s2.m_str.rbegin(), re2 = s2.m_str.rend();
        while (r1 != re1 && r2 != re2) {
            if (*r1 != *r2) {
                return *r1 < *r2 ? 1 : 0;
            }
            ++r1; ++r2;
        }
        return 0;
    }
};

typedef multiset<SfString, SuffCmp> SuffixStore;
#define STOPSUFFIXES ((SuffixStore *)m_stopsuffixes)
...
    string fn(fni, pos);

    stringtolower(fn);
    SuffixStore::const_iterator it = STOPSUFFIXES->find(fn);
    if (it != STOPSUFFIXES->end()) {
        LOGDEB2("RclConfig::inStopSuffixes: Found (" << fni << ") ["  <<
                ((*it).m_str) << "]\n");
        return true;
    } else {
        LOGDEB2("RclConfig::inStopSuffixes: not found [" << fni << "]\n");
        return false;
    }
}

string RclConfig::getMimeTypeFromSuffix(const string& suff) const
{
...
    // Try again from local data. The map is in the wrong direction,
    // have to walk it.
    vector<string> sfs = mimemap->getNames(cstr_null);
    for (const auto& suff : sfs) {
        string mt1;
        if (mimemap->get(suff, mt1, cstr_null) && !stringicmp(mt, mt1)) {
            return suff;
        }
    }
    return cstr_null;
}

/** Get list of file categories from mimeconf */
bool RclConfig::getMimeCategories(vector<string>& cats) const
{
    if (!mimeconf)
        return false;
    cats = mimeconf->getNames("categories");
    return true;
}

bool RclConfig::isMimeCategory(string& cat) const
{
    vector<string>cats;
    getMimeCategories(cats);
    for (vector<string>::iterator it = cats.begin(); it != cats.end(); it++) {
        if (!stringicmp(*it,cat))
            return true;
    }
    return false;
}

/** Get list of mime types for category from mimeconf */
bool RclConfig::getMimeCatTypes(const string& cat, vector<string>& tps) const
{
    tps.clear();
    if (!mimeconf)
        return false;
    string slist;
    if (!mimeconf->get(cat, slist, "categories"))
        return false;

    stringToStrings(slist, tps);
    return true;
}

...
            return hs;
        }
    }

    if (!mimeconf->get(mtype, hs, "index")) {
        LOGDEB1("getMimeHandlerDef: no handler for '" << mtype << "'\n");
    }
    return hs;
}

const vector<MDReaper>& RclConfig::getMDReapers()
{
    string hs;
    if (m_mdrstate.needrecompute()) {
        m_mdreapers.clear();
        // New value now stored in m_mdrstate.getvalue(0)
        const string& sreapers = m_mdrstate.getvalue(0);
        if (sreapers.empty())
            return m_mdreapers;
        string value;
        ConfSimple attrs;
        valueSplitAttributes(sreapers, value, attrs);
        vector<string> nmlst = attrs.getNames(cstr_null);
        for (vector<string>::const_iterator it = nmlst.begin();
             it != nmlst.end(); it++) {
            MDReaper reaper;
            reaper.fieldname = fieldCanon(*it);
            string s;
            attrs.get(*it, s);
            stringToStrings(s, reaper.cmdv);
            m_mdreapers.push_back(reaper);
        }
    }
    return m_mdreapers;
}

bool RclConfig::getGuiFilterNames(vector<string>& cats) const
{
    if (!mimeconf)
        return false;
    cats = mimeconf->getNamesShallow("guifilters");
    return true;
}

bool RclConfig::getGuiFilter(const string& catfiltername, string& frag) const
{
    frag.clear();
    if (!mimeconf)
        return false;
    if (!mimeconf->get(catfiltername, frag, "guifilters"))
        return false;
    return true;
}

bool RclConfig::valueSplitAttributes(const string& whole, string& value, 
                                     ConfSimple& attrs)
{
    /* There is currently no way to escape a semi-colon */
    string::size_type semicol0 = whole.find_first_of(";");
    value = whole.substr(0, semicol0);
    trimstring(value);
...
    // with newlines and use a ConfSimple
    if (!attrstr.empty()) {
        for (string::size_type i = 0; i < attrstr.size(); i++) {
            if (attrstr[i] == ';')
                attrstr[i] = '\n';
        }
        attrs.reparse(attrstr);
    } else {
        attrs.clear();
    }
    
    return true;
}

bool RclConfig::getMissingHelperDesc(string& out) const
{
    string fmiss = path_cat(getConfDir(), "missing");
    out.clear();
    if (!file_to_string(fmiss, out))
        return false;
    return true;
}

void RclConfig::storeMissingHelperDesc(const string &s)
{
    string fmiss = path_cat(getCacheDir(), "missing");
    FILE *fp = fopen(fmiss.c_str(), "w");
    if (fp) {
        if (s.size() > 0 && fwrite(s.c_str(), s.size(), 1, fp) != 1) {
            LOGERR("storeMissingHelperDesc: fwrite failed\n");
        }
        fclose(fp);
    }
}

// Read definitions for field prefixes, aliases, and hierarchy and arrange 
// things for speed (theses are used a lot during indexing)
bool RclConfig::readFieldsConfig(const string& cnferrloc)
{
    LOGDEB2("RclConfig::readFieldsConfig\n");
    m_fields = new ConfStack<ConfSimple>("fields", m_cdirs, true);
    if (m_fields == 0 || !m_fields->ok()) {
        m_reason = string("No/bad fields file in: ") + cnferrloc;
        return false;
    }

    // Build a direct map avoiding all indirections for field to
    // prefix translation
    // Add direct prefixes from the [prefixes] section
    vector<string> tps = m_fields->getNames("prefixes");
    for (const auto& fieldname : tps) {
        string val;
        m_fields->get(fieldname, val, "prefixes");
        ConfSimple attrs;
        FieldTraits ft;
        // fieldname = prefix ; attr1=val;attr2=val...
        if (!valueSplitAttributes(val, ft.pfx, attrs)) {
            LOGERR("readFieldsConfig: bad config line for ["  << fieldname <<
                   "]: [" << val << "]\n");
            return 0;
        }
        string tval;
        if (attrs.get("wdfinc", tval))
            ft.wdfinc = atoi(tval.c_str());
        if (attrs.get("boost", tval))
            ft.boost = atof(tval.c_str());
        if (attrs.get("pfxonly", tval))
            ft.pfxonly = stringToBool(tval);
        if (attrs.get("noterms", tval))
            ft.noterms = stringToBool(tval);
        m_fldtotraits[stringtolower(fieldname)] = ft;
        LOGDEB2("readFieldsConfig: ["  << fieldname << "] -> ["  << ft.pfx <<
                "] " << ft.wdfinc << " " << ft.boost << "\n");
    }

    // Values section
    tps = m_fields->getNames("values");
    for (const auto& fieldname : tps) {
        string canonic = stringtolower(fieldname); // canonic name
        string val;
        m_fields->get(fieldname, val, "values");
        ConfSimple attrs;
        string svslot;
        // fieldname = valueslot ; attr1=val;attr2=val...
        if (!valueSplitAttributes(val, svslot, attrs)) {
            LOGERR("readFieldsConfig: bad value line for ["  << fieldname <<
                   "]: [" << val << "]\n");
            return 0;
        }
        uint32_t valueslot = uint32_t(atoi(svslot.c_str()));
        if (valueslot == 0) {
            LOGERR("readFieldsConfig: found 0 value slot for [" << fieldname <<
                   "]: [" << val << "]\n");
            continue;
...
        if (attrs.get("len", tval)) {
            valuelen = atoi(tval.c_str());
        }
        
        // Find or insert traits entry
        const auto pit =
            m_fldtotraits.insert(
                pair<string, FieldTraits>(canonic, FieldTraits())).first;
        pit->second.valueslot = valueslot;
        pit->second.valuetype = valuetype;
        pit->second.valuelen = valuelen;
    }
...
    // Add prefixes for aliases and build alias-to-canonic map while
    // we're at it. Having the aliases in the prefix map avoids an
    // additional indirection at index time.
    tps = m_fields->getNames("aliases");
    for (const auto& fieldname : tps) {
        string canonic = stringtolower(fieldname); // canonic name
        FieldTraits ft;
        const auto pit = m_fldtotraits.find(canonic);








        if (pit != m_fldtotraits.end()) {
            ft = pit->second;
        }
        string aliases;
        m_fields->get(canonic, aliases, "aliases");
        vector<string> l;
        stringToStrings(aliases, l);
        for (const auto& alias : l) {
            if (pit != m_fldtotraits.end())
                m_fldtotraits[stringtolower(alias)] = ft;
            m_aliastocanon[stringtolower(alias)] = canonic;
        }
    }

    // Query aliases map
    tps = m_fields->getNames("queryaliases");
    for (const auto& entry: tps) {
        string canonic = stringtolower(entry); // canonic name
        string aliases;
        m_fields->get(canonic, aliases, "queryaliases");
        vector<string> l;
        stringToStrings(aliases, l);
        for (const auto& alias : l) {
            m_aliastoqcanon[stringtolower(alias)] = canonic;
        }
    }

#if 0
    for (map<string, FieldTraits>::const_iterator it = m_fldtotraits.begin();
         it != m_fldtotraits.end(); it++) {
        LOGDEB("readFieldsConfig: ["  << entry << "] -> ["  << it->second.pfx <<
               "] " << it->second.wdfinc << " " << it->second.boost << "\n");
    }
#endif

    vector<string> sl = m_fields->getNames("stored");
...
    }

    // Extended file attribute to field translations
    vector<string>xattrs = m_fields->getNames("xattrtofields");
    for (const auto& xattr : xattrs) {
        string val;
        m_fields->get(xattr, val, "xattrtofields");
        m_xattrtofld[xattr] = val;
    }

    return true;
}

// Return specifics for field name:
bool RclConfig::getFieldTraits(const string& _fld, const FieldTraits **ftpp,
                               bool isquery) const
{
    string fld = isquery ? fieldQCanon(_fld) : fieldCanon(_fld);
    map<string, FieldTraits>::const_iterator pit = m_fldtotraits.find(fld);
    if (pit != m_fldtotraits.end()) {
        *ftpp = &pit->second;
        LOGDEB1("RclConfig::getFieldTraits: [" << _fld << "]->["  <<
                pit->second.pfx << "]\n");
        return true;
    } else {
        LOGDEB1("RclConfig::getFieldTraits: no prefix for field [" << fld <<
                "]\n");
        *ftpp = 0;
        return false;
    }
}

set<string> RclConfig::getIndexedFields() const
{
    set<string> flds;
    if (m_fields == 0)
        return flds;

    vector<string> sl = m_fields->getNames("prefixes");
    flds.insert(sl.begin(), sl.end());
    return flds;
}
...
string RclConfig::fieldCanon(const string& f) const
{
    string fld = stringtolower(f);
    map<string, string>::const_iterator it = m_aliastocanon.find(fld);
    if (it != m_aliastocanon.end()) {
        LOGDEB1("RclConfig::fieldCanon: [" << f << "] -> [" << it->second <<
                "]\n");
        return it->second;
    }
    LOGDEB1("RclConfig::fieldCanon: ["  << (f) << "] -> ["  << (fld) << "]\n");
    return fld;
}

string RclConfig::fieldQCanon(const string& f) const
{
    string fld = stringtolower(f);
    map<string, string>::const_iterator it = m_aliastoqcanon.find(fld);
    if (it != m_aliastoqcanon.end()) {
        LOGDEB1("RclConfig::fieldQCanon: [" << f << "] -> ["  << it->second <<
                "]\n");
        return it->second;
    }
    return fieldCanon(f);
}

vector<string> RclConfig::getFieldSectNames(const string &sk, const char* patrn)
...

set<string> RclConfig::getMimeViewerAllEx() const
{
    set<string> res;
    if (mimeview == 0)
        return res;

    string base, plus, minus;
    mimeview->get("xallexcepts", base, "");
    LOGDEB1("RclConfig::getMimeViewerAllEx(): base: " << s << endl);
    mimeview->get("xallexcepts+", plus, "");
...
    mimeview->get("xallexcepts-", minus, "");
    LOGDEB1("RclConfig::getMimeViewerAllEx(): minus: " << minus << endl);

    computeBasePlusMinus(res, base, plus, minus);
    LOGDEB1("RclConfig::getMimeViewerAllEx(): res: " << stringsToString(res)
            << endl);
    return res;
}

bool RclConfig::setMimeViewerAllEx(const set<string>& allex)
{
...

    string splus, sminus;
    setPlusMinus(sbase, allex, splus, sminus);

    if (!mimeview->set("xallexcepts-", sminus, "")) {
        m_reason = string("RclConfig:: cant set value. Readonly?");
        return false;
    }
    if (!mimeview->set("xallexcepts+", splus, "")) {
        m_reason = string("RclConfig:: cant set value. Readonly?");
        return false;
    }

    return true;
}

string RclConfig::getMimeViewerDef(const string &mtype, const string& apptag,
                                   bool useall) const
{
    LOGDEB2("RclConfig::getMimeViewerDef: mtype [" << mtype << "] apptag ["
            << apptag << "]\n");
    string hs;
    if (mimeview == 0)
        return hs;

    if (useall) {
        // Check for exception
        set<string> allex = getMimeViewerAllEx();
        bool isexcept = false;
        for (auto& it : allex) {
            vector<string> mita;
            stringToTokens(it, mita, "|");
            if ((mita.size() == 1 && apptag.empty() && mita[0] == mtype) ||
                (mita.size() == 2 && mita[1] == apptag && mita[0] == mtype)) {
                // Exception to x-all
                isexcept = true;
                break;
            }
        }

        if (isexcept == false) {
            mimeview->get("application/x-all", hs, "view");
            return hs;
        }
        // Fallthrough to normal case.
    }

    if (apptag.empty() || !mimeview->get(mtype + string("|") + apptag,
                                         hs, "view"))
        mimeview->get(mtype, hs, "view");
...
}

bool RclConfig::getMimeViewerDefs(vector<pair<string, string> >& defs) const
{
    if (mimeview == 0)
        return false;
    vector<string>tps = mimeview->getNames("view");
    for (vector<string>::const_iterator it = tps.begin(); 
         it != tps.end();it++) {
        defs.push_back(pair<string, string>(*it, getMimeViewerDef(*it, "", 0)));
    }
    return true;
}

bool RclConfig::setMimeViewerDef(const string& mt, const string& def)
{
    if (mimeview == 0)
        return false;
    bool status;
    if (!def.empty()) 
        status = mimeview->set(mt, def, "view");
    else 
        status = mimeview->erase(mt, "view");

    if (!status) {
        m_reason = string("RclConfig:: cant set value. Readonly?");
        return false;
    }
    return true;
}

bool RclConfig::mimeViewerNeedsUncomp(const string &mimetype) const
...
string RclConfig::getMimeIconPath(const string &mtype, const string &apptag)
    const
{
    string iconname;
    if (!apptag.empty())
        mimeconf->get(mtype + string("|") + apptag, iconname, "icons");
    if (iconname.empty())
        mimeconf->get(mtype, iconname, "icons");
    if (iconname.empty())
        iconname = "document";

    string iconpath;
#if defined (__FreeBSD__) && __FreeBSD_version < 500000
    // gcc 2.95 dies if we call getConfParam here ??
    if (m_conf) m_conf->get(string("iconsdir"), iconpath, m_keydir);
#else
    getConfParam("iconsdir", iconpath);
#endif

    if (iconpath.empty()) {
        iconpath = path_cat(m_datadir, "images");
    } else {
        iconpath = path_tildexpand(iconpath);
    }
    return path_cat(iconpath, iconname) + ".png";
}

// Return path defined by varname. May be absolute or relative to
// confdir, with default in confdir
string RclConfig::getConfdirPath(const char *varname, const char *dflt) const
{
    string result;
    if (!getConfParam(varname, result)) {
        result = path_cat(getConfDir(), dflt);
    } else {
        result = path_tildexpand(result);
        // If not an absolute path, compute relative to config dir
        if (!path_isabsolute(result)) {
            result = path_cat(getConfDir(), result);
        }
    }
    return path_canon(result);
}

string RclConfig::getCacheDir() const
...
// confdir, with default in confdir
string RclConfig::getCachedirPath(const char *varname, const char *dflt) const
{
    string result;
    if (!getConfParam(varname, result)) {
        result = path_cat(getCacheDir(), dflt);
    } else {
        result = path_tildexpand(result);
        // If not an absolute path, compute relative to cache dir
        if (!path_isabsolute(result)) {
            result = path_cat(getCacheDir(), result);
        }
    }
    return path_canon(result);
}

string RclConfig::getDbDir() const
...
 * /mnt1/common/part /mnt2/common/part -> /mnt1 /mnt2. This is used
 * for computing translations for paths when the dataset has been
 * moved. Of course this could be done more efficiently than by splitting 
 * into vectors, but we don't care.*/
static string path_diffstems(const string& p1, const string& p2,
                             string& r1, string& r2)
{
    string reason;
    r1.clear();
    r2.clear();
    vector<string> v1, v2;
...
    if (m_conf->get("orgidxconfdir", orig_confdir, "")) {
        if (!m_conf->get("curidxconfdir", cur_confdir, "")) {
            cur_confdir = m_confdir;
        }
        LOGDEB1("RclConfig::urlrewrite: orgidxconfdir: " << orig_confdir <<
                " cur_confdir " << cur_confdir << endl);
        string reason = path_diffstems(orig_confdir, cur_confdir,
                                       confstemorg, confstemrep);
        if (!reason.empty()) {
            LOGERR("urlrewrite: path_diffstems failed: " << reason <<
                   " : orig_confdir [" << orig_confdir <<
...
    }
    
    // Do path translations exist for this index ?
    bool needptrans = true;
    if (m_ptrans == 0 || !m_ptrans->hasSubKey(dbdir)) {
        LOGDEB2("RclConfig::urlrewrite: no paths translations (m_ptrans " <<
                m_ptrans << ")\n");
        needptrans = false;
    }

    if (!needptrans && confstemorg.empty()) {
...
    }
    bool computeurl = false;
    
    string path = fileurltolocalpath(url);
    if (path.empty()) {
        LOGDEB2("RclConfig::urlrewrite: not file url\n");
        return;
    }
    
    // Do the movable volume thing.
    if (!confstemorg.empty() && confstemorg.size() <= path.size() &&
        !path.compare(0, confstemorg.size(), confstemorg)) {
...
}

bool RclConfig::sourceChanged() const
{
    if (m_conf && m_conf->sourceChanged())
        return true;
    if (mimemap && mimemap->sourceChanged())
        return true;
    if (mimeconf && mimeconf->sourceChanged())
        return true;
    if (mimeview && mimeview->sourceChanged())
        return true;
    if (m_fields && m_fields->sourceChanged())
        return true;
    if (m_ptrans && m_ptrans->sourceChanged())
        return true;
    return false;
}

string RclConfig::getWebQueueDir() const
{
    string webqueuedir;
    if (!getConfParam("webqueuedir", webqueuedir))
        webqueuedir = "~/.recollweb/ToIndex/";
    webqueuedir = path_tildexpand(webqueuedir);
    return webqueuedir;
}

vector<string>& RclConfig::getSkippedNames()
...
        skpl.push_back(getCacheDir());
    }
    // And the web queue dir
    skpl.push_back(getWebQueueDir());
    for (vector<string>::iterator it = skpl.begin(); it != skpl.end(); it++) {
        *it = path_tildexpand(*it);
        *it = path_canon(*it);
    }
    sort(skpl.begin(), skpl.end());
    vector<string>::iterator uit = unique(skpl.begin(), skpl.end());
    skpl.resize(uit - skpl.begin());
    return skpl;
...
{
    vector<string> dskpl;
    getConfParam("daemSkippedPaths", &dskpl);

    for (vector<string>::iterator it = dskpl.begin(); it != dskpl.end(); it++) {
        *it = path_tildexpand(*it);
        *it = path_canon(*it);
    }

    vector<string> skpl1 = getSkippedPaths();
    vector<string> skpl;
    if (dskpl.empty()) {
        skpl = skpl1;
    } else {
        sort(dskpl.begin(), dskpl.end());
        merge(dskpl.begin(), dskpl.end(), skpl1.begin(), skpl1.end(), 
              skpl.begin());
        vector<string>::iterator uit = unique(skpl.begin(), skpl.end());
        skpl.resize(uit - skpl.begin());
    }
    return skpl;
}


...
// and filtersdir from the config file to the PATH, then use execmd::which()
string RclConfig::findFilter(const string &icmd) const
{
    // If the path is absolute, this is it
    if (path_isabsolute(icmd))
        return icmd;

    const char *cp = getenv("PATH");
    if (!cp) //??
        cp = "";
    string PATH(cp);
...
{
    string hs;

    mimeconf->get(mtype, hs, cstr_null);
    if (hs.empty())
        return false;
    vector<string> tokens;
    stringToStrings(hs, tokens);
    if (tokens.empty()) {
        LOGERR("getUncompressor: empty spec for mtype " << mtype << "\n");
        return false;
    }
    vector<string>::iterator it = tokens.begin();
    if (tokens.size() < 2)
        return false;
    if (stringlowercmp("uncompress", *it++)) 
        return false;
    cmd.clear();
    cmd.push_back(findFilter(*it));

    // Special-case python and perl on windows: we need to also locate the
    // first argument which is the script name "python somescript.py". 
...
"# at them for an explanation of what can be set (you could also take a look\n"
"# at the manual instead).\n"
"# Values set in this file will override the system-wide values for the file\n"
"# with the same name in the central directory. The syntax for setting\n"
"# values is identical.\n"
;
// We just use path_max to print the path to /usr/share/recoll/examples 
// inside the config file. At worse, the text is truncated (using
// snprintf). But 4096 should be enough :)
#ifndef PATH_MAX
#define MYPATHALLOC 4096
#else
#define MYPATHALLOC PATH_MAX
#endif

// Use uni2ascii -a K to generate these from the utf-8 strings
// Swedish and Danish. 
static const char swedish_ex[] = "unac_except_trans = \303\244\303\244 \303\204\303\244 \303\266\303\266 \303\226\303\266 \303\274\303\274 \303\234\303\274 \303\237ss \305\223oe \305\222oe \303\246ae \303\206ae \357\254\201fi \357\254\202fl \303\245\303\245 \303\205\303\245";
// German:
static const char german_ex[] = "unac_except_trans = \303\244\303\244 \303\204\303\244 \303\266\303\266 \303\226\303\266 \303\274\303\274 \303\234\303\274 \303\237ss \305\223oe \305\222oe \303\246ae \303\206ae \357\254\201fi \357\254\202fl";

// Create initial user config by creating commented empty files
static const char *configfiles[] = {"recoll.conf", "mimemap", "mimeconf", 
                                    "mimeview"};
static int ncffiles = sizeof(configfiles) / sizeof(char *);
bool RclConfig::initUserConfig()
{
    // Explanatory text
    const int bs = sizeof(blurb0)+MYPATHALLOC+1;
    char blurb[bs];
    string exdir = path_cat(m_datadir, "examples");
    snprintf(blurb, bs, blurb0, exdir.c_str());

    // Use protective 700 mode to create the top configuration
    // directory: documents can be reconstructed from index data.
    if (!path_exists(m_confdir) && 
        mkdir(m_confdir.c_str(), 0700) < 0) {
        m_reason += string("mkdir(") + m_confdir + ") failed: " + 
            strerror(errno);
        return false;
    }
    string lang = localelang();
    for (int i = 0; i < ncffiles; i++) {
        string dst = path_cat(m_confdir, string(configfiles[i])); 
        if (!path_exists(dst)) {
            FILE *fp = fopen(dst.c_str(), "w");
            if (fp) {
                fprintf(fp, "%s\n", blurb);
                if (!strcmp(configfiles[i], "recoll.conf")) {
                    // Add improved unac_except_trans for some languages
                    if (lang == "se" || lang == "dk" || lang == "no" || 
                        lang == "fi") {
                        fprintf(fp, "%s\n", swedish_ex);
                    } else if (lang == "de") {
                        fprintf(fp, "%s\n", german_ex);
                    }
                }
                fclose(fp);
            } else {
                m_reason += string("fopen ") + dst + ": " + strerror(errno);
                return false;
            }
        }
    }
    return true;
}

void RclConfig::zeroMe() {
...

void RclConfig::initFrom(const RclConfig& r)
{
    zeroMe();
    if (!(m_ok = r.m_ok))
        return;

    // Copyable fields
    m_ok = r.m_ok;
    m_reason = r.m_reason;
    m_confdir = r.m_confdir;
...
    m_thrConf = r.m_thrConf;
    m_mdreapers = r.m_mdreapers;

    // Special treatment
    if (r.m_conf)
        m_conf = new ConfStack<ConfTree>(*(r.m_conf));
    if (r.mimemap)
        mimemap = new ConfStack<ConfTree>(*(r.mimemap));
    if (r.mimeconf)
        mimeconf = new ConfStack<ConfSimple>(*(r.mimeconf));
    if (r.mimeview)
        mimeview = new ConfStack<ConfSimple>(*(r.mimeview));
    if (r.m_fields)
        m_fields = new ConfStack<ConfSimple>(*(r.m_fields));
    if (r.m_ptrans)
        m_ptrans = new ConfSimple(*(r.m_ptrans));
    if (r.m_stopsuffixes)
        m_stopsuffixes = new SuffixStore(*((SuffixStore*)r.m_stopsuffixes));
    initParamStale(m_conf, mimemap);
}

void RclConfig::initParamStale(ConfNull *cnf, ConfNull *mimemap)
{
...
#include "cstr.h"

static char *thisprog;

static char usage [] = "\n"
    "-c: check a few things in the configuration files\n"
    "[-s subkey] -q param : query parameter value\n"
    "-f : print some field data\n"
    "  : default: print parameters\n"

    ;
static void
Usage(void)
{
    fprintf(stderr, "%s: usage: %s\n", thisprog, usage);
    exit(1);
}

static int     op_flags;
#define OPT_MOINS 0x1
#define OPT_s     0x2 
#define OPT_q     0x4 
#define OPT_c     0x8
#define OPT_f     0x10

int main(int argc, char **argv)
{
...
    
    thisprog = argv[0];
    argc--; argv++;

    while (argc > 0 && **argv == '-') {
        (*argv)++;
        if (!(**argv))
            /* Cas du "adb - core" */
            Usage();
        while (**argv)
            switch (*(*argv)++) {
            case 'c':   op_flags |= OPT_c; break;
            case 'f':   op_flags |= OPT_f; break;
            case 's':   op_flags |= OPT_s; if (argc < 2)  Usage();
                skey = *(++argv);
                argc--; 
                goto b1;
            case 'q':   op_flags |= OPT_q; if (argc < 2)  Usage();
                pname = *(++argv);
                argc--; 
                goto b1;
            default: Usage();   break;
            }
    b1: argc--; argv++;
    }

    if (argc != 0)
        Usage();

    string reason;
    RclConfig *config = recollinit(0, 0, reason);
    if (config == 0 || !config->ok()) {
        cerr << "Configuration problem: " << reason << endl;
        exit(1);
    }
    if (op_flags & OPT_s)
        config->setKeyDir(skey);
    if (op_flags & OPT_q) {
        string value;
        if (!config->getConfParam(pname, value)) {
            fprintf(stderr, "getConfParam failed for [%s]\n", pname.c_str());
            exit(1);
        }
        printf("[%s] -> [%s]\n", pname.c_str(), value.c_str());
    } else if (op_flags & OPT_f) {
        set<string> stored = config->getStoredFields();
        set<string> indexed = config->getIndexedFields();
        cout << "Stored fields: ";
        for (set<string>::const_iterator it = stored.begin(); 
             it != stored.end(); it++) {
            cout << "[" << *it << "] ";
        }
        cout << endl;   
        cout << "Indexed fields: ";
        for (set<string>::const_iterator it = indexed.begin(); 
             it != indexed.end(); it++) {
            const FieldTraits *ftp;
            config->getFieldTraits(*it, &ftp);
            if (ftp)
                cout << "[" << *it << "]" << " -> [" << ftp->pfx << "] ";
            else 
                cout << "[" << *it << "]" << " -> [" << "(none)" << "] ";

        }
        cout << endl;   
    } else if (op_flags & OPT_c) {
        // Checking the configuration consistency
    
        // Find and display category names
        vector<string> catnames;
        config->getMimeCategories(catnames);
        cout << "Categories: ";
        for (vector<string>::const_iterator it = catnames.begin(); 
             it != catnames.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;

        // Compute union of all types from each category. Check that there
        // are no duplicates while we are at it.
        set<string> allmtsfromcats;
        for (vector<string>::const_iterator it = catnames.begin(); 
             it != catnames.end(); it++) {
            vector<string> cts;
            config->getMimeCatTypes(*it, cts);
...
                }
                allmtsfromcats.insert(*it1);
            }
        }

        // Retrieve complete list of mime types 
        vector<string> mtypes = config->getAllMimeTypes();

        // And check that each mime type is found in exactly one category
        for (vector<string>::const_iterator it = mtypes.begin();
             it != mtypes.end(); it++) {
            if (allmtsfromcats.find(*it) == allmtsfromcats.end()) {
                cout << "Not found in catgs: [" << *it << "]" << endl;
            }
        }

        // List mime types not in mimeview
        for (vector<string>::const_iterator it = mtypes.begin();
             it != mtypes.end(); it++) {
            if (config->getMimeViewerDef(*it, "", false).empty()) {
                cout << "No viewer: [" << *it << "]" << endl;

            }
        }

        // Check that each mime type has an indexer
        for (vector<string>::const_iterator it = mtypes.begin();
             it != mtypes.end(); it++) {
            if (config->getMimeHandlerDef(*it, false).empty()) {
                cout << "No filter: [" << *it << "]" << endl;

            }
        }

        // Check that each mime type has a defined icon
        for (vector<string>::const_iterator it = mtypes.begin();
             it != mtypes.end(); it++) {
            if (config->getMimeIconPath(*it, "") == "document") {
                cout << "No or generic icon: [" << *it << "]" << endl;
            }
        }

    } else {
        config->setKeyDir(cstr_null);
        vector<string> names = config->getConfNames();
        for (vector<string>::iterator it = names.begin(); 
             it != names.end();it++) {
            string value;
            config->getConfParam(*it, value);
            cout << *it << " -> [" << value << "]" << endl;
        }
    }
    exit(0);
}

#endif // TEST_RCLCONFIG

	a/src/common/rclconfig.cpp		b/src/common/rclconfig.cpp
	...		...
204	m_mdrstate(this, "metadatacmds")	204	m_mdrstate(this, "metadatacmds")
205	{	205	{
206	zeroMe();	206	zeroMe();
207		207
208	if (o_origcwd.empty()) {	208	if (o_origcwd.empty()) {
209	char buf[MAXPATHLEN];	209	char buf[MAXPATHLEN];
210	if (getcwd(buf, MAXPATHLEN)) {	210	if (getcwd(buf, MAXPATHLEN)) {
211	o_origcwd = string(buf);	211	o_origcwd = string(buf);
212	} else {	212	} else {
213	fprintf(stderr, "recollxx: can't retrieve current working "	213	fprintf(stderr, "recollxx: can't retrieve current working "
214	"directory: relative path translations will fail\n");	214	"directory: relative path translations will fail\n");
215	}	215	}
216	}	216	}
217		217
218	// Compute our data dir name, typically /usr/local/share/recoll	218	// Compute our data dir name, typically /usr/local/share/recoll
219	m_datadir = path_pkgdatadir();	219	m_datadir = path_pkgdatadir();
220	// We only do the automatic configuration creation thing for the default	220	// We only do the automatic configuration creation thing for the default
221	// config dir, not if it was specified through -c or RECOLL_CONFDIR	221	// config dir, not if it was specified through -c or RECOLL_CONFDIR
222	bool autoconfdir = false;	222	bool autoconfdir = false;
223		223
224	// Command line config name overrides environment	224	// Command line config name overrides environment
225	if (argcnf && !argcnf->empty()) {	225	if (argcnf && !argcnf->empty()) {
226	m_confdir = path_absolute(*argcnf);	226	m_confdir = path_absolute(*argcnf);
227	if (m_confdir.empty()) {	227	if (m_confdir.empty()) {
228	m_reason =	228	m_reason =
229	string("Cant turn [") + *argcnf + "] into absolute path";	229	string("Cant turn [") + *argcnf + "] into absolute path";
230	return;	230	return;
231	}	231	}
232	} else {	232	} else {
233	const char *cp = getenv("RECOLL_CONFDIR");	233	const char *cp = getenv("RECOLL_CONFDIR");
234	if (cp) {	234	if (cp) {
235	m_confdir = path_canon(cp);	235	m_confdir = path_canon(cp);
236	} else {	236	} else {
237	autoconfdir = true;	237	autoconfdir = true;
238	m_confdir=path_cat(path_homedata(), path_defaultrecollconfsubdir());	238	m_confdir=path_cat(path_homedata(), path_defaultrecollconfsubdir());
239	}	239	}
240	}	240	}
241		241
242	// Note: autoconfdir and isDefaultConfig() are normally the same. We just	242	// Note: autoconfdir and isDefaultConfig() are normally the same. We just
243	// want to avoid the imperfect test in isDefaultConfig() if we actually know	243	// want to avoid the imperfect test in isDefaultConfig() if we actually know
244	// this is the default conf	244	// this is the default conf
245	if (!autoconfdir && !isDefaultConfig()) {	245	if (!autoconfdir && !isDefaultConfig()) {
246	if (!path_exists(m_confdir)) {	246	if (!path_exists(m_confdir)) {
247	m_reason = "Explicitly specified configuration "	247	m_reason = "Explicitly specified configuration "
248	"directory must exist"	248	"directory must exist"
249	" (won't be automatically created). Use mkdir first";	249	" (won't be automatically created). Use mkdir first";
250	return;	250	return;
251	}	251	}
252	}	252	}
253		253
254	if (!path_exists(m_confdir)) {	254	if (!path_exists(m_confdir)) {
255	if (!initUserConfig())	255	if (!initUserConfig())
256	return;	256	return;
257	}	257	}
258		258
259	// This can't change once computed inside a process. It would be	259	// This can't change once computed inside a process. It would be
260	// nicer to move this to a static class initializer to avoid	260	// nicer to move this to a static class initializer to avoid
261	// possible threading issues but this doesn't work (tried) as	261	// possible threading issues but this doesn't work (tried) as
262	// things would not be ready. In practise we make sure that this	262	// things would not be ready. In practise we make sure that this
263	// is called from the main thread at once, by constructing a config	263	// is called from the main thread at once, by constructing a config
264	// from recollinit	264	// from recollinit
265	if (o_localecharset.empty()) {	265	if (o_localecharset.empty()) {
266	#ifndef _WIN32	266	#ifndef _WIN32
267	const char *cp;	267	const char *cp;
268	cp = nl_langinfo(CODESET);	268	cp = nl_langinfo(CODESET);
269	// We don't keep US-ASCII. It's better to use a superset	269	// We don't keep US-ASCII. It's better to use a superset
270	// Ie: me have a C locale and some french file names, and I	270	// Ie: me have a C locale and some french file names, and I
271	// can't imagine a version of iconv that couldn't translate	271	// can't imagine a version of iconv that couldn't translate
272	// from iso8859?	272	// from iso8859?
273	// The 646 thing is for solaris.	273	// The 646 thing is for solaris.
274	if (cp && *cp && strcmp(cp, "US-ASCII")	274	if (cp && *cp && strcmp(cp, "US-ASCII")
275	#ifdef sun	275	#ifdef sun
276	&& strcmp(cp, "646")	276	&& strcmp(cp, "646")
277	#endif	277	#endif
278	) {	278	) {
279	o_localecharset = string(cp);	279	o_localecharset = string(cp);
280	} else {	280	} else {
281	// Use cp1252 instead of iso-8859-1, it's a superset.	281	// Use cp1252 instead of iso-8859-1, it's a superset.
282	o_localecharset = string(cstr_cp1252);	282	o_localecharset = string(cstr_cp1252);
283	}	283	}
284	#else	284	#else
285	o_localecharset = winACPName();	285	o_localecharset = winACPName();
286	#endif	286	#endif
287	LOGDEB1("RclConfig::getDefCharset: localecharset [" <<	287	LOGDEB1("RclConfig::getDefCharset: localecharset [" <<
288	o_localecharset << "]\n");	288	o_localecharset << "]\n");
289	}	289	}
290		290
291	const char *cp;	291	const char *cp;
292		292
293	// Additional config directory, values override user ones	293	// Additional config directory, values override user ones
294	if ((cp = getenv("RECOLL_CONFTOP"))) {	294	if ((cp = getenv("RECOLL_CONFTOP"))) {
295	m_cdirs.push_back(cp);	295	m_cdirs.push_back(cp);
296	}	296	}
297		297
298	// User config	298	// User config
299	m_cdirs.push_back(m_confdir);	299	m_cdirs.push_back(m_confdir);
300		300
301	// Additional config directory, overrides system's, overridden by user's	301	// Additional config directory, overrides system's, overridden by user's
302	if ((cp = getenv("RECOLL_CONFMID"))) {	302	if ((cp = getenv("RECOLL_CONFMID"))) {
303	m_cdirs.push_back(cp);	303	m_cdirs.push_back(cp);
304	}	304	}
305		305
306	// Base/installation config	306	// Base/installation config
307	m_cdirs.push_back(path_cat(m_datadir, "examples"));	307	m_cdirs.push_back(path_cat(m_datadir, "examples"));
308		308
309	string cnferrloc;	309	string cnferrloc;
310	for (vector<string>::const_iterator it = m_cdirs.begin();	310	for (vector<string>::const_iterator it = m_cdirs.begin();
311	it != m_cdirs.end(); it++) {	311	it != m_cdirs.end(); it++) {
312	if (it != m_cdirs.begin())	312	if (it != m_cdirs.begin())
313	cnferrloc += string(" or ");	313	cnferrloc += string(" or ");
314	cnferrloc += *it;	314	cnferrloc += *it;
315	}	315	}
316		316
317	// Read and process "recoll.conf"	317	// Read and process "recoll.conf"
318	if (!updateMainConfig())	318	if (!updateMainConfig())
319	return;	319	return;
320	// Other files	320	// Other files
321	mimemap = new ConfStack<ConfTree>("mimemap", m_cdirs, true);	321	mimemap = new ConfStack<ConfTree>("mimemap", m_cdirs, true);
322	if (mimemap == 0 \|\| !mimemap->ok()) {	322	if (mimemap == 0 \|\| !mimemap->ok()) {
323	m_reason = string("No or bad mimemap file in: ") + cnferrloc;	323	m_reason = string("No or bad mimemap file in: ") + cnferrloc;
324	return;	324	return;
325	}	325	}
326		326
327	// Maybe create the MIME to suffix association reverse map. Do it	327	// Maybe create the MIME to suffix association reverse map. Do it
328	// in file order so that we can control what suffix is used when	328	// in file order so that we can control what suffix is used when
329	// there are several. This only uses the distributed file, not any	329	// there are several. This only uses the distributed file, not any
	...		...
344	}	344	}
345	}	345	}
346		346
347	mimeconf = new ConfStack<ConfSimple>("mimeconf", m_cdirs, true);	347	mimeconf = new ConfStack<ConfSimple>("mimeconf", m_cdirs, true);
348	if (mimeconf == 0 \|\| !mimeconf->ok()) {	348	if (mimeconf == 0 \|\| !mimeconf->ok()) {
349	m_reason = string("No/bad mimeconf in: ") + cnferrloc;	349	m_reason = string("No/bad mimeconf in: ") + cnferrloc;
350	return;	350	return;
351	}	351	}
352	mimeview = new ConfStack<ConfSimple>("mimeview", m_cdirs, false);	352	mimeview = new ConfStack<ConfSimple>("mimeview", m_cdirs, false);
353	if (mimeview == 0)	353	if (mimeview == 0)
354	mimeview = new ConfStack<ConfSimple>("mimeview", m_cdirs, true);	354	mimeview = new ConfStack<ConfSimple>("mimeview", m_cdirs, true);
355	if (mimeview == 0 \|\| !mimeview->ok()) {	355	if (mimeview == 0 \|\| !mimeview->ok()) {
356	m_reason = string("No/bad mimeview in: ") + cnferrloc;	356	m_reason = string("No/bad mimeview in: ") + cnferrloc;
357	return;	357	return;
358	}	358	}
359	if (!readFieldsConfig(cnferrloc))	359	if (!readFieldsConfig(cnferrloc))
360	return;	360	return;
361		361
362	// Default is no threading	362	// Default is no threading
363	m_thrConf = {{-1, 0}, {-1, 0}, {-1, 0}};	363	m_thrConf = {{-1, 0}, {-1, 0}, {-1, 0}};
364		364
365	m_ptrans = new ConfSimple(path_cat(m_confdir, "ptrans").c_str());	365	m_ptrans = new ConfSimple(path_cat(m_confdir, "ptrans").c_str());
	...		...
373	}	373	}
374		374
375	bool RclConfig::updateMainConfig()	375	bool RclConfig::updateMainConfig()
376	{	376	{
377	ConfStack<ConfTree> *newconf =	377	ConfStack<ConfTree> *newconf =
378	new ConfStack<ConfTree>("recoll.conf", m_cdirs, true);	378	new ConfStack<ConfTree>("recoll.conf", m_cdirs, true);
379	if (newconf == 0 \|\| !newconf->ok()) {	379	if (newconf == 0 \|\| !newconf->ok()) {
380	if (m_conf)	380	if (m_conf)
381	return false;	381	return false;
382	string where;	382	string where;
383	stringsToString(m_cdirs, where);	383	stringsToString(m_cdirs, where);
384	m_reason = string("No/bad main configuration file in: ") + where;	384	m_reason = string("No/bad main configuration file in: ") + where;
385	m_ok = false;	385	m_ok = false;
386	initParamStale(0, 0);	386	initParamStale(0, 0);
387	return false;	387	return false;
388	}	388	}
389		389
390	delete m_conf;	390	delete m_conf;
391	m_conf = newconf;	391	m_conf = newconf;
392		392
	...		...
394		394
395	setKeyDir(cstr_null);	395	setKeyDir(cstr_null);
396		396
397	bool bvalue = false;	397	bool bvalue = false;
398	if (getConfParam("nocjk", &bvalue) && bvalue == true) {	398	if (getConfParam("nocjk", &bvalue) && bvalue == true) {
399	TextSplit::cjkProcessing(false);	399	TextSplit::cjkProcessing(false);
400	} else {	400	} else {
401	int ngramlen;	401	int ngramlen;
402	if (getConfParam("cjkngramlen", &ngramlen)) {	402	if (getConfParam("cjkngramlen", &ngramlen)) {
403	TextSplit::cjkProcessing(true, (unsigned int)ngramlen);	403	TextSplit::cjkProcessing(true, (unsigned int)ngramlen);
404	} else {	404	} else {
405	TextSplit::cjkProcessing(true);	405	TextSplit::cjkProcessing(true);
406	}	406	}
407	}	407	}
408		408
409	bvalue = false;	409	bvalue = false;
410	if (getConfParam("nonumbers", &bvalue) && bvalue == true) {	410	if (getConfParam("nonumbers", &bvalue) && bvalue == true) {
411	TextSplit::noNumbers();	411	TextSplit::noNumbers();
412	}	412	}
413		413
414	bvalue = false;	414	bvalue = false;
415	if (getConfParam("dehyphenate", &bvalue)) {	415	if (getConfParam("dehyphenate", &bvalue)) {
416	TextSplit::deHyphenate(bvalue);	416	TextSplit::deHyphenate(bvalue);
417	}	417	}
418		418
419	bvalue = true;	419	bvalue = true;
420	if (getConfParam("skippedPathsFnmPathname", &bvalue) && bvalue == false) {	420	if (getConfParam("skippedPathsFnmPathname", &bvalue) && bvalue == false) {
421	FsTreeWalker::setNoFnmPathname();	421	FsTreeWalker::setNoFnmPathname();
422	}	422	}
423		423
424	static int m_index_stripchars_init = 0;	424	static int m_index_stripchars_init = 0;
425	if (!m_index_stripchars_init) {	425	if (!m_index_stripchars_init) {
426	getConfParam("indexStripChars", &o_index_stripchars);	426	getConfParam("indexStripChars", &o_index_stripchars);
427	getConfParam("indexStoreDocText", &o_index_storedoctext);	427	getConfParam("indexStoreDocText", &o_index_storedoctext);
428	getConfParam("testmodifusemtime", &o_uptodate_test_use_mtime);	428	getConfParam("testmodifusemtime", &o_uptodate_test_use_mtime);
429	m_index_stripchars_init = 1;	429	m_index_stripchars_init = 1;
430	}	430	}
431		431
432	if (getConfParam("cachedir", m_cachedir)) {	432	if (getConfParam("cachedir", m_cachedir)) {
433	m_cachedir = path_canon(path_tildexpand(m_cachedir));	433	m_cachedir = path_canon(path_tildexpand(m_cachedir));
434	}	434	}
	...		...
437		437
438	ConfNull *RclConfig::cloneMainConfig()	438	ConfNull *RclConfig::cloneMainConfig()
439	{	439	{
440	ConfNull *conf = new ConfStack<ConfTree>("recoll.conf", m_cdirs, false);	440	ConfNull *conf = new ConfStack<ConfTree>("recoll.conf", m_cdirs, false);
441	if (conf == 0 \|\| !conf->ok()) {	441	if (conf == 0 \|\| !conf->ok()) {
442	m_reason = string("Can't read config");	442	m_reason = string("Can't read config");
443	return 0;	443	return 0;
444	}	444	}
445	return conf;	445	return conf;
446	}	446	}
447		447
448	// Remember what directory we're under (for further conf->get()s), and	448	// Remember what directory we're under (for further conf->get()s), and
	...		...
453	return;	453	return;
454		454
455	m_keydirgen++;	455	m_keydirgen++;
456	m_keydir = dir;	456	m_keydir = dir;
457	if (m_conf == 0)	457	if (m_conf == 0)
458	return;	458	return;
459		459
460	if (!m_conf->get("defaultcharset", m_defcharset, m_keydir))	460	if (!m_conf->get("defaultcharset", m_defcharset, m_keydir))
461	m_defcharset.erase();	461	m_defcharset.erase();
462	}	462	}
463		463
464	bool RclConfig::getConfParam(const string &name, int *ivp, bool shallow) const	464	bool RclConfig::getConfParam(const string &name, int *ivp, bool shallow) const
465	{	465	{
466	string value;	466	string value;
467	if (!getConfParam(name, value, shallow))	467	if (!getConfParam(name, value, shallow))
468	return false;	468	return false;
469	errno = 0;	469	errno = 0;
470	long lval = strtol(value.c_str(), 0, 0);	470	long lval = strtol(value.c_str(), 0, 0);
471	if (lval == 0 && errno)	471	if (lval == 0 && errno)
472	return 0;	472	return 0;
473	if (ivp)	473	if (ivp)
474	*ivp = int(lval);	474	*ivp = int(lval);
475	return true;	475	return true;
476	}	476	}
477		477
478	bool RclConfig::getConfParam(const string &name, bool *bvp, bool shallow) const	478	bool RclConfig::getConfParam(const string &name, bool *bvp, bool shallow) const
479	{	479	{
480	if (!bvp)	480	if (!bvp)
481	return false;	481	return false;
482		482
483	*bvp = false;	483	*bvp = false;
484	string s;	484	string s;
485	if (!getConfParam(name, s, shallow))	485	if (!getConfParam(name, s, shallow))
486	return false;	486	return false;
487	*bvp = stringToBool(s);	487	*bvp = stringToBool(s);
488	return true;	488	return true;
489	}	489	}
490		490
491	bool RclConfig::getConfParam(const string &name, vector<string> *svvp,	491	bool RclConfig::getConfParam(const string &name, vector<string> *svvp,
492	bool shallow) const	492	bool shallow) const
493	{	493	{
494	if (!svvp)	494	if (!svvp)
495	return false;	495	return false;
496	svvp->clear();	496	svvp->clear();
497	string s;	497	string s;
498	if (!getConfParam(name, s, shallow))	498	if (!getConfParam(name, s, shallow))
499	return false;	499	return false;
500	return stringToStrings(s, *svvp);	500	return stringToStrings(s, *svvp);
501	}	501	}
502		502
503	bool RclConfig::getConfParam(const string &name, unordered_set<string> *out,	503	bool RclConfig::getConfParam(const string &name, unordered_set<string> *out,
504	bool shallow) const	504	bool shallow) const
505	{	505	{
506	vector<string> v;	506	vector<string> v;
507	if (!out \|\| !getConfParam(name, &v, shallow)) {	507	if (!out \|\| !getConfParam(name, &v, shallow)) {
508	return false;	508	return false;
509	}	509	}
510	out->clear();	510	out->clear();
511	out->insert(v.begin(), v.end());	511	out->insert(v.begin(), v.end());
512	return true;	512	return true;
513	}	513	}
514		514
515	bool RclConfig::getConfParam(const string &name, vector<int> *vip,	515	bool RclConfig::getConfParam(const string &name, vector<int> *vip,
516	bool shallow) const	516	bool shallow) const
517	{	517	{
518	if (!vip)	518	if (!vip)
519	return false;	519	return false;
520	vip->clear();	520	vip->clear();
521	vector<string> vs;	521	vector<string> vs;
522	if (!getConfParam(name, &vs, shallow))	522	if (!getConfParam(name, &vs, shallow))
523	return false;	523	return false;
524	vip->reserve(vs.size());	524	vip->reserve(vs.size());
525	for (unsigned int i = 0; i < vs.size(); i++) {	525	for (unsigned int i = 0; i < vs.size(); i++) {
526	char *ep;	526	char *ep;
527	vip->push_back(strtol(vs[i].c_str(), &ep, 0));	527	vip->push_back(strtol(vs[i].c_str(), &ep, 0));
528	if (ep == vs[i].c_str()) {	528	if (ep == vs[i].c_str()) {
529	LOGDEB("RclConfig::getConfParam: bad int value in [" << name <<	529	LOGDEB("RclConfig::getConfParam: bad int value in [" << name <<
530	"]\n");	530	"]\n");
531	return false;	531	return false;
532	}	532	}
533	}	533	}
534	return true;	534	return true;
535	}	535	}
536		536
537	void RclConfig::initThrConf()	537	void RclConfig::initThrConf()
	...		...
540	m_thrConf = {{-1, 0}, {-1, 0}, {-1, 0}};	540	m_thrConf = {{-1, 0}, {-1, 0}, {-1, 0}};
541		541
542	vector<int> vq;	542	vector<int> vq;
543	vector<int> vt;	543	vector<int> vt;
544	if (!getConfParam("thrQSizes", &vq)) {	544	if (!getConfParam("thrQSizes", &vq)) {
545	LOGINFO("RclConfig::initThrConf: no thread info (queues)\n");	545	LOGINFO("RclConfig::initThrConf: no thread info (queues)\n");
546	goto out;	546	goto out;
547	}	547	}
548		548
549	// If the first queue size is 0, autoconf is requested.	549	// If the first queue size is 0, autoconf is requested.
550	if (vq.size() > 0 && vq[0] == 0) {	550	if (vq.size() > 0 && vq[0] == 0) {
551	CpuConf cpus;	551	CpuConf cpus;
552	if (!getCpuConf(cpus) \|\| cpus.ncpus < 1) {	552	if (!getCpuConf(cpus) \|\| cpus.ncpus < 1) {
553	LOGERR("RclConfig::initThrConf: could not retrieve cpu conf\n");	553	LOGERR("RclConfig::initThrConf: could not retrieve cpu conf\n");
554	cpus.ncpus = 1;	554	cpus.ncpus = 1;
555	}	555	}
556	if (cpus.ncpus != 1) {	556	if (cpus.ncpus != 1) {
557	LOGDEB("RclConfig::initThrConf: autoconf requested. " <<	557	LOGDEB("RclConfig::initThrConf: autoconf requested. " <<
558	cpus.ncpus << " concurrent threads available.\n");	558	cpus.ncpus << " concurrent threads available.\n");
559	}	559	}
560		560
561	// Arbitrarily set threads config based on number of CPUS. This also	561	// Arbitrarily set threads config based on number of CPUS. This also
562	// depends on the IO setup actually, so we're bound to be wrong...	562	// depends on the IO setup actually, so we're bound to be wrong...
563	if (cpus.ncpus == 1) {	563	if (cpus.ncpus == 1) {
564	// Somewhat counter-intuitively (because of possible IO//)	564	// Somewhat counter-intuitively (because of possible IO//)
565	// it seems that the best config here is no threading	565	// it seems that the best config here is no threading
566	} else if (cpus.ncpus < 4) {	566	} else if (cpus.ncpus < 4) {
567	// Untested so let's guess...	567	// Untested so let's guess...
568	m_thrConf = {{2, 2}, {2, 2}, {2, 1}};	568	m_thrConf = {{2, 2}, {2, 2}, {2, 1}};
569	} else if (cpus.ncpus < 6) {	569	} else if (cpus.ncpus < 6) {
570	m_thrConf = {{2, 4}, {2, 2}, {2, 1}};	570	m_thrConf = {{2, 4}, {2, 2}, {2, 1}};
571	} else {	571	} else {
572	m_thrConf = {{2, 5}, {2, 3}, {2, 1}};	572	m_thrConf = {{2, 5}, {2, 3}, {2, 1}};
573	}	573	}
574	goto out;	574	goto out;
575	} else if (vq.size() > 0 && vq[0] < 0) {	575	} else if (vq.size() > 0 && vq[0] < 0) {
576	// threads disabled by config	576	// threads disabled by config
577	goto out;	577	goto out;
578	}	578	}
579		579
580	if (!getConfParam("thrTCounts", &vt) ) {	580	if (!getConfParam("thrTCounts", &vt) ) {
581	LOGINFO("RclConfig::initThrConf: no thread info (threads)\n");	581	LOGINFO("RclConfig::initThrConf: no thread info (threads)\n");
582	goto out;	582	goto out;
583	}	583	}
584		584
585	if (vq.size() != 3 \|\| vt.size() != 3) {	585	if (vq.size() != 3 \|\| vt.size() != 3) {
586	LOGINFO("RclConfig::initThrConf: bad thread info vector sizes\n");	586	LOGINFO("RclConfig::initThrConf: bad thread info vector sizes\n");
587	goto out;	587	goto out;
588	}	588	}
589		589
590	// Normal case: record info from config	590	// Normal case: record info from config
591	m_thrConf.clear();	591	m_thrConf.clear();
592	for (unsigned int i = 0; i < 3; i++) {	592	for (unsigned int i = 0; i < 3; i++) {
593	m_thrConf.push_back({vq[i], vt[i]});	593	m_thrConf.push_back({vq[i], vt[i]});
594	}	594	}
595		595
596	out:	596	out:
597	ostringstream sconf;	597	ostringstream sconf;
598	for (unsigned int i = 0; i < 3; i++) {	598	for (unsigned int i = 0; i < 3; i++) {
599	sconf << "(" << m_thrConf[i].first << ", " << m_thrConf[i].second <<	599	sconf << "(" << m_thrConf[i].first << ", " << m_thrConf[i].second <<
600	") ";	600	") ";
601	}	601	}
602		602
603	LOGDEB("RclConfig::initThrConf: chosen config (ql,nt): " << sconf.str() <<	603	LOGDEB("RclConfig::initThrConf: chosen config (ql,nt): " << sconf.str() <<
604	"\n");	604	"\n");
605	}	605	}
606		606
607	pair<int,int> RclConfig::getThrConf(ThrStage who) const	607	pair<int,int> RclConfig::getThrConf(ThrStage who) const
608	{	608	{
609	if (m_thrConf.size() != 3) {	609	if (m_thrConf.size() != 3) {
610	LOGERR("RclConfig::getThrConf: bad data in rclconfig\n");	610	LOGERR("RclConfig::getThrConf: bad data in rclconfig\n");
611	return pair<int,int>(-1,-1);	611	return pair<int,int>(-1,-1);
612	}	612	}
613	return m_thrConf[who];	613	return m_thrConf[who];
614	}	614	}
615		615
616	vector<string> RclConfig::getTopdirs(bool formonitor) const	616	vector<string> RclConfig::getTopdirs(bool formonitor) const
	...		...
622	}	622	}
623	} else {	623	} else {
624	getConfParam("topdirs", &tdl);	624	getConfParam("topdirs", &tdl);
625	}	625	}
626	if (tdl.empty()) {	626	if (tdl.empty()) {
627	LOGERR("RclConfig::getTopdirs: nothing to index: topdirs/monitordirs "	627	LOGERR("RclConfig::getTopdirs: nothing to index: topdirs/monitordirs "
628	" are not set or have a bad list format\n");	628	" are not set or have a bad list format\n");
629	return tdl;	629	return tdl;
630	}	630	}
631		631
632	for (auto& dir : tdl) {	632	for (auto& dir : tdl) {
633	dir = path_canon(path_tildexpand(dir));	633	dir = path_canon(path_tildexpand(dir));
634	}	634	}
635	return tdl;	635	return tdl;
636	}	636	}
637		637
638	const string& RclConfig::getLocaleCharset()	638	const string& RclConfig::getLocaleCharset()
	...		...
650	// For filenames, same thing except that we do not use the config file value	650	// For filenames, same thing except that we do not use the config file value
651	// (only the locale).	651	// (only the locale).
652	const string& RclConfig::getDefCharset(bool filename) const	652	const string& RclConfig::getDefCharset(bool filename) const
653	{	653	{
654	if (filename) {	654	if (filename) {
655	return o_localecharset;	655	return o_localecharset;
656	} else {	656	} else {
657	return m_defcharset.empty() ? o_localecharset : m_defcharset;	657	return m_defcharset.empty() ? o_localecharset : m_defcharset;
658	}	658	}
659	}	659	}
660		660
661	// Get all known document mime values. We get them from the mimeconf	661	// Get all known document mime values. We get them from the mimeconf
662	// 'index' submap.	662	// 'index' submap.
	...		...
676	// comparison with suffix-only sensitivity	676	// comparison with suffix-only sensitivity
677	class SfString {	677	class SfString {
678	public:	678	public:
679	SfString(const string& s) : m_str(s) {}	679	SfString(const string& s) : m_str(s) {}
680	bool operator==(const SfString& s2) {	680	bool operator==(const SfString& s2) {
681	string::const_reverse_iterator r1 = m_str.rbegin(), re1 = m_str.rend(),	681	string::const_reverse_iterator r1 = m_str.rbegin(), re1 = m_str.rend(),
682	r2 = s2.m_str.rbegin(), re2 = s2.m_str.rend();	682	r2 = s2.m_str.rbegin(), re2 = s2.m_str.rend();
683	while (r1 != re1 && r2 != re2) {	683	while (r1 != re1 && r2 != re2) {
684	if (r1 != r2) {	684	if (r1 != r2) {
685	return 0;	685	return 0;
686	}	686	}
687	++r1; ++r2;	687	++r1; ++r2;
688	}	688	}
689	return 1;	689	return 1;
690	}	690	}
691	string m_str;	691	string m_str;
692	};	692	};
693		693
694	class SuffCmp {	694	class SuffCmp {
695	public:	695	public:
696	int operator()(const SfString& s1, const SfString& s2) {	696	int operator()(const SfString& s1, const SfString& s2) {
697	//cout << "Comparing " << s1.m_str << " and " << s2.m_str << endl;	697	//cout << "Comparing " << s1.m_str << " and " << s2.m_str << endl;
698	string::const_reverse_iterator	698	string::const_reverse_iterator
699	r1 = s1.m_str.rbegin(), re1 = s1.m_str.rend(),	699	r1 = s1.m_str.rbegin(), re1 = s1.m_str.rend(),
700	r2 = s2.m_str.rbegin(), re2 = s2.m_str.rend();	700	r2 = s2.m_str.rbegin(), re2 = s2.m_str.rend();
701	while (r1 != re1 && r2 != re2) {	701	while (r1 != re1 && r2 != re2) {
702	if (r1 != r2) {	702	if (r1 != r2) {
703	return r1 < r2 ? 1 : 0;	703	return r1 < r2 ? 1 : 0;
704	}	704	}
705	++r1; ++r2;	705	++r1; ++r2;
706	}	706	}
707	return 0;	707	return 0;
708	}	708	}
709	};	709	};
710		710
711	typedef multiset<SfString, SuffCmp> SuffixStore;	711	typedef multiset<SfString, SuffCmp> SuffixStore;
712	#define STOPSUFFIXES ((SuffixStore *)m_stopsuffixes)	712	#define STOPSUFFIXES ((SuffixStore *)m_stopsuffixes)
	...		...
761	string fn(fni, pos);	761	string fn(fni, pos);
762		762
763	stringtolower(fn);	763	stringtolower(fn);
764	SuffixStore::const_iterator it = STOPSUFFIXES->find(fn);	764	SuffixStore::const_iterator it = STOPSUFFIXES->find(fn);
765	if (it != STOPSUFFIXES->end()) {	765	if (it != STOPSUFFIXES->end()) {
766	LOGDEB2("RclConfig::inStopSuffixes: Found (" << fni << ") [" <<	766	LOGDEB2("RclConfig::inStopSuffixes: Found (" << fni << ") [" <<
767	((*it).m_str) << "]\n");	767	((*it).m_str) << "]\n");
768	return true;	768	return true;
769	} else {	769	} else {
770	LOGDEB2("RclConfig::inStopSuffixes: not found [" << fni << "]\n");	770	LOGDEB2("RclConfig::inStopSuffixes: not found [" << fni << "]\n");
771	return false;	771	return false;
772	}	772	}
773	}	773	}
774		774
775	string RclConfig::getMimeTypeFromSuffix(const string& suff) const	775	string RclConfig::getMimeTypeFromSuffix(const string& suff) const
776	{	776	{
	...		...
790	// Try again from local data. The map is in the wrong direction,	790	// Try again from local data. The map is in the wrong direction,
791	// have to walk it.	791	// have to walk it.
792	vector<string> sfs = mimemap->getNames(cstr_null);	792	vector<string> sfs = mimemap->getNames(cstr_null);
793	for (const auto& suff : sfs) {	793	for (const auto& suff : sfs) {
794	string mt1;	794	string mt1;
795	if (mimemap->get(suff, mt1, cstr_null) && !stringicmp(mt, mt1)) {	795	if (mimemap->get(suff, mt1, cstr_null) && !stringicmp(mt, mt1)) {
796	return suff;	796	return suff;
797	}	797	}
798	}	798	}
799	return cstr_null;	799	return cstr_null;
800	}	800	}
801		801
802	/** Get list of file categories from mimeconf */	802	/** Get list of file categories from mimeconf */
803	bool RclConfig::getMimeCategories(vector<string>& cats) const	803	bool RclConfig::getMimeCategories(vector<string>& cats) const
804	{	804	{
805	if (!mimeconf)	805	if (!mimeconf)
806	return false;	806	return false;
807	cats = mimeconf->getNames("categories");	807	cats = mimeconf->getNames("categories");
808	return true;	808	return true;
809	}	809	}
810		810
811	bool RclConfig::isMimeCategory(string& cat) const	811	bool RclConfig::isMimeCategory(string& cat) const