u/joerg-krause / sc2mpd - Code / Diff of /sc2src/conftree.cpp

Diff of /sc2src/conftree.cpp [6baab1] .. [43d250]

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.
 *
...
#define LOGDEB(X) fprintf X
#else
#define LOGDEB(X)
#endif

#ifndef MIN
#define MIN(A,B) ((A) < (B) ? (A) : (B))
#endif

#define LL 2048

...
{
    uid_t uid = getuid();

    struct passwd *entry = getpwuid(uid);
    if (entry == 0) {
        const char *cp = getenv("HOME");
        if (cp) {
            return cp;
        } else {
            return "/";
        }
    }

    string homedir = entry->pw_dir;
    path_catslash(homedir);
    return homedir;
}

void ConfNull::path_catslash(string& s)
{
    if (s.empty() || s[s.length() - 1] != '/') {
        s += '/';
    }
}

string ConfNull::path_cat(const string& s1, const string& s2)
{
    string res = s1;
    path_catslash(res);
    res +=  s2;
    return res;
}

string ConfNull::path_tildexpand(const string& s)
{
    if (s.empty() || s[0] != '~') {
        return s;
    }
    string o = s;
    if (s.length() == 1) {
        o.replace(0, 1, path_home());
    } else if (s[1] == '/') {
        o.replace(0, 2, path_home());
    } else {
        string::size_type pos = s.find('/');
        int l = (pos == string::npos) ? s.length() - 1 : pos - 1;
        struct passwd *entry = getpwnam(s.substr(1, l).c_str());
        if (entry) {
            o.replace(0, l + 1, entry->pw_dir);
        }
    }
    return o;
}
void ConfNull::trimstring(string& s, const char *ws)
{
    string::size_type pos = s.find_first_not_of(ws);
    if (pos == string::npos) {
        s.clear();
        return;
    }
    s.replace(0, pos, string());

    pos = s.find_last_not_of(ws);
    if (pos != string::npos && pos != s.length() - 1) {
        s.replace(pos + 1, string::npos, string());
    }
}

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

    for (;;) {
        cline[0] = 0;
        input.getline(cline, LL - 1);
        LOGDEB((stderr, "Parse:line: [%s] status %d\n", cline, 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;
        }

        {
            int ll = strlen(cline);
            while (ll > 0 && (cline[ll - 1] == '\n' || cline[ll - 1] == '\r')) {
                cline[ll - 1] = 0;
                ll--;
            }
        }

        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;
            }
            // 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 (access(fname, 0) < 0) {
            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.
// Splits long lines
static ConfSimple::WalkerCode varprinter(void *f, const string& nm,
        const string& value)
{
    ostream *output = (ostream *)f;
    if (nm.empty()) {
        *output << "\n[" << value << "]\n";
    } else {
        string value1;
        if (value.length() < 60) {
            value1 = value;
        } else {
            string::size_type pos = 0;
            while (pos < value.length()) {
                string::size_type len = MIN(60, value.length() - pos);
                value1 += value.substr(pos, len);
                pos += len;
                if (pos < value.length()) {
                    value1 += "\\\n";
                }
            }
        }
        *output << nm << " = " << value1 << "\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() || sk[0] != '/') {
        //  LOGDEB((stderr, "ConfTree::get: looking in global space\n"));
        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 {
            break;
        }
    }
    return 0;
}

#else // TEST_CONFTREE
...
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/sc2src/conftree.cpp		b/sc2src/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	*
	...		...
38	#define LOGDEB(X) fprintf X	38	#define LOGDEB(X) fprintf X
39	#else	39	#else
40	#define LOGDEB(X)	40	#define LOGDEB(X)
41	#endif	41	#endif
42		42
43	#ifndef MIN	43	#ifndef MIN
44	#define MIN(A,B) ((A) < (B) ? (A) : (B))	44	#define MIN(A,B) ((A) < (B) ? (A) : (B))
45	#endif	45	#endif
46		46
47	#define LL 2048	47	#define LL 2048
48		48
	...		...
50	{	50	{
51	uid_t uid = getuid();	51	uid_t uid = getuid();
52		52
53	struct passwd *entry = getpwuid(uid);	53	struct passwd *entry = getpwuid(uid);
54	if (entry == 0) {	54	if (entry == 0) {
55	const char *cp = getenv("HOME");	55	const char *cp = getenv("HOME");
56	if (cp)	56	if (cp) {
57	return cp;	57	return cp;
58	else	58	} else {
59	return "/";	59	return "/";
		60	}
60	}	61	}
61		62
62	string homedir = entry->pw_dir;	63	string homedir = entry->pw_dir;
63	path_catslash(homedir);	64	path_catslash(homedir);
64	return homedir;	65	return homedir;
65	}	66	}
66		67
67	void ConfNull::path_catslash(string &s) {	68	void ConfNull::path_catslash(string& s)
		69	{
68	if (s.empty() \|\| s[s.length() - 1] != '/')	70	if (s.empty() \|\| s[s.length() - 1] != '/') {
69	s += '/';	71	s += '/';
		72	}
70	}	73	}
71		74
72	string ConfNull::path_cat(const string &s1, const string &s2) {	75	string ConfNull::path_cat(const string& s1, const string& s2)
		76	{
73	string res = s1;	77	string res = s1;
74	path_catslash(res);	78	path_catslash(res);
75	res += s2;	79	res += s2;
76	return res;	80	return res;
77	}	81	}
78		82
79	string ConfNull::path_tildexpand(const string &s)	83	string ConfNull::path_tildexpand(const string& s)
80	{	84	{
81	if (s.empty() \|\| s[0] != '~')	85	if (s.empty() \|\| s[0] != '~') {
82	return s;	86	return s;
		87	}
83	string o = s;	88	string o = s;
84	if (s.length() == 1) {	89	if (s.length() == 1) {
85	o.replace(0, 1, path_home());	90	o.replace(0, 1, path_home());
86	} else if (s[1] == '/') {	91	} else if (s[1] == '/') {
87	o.replace(0, 2, path_home());	92	o.replace(0, 2, path_home());
88	} else {	93	} else {
89	string::size_type pos = s.find('/');	94	string::size_type pos = s.find('/');
90	int l = (pos == string::npos) ? s.length() - 1 : pos - 1;	95	int l = (pos == string::npos) ? s.length() - 1 : pos - 1;
91	struct passwd *entry = getpwnam(s.substr(1, l).c_str());	96	struct passwd *entry = getpwnam(s.substr(1, l).c_str());
92	if (entry)	97	if (entry) {
93	o.replace(0, l+1, entry->pw_dir);	98	o.replace(0, l + 1, entry->pw_dir);
		99	}
94	}	100	}
95	return o;	101	return o;
96	}	102	}
97	void ConfNull::trimstring(string &s, const char *ws)	103	void ConfNull::trimstring(string& s, const char *ws)
98	{	104	{
99	string::size_type pos = s.find_first_not_of(ws);	105	string::size_type pos = s.find_first_not_of(ws);
100	if (pos == string::npos) {	106	if (pos == string::npos) {
101	s.clear();	107	s.clear();
102	return;	108	return;
103	}	109	}
104	s.replace(0, pos, string());	110	s.replace(0, pos, string());
105		111
106	pos = s.find_last_not_of(ws);	112	pos = s.find_last_not_of(ws);
107	if (pos != string::npos && pos != s.length()-1)	113	if (pos != string::npos && pos != s.length() - 1) {
108	s.replace(pos+1, string::npos, string());	114	s.replace(pos + 1, string::npos, string());
		115	}
109	}	116	}
110		117
111	void ConfSimple::parseinput(istream &input)	118	void ConfSimple::parseinput(istream& input)
112	{	119	{
113	string submapkey;	120	string submapkey;
114	char cline[LL];	121	char cline[LL];
115	bool appending = false;	122	bool appending = false;
116	string line;	123	string line;
117	bool eof = false;	124	bool eof = false;
118		125
119	for (;;) {	126	for (;;) {
120	cline[0] = 0;	127	cline[0] = 0;
121	input.getline(cline, LL-1);	128	input.getline(cline, LL - 1);
122	LOGDEB((stderr, "Parse:line: [%s] status %d\n", cline, int(status)));	129	LOGDEB((stderr, "Parse:line: [%s] status %d\n", cline, int(status)));
123	if (!input.good()) {	130	if (!input.good()) {
124	if (input.bad()) {	131	if (input.bad()) {
125	LOGDEB((stderr, "Parse: input.bad()\n"));	132	LOGDEB((stderr, "Parse: input.bad()\n"));
126	status = STATUS_ERROR;	133	status = STATUS_ERROR;
127	return;	134	return;
128	}	135	}
129	LOGDEB((stderr, "Parse: eof\n"));	136	LOGDEB((stderr, "Parse: eof\n"));
130	// Must be eof ? But maybe we have a partial line which	137	// Must be eof ? But maybe we have a partial line which
131	// must be processed. This happens if the last line before	138	// must be processed. This happens if the last line before
132	// eof ends with a backslash, or there is no final \n	139	// eof ends with a backslash, or there is no final \n
133	eof = true;	140	eof = true;
134	}	141	}
135		142
136	{	143	{
137	int ll = strlen(cline);	144	int ll = strlen(cline);
138	while (ll > 0 && (cline[ll-1] == '\n' \|\| cline[ll-1] == '\r')) {	145	while (ll > 0 && (cline[ll - 1] == '\n' \|\| cline[ll - 1] == '\r')) {
139	cline[ll-1] = 0;	146	cline[ll - 1] = 0;
140	ll--;	147	ll--;
141	}	148	}
142	}	149	}
143		150
144	if (appending)	151	if (appending) {
145	line += cline;	152	line += cline;
146	else	153	} else {
147	line = cline;	154	line = cline;
		155	}
148		156
149	// Note that we trim whitespace before checking for backslash-eol	157	// Note that we trim whitespace before checking for backslash-eol
150	// This avoids invisible whitespace problems.	158	// This avoids invisible whitespace problems.
151	trimstring(line);	159	trimstring(line);
152	if (line.empty() \|\| line.at(0) == '#') {	160	if (line.empty() \|\| line.at(0) == '#') {
153	if (eof)	161	if (eof) {
154	break;	162	break;
		163	}
155	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));	164	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
156	continue;	165	continue;
157	}	166	}
158	if (line[line.length() - 1] == '\\') {	167	if (line[line.length() - 1] == '\\') {
159	line.erase(line.length() - 1);	168	line.erase(line.length() - 1);
160	appending = true;	169	appending = true;
161	continue;	170	continue;
162	}	171	}
163	appending = false;	172	appending = false;
164		173
165	if (line[0] == '[') {	174	if (line[0] == '[') {
166	trimstring(line, "[]");	175	trimstring(line, "[]");
167	if (dotildexpand)	176	if (dotildexpand) {
168	submapkey = path_tildexpand(line);	177	submapkey = path_tildexpand(line);
169	else	178	} else {
170	submapkey = line;	179	submapkey = line;
		180	}
171	// No need for adding sk to order, will be done with first	181	// No need for adding sk to order, will be done with first
172	// variable insert. Also means that empty section are	182	// variable insert. Also means that empty section are
173	// expandable (won't be output when rewriting)	183	// expandable (won't be output when rewriting)
174	// Another option would be to add the subsec to m_order here	184	// Another option would be to add the subsec to m_order here
175	// and not do it inside i_set() if init is true	185	// and not do it inside i_set() if init is true
176	continue;	186	continue;
177	}	187	}
178		188
179	// Look for first equal sign	189	// Look for first equal sign
180	string::size_type eqpos = line.find("=");	190	string::size_type eqpos = line.find("=");
181	if (eqpos == string::npos) {	191	if (eqpos == string::npos) {
182	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));	192	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
183	continue;	193	continue;
184	}	194	}
185		195
186	// Compute name and value, trim white space	196	// Compute name and value, trim white space
187	string nm, val;	197	string nm, val;
188	nm = line.substr(0, eqpos);	198	nm = line.substr(0, eqpos);
189	trimstring(nm);	199	trimstring(nm);
190	val = line.substr(eqpos+1, string::npos);	200	val = line.substr(eqpos + 1, string::npos);
191	trimstring(val);	201	trimstring(val);
192		202
193	if (nm.length() == 0) {	203	if (nm.length() == 0) {
194	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));	204	m_order.push_back(ConfLine(ConfLine::CFL_COMMENT, line));
195	continue;	205	continue;
196	}	206	}
197	i_set(nm, val, submapkey, true);	207	i_set(nm, val, submapkey, true);
198	if (eof)	208	if (eof) {
199	break;	209	break;
		210	}
200	}	211	}
201	}	212	}
202		213
203		214
204	ConfSimple::ConfSimple(int readonly, bool tildexp)	215	ConfSimple::ConfSimple(int readonly, bool tildexp)
	...		...
228	{	239	{
229	status = readonly ? STATUS_RO : STATUS_RW;	240	status = readonly ? STATUS_RO : STATUS_RW;
230		241
231	ifstream input;	242	ifstream input;
232	if (readonly) {	243	if (readonly) {
233	input.open(fname, ios::in);	244	input.open(fname, ios::in);
234	} else {	245	} else {
235	ios::openmode mode = ios::in\|ios::out;	246	ios::openmode mode = ios::in \| ios::out;
236	// It seems that there is no separate 'create if not exists'	247	// It seems that there is no separate 'create if not exists'
237	// open flag. Have to truncate to create, but dont want to do	248	// open flag. Have to truncate to create, but dont want to do
238	// this to an existing file !	249	// this to an existing file !
239	if (access(fname, 0) < 0) {	250	if (access(fname, 0) < 0) {
240	mode \|= ios::trunc;	251	mode \|= ios::trunc;
241	}	252	}
242	input.open(fname, mode);	253	input.open(fname, mode);
243	if (input.is_open()) {
244	status = STATUS_RW;
245	} else {
246	input.clear();
247	input.open(fname, ios::in);
248	if (input.is_open()) {	254	if (input.is_open()) {
249	status = STATUS_RO;	255	status = STATUS_RW;
250	}	256	} else {
251	}	257	input.clear();
		258	input.open(fname, ios::in);
		259	if (input.is_open()) {
		260	status = STATUS_RO;
		261	}
		262	}
252	}	263	}
253		264
254	if (!input.is_open()) {	265	if (!input.is_open()) {
255	status = STATUS_ERROR;	266	status = STATUS_ERROR;
256	return;	267	return;
257	}	268	}
258		269
259	parseinput(input);	270	parseinput(input);
260	i_changed(true);	271	i_changed(true);
261	}	272	}
262		273
263	ConfSimple::StatusCode ConfSimple::getStatus() const	274	ConfSimple::StatusCode ConfSimple::getStatus() const
264	{	275	{
265	switch (status) {	276	switch (status) {
266	case STATUS_RO: return STATUS_RO;	277	case STATUS_RO:
267	case STATUS_RW: return STATUS_RW;	278	return STATUS_RO;
		279	case STATUS_RW:
		280	return STATUS_RW;
		281	default:
268	default: return STATUS_ERROR;	282	return STATUS_ERROR;
269	}	283	}
270	}	284	}
271		285
272	bool ConfSimple::sourceChanged() const	286	bool ConfSimple::sourceChanged() const
273	{	287	{
274	if (!m_filename.empty()) {	288	if (!m_filename.empty()) {
275	struct stat st;	289	struct stat st;
276	if (stat(m_filename.c_str(), &st) == 0) {	290	if (stat(m_filename.c_str(), &st) == 0) {
277	if (m_fmtime != st.st_mtime) {	291	if (m_fmtime != st.st_mtime) {
278	return true;	292	return true;
279	}	293	}
280	}	294	}
281	}	295	}
282	return false;	296	return false;
283	}	297	}
284		298
285	bool ConfSimple::i_changed(bool upd)	299	bool ConfSimple::i_changed(bool upd)
286	{	300	{
287	if (!m_filename.empty()) {	301	if (!m_filename.empty()) {
288	struct stat st;	302	struct stat st;
289	if (stat(m_filename.c_str(), &st) == 0) {	303	if (stat(m_filename.c_str(), &st) == 0) {
290	if (m_fmtime != st.st_mtime) {	304	if (m_fmtime != st.st_mtime) {
291	if (upd)	305	if (upd) {
292	m_fmtime = st.st_mtime;	306	m_fmtime = st.st_mtime;
293	return true;	307	}
294	}	308	return true;
295	}	309	}
		310	}
296	}	311	}
297	return false;	312	return false;
298	}	313	}
299		314
300	int ConfSimple::get(const string &nm, string &value, const string &sk) const	315	int ConfSimple::get(const string& nm, string& value, const string& sk) const
301	{	316	{
302	if (!ok())	317	if (!ok()) {
303	return 0;	318	return 0;
		319	}
304		320
305	// Find submap	321	// Find submap
306	map<string, map<string, string> >::const_iterator ss;	322	map<string, map<string, string> >::const_iterator ss;
307	if ((ss = m_submaps.find(sk)) == m_submaps.end())	323	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
308	return 0;	324	return 0;
		325	}
309		326
310	// Find named value	327	// Find named value
311	map<string, string>::const_iterator s;	328	map<string, string>::const_iterator s;
312	if ((s = ss->second.find(nm)) == ss->second.end())	329	if ((s = ss->second.find(nm)) == ss->second.end()) {
313	return 0;	330	return 0;
		331	}
314	value = s->second;	332	value = s->second;
315	return 1;	333	return 1;
316	}	334	}
317		335
318	// Appropriately output a subkey (nm=="") or variable line.	336	// Appropriately output a subkey (nm=="") or variable line.
319	// Splits long lines	337	// Splits long lines
320	static ConfSimple::WalkerCode varprinter(void *f, const string &nm,	338	static ConfSimple::WalkerCode varprinter(void *f, const string& nm,
321	const string &value)	339	const string& value)
322	{	340	{
323	ostream output = (ostream )f;	341	ostream output = (ostream )f;
324	if (nm.empty()) {	342	if (nm.empty()) {
325	*output << "\n[" << value << "]\n";	343	*output << "\n[" << value << "]\n";
326	} else {	344	} else {
327	string value1;	345	string value1;
328	if (value.length() < 60) {	346	if (value.length() < 60) {
329	value1 = value;	347	value1 = value;
330	} else {	348	} else {
331	string::size_type pos = 0;	349	string::size_type pos = 0;
332	while (pos < value.length()) {	350	while (pos < value.length()) {
333	string::size_type len = MIN(60, value.length() - pos);	351	string::size_type len = MIN(60, value.length() - pos);
334	value1 += value.substr(pos, len);	352	value1 += value.substr(pos, len);
335	pos += len;	353	pos += len;
336	if (pos < value.length())	354	if (pos < value.length()) {
337	value1 += "\\\n";	355	value1 += "\\\n";
338	}	356	}
339	}	357	}
		358	}
340	*output << nm << " = " << value1 << "\n";	359	*output << nm << " = " << value1 << "\n";
341	}	360	}
342	return ConfSimple::WALK_CONTINUE;	361	return ConfSimple::WALK_CONTINUE;
343	}	362	}
344		363
345	// Set variable and rewrite data	364	// Set variable and rewrite data
346	int ConfSimple::set(const std::string &nm, const std::string &value,	365	int ConfSimple::set(const std::string& nm, const std::string& value,
347	const string &sk)	366	const string& sk)
348	{	367	{
349	if (status != STATUS_RW)	368	if (status != STATUS_RW) {
350	return 0;	369	return 0;
		370	}
351	LOGDEB((stderr, "ConfSimple::set [%s]:[%s] -> [%s]\n", sk.c_str(),	371	LOGDEB((stderr, "ConfSimple::set [%s]:[%s] -> [%s]\n", sk.c_str(),
352	nm.c_str(), value.c_str()));	372	nm.c_str(), value.c_str()));
353	if (!i_set(nm, value, sk))	373	if (!i_set(nm, value, sk)) {
354	return 0;	374	return 0;
		375	}
355	return write();	376	return write();
356	}	377	}
357		378
358	// Internal set variable: no rw checking or file rewriting. If init is	379	// Internal set variable: no rw checking or file rewriting. If init is
359	// set, we're doing initial parsing, else we are changing a parsed	380	// set, we're doing initial parsing, else we are changing a parsed
360	// tree (changes the way we update the order data)	381	// tree (changes the way we update the order data)
361	int ConfSimple::i_set(const std::string &nm, const std::string &value,	382	int ConfSimple::i_set(const std::string& nm, const std::string& value,
362	const string &sk, bool init)	383	const string& sk, bool init)
363	{	384	{
364	LOGDEB((stderr, "ConfSimple::i_set: nm[%s] val[%s] key[%s], init %d\n",	385	LOGDEB((stderr, "ConfSimple::i_set: nm[%s] val[%s] key[%s], init %d\n",
365	nm.c_str(), value.c_str(), sk.c_str(), init));	386	nm.c_str(), value.c_str(), sk.c_str(), init));
366	// Values must not have embedded newlines	387	// Values must not have embedded newlines
367	if (value.find_first_of("\n\r") != string::npos) {	388	if (value.find_first_of("\n\r") != string::npos) {
368	LOGDEB((stderr, "ConfSimple::i_set: LF in value\n"));	389	LOGDEB((stderr, "ConfSimple::i_set: LF in value\n"));
369	return 0;	390	return 0;
370	}	391	}
371	bool existing = false;	392	bool existing = false;
372	map<string, map<string, string> >::iterator ss;	393	map<string, map<string, string> >::iterator ss;
373	// Test if submap already exists, else create it, and insert variable:	394	// Test if submap already exists, else create it, and insert variable:
374	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {	395	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
375	LOGDEB((stderr, "ConfSimple::i_set: new submap\n"));	396	LOGDEB((stderr, "ConfSimple::i_set: new submap\n"));
376	map<string, string> submap;	397	map<string, string> submap;
377	submap[nm] = value;	398	submap[nm] = value;
378	m_submaps[sk] = submap;	399	m_submaps[sk] = submap;
379		400
380	// Maybe add sk entry to m_order data:	401	// Maybe add sk entry to m_order data:
381	if (!sk.empty()) {	402	if (!sk.empty()) {
382	ConfLine nl(ConfLine::CFL_SK, sk);	403	ConfLine nl(ConfLine::CFL_SK, sk);
383	// Append SK entry only if it's not already there (erase	404	// Append SK entry only if it's not already there (erase
384	// does not remove entries from the order data, adn it may	405	// does not remove entries from the order data, adn it may
385	// be being recreated after deletion)	406	// be being recreated after deletion)
386	if (find(m_order.begin(), m_order.end(), nl) == m_order.end()) {	407	if (find(m_order.begin(), m_order.end(), nl) == m_order.end()) {
387	m_order.push_back(nl);	408	m_order.push_back(nl);
388	}	409	}
389	}	410	}
390	} else {	411	} else {
391	// Insert or update variable in existing map.	412	// Insert or update variable in existing map.
392	map<string, string>::iterator it;	413	map<string, string>::iterator it;
393	it = ss->second.find(nm);	414	it = ss->second.find(nm);
394	if (it == ss->second.end()) {	415	if (it == ss->second.end()) {
395	ss->second.insert(pair<string,string>(nm, value));	416	ss->second.insert(pair<string, string>(nm, value));
396	} else {	417	} else {
397	it->second = value;	418	it->second = value;
398	existing = true;	419	existing = true;
399	}	420	}
400	}	421	}
401		422
402	// If the variable already existed, no need to change the m_order data	423	// If the variable already existed, no need to change the m_order data
403	if (existing) {	424	if (existing) {
404	LOGDEB((stderr, "ConfSimple::i_set: existing var: no order update\n"));	425	LOGDEB((stderr, "ConfSimple::i_set: existing var: no order update\n"));
405	return 1;	426	return 1;
406	}	427	}
407		428
408	// Add the new variable at the end of its submap in the order data.	429	// Add the new variable at the end of its submap in the order data.
409		430
410	if (init) {	431	if (init) {
411	// During the initial construction, just append:	432	// During the initial construction, just append:
412	LOGDEB((stderr, "ConfSimple::i_set: init true: append\n"));	433	LOGDEB((stderr, "ConfSimple::i_set: init true: append\n"));
413	m_order.push_back(ConfLine(ConfLine::CFL_VAR, nm));	434	m_order.push_back(ConfLine(ConfLine::CFL_VAR, nm));
414	return 1;	435	return 1;
415	}	436	}
416		437
417	// Look for the start and end of the subkey zone. Start is either	438	// Look for the start and end of the subkey zone. Start is either
418	// at begin() for a null subkey, or just behind the subkey	439	// at begin() for a null subkey, or just behind the subkey
419	// entry. End is either the next subkey entry, or the end of	440	// entry. End is either the next subkey entry, or the end of
420	// list. We insert the new entry just before end.	441	// list. We insert the new entry just before end.
421	vector<ConfLine>::iterator start, fin;	442	vector<ConfLine>::iterator start, fin;
422	if (sk.empty()) {	443	if (sk.empty()) {
423	start = m_order.begin();	444	start = m_order.begin();
424	LOGDEB((stderr,"ConfSimple::i_set: null sk, start at top of order\n"));	445	LOGDEB((stderr, "ConfSimple::i_set: null sk, start at top of order\n"));
425	} else {	446	} else {
426	start = find(m_order.begin(), m_order.end(),	447	start = find(m_order.begin(), m_order.end(),
427	ConfLine(ConfLine::CFL_SK, sk));	448	ConfLine(ConfLine::CFL_SK, sk));
428	if (start == m_order.end()) {	449	if (start == m_order.end()) {
429	// This is not logically possible. The subkey must	450	// This is not logically possible. The subkey must
430	// exist. We're doomed	451	// exist. We're doomed
431	std::cerr << "Logical failure during configuration variable "	452	std::cerr << "Logical failure during configuration variable "
432	"insertion" << endl;	453	"insertion" << endl;
433	abort();	454	abort();
434	}	455	}
435	}	456	}
436		457
437	fin = m_order.end();	458	fin = m_order.end();
438	if (start != m_order.end()) {	459	if (start != m_order.end()) {
439	// The null subkey has no entry (maybe it should)	460	// The null subkey has no entry (maybe it should)
440	if (!sk.empty())	461	if (!sk.empty()) {
441	start++;	462	start++;
		463	}
442	for (vector<ConfLine>::iterator it = start; it != m_order.end(); it++) {	464	for (vector<ConfLine>::iterator it = start; it != m_order.end(); it++) {
443	if (it->m_kind == ConfLine::CFL_SK) {	465	if (it->m_kind == ConfLine::CFL_SK) {
444	fin = it;	466	fin = it;
445	break;	467	break;
446	}	468	}
447	}	469	}
448	}	470	}
449		471
450	// It may happen that the order entry already exists because erase doesnt	472	// It may happen that the order entry already exists because erase doesnt
451	// update m_order	473	// update m_order
452	if (find(start, fin, ConfLine(ConfLine::CFL_VAR, nm)) == fin) {	474	if (find(start, fin, ConfLine(ConfLine::CFL_VAR, nm)) == fin) {
453	m_order.insert(fin, ConfLine(ConfLine::CFL_VAR, nm));	475	m_order.insert(fin, ConfLine(ConfLine::CFL_VAR, nm));
454	}	476	}
455	return 1;	477	return 1;
456	}	478	}
457		479
458	int ConfSimple::erase(const string &nm, const string &sk)	480	int ConfSimple::erase(const string& nm, const string& sk)
459	{	481	{
460	if (status != STATUS_RW)	482	if (status != STATUS_RW) {
461	return 0;	483	return 0;
		484	}
462		485
463	map<string, map<string, string> >::iterator ss;	486	map<string, map<string, string> >::iterator ss;
464	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {	487	if ((ss = m_submaps.find(sk)) == m_submaps.end()) {
465	return 0;	488	return 0;
466	}
467		489	}
		490
468	ss->second.erase(nm);	491	ss->second.erase(nm);
469	if (ss->second.empty()) {	492	if (ss->second.empty()) {
470	m_submaps.erase(ss);	493	m_submaps.erase(ss);
471	}	494	}
472	return write();	495	return write();
473	}	496	}
474		497
475	int ConfSimple::eraseKey(const string &sk)	498	int ConfSimple::eraseKey(const string& sk)
476	{	499	{
477	vector<string> nms = getNames(sk);	500	vector<string> nms = getNames(sk);
478	for (vector<string>::iterator it = nms.begin(); it != nms.end(); it++) {	501	for (vector<string>::iterator it = nms.begin(); it != nms.end(); it++) {
479	erase(*it, sk);	502	erase(*it, sk);
480	}	503	}
481	return write();	504	return write();
482	}	505	}
483		506
484	// Walk the tree, calling user function at each node	507	// Walk the tree, calling user function at each node
485	ConfSimple::WalkerCode	508	ConfSimple::WalkerCode
486	ConfSimple::sortwalk(WalkerCode (walker)(void ,const string&,const string&),	509	ConfSimple::sortwalk(WalkerCode(walker)(void , const string&, const string&),
487	void *clidata) const	510	void *clidata) const
488	{	511	{
489	if (!ok())	512	if (!ok()) {
490	return WALK_STOP;	513	return WALK_STOP;
		514	}
491	// For all submaps:	515	// For all submaps:
492	for (map<string, map<string, string> >::const_iterator sit =	516	for (map<string, map<string, string> >::const_iterator sit =
493	m_submaps.begin();	517	m_submaps.begin();
494	sit != m_submaps.end(); sit++) {	518	sit != m_submaps.end(); sit++) {
495		519
496	// Possibly emit submap name:	520	// Possibly emit submap name:
497	if (!sit->first.empty() && walker(clidata, string(), sit->first.c_str())	521	if (!sit->first.empty() && walker(clidata, string(), sit->first.c_str())
498	== WALK_STOP)	522	== WALK_STOP) {
499	return WALK_STOP;	523	return WALK_STOP;
		524	}
500		525
501	// Walk submap	526	// Walk submap
502	const map<string, string> &sm = sit->second;	527	const map<string, string>& sm = sit->second;
503	for (map<string, string>::const_iterator it = sm.begin();it != sm.end();	528	for (map<string, string>::const_iterator it = sm.begin(); it != sm.end();
504	it++) {	529	it++) {
505	if (walker(clidata, it->first, it->second) == WALK_STOP)	530	if (walker(clidata, it->first, it->second) == WALK_STOP) {
506	return WALK_STOP;	531	return WALK_STOP;
507	}	532	}
		533	}
508	}	534	}
509	return WALK_CONTINUE;	535	return WALK_CONTINUE;
510	}	536	}
511		537
512	// Write to default output. This currently only does something if output is	538	// Write to default output. This currently only does something if output is
513	// a file	539	// a file
514	bool ConfSimple::write()	540	bool ConfSimple::write()
515	{	541	{
516	if (!ok())	542	if (!ok()) {
517	return false;	543	return false;
		544	}
518	if (m_holdWrites)	545	if (m_holdWrites) {
519	return true;	546	return true;