/* 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.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the

 *   Free Software Foundation, Inc.,

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */

#ifndef TEST_CONFTREE

#include <unistd.h> // for access(2)

#include <ctype.h>

#include <fnmatch.h>

#include <sys/stat.h>

#include <fstream>

#include <sstream>

#include <algorithm>

#include <iostream>

#include <cstring>

using namespace std;

#include "conftree.hxx"

#include "upmpdutils.hxx"

#undef DEBUG

#ifdef DEBUG

#define LOGDEB(X) fprintf X

#else

#define LOGDEB(X)

#endif

#ifndef MIN 

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

#endif

#define LL 1024

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)

    : dotildexpand(tildexp), m_fmtime(0), m_holdWrites(false)

{

    status = readonly ? STATUS_RO : STATUS_RW;

}

void ConfSimple::reparse(const string& d)

{

    clear();

    stringstream input(d, ios::in);

    parseinput(input);

}

ConfSimple::ConfSimple(const string& d, int readonly, bool tildexp)

    : dotildexpand(tildexp), m_fmtime(0), m_holdWrites(false)

{

    status = readonly ? STATUS_RO : STATUS_RW;

    stringstream input(d, ios::in);

    parseinput(input);

}

ConfSimple::ConfSimple(const char *fname, int readonly, bool tildexp)

    : dotildexpand(tildexp), m_filename(fname), m_fmtime(0), m_holdWrites(false)

{

    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;

    // Handle the case where the config file path has an ending / and not

    // 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

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <string.h>

#include <sstream>

#include <iostream>

#include <vector>

#include "conftree.h"

#include "smallut.h"

#include "readfile.h"

using namespace std;

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.set("nm-1", "val1-1", "/dir1");

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

    conf.set("nm-1", "val2-1", "/dir2");

    conf.set("nm-2", "val2-2", "/dir2");

    conf.set("nm-1", "val11-1", "/dir1/dir1");

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

    conf.eraseKey("/dir2");

    conf.set("nm-1", "val2-1", "/dir2");

    conf.set("nm-2", "val2-2", "/dir2");

    conf.erase("nm-1", "");

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

    conf.eraseKey("/dir1");

    conf.eraseKey("/dir2");

    conf.eraseKey("/dir1/dir1");

    conf.set("nm-1", "val1-1", "/dir1");

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

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

    conf.set("nm-1", "val2-1", "/dir2");

    conf.set("nm-2", "val2-2", "/dir2");

    conf.set("nm-1", "val11-1", "/dir1/dir1");

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

    conf.erase("nm-1", "/dir2");

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

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

    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 [] =

    "testconftree [opts] filename\n"

    "[-w]  : read/write test.\n"

    "[-s]  : string parsing test. Filename must hold parm 'strings'\n"

    "-a nm value sect : add/set nm,value in 'sect' which can be ''\n"

    "-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

#define OPT_a     0x80

#define OPT_k     0x100

#define OPT_E     0x200

#define OPT_U      0x400

int main(int argc, char **argv)

{

    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