recoll / Code / Diff of /src/utils/conftree.cpp

Diff of /src/utils/conftree.cpp [f5f936] .. [e6428d]

Switch to unified view


/* Copyright (C) 2003 J.F.Dockes
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
...
 */
#include "autoconfig.h"

#ifndef TEST_CONFTREE

#include "conftree.h"

#include <ctype.h>
#include <fnmatch.h>
#include "safesysstat.h"

#include <algorithm>
#include <cstring>
#include <fstream>
#include <iostream>
#include <sstream>
#include <utility>






#include "pathut.h"
#include "smallut.h"

using namespace std;

#undef DEBUG
#ifdef DEBUG
#define LOGDEB(X) fprintf X
#else
#define LOGDEB(X)
#endif

void ConfSimple::parseinput(istream& input)
{
    string submapkey;
    string cline;
    bool appending = false;
    string line;
    bool eof = false;

    for (;;) {
        cline.clear();
        std::getline(input, cline);
        LOGDEB((stderr, "Parse:line: [%s] status %d\n",
                cline.c_str(), int(status)));
        if (!input.good()) {
            if (input.bad()) {
                LOGDEB((stderr, "Parse: input.bad()\n"));
                status = STATUS_ERROR;
                return;
            }
            LOGDEB((stderr, "Parse: eof\n"));
            // Must be eof ? But maybe we have a partial line which
            // must be processed. This happens if the last line before
            // eof ends with a backslash, or there is no final \n
            eof = true;
        }

        {
            string::size_type pos = cline.find_last_not_of("\n\r");
            if (pos == string::npos) {
                cline.clear();
            } else if (pos != cline.length() - 1) {
                cline.erase(pos + 1);

            }
        }

        if (appending) {
            line += cline;
        } else {
            line = cline;
        }

        // Note that we trim whitespace before checking for backslash-eol
        // This avoids invisible whitespace problems.
        trimstring(line);
        if (line.empty() || line.at(0) == '#') {
            if (eof) {
                break;
            }
            m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
            continue;
        }
        if (line[line.length() - 1] == '\\') {
            line.erase(line.length() - 1);
            appending = true;
            continue;
        }
        appending = false;

        if (line[0] == '[') {
            trimstring(line, "[]");
            if (dotildexpand) {
                submapkey = path_tildexpand(line);
            } else {
                submapkey = line;
            }
            m_subkeys_unsorted.push_back(submapkey);

            // No need for adding sk to order, will be done with first
            // variable insert. Also means that empty section are
            // expandable (won't be output when rewriting)
            // Another option would be to add the subsec to m_order here
            // and not do it inside i_set() if init is true
            continue;
        }

        // Look for first equal sign
        string::size_type eqpos = line.find("=");
        if (eqpos == string::npos) {
            m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
            continue;
        }

        // Compute name and value, trim white space
        string nm, val;
        nm = line.substr(0, eqpos);
        trimstring(nm);
        val = line.substr(eqpos + 1, string::npos);
        trimstring(val);

        if (nm.length() == 0) {
            m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
            continue;
        }
        i_set(nm, val, submapkey, true);
        if (eof) {
            break;
        }
    }
}


ConfSimple::ConfSimple(int readonly, bool tildexp)
...
{
    status = readonly ? STATUS_RO : STATUS_RW;

    ifstream input;
    if (readonly) {
        input.open(fname, ios::in);
    } else {
        ios::openmode mode = ios::in | ios::out;
        // It seems that there is no separate 'create if not exists'
        // open flag. Have to truncate to create, but dont want to do
        // this to an existing file !
        if (!path_exists(fname)) {
            mode |= ios::trunc;
        }
        input.open(fname, mode);





        if (input.is_open()) {
            status = STATUS_RW;
        } else {
            input.clear();
            input.open(fname, ios::in);
            if (input.is_open()) {
                status = STATUS_RO;
            }
        }
    }

    if (!input.is_open()) {
        status = STATUS_ERROR;
        return;
    }

    parseinput(input);
    i_changed(true);
}

ConfSimple::StatusCode ConfSimple::getStatus() const
{
    switch (status) {
    case STATUS_RO:
        return STATUS_RO;
    case STATUS_RW:
        return STATUS_RW;
    default:
        return STATUS_ERROR;
    }
}

bool ConfSimple::sourceChanged() const
{
    if (!m_filename.empty()) {
        struct stat st;
        if (stat(m_filename.c_str(), &st) == 0) {
            if (m_fmtime != st.st_mtime) {
                return true;
            }
        }
    }
    return false;
}

bool ConfSimple::i_changed(bool upd)
{
    if (!m_filename.empty()) {
        struct stat st;
        if (stat(m_filename.c_str(), &st) == 0) {
            if (m_fmtime != st.st_mtime) {
                if (upd) {
                    m_fmtime = st.st_mtime;
                }
                return true;
            }
        }
    }
    return false;
}

int ConfSimple::get(const string& nm, string& value, const string& sk) const
{
    if (!ok()) {
        return 0;
    }

    // Find submap
    map<string, map<string, string> >::const_iterator ss;
    if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
        return 0;
    }

    // Find named value
    map<string, string>::const_iterator s;
    if ((s = ss->second.find(nm)) == ss->second.end()) {
        return 0;
    }
    value = s->second;
    return 1;
}

// Appropriately output a subkey (nm=="") or variable line.
...
// break some other encoding with, e.g. escape sequences? So break at
// whitespace (is this safe with all encodings?).
// Note that the choice of break point does not affect the validity of
// the file data (when read back by conftree), only its ease of
// editing with a normal editor.
static ConfSimple::WalkerCode varprinter(void *f, const string& nm,
        const string& value)
{
    ostream& output = *((ostream *)f);
    if (nm.empty()) {
        output << "\n[" << value << "]\n";
    } else {
        output << nm << " = ";
        if (nm.length() + value.length() < 75) {
            output << value;
        } else {
            string::size_type ll = 0;
            for (string::size_type pos = 0; pos < value.length(); pos++) {
                string::value_type c = value[pos];
                output << c;
                ll++;
                // Break at whitespace if line too long and "a lot" of
                // remaining data
                if (ll > 50 && (value.length() - pos) > 10 &&
                        (c == ' ' || c == '\t')) {
                    ll = 0;
                    output << "\\\n";
                }
            }
        }
        output << "\n";
    }
    return ConfSimple::WALK_CONTINUE;
}

// Set variable and rewrite data
int ConfSimple::set(const std::string& nm, const std::string& value,
                    const string& sk)
{
    if (status  != STATUS_RW) {
        return 0;
    }
    LOGDEB((stderr, "ConfSimple::set [%s]:[%s] -> [%s]\n", sk.c_str(),
            nm.c_str(), value.c_str()));
    if (!i_set(nm, value, sk)) {
        return 0;
    }
    return write();
}

// Internal set variable: no rw checking or file rewriting. If init is
// set, we're doing initial parsing, else we are changing a parsed
// tree (changes the way we update the order data)
int ConfSimple::i_set(const std::string& nm, const std::string& value,
                      const string& sk, bool init)
{
    LOGDEB((stderr, "ConfSimple::i_set: nm[%s] val[%s] key[%s], init %d\n",
            nm.c_str(), value.c_str(), sk.c_str(), init));
    // Values must not have embedded newlines
    if (value.find_first_of("\n\r") != string::npos) {
        LOGDEB((stderr, "ConfSimple::i_set: LF in value\n"));
        return 0;
    }
    bool existing = false;
    map<string, map<string, string> >::iterator ss;
    // Test if submap already exists, else create it, and insert variable:
    if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
        LOGDEB((stderr, "ConfSimple::i_set: new submap\n"));
        map<string, string> submap;
        submap[nm] = value;
        m_submaps[sk] = submap;

        // Maybe add sk entry to m_order data:
        if (!sk.empty()) {
            ConfLine nl(ConfLine::CFL_SK, sk);
            // Append SK entry only if it's not already there (erase
            // does not remove entries from the order data, adn it may
            // be being recreated after deletion)
            if (find(m_order.begin(), m_order.end(), nl) == m_order.end()) {
                m_order.push_back(nl);
            }
        }
    } else {
        // Insert or update variable in existing map.
        map<string, string>::iterator it;
        it = ss->second.find(nm);
        if (it == ss->second.end()) {
            ss->second.insert(pair<string, string>(nm, value));
        } else {
            it->second = value;
            existing = true;
        }
    }

    // If the variable already existed, no need to change the m_order data
    if (existing) {
        LOGDEB((stderr, "ConfSimple::i_set: existing var: no order update\n"));
        return 1;
    }

    // Add the new variable at the end of its submap in the order data.

    if (init) {
        // During the initial construction, just append:
        LOGDEB((stderr, "ConfSimple::i_set: init true: append\n"));
        m_order.push_back(ConfLine(ConfLine::CFL_VAR, nm));
        return 1;
    }

    // Look for the start and end of the subkey zone. Start is either
    // at begin() for a null subkey, or just behind the subkey
    // entry. End is either the next subkey entry, or the end of
    // list. We insert the new entry just before end.
    vector<ConfLine>::iterator start, fin;
    if (sk.empty()) {
        start = m_order.begin();
        LOGDEB((stderr, "ConfSimple::i_set: null sk, start at top of order\n"));
    } else {
        start = find(m_order.begin(), m_order.end(),
                     ConfLine(ConfLine::CFL_SK, sk));
        if (start == m_order.end()) {
            // This is not logically possible. The subkey must
            // exist. We're doomed
            std::cerr << "Logical failure during configuration variable "
                      "insertion" << endl;
            abort();
        }
    }

    fin = m_order.end();
    if (start != m_order.end()) {
        // The null subkey has no entry (maybe it should)
        if (!sk.empty()) {
            start++;
        }
        for (vector<ConfLine>::iterator it = start; it != m_order.end(); it++) {
            if (it->m_kind == ConfLine::CFL_SK) {
                fin = it;
                break;
            }
        }
    }

    // It may happen that the order entry already exists because erase doesnt
    // update m_order
    if (find(start, fin, ConfLine(ConfLine::CFL_VAR, nm)) == fin) {
        m_order.insert(fin, ConfLine(ConfLine::CFL_VAR, nm));
    }
    return 1;
}

int ConfSimple::erase(const string& nm, const string& sk)
{
    if (status  != STATUS_RW) {
        return 0;
    }

    map<string, map<string, string> >::iterator ss;
    if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
        return 0;

    }

    ss->second.erase(nm);
    if (ss->second.empty()) {
        m_submaps.erase(ss);
    }
    return write();
}

int ConfSimple::eraseKey(const string& sk)
{
    vector<string> nms = getNames(sk);
    for (vector<string>::iterator it = nms.begin(); it != nms.end(); it++) {
        erase(*it, sk);
    }
    return write();
}

// Walk the tree, calling user function at each node
ConfSimple::WalkerCode
ConfSimple::sortwalk(WalkerCode(*walker)(void *, const string&, const string&),
                     void *clidata) const
{
    if (!ok()) {
        return WALK_STOP;
    }
    // For all submaps:
    for (map<string, map<string, string> >::const_iterator sit =
                m_submaps.begin();
            sit != m_submaps.end(); sit++) {

        // Possibly emit submap name:
        if (!sit->first.empty() && walker(clidata, string(), sit->first.c_str())
                == WALK_STOP) {
            return WALK_STOP;
        }

        // Walk submap
        const map<string, string>& sm = sit->second;
        for (map<string, string>::const_iterator it = sm.begin(); it != sm.end();
                it++) {
            if (walker(clidata, it->first, it->second) == WALK_STOP) {
                return WALK_STOP;
            }
        }
    }
    return WALK_CONTINUE;
}

// Write to default output. This currently only does something if output is
// a file
bool ConfSimple::write()
{
    if (!ok()) {
        return false;
    }
    if (m_holdWrites) {
        return true;
    }
    if (m_filename.length()) {
        ofstream output(m_filename.c_str(), ios::out | ios::trunc);
        if (!output.is_open()) {
            return 0;
        }
        return write(output);
    } else {
        // No backing store, no writing. Maybe one day we'll need it with
        // some kind of output string. This can't be the original string which
        // is currently readonly.
        //ostringstream output(m_ostring, ios::out | ios::trunc);
        return 1;
    }
}

// Write out the tree in configuration file format:
// This does not check holdWrites, this is done by write(void), which
// lets ie: showall work even when holdWrites is set
bool ConfSimple::write(ostream& out) const
{
    if (!ok()) {
        return false;
    }
    string sk;
    for (vector<ConfLine>::const_iterator it = m_order.begin();
            it != m_order.end(); it++) {
        switch (it->m_kind) {
        case ConfLine::CFL_COMMENT:
            out << it->m_data << endl;
            if (!out.good()) {
                return false;
            }
            break;
        case ConfLine::CFL_SK:
            sk = it->m_data;
            LOGDEB((stderr, "ConfSimple::write: SK [%s]\n", sk.c_str()));
            // Check that the submap still exists, and only output it if it
            // does
            if (m_submaps.find(sk) != m_submaps.end()) {
                out << "[" << it->m_data << "]" << endl;
                if (!out.good()) {
                    return false;
                }
            }
            break;
        case ConfLine::CFL_VAR:
            string nm = it->m_data;
            LOGDEB((stderr, "ConfSimple::write: VAR [%s], sk [%s]\n",
                    nm.c_str(), sk.c_str()));
            // As erase() doesnt update m_order we can find unexisting
            // variables, and must not output anything for them. Have
            // to use a ConfSimple::get() to check here, because
            // ConfTree's could retrieve from an ancestor even if the
            // local var is gone.
            string value;
            if (ConfSimple::get(nm, value, sk)) {
                varprinter(&out, nm, value);
                if (!out.good()) {
                    return false;
                }
                break;
            }
            LOGDEB((stderr, "ConfSimple::write: no value: nm[%s] sk[%s]\n",
                    nm.c_str(), sk.c_str()));
            break;
        }
    }
    return true;
}

void ConfSimple::showall() const
{
    if (!ok()) {
        return;
    }
    write(std::cout);
}

vector<string> ConfSimple::getNames(const string& sk, const char *pattern) const
{
    vector<string> mylist;
    if (!ok()) {
        return mylist;
    }
    map<string, map<string, string> >::const_iterator ss;
    if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
        return mylist;
    }
    mylist.reserve(ss->second.size());
    map<string, string>::const_iterator it;
    for (it = ss->second.begin(); it != ss->second.end(); it++) {
        if (pattern && 0 != fnmatch(pattern, it->first.c_str(), 0)) {
            continue;
        }
        mylist.push_back(it->first);
    }
    return mylist;
}

vector<string> ConfSimple::getSubKeys() const
{
    vector<string> mylist;
    if (!ok()) {
        return mylist;
    }
    mylist.reserve(m_submaps.size());
    map<string, map<string, string> >::const_iterator ss;
    for (ss = m_submaps.begin(); ss != m_submaps.end(); ss++) {
        mylist.push_back(ss->first);
    }
    return mylist;
}

bool ConfSimple::hasNameAnywhere(const string& nm) const
{
    vector<string>keys = getSubKeys();
    for (vector<string>::const_iterator it = keys.begin();
            it != keys.end(); it++) {
        string val;
        if (get(nm, val, *it)) {
            return true;
        }
    }
    return false;
}

// //////////////////////////////////////////////////////////////////////////
// ConfTree Methods: conftree interpret keys like a hierarchical file tree
// //////////////////////////////////////////////////////////////////////////

int ConfTree::get(const std::string& name, string& value, const string& sk)
const
{
    if (sk.empty() || !path_isabsolute(sk)) {
        // LOGDEB((stderr, "ConfTree::get: looking in global space for [%s]\n",
        // sk.c_str()));
        return ConfSimple::get(name, value, sk);
    }

    // Get writable copy of subkey path
    string msk = sk;

...
    // the input sk
    path_catslash(msk);

    // Look in subkey and up its parents until root ('')
    for (;;) {
        // LOGDEB((stderr,"ConfTree::get: looking for '%s' in '%s'\n",
        // name.c_str(), msk.c_str()));
        if (ConfSimple::get(name, value, msk)) {
            return 1;
        }
        string::size_type pos = msk.rfind("/");
        if (pos != string::npos) {
            msk.replace(pos, string::npos, string());
        } else {
#ifdef _WIN32
            if (msk.size() == 2 && isalpha(msk[0]) && msk[1] == ':') {
                msk.clear();
            } else
#endif
                break;
        }
    }
    return 0;
}

...
static char *thisprog;

bool complex_updates(const string& fn)
{
    int fd;
    if ((fd = open(fn.c_str(), O_RDWR | O_TRUNC | O_CREAT, 0666)) < 0) {
        perror("open/create");
        return false;
    }
    close(fd);

    ConfTree conf(fn.c_str());
    if (!conf.ok()) {
        cerr << "Config init failed" << endl;
        return false;
    }

    conf.set("nm-1", "val-1", "");
    conf.set("nm-2", "val-2", "");

...
    conf.erase("nm-2", "/dir1/dir1");

    string data;
    file_to_string(fn, data, 0);
    const string ref =
        "nm-1 = val-1\n"
        "[/dir1]\n"
        "nm-1 = val1-1\n"
        "nm-2 = val1-2\n"
        ;
    if (data.compare(ref)) {
        cerr << "Final file:" << endl << data << endl << "Differs from ref:" <<
             endl << ref << endl;
        return false;
    } else {
        cout << "Updates test Ok" << endl;
    }
    return true;
}

ConfSimple::WalkerCode mywalker(void *, const string& nm, const string& value)
{
    if (nm.empty()) {
        printf("\n[%s]\n", value.c_str());
    } else {
        printf("'%s' -> '%s'\n", nm.c_str(), value.c_str());
    }
    return ConfSimple::WALK_CONTINUE;
}

const char *longvalue =
    "Donnees012345678901234567890123456789012345678901234567890123456789AA"
    "0123456789012345678901234567890123456789012345678901234567890123456789FIN"
    ;

void memtest(ConfSimple& c)
{
    cout << "Initial:" << endl;
    c.showall();
    if (c.set("nom", "avec nl \n 2eme ligne", "")) {
        fprintf(stderr, "set with embedded nl succeeded !\n");
        exit(1);
    }
    if (!c.set(string("parm1"), string("1"), string("subkey1"))) {
        fprintf(stderr, "Set error");
        exit(1);
    }
    if (!c.set("sparm", "Parametre \"string\" bla", "s2")) {
        fprintf(stderr, "Set error");
        exit(1);
    }
    if (!c.set("long", longvalue, "")) {
        fprintf(stderr, "Set error");
        exit(1);
    }

    cout << "Final:" << endl;
    c.showall();
}

bool readwrite(ConfNull *conf)
{
    if (conf->ok()) {
        // It's ok for the file to not exist here
        string value;

        if (conf->get("mypid", value)) {
            cout << "Value for mypid is [" << value << "]" << endl;
        } else {
            cout << "mypid not set" << endl;
        }

        if (conf->get("unstring", value)) {
            cout << "Value for unstring is [" << value << "]" << endl;
        } else {
            cout << "unstring not set" << endl;
        }
    }
    char spid[100];
    sprintf(spid, "%d", getpid());
    if (!conf->set("mypid", spid)) {
        cerr << "Set mypid failed" << endl;
    }

    ostringstream ost;
    ost << "mypid" << getpid();
    if (!conf->set(ost.str(), spid, "")) {
        cerr << "Set mypid failed (2)" << endl;
    }
    if (!conf->set("unstring", "Une jolie phrase pour essayer")) {
        cerr << "Set unstring failed" << endl;
    }
    return true;
}

bool query(ConfNull *conf, const string& nm, const string& sub)
{
    if (!conf->ok()) {
        cerr <<  "Error opening or parsing file\n" << endl;
        return false;
    }
    string value;
    if (!conf->get(nm, value, sub)) {
        cerr << "name [" << nm << "] not found in [" << sub << "]" << endl;
        return false;
    }
    cout << "[" << sub << "] " << nm << " " << value << endl;
    return true;
}

bool erase(ConfNull *conf, const string& nm, const string& sub)
{
    if (!conf->ok()) {
        cerr <<  "Error opening or parsing file\n" << endl;
        return false;
    }

    if (!conf->erase(nm, sub)) {
        cerr <<  "delete name [" << nm <<  "] in [" << sub << "] failed" << endl;
        return false;
    }
    return true;
}

bool eraseKey(ConfNull *conf, const string& sub)
{
    if (!conf->ok()) {
        cerr <<  "Error opening or parsing file\n" << endl;
        return false;
    }

    if (!conf->eraseKey(sub)) {
        cerr <<  "delete key [" << sub <<  "] failed" << endl;
        return false;
    }
    return true;
}

bool setvar(ConfNull *conf, const string& nm, const string& value,
            const string& sub)
{
    if (!conf->ok()) {
        cerr <<  "Error opening or parsing file\n" << endl;
        return false;
    }
    if (!conf->set(nm, value, sub)) {
        cerr <<  "Set error\n" << endl;
        return false;
    }
    return true;
}

static char usage [] =
...
    "-q nm sect : subsection test: look for nm in 'sect' which can be ''\n"
    "-d nm sect : delete nm in 'sect' which can be ''\n"
    "-E sect : erase key (and all its names)\n"
    "-S : string io test. No filename in this case\n"
    "-V : volatile config test. No filename in this case\n"
    "-U : complex update test. Will erase the named file parameter\n"
    ;

void Usage()
{
    fprintf(stderr, "%s:%s\n", thisprog, usage);
    exit(1);
}
static int     op_flags;
#define OPT_MOINS 0x1
#define OPT_w     0x2
#define OPT_q     0x4
#define OPT_s     0x8
#define OPT_S     0x10
#define OPT_d     0x20
#define OPT_V     0x40
...
    const char *nm = 0;
    const char *sub = 0;
    const char *value = 0;

    thisprog = argv[0];
    argc--;
    argv++;

    while (argc > 0 && **argv == '-') {
        (*argv)++;
        if (!(**argv))
            /* Cas du "adb - core" */
        {
            Usage();
        }
        while (**argv)
            switch (*(*argv)++) {
            case 'a':
                op_flags |= OPT_a;
                if (argc < 4) {
                    Usage();
                }
                nm = *(++argv);
                argc--;
                value = *(++argv);
                argc--;
                sub = *(++argv);
                argc--;
                goto b1;
            case 'd':
                op_flags |= OPT_d;
                if (argc < 3) {
                    Usage();
                }
                nm = *(++argv);
                argc--;
                sub = *(++argv);
                argc--;
                goto b1;
            case 'E':
                op_flags |= OPT_E;
                if (argc < 2) {
                    Usage();
                }
                sub = *(++argv);
                argc--;
                goto b1;
            case 'k':
                op_flags |= OPT_k;
                break;
            case 'q':
                op_flags |= OPT_q;
                if (argc < 3) {
                    Usage();
                }
                nm = *(++argv);
                argc--;
                sub = *(++argv);
                argc--;
                goto b1;
            case 's':
                op_flags |= OPT_s;
                break;
            case 'S':
                op_flags |= OPT_S;
                break;
            case 'V':
                op_flags |= OPT_V;
                break;
            case 'U':
                op_flags |= OPT_U;
                break;
            case 'w':
                op_flags |= OPT_w;
                break;

            default:
                Usage();
                break;
            }
b1:
        argc--;
        argv++;
    }

    if ((op_flags & OPT_S)) {
        // String storage test
        if (argc != 0) {
            Usage();
        }
        string s;
        ConfSimple c(s);
        memtest(c);
        exit(0);
    } else if ((op_flags & OPT_V)) {
        // No storage test
        if (argc != 0) {
            Usage();
        }
        ConfSimple c;
        memtest(c);
        exit(0);
    }

    // Other tests use file(s) as backing store
    if (argc < 1) {
        Usage();
    }

    if (op_flags & OPT_U) {
        exit(!complex_updates(argv[0]));
    }
    vector<string> flist;
    while (argc--) {
        flist.push_back(*argv++);
    }
    bool ro = !(op_flags & (OPT_w | OPT_a | OPT_d | OPT_E));
    ConfNull *conf = 0;
    switch (flist.size()) {
    case 0:
        Usage();
        break;
    case 1:
        conf = new ConfTree(flist.front().c_str(), ro);
        break;
    default:
        conf = new ConfStack<ConfTree>(flist, ro);
        break;
    }

    if (op_flags & OPT_w) {
        exit(!readwrite(conf));
    } else if (op_flags & OPT_q) {
        exit(!query(conf, nm, sub));
    } else if (op_flags & OPT_k) {
        if (!conf->ok()) {
            cerr << "conf init error" << endl;
            exit(1);
        }
        vector<string>lst = conf->getSubKeys();
        for (vector<string>::const_iterator it = lst.begin();
                it != lst.end(); it++) {
            cout << *it << endl;
        }
        exit(0);
    } else if (op_flags & OPT_a) {
        exit(!setvar(conf, nm, value, sub));
    } else if (op_flags & OPT_d) {
        exit(!erase(conf, nm, sub));
    } else if (op_flags & OPT_E) {
        exit(!eraseKey(conf, sub));
    } else if (op_flags & OPT_s) {
        if (!conf->ok()) {
            cerr << "Cant open /parse conf file " << endl;
            exit(1);
        }

        string source;
        if (!conf->get(string("strings"), source, "")) {
            cerr << "Cant get param 'strings'" << endl;
            exit(1);
        }
        cout << "source: [" << source << "]" << endl;
        vector<string> strings;
        if (!stringToStrings(source, strings)) {
            cerr << "parse failed" << endl;
            exit(1);
        }

        for (vector<string>::iterator it = strings.begin();
                it != strings.end(); it++) {
            cout << "[" << *it << "]" << endl;
        }

    } else {
        if (!conf->ok()) {
            fprintf(stderr, "Open failed\n");
            exit(1);
        }
        printf("LIST\n");
        conf->showall();
        //printf("WALK\n");conf->sortwalk(mywalker, 0);
        printf("\nNAMES in global space:\n");
        vector<string> names = conf->getNames("");
        for (vector<string>::iterator it = names.begin();
                it != names.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
        printf("\nNAMES in global space matching t* \n");
        names = conf->getNames("", "t*");
        for (vector<string>::iterator it = names.begin();
                it != names.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
    }
}

#endif

	a/src/utils/conftree.cpp		b/src/utils/conftree.cpp
1	/* Copyright (C) 2003 J.F.Dockes	1	/* Copyright (C) 2003 J.F.Dockes
2	* This program is free software; you can redistribute it and/or modify	2	* This program is free software; you can redistribute it and/or modify
3	* it under the terms of the GNU General Public License as published by	3	* it under the terms of the GNU General Public License as published by
4	* the Free Software Foundation; either version 2 of the License, or	4	* the Free Software Foundation; either version 2 of the License, or
5	* (at your option) any later version.	5	* (at your option) any later version.
6	*	6	*
	...		...
16	*/	16	*/
17	#include "autoconfig.h"	17	#include "autoconfig.h"
18		18
19	#ifndef TEST_CONFTREE	19	#ifndef TEST_CONFTREE
20		20
		21	#include "conftree.h"
		22
21	#include <ctype.h>	23	#include <ctype.h>
22	#include <fnmatch.h>	24	#include <fnmatch.h>
23	#include "safesysstat.h"	25	#include "safesysstat.h"
24		26
		27	#include <algorithm>
		28	#include <cstring>
25	#include <fstream>	29	#include <fstream>
		30	#include <iostream>
26	#include <sstream>	31	#include <sstream>
27	#include <algorithm>	32	#include <utility>
28	#include <iostream>
29	#include <cstring>
30		33
31	using namespace std;
32
33	#include "conftree.h"
34	#include "pathut.h"	34	#include "pathut.h"
35	#include "smallut.h"	35	#include "smallut.h"
		36
		37	using namespace std;
36		38
37	#undef DEBUG	39	#undef DEBUG
38	#ifdef DEBUG	40	#ifdef DEBUG
39	#define LOGDEB(X) fprintf X	41	#define LOGDEB(X) fprintf X
40	#else	42	#else
41	#define LOGDEB(X)	43	#define LOGDEB(X)
42	#endif	44	#endif
43		45
44	void ConfSimple::parseinput(istream &input)	46	void ConfSimple::parseinput(istream& input)
45	{	47	{
46	string submapkey;	48	string submapkey;
47	string cline;	49	string cline;
48	bool appending = false;	50	bool appending = false;
49	string line;	51	string line;
50	bool eof = false;	52	bool eof = false;
51		53
52	for (;;) {	54	for (;;) {
53	cline.clear();	55	cline.clear();
54	std::getline(input, cline);	56	std::getline(input, cline);
55	LOGDEB((stderr, "Parse:line: [%s] status %d\n",	57	LOGDEB((stderr, "Parse:line: [%s] status %d\n",
56	cline.c_str(), int(status)));	58	cline.c_str(), int(status)));
57	if (!input.good()) {	59	if (!input.good()) {
58	if (input.bad()) {	60	if (input.bad()) {
59	LOGDEB((stderr, "Parse: input.bad()\n"));	61	LOGDEB((stderr, "Parse: input.bad()\n"));
60	status = STATUS_ERROR;	62	status = STATUS_ERROR;
61	return;	63	return;
62	}	64	}
63	LOGDEB((stderr, "Parse: eof\n"));	65	LOGDEB((stderr, "Parse: eof\n"));
64	// Must be eof ? But maybe we have a partial line which	66	// Must be eof ? But maybe we have a partial line which
65	// must be processed. This happens if the last line before	67	// must be processed. This happens if the last line before
66	// eof ends with a backslash, or there is no final \n	68	// eof ends with a backslash, or there is no final \n
67	eof = true;	69	eof = true;
68	}	70	}
69		71
70	{	72	{
71	string::size_type pos = cline.find_last_not_of("\n\r");	73	string::size_type pos = cline.find_last_not_of("\n\r");
72	if (pos == string::npos) {	74	if (pos == string::npos) {
73	cline.clear();	75	cline.clear();
74	} else if (pos != cline.length()-1) {	76	} else if (pos != cline.length() - 1) {
75	cline.erase(pos+1);	77	cline.erase(pos + 1);
76	}
77	}	78	}
		79	}
78		80
79	if (appending)	81	if (appending) {
80	line += cline;	82	line += cline;
81	else	83	} else {
82	line = cline;	84	line = cline;
		85	}
83		86
84	// Note that we trim whitespace before checking for backslash-eol	87	// Note that we trim whitespace before checking for backslash-eol
85	// This avoids invisible whitespace problems.	88	// This avoids invisible whitespace problems.
86	trimstring(line);	89	trimstring(line);
87	if (line.empty() \|\| line.at(0) == '#') {	90	if (line.empty() \|\| line.at(0) == '#') {
88	if (eof)	91	if (eof) {
89	break;	92	break;
		93	}
90	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));	94	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
91	continue;	95	continue;
92	}	96	}
93	if (line[line.length() - 1] == '\\') {	97	if (line[line.length() - 1] == '\\') {
94	line.erase(line.length() - 1);	98	line.erase(line.length() - 1);
95	appending = true;	99	appending = true;
96	continue;	100	continue;
97	}	101	}
98	appending = false;	102	appending = false;
99		103
100	if (line[0] == '[') {	104	if (line[0] == '[') {
101	trimstring(line, "[]");	105	trimstring(line, "[]");
102	if (dotildexpand)	106	if (dotildexpand) {
103	submapkey = path_tildexpand(line);	107	submapkey = path_tildexpand(line);
104	else	108	} else {
105	submapkey = line;	109	submapkey = line;
		110	}
		111	m_subkeys_unsorted.push_back(submapkey);
		112
106	// No need for adding sk to order, will be done with first	113	// No need for adding sk to order, will be done with first
107	// variable insert. Also means that empty section are	114	// variable insert. Also means that empty section are
108	// expandable (won't be output when rewriting)	115	// expandable (won't be output when rewriting)
109	// Another option would be to add the subsec to m_order here	116	// Another option would be to add the subsec to m_order here
110	// and not do it inside i_set() if init is true	117	// and not do it inside i_set() if init is true
111	continue;	118	continue;
112	}	119	}
113		120
114	// Look for first equal sign	121	// Look for first equal sign
115	string::size_type eqpos = line.find("=");	122	string::size_type eqpos = line.find("=");
116	if (eqpos == string::npos) {	123	if (eqpos == string::npos) {
117	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));	124	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
118	continue;	125	continue;
119	}	126	}
120		127
121	// Compute name and value, trim white space	128	// Compute name and value, trim white space
122	string nm, val;	129	string nm, val;
123	nm = line.substr(0, eqpos);	130	nm = line.substr(0, eqpos);
124	trimstring(nm);	131	trimstring(nm);
125	val = line.substr(eqpos+1, string::npos);	132	val = line.substr(eqpos + 1, string::npos);
126	trimstring(val);	133	trimstring(val);
127		134
128	if (nm.length() == 0) {	135	if (nm.length() == 0) {
129	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));	136	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
130	continue;	137	continue;
131	}	138	}
132	i_set(nm, val, submapkey, true);	139	i_set(nm, val, submapkey, true);
133	if (eof)	140	if (eof) {
134	break;	141	break;
		142	}
135	}	143	}
136	}	144	}
137		145
138		146
139	ConfSimple::ConfSimple(int readonly, bool tildexp)	147	ConfSimple::ConfSimple(int readonly, bool tildexp)
	...		...
163	{	171	{
164	status = readonly ? STATUS_RO : STATUS_RW;	172	status = readonly ? STATUS_RO : STATUS_RW;
165		173
166	ifstream input;	174	ifstream input;
167	if (readonly) {	175	if (readonly) {
168	input.open(fname, ios::in);	176	input.open(fname, ios::in);
169	} else {	177	} else {
170	ios::openmode mode = ios::in\|ios::out;	178	ios::openmode mode = ios::in \| ios::out;
171	// It seems that there is no separate 'create if not exists'	179	// It seems that there is no separate 'create if not exists'
172	// open flag. Have to truncate to create, but dont want to do	180	// open flag. Have to truncate to create, but dont want to do
173	// this to an existing file !	181	// this to an existing file !
174	if (!path_exists(fname)) {	182	if (!path_exists(fname)) {
175	mode \|= ios::trunc;	183	mode \|= ios::trunc;
176	}	184	}
177	input.open(fname, mode);	185	input.open(fname, mode);
178	if (input.is_open()) {
179	status = STATUS_RW;
180	} else {
181	input.clear();
182	input.open(fname, ios::in);
183	if (input.is_open()) {	186	if (input.is_open()) {
184	status = STATUS_RO;	187	status = STATUS_RW;
185	}	188	} else {
186	}	189	input.clear();
		190	input.open(fname, ios::in);
		191	if (input.is_open()) {
		192	status = STATUS_RO;
		193	}
		194	}
187	}	195	}
188		196
189	if (!input.is_open()) {	197	if (!input.is_open()) {
190	status = STATUS_ERROR;	198	status = STATUS_ERROR;
191	return;	199	return;
192	}	200	}
193		201
194	parseinput(input);	202	parseinput(input);
195	i_changed(true);	203	i_changed(true);
196	}	204	}
197		205
198	ConfSimple::StatusCode ConfSimple::getStatus() const	206	ConfSimple::StatusCode ConfSimple::getStatus() const
199	{	207	{
200	switch (status) {	208	switch (status) {
201	case STATUS_RO: return STATUS_RO;	209	case STATUS_RO:
202	case STATUS_RW: return STATUS_RW;	210	return STATUS_RO;
		211	case STATUS_RW:
		212	return STATUS_RW;
		213	default:
203	default: return STATUS_ERROR;	214	return STATUS_ERROR;
204	}	215	}
205	}	216	}
206		217
207	bool ConfSimple::sourceChanged() const	218	bool ConfSimple::sourceChanged() const
208	{	219	{
209	if (!m_filename.empty()) {	220	if (!m_filename.empty()) {
210	struct stat st;	221	struct stat st;
211	if (stat(m_filename.c_str(), &st) == 0) {	222	if (stat(m_filename.c_str(), &st) == 0) {
212	if (m_fmtime != st.st_mtime) {	223	if (m_fmtime != st.st_mtime) {
213	return true;	224	return true;
214	}	225	}
215	}	226	}
216	}	227	}
217	return false;	228	return false;
218	}	229	}
219		230
220	bool ConfSimple::i_changed(bool upd)	231	bool ConfSimple::i_changed(bool upd)
221	{	232	{
222	if (!m_filename.empty()) {	233	if (!m_filename.empty()) {
223	struct stat st;	234	struct stat st;
224	if (stat(m_filename.c_str(), &st) == 0) {	235	if (stat(m_filename.c_str(), &st) == 0) {
225	if (m_fmtime != st.st_mtime) {	236	if (m_fmtime != st.st_mtime) {
226	if (upd)	237	if (upd) {
227	m_fmtime = st.st_mtime;	238	m_fmtime = st.st_mtime;
228	return true;	239	}
229	}	240	return true;
230	}	241	}
		242	}
231	}	243	}
232	return false;	244	return false;
233	}	245	}
234		246
235	int ConfSimple::get(const string &nm, string &value, const string &sk) const	247	int ConfSimple::get(const string& nm, string& value, const string& sk) const
236	{	248	{
237	if (!ok())	249	if (!ok()) {
238	return 0;	250	return 0;
		251	}
239		252
240	// Find submap	253	// Find submap
241	map<string, map<string, string> >::const_iterator ss;	254	map<string, map<string, string> >::const_iterator ss;
242	if ((ss = m_submaps.find(sk)) == m_submaps.end())	255	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
243	return 0;	256	return 0;
		257	}
244		258
245	// Find named value	259	// Find named value
246	map<string, string>::const_iterator s;	260	map<string, string>::const_iterator s;
247	if ((s = ss->second.find(nm)) == ss->second.end())	261	if ((s = ss->second.find(nm)) == ss->second.end()) {
248	return 0;	262	return 0;
		263	}
249	value = s->second;	264	value = s->second;
250	return 1;	265	return 1;
251	}	266	}
252		267
253	// Appropriately output a subkey (nm=="") or variable line.	268	// Appropriately output a subkey (nm=="") or variable line.
	...		...
262	// break some other encoding with, e.g. escape sequences? So break at	277	// break some other encoding with, e.g. escape sequences? So break at
263	// whitespace (is this safe with all encodings?).	278	// whitespace (is this safe with all encodings?).
264	// Note that the choice of break point does not affect the validity of	279	// Note that the choice of break point does not affect the validity of
265	// the file data (when read back by conftree), only its ease of	280	// the file data (when read back by conftree), only its ease of
266	// editing with a normal editor.	281	// editing with a normal editor.
267	static ConfSimple::WalkerCode varprinter(void *f, const string &nm,	282	static ConfSimple::WalkerCode varprinter(void *f, const string& nm,
268	const string &value)	283	const string& value)
269	{	284	{
270	ostream& output = ((ostream )f);	285	ostream& output = ((ostream )f);
271	if (nm.empty()) {	286	if (nm.empty()) {
272	output << "\n[" << value << "]\n";	287	output << "\n[" << value << "]\n";
273	} else {	288	} else {
274	output << nm << " = ";	289	output << nm << " = ";
275	if (nm.length() + value.length() < 75) {	290	if (nm.length() + value.length() < 75) {
276	output << value;	291	output << value;
277	} else {	292	} else {
278	string::size_type ll = 0;	293	string::size_type ll = 0;
279	for (string::size_type pos = 0; pos < value.length(); pos++) {	294	for (string::size_type pos = 0; pos < value.length(); pos++) {
280	string::value_type c = value[pos];	295	string::value_type c = value[pos];
281	output << c;	296	output << c;
282	ll++;	297	ll++;
283	// Break at whitespace if line too long and "a lot" of	298	// Break at whitespace if line too long and "a lot" of
284	// remaining data	299	// remaining data
285	if (ll > 50 && (value.length() - pos) > 10 &&	300	if (ll > 50 && (value.length() - pos) > 10 &&
286	(c == ' ' \|\| c == '\t')) {	301	(c == ' ' \|\| c == '\t')) {
287	ll = 0;	302	ll = 0;
288	output << "\\\n";	303	output << "\\\n";
289	}	304	}
290	}	305	}
291	}	306	}
292	output << "\n";	307	output << "\n";
293	}	308	}
294	return ConfSimple::WALK_CONTINUE;	309	return ConfSimple::WALK_CONTINUE;
295	}	310	}
296		311
297	// Set variable and rewrite data	312	// Set variable and rewrite data
298	int ConfSimple::set(const std::string &nm, const std::string &value,	313	int ConfSimple::set(const std::string& nm, const std::string& value,
299	const string &sk)	314	const string& sk)
300	{	315	{
301	if (status != STATUS_RW)	316	if (status != STATUS_RW) {
302	return 0;	317	return 0;
		318	}
303	LOGDEB((stderr, "ConfSimple::set [%s]:[%s] -> [%s]\n", sk.c_str(),	319	LOGDEB((stderr, "ConfSimple::set [%s]:[%s] -> [%s]\n", sk.c_str(),
304	nm.c_str(), value.c_str()));	320	nm.c_str(), value.c_str()));
305	if (!i_set(nm, value, sk))	321	if (!i_set(nm, value, sk)) {
306	return 0;	322	return 0;
		323	}
307	return write();	324	return write();
308	}	325	}
309		326
310	// Internal set variable: no rw checking or file rewriting. If init is	327	// Internal set variable: no rw checking or file rewriting. If init is
311	// set, we're doing initial parsing, else we are changing a parsed	328	// set, we're doing initial parsing, else we are changing a parsed
312	// tree (changes the way we update the order data)	329	// tree (changes the way we update the order data)
313	int ConfSimple::i_set(const std::string &nm, const std::string &value,	330	int ConfSimple::i_set(const std::string& nm, const std::string& value,
314	const string &sk, bool init)	331	const string& sk, bool init)
315	{	332	{
316	LOGDEB((stderr, "ConfSimple::i_set: nm[%s] val[%s] key[%s], init %d\n",	333	LOGDEB((stderr, "ConfSimple::i_set: nm[%s] val[%s] key[%s], init %d\n",
317	nm.c_str(), value.c_str(), sk.c_str(), init));	334	nm.c_str(), value.c_str(), sk.c_str(), init));
318	// Values must not have embedded newlines	335	// Values must not have embedded newlines
319	if (value.find_first_of("\n\r") != string::npos) {	336	if (value.find_first_of("\n\r") != string::npos) {
320	LOGDEB((stderr, "ConfSimple::i_set: LF in value\n"));	337	LOGDEB((stderr, "ConfSimple::i_set: LF in value\n"));
321	return 0;	338	return 0;
322	}	339	}
323	bool existing = false;	340	bool existing = false;
324	map<string, map<string, string> >::iterator ss;	341	map<string, map<string, string> >::iterator ss;
325	// Test if submap already exists, else create it, and insert variable:	342	// Test if submap already exists, else create it, and insert variable:
326	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {	343	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
327	LOGDEB((stderr, "ConfSimple::i_set: new submap\n"));	344	LOGDEB((stderr, "ConfSimple::i_set: new submap\n"));
328	map<string, string> submap;	345	map<string, string> submap;
329	submap[nm] = value;	346	submap[nm] = value;
330	m_submaps[sk] = submap;	347	m_submaps[sk] = submap;
331		348
332	// Maybe add sk entry to m_order data:	349	// Maybe add sk entry to m_order data:
333	if (!sk.empty()) {	350	if (!sk.empty()) {
334	ConfLine nl(ConfLine::CFL_SK, sk);	351	ConfLine nl(ConfLine::CFL_SK, sk);
335	// Append SK entry only if it's not already there (erase	352	// Append SK entry only if it's not already there (erase
336	// does not remove entries from the order data, adn it may	353	// does not remove entries from the order data, adn it may
337	// be being recreated after deletion)	354	// be being recreated after deletion)
338	if (find(m_order.begin(), m_order.end(), nl) == m_order.end()) {	355	if (find(m_order.begin(), m_order.end(), nl) == m_order.end()) {
339	m_order.push_back(nl);	356	m_order.push_back(nl);
340	}	357	}
341	}	358	}
342	} else {	359	} else {
343	// Insert or update variable in existing map.	360	// Insert or update variable in existing map.
344	map<string, string>::iterator it;	361	map<string, string>::iterator it;
345	it = ss->second.find(nm);	362	it = ss->second.find(nm);
346	if (it == ss->second.end()) {	363	if (it == ss->second.end()) {
347	ss->second.insert(pair<string,string>(nm, value));	364	ss->second.insert(pair<string, string>(nm, value));
348	} else {	365	} else {
349	it->second = value;	366	it->second = value;
350	existing = true;	367	existing = true;
351	}	368	}
352	}	369	}
353		370
354	// If the variable already existed, no need to change the m_order data	371	// If the variable already existed, no need to change the m_order data
355	if (existing) {	372	if (existing) {
356	LOGDEB((stderr, "ConfSimple::i_set: existing var: no order update\n"));	373	LOGDEB((stderr, "ConfSimple::i_set: existing var: no order update\n"));
357	return 1;	374	return 1;
358	}	375	}
359		376
360	// Add the new variable at the end of its submap in the order data.	377	// Add the new variable at the end of its submap in the order data.
361		378
362	if (init) {	379	if (init) {
363	// During the initial construction, just append:	380	// During the initial construction, just append:
364	LOGDEB((stderr, "ConfSimple::i_set: init true: append\n"));	381	LOGDEB((stderr, "ConfSimple::i_set: init true: append\n"));
365	m_order.push_back(ConfLine(ConfLine::CFL_VAR, nm));	382	m_order.push_back(ConfLine(ConfLine::CFL_VAR, nm));
366	return 1;	383	return 1;
367	}	384	}
368		385
369	// Look for the start and end of the subkey zone. Start is either	386	// Look for the start and end of the subkey zone. Start is either
370	// at begin() for a null subkey, or just behind the subkey	387	// at begin() for a null subkey, or just behind the subkey
371	// entry. End is either the next subkey entry, or the end of	388	// entry. End is either the next subkey entry, or the end of
372	// list. We insert the new entry just before end.	389	// list. We insert the new entry just before end.
373	vector<ConfLine>::iterator start, fin;	390	vector<ConfLine>::iterator start, fin;
374	if (sk.empty()) {	391	if (sk.empty()) {
375	start = m_order.begin();	392	start = m_order.begin();
376	LOGDEB((stderr,"ConfSimple::i_set: null sk, start at top of order\n"));	393	LOGDEB((stderr, "ConfSimple::i_set: null sk, start at top of order\n"));
377	} else {	394	} else {
378	start = find(m_order.begin(), m_order.end(),	395	start = find(m_order.begin(), m_order.end(),
379	ConfLine(ConfLine::CFL_SK, sk));	396	ConfLine(ConfLine::CFL_SK, sk));
380	if (start == m_order.end()) {	397	if (start == m_order.end()) {
381	// This is not logically possible. The subkey must	398	// This is not logically possible. The subkey must
382	// exist. We're doomed	399	// exist. We're doomed
383	std::cerr << "Logical failure during configuration variable "	400	std::cerr << "Logical failure during configuration variable "
384	"insertion" << endl;	401	"insertion" << endl;
385	abort();	402	abort();
386	}	403	}
387	}	404	}
388		405
389	fin = m_order.end();	406	fin = m_order.end();
390	if (start != m_order.end()) {	407	if (start != m_order.end()) {
391	// The null subkey has no entry (maybe it should)	408	// The null subkey has no entry (maybe it should)
392	if (!sk.empty())	409	if (!sk.empty()) {
393	start++;	410	start++;
		411	}
394	for (vector<ConfLine>::iterator it = start; it != m_order.end(); it++) {	412	for (vector<ConfLine>::iterator it = start; it != m_order.end(); it++) {
395	if (it->m_kind == ConfLine::CFL_SK) {	413	if (it->m_kind == ConfLine::CFL_SK) {
396	fin = it;	414	fin = it;
397	break;	415	break;
398	}	416	}
399	}	417	}
400	}	418	}
401		419
402	// It may happen that the order entry already exists because erase doesnt	420	// It may happen that the order entry already exists because erase doesnt
403	// update m_order	421	// update m_order
404	if (find(start, fin, ConfLine(ConfLine::CFL_VAR, nm)) == fin) {	422	if (find(start, fin, ConfLine(ConfLine::CFL_VAR, nm)) == fin) {
405	m_order.insert(fin, ConfLine(ConfLine::CFL_VAR, nm));	423	m_order.insert(fin, ConfLine(ConfLine::CFL_VAR, nm));
406	}	424	}
407	return 1;	425	return 1;
408	}	426	}
409		427
410	int ConfSimple::erase(const string &nm, const string &sk)	428	int ConfSimple::erase(const string& nm, const string& sk)
411	{	429	{
412	if (status != STATUS_RW)	430	if (status != STATUS_RW) {
413	return 0;	431	return 0;
		432	}
414		433
415	map<string, map<string, string> >::iterator ss;	434	map<string, map<string, string> >::iterator ss;
416	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {	435	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
417	return 0;	436	return 0;
418	}
419		437	}
		438
420	ss->second.erase(nm);	439	ss->second.erase(nm);
421	if (ss->second.empty()) {	440	if (ss->second.empty()) {
422	m_submaps.erase(ss);	441	m_submaps.erase(ss);
423	}	442	}
424	return write();	443	return write();
425	}	444	}
426		445
427	int ConfSimple::eraseKey(const string &sk)	446	int ConfSimple::eraseKey(const string& sk)
428	{	447	{
429	vector<string> nms = getNames(sk);	448	vector<string> nms = getNames(sk);
430	for (vector<string>::iterator it = nms.begin(); it != nms.end(); it++) {	449	for (vector<string>::iterator it = nms.begin(); it != nms.end(); it++) {
431	erase(*it, sk);	450	erase(*it, sk);
432	}	451	}
433	return write();	452	return write();
434	}	453	}
435		454
436	// Walk the tree, calling user function at each node	455	// Walk the tree, calling user function at each node
437	ConfSimple::WalkerCode	456	ConfSimple::WalkerCode
438	ConfSimple::sortwalk(WalkerCode (walker)(void ,const string&,const string&),	457	ConfSimple::sortwalk(WalkerCode(walker)(void , const string&, const string&),
439	void *clidata) const	458	void *clidata) const
440	{	459	{
441	if (!ok())	460	if (!ok()) {
442	return WALK_STOP;	461	return WALK_STOP;
		462	}
443	// For all submaps:	463	// For all submaps:
444	for (map<string, map<string, string> >::const_iterator sit =	464	for (map<string, map<string, string> >::const_iterator sit =
445	m_submaps.begin();	465	m_submaps.begin();
446	sit != m_submaps.end(); sit++) {	466	sit != m_submaps.end(); sit++) {
447		467
448	// Possibly emit submap name:	468	// Possibly emit submap name:
449	if (!sit->first.empty() && walker(clidata, string(), sit->first.c_str())	469	if (!sit->first.empty() && walker(clidata, string(), sit->first.c_str())
450	== WALK_STOP)	470	== WALK_STOP) {
451	return WALK_STOP;	471	return WALK_STOP;
		472	}
452		473
453	// Walk submap	474	// Walk submap
454	const map<string, string> &sm = sit->second;	475	const map<string, string>& sm = sit->second;
455	for (map<string, string>::const_iterator it = sm.begin();it != sm.end();	476	for (map<string, string>::const_iterator it = sm.begin(); it != sm.end();
456	it++) {	477	it++) {
457	if (walker(clidata, it->first, it->second) == WALK_STOP)	478	if (walker(clidata, it->first, it->second) == WALK_STOP) {
458	return WALK_STOP;	479	return WALK_STOP;
459	}	480	}
		481	}
460	}	482	}
461	return WALK_CONTINUE;	483	return WALK_CONTINUE;
462	}	484	}
463		485
464	// Write to default output. This currently only does something if output is	486	// Write to default output. This currently only does something if output is
465	// a file	487	// a file
466	bool ConfSimple::write()	488	bool ConfSimple::write()
467	{	489	{
468	if (!ok())	490	if (!ok()) {
469	return false;	491	return false;
		492	}
470	if (m_holdWrites)	493	if (m_holdWrites) {
471	return true;	494	return true;
		495	}
472	if (m_filename.length()) {	496	if (m_filename.length()) {
473	ofstream output(m_filename.c_str(), ios::out\|ios::trunc);	497	ofstream output(m_filename.c_str(), ios::out \| ios::trunc);
474	if (!output.is_open())	498	if (!output.is_open()) {
475	return 0;	499	return 0;
		500	}
476	return write(output);	501	return write(output);
477	} else {	502	} else {
478	// No backing store, no writing. Maybe one day we'll need it with	503	// No backing store, no writing. Maybe one day we'll need it with
479	// some kind of output string. This can't be the original string which	504	// some kind of output string. This can't be the original string which
480	// is currently readonly.	505	// is currently readonly.
481	//ostringstream output(m_ostring, ios::out \| ios::trunc);	506	//ostringstream output(m_ostring, ios::out \| ios::trunc);
482	return 1;	507	return 1;
483	}	508	}
484	}	509	}
485		510
486	// Write out the tree in configuration file format:	511	// Write out the tree in configuration file format:
487	// This does not check holdWrites, this is done by write(void), which	512	// This does not check holdWrites, this is done by write(void), which
488	// lets ie: showall work even when holdWrites is set	513	// lets ie: showall work even when holdWrites is set
489	bool ConfSimple::write(ostream& out) const	514	bool ConfSimple::write(ostream& out) const
490	{	515	{
491	if (!ok())	516	if (!ok()) {
492	return false;	517	return false;
		518	}
493	string sk;	519	string sk;
494	for (vector<ConfLine>::const_iterator it = m_order.begin();	520	for (vector<ConfLine>::const_iterator it = m_order.begin();
495	it != m_order.end(); it++) {	521	it != m_order.end(); it++) {
496	switch(it->m_kind) {	522	switch (it->m_kind) {
497	case ConfLine::CFL_COMMENT:	523	case ConfLine::CFL_COMMENT:
498	out << it->m_data << endl;	524	out << it->m_data << endl;
499	if (!out.good())	525	if (!out.good()) {