upmpdcli / Code / Diff of /src/conftree.cxx

Diff of /src/conftree.cxx [2ae704] .. [d50db5]

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

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