~drizzle-trunk/drizzle/development

/*

 * Copyright (C) 2002-2004 Vladimir Prus.

 * Copyright (C) 2010 Monty Taylor

 *

 * Distributed under the Boost Software License, Version 1.0.

 * (See accompanying file LICENSE_1_0.txt or copy at

 * http://www.boost.org/LICENSE_1_0.txt)

 */

#pragma once

#include <boost/program_options.hpp>

#include <boost/program_options/eof_iterator.hpp>

#include <boost/type_traits/is_same.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/noncopyable.hpp>

#include <iosfwd>

#include <vector>

#include <utility>

#include <set>

namespace drizzled {

namespace program_options {

typedef std::pair<std::string, std::string> option_result_pair;

std::string parse_suffix(const std::string& arg_val);

option_result_pair parse_size_suffixes(std::string s);

option_result_pair parse_size_arg(std::string s);

std::string parse_suffix(const std::string& arg_val)

{

  try

  {

    size_t size_suffix_pos= arg_val.find_last_of("kmgKMG");

    if (size_suffix_pos == arg_val.size()-1)

    {

      char suffix= arg_val[size_suffix_pos];

      std::string size_val(arg_val.substr(0, size_suffix_pos));

      uint64_t base_size= boost::lexical_cast<uint64_t>(size_val);

      uint64_t new_size= 0;

      switch (suffix)

      {

      case 'K':

      case 'k':

        new_size= base_size * 1024;

        break;

      case 'M':

      case 'm':

        new_size= base_size * 1024 * 1024;

        break;

      case 'G':

      case 'g':

        new_size= base_size * 1024 * 1024 * 1024;

        break;

      }

      return boost::lexical_cast<std::string>(new_size);

    }

  }

  catch (std::exception&)

  { }

  return arg_val;

}

option_result_pair parse_size_suffixes(std::string s)

{

  size_t equal_pos= s.find("=");

  if (equal_pos != std::string::npos)

  {

    std::string arg_key(s.substr(0, equal_pos));

    std::string arg_val(parse_suffix(s.substr(equal_pos+1)));

    if (arg_val != s.substr(equal_pos+1))

    {

      return std::make_pair(arg_key, arg_val);

    }

  }

  return std::make_pair(std::string(""), std::string(""));

}

option_result_pair parse_size_arg(std::string s)

{

  if (s.find("--") == 0)

  {

    return parse_size_suffixes(s.substr(2));

  }

  return make_pair(std::string(""), std::string(""));

}

class invalid_syntax :

  public boost::program_options::error

{

public:

  enum kind_t

  {

    long_not_allowed = 30,

    long_adjacent_not_allowed,

    short_adjacent_not_allowed,

    empty_adjacent_parameter,

    missing_parameter,

    extra_parameter,

    unrecognized_line

  };

  invalid_syntax(const std::string& in_tokens, kind_t in_kind);

  // gcc says that throw specification on dtor is loosened

  // without this line

  ~invalid_syntax() throw() {}

  kind_t kind() const

  {

    return m_kind;

  }

  const std::string& tokens() const

  {

    return m_tokens;

  }

protected:

  /** Used to convert kind_t to a related error text */

  static std::string error_message(kind_t kind)

  {

    // Initially, store the message in 'const char*' variable, to avoid

    // conversion to string in all cases.

    const char* msg;

    switch(kind)

    {

    case long_not_allowed:

      msg = "long options are not allowed";

      break;

    case long_adjacent_not_allowed:

      msg = "parameters adjacent to long options not allowed";

      break;

    case short_adjacent_not_allowed:

      msg = "parameters adjust to short options are not allowed";

      break;

    case empty_adjacent_parameter:

      msg = "adjacent parameter is empty";

      break;

    case missing_parameter:

      msg = "required parameter is missing";

      break;

    case extra_parameter:

      msg = "extra parameter";

      break;

    case unrecognized_line:

      msg = "unrecognized line";

      break;

    default:

      msg = "unknown error";

    }

    return msg;

  }

private:

  // TODO: copy ctor might throw

  std::string m_tokens;

  kind_t m_kind;

};

invalid_syntax::invalid_syntax(const std::string& in_tokens,

                               invalid_syntax::kind_t in_kind) :

  boost::program_options::error(error_message(in_kind).append(" in '").append(in_tokens).append("'")),

  m_tokens(in_tokens),

  m_kind(in_kind)

{ }

namespace detail

{

/** Standalone parser for config files in ini-line format.

  The parser is a model of single-pass lvalue iterator, and

  default constructor creates past-the-end-iterator. The typical usage is:

  config_file_iterator i(is, ... set of options ...), e;

  for(; i !=e; ++i) {

 *i;

 }

 Syntax conventions:

 - config file can not contain positional options

 - '#' is comment character: it is ignored together with

 the rest of the line.

 - variable assignments are in the form

 name '=' value.

 spaces around '=' are trimmed.

 - Section names are given in brackets. 

 The actual option name is constructed by combining current section

 name and specified option name, with dot between. If section_name 

 already contains dot at the end, new dot is not inserted. For example:

 @verbatim

 [gui.accessibility]

 visual_bell=yes

 @endverbatim

 will result in option "gui.accessibility.visual_bell" with value

 "yes" been returned.

 */    

class common_config_file_iterator :

  public boost::eof_iterator<common_config_file_iterator,

                             boost::program_options::option>

{

public:

  common_config_file_iterator()

  {

    found_eof();

  }

  common_config_file_iterator(const std::set<std::string>& in_allowed_options,

                              bool allow_unregistered) :

    allowed_options(in_allowed_options),

    m_allow_unregistered(allow_unregistered)

  {

    for(std::set<std::string>::const_iterator i = allowed_options.begin();

        i != allowed_options.end(); 

        ++i)

    {

      add_option(i->c_str());

    }

  }

  virtual ~common_config_file_iterator() {}

public: // Method required by eof_iterator

  void get()

  {

    std::string s;

    std::string::size_type n;

    bool found = false;

    while(this->getline(s)) {

      // strip '#' comments and whitespace

      if ((n = s.find('#')) != std::string::npos)

        s = s.substr(0, n);

      boost::trim(s);

      if (!s.empty()) {

        // Handle section name

        if (*s.begin() == '[' && *s.rbegin() == ']')

        {

          m_prefix = s.substr(1, s.size()-2);

          if (*m_prefix.rbegin() != '.')

            m_prefix += '.';

        }

        else

        {

          std::string name;

          std::string option_value("true");

          if ((n = s.find('=')) != std::string::npos)

          {

            name = m_prefix + boost::trim_copy(s.substr(0, n));

            option_value = boost::trim_copy(parse_suffix(s.substr(n+1)));

          }

          else

          {

            name = m_prefix + boost::trim_copy(s);

          }

          bool registered = allowed_option(name);

          if (!registered && !m_allow_unregistered)

            boost::throw_exception(boost::program_options::unknown_option(name));

          found = true;

          this->value().string_key = name;

          this->value().value.clear();

          this->value().value.push_back(option_value);

          this->value().unregistered = !registered;

          this->value().original_tokens.clear();

          this->value().original_tokens.push_back(name);

          this->value().original_tokens.push_back(option_value);

          break;

        }

      }

    }

    if (!found)

      found_eof();

  }

protected: // Stubs for derived classes

  // Obtains next line from the config file

  // Note: really, this design is a bit ugly

  // The most clean thing would be to pass 'line_iterator' to

  // constructor of this class, but to avoid templating this class

  // we'd need polymorphic iterator, which does not exist yet.

  virtual bool getline(std::string&) { return false; }

private:

  /** Adds another allowed option. If the 'name' ends with

    '*', then all options with the same prefix are

    allowed. For example, if 'name' is 'foo*', then 'foo1' and

    'foo_bar' are allowed. */

  void add_option(const char* name)

  {

    std::string s(name);

    assert(!s.empty());

    if (*s.rbegin() == '*')

    {

      s.resize(s.size()-1);

      bool bad_prefixes(false);

      // If 's' is a prefix of one of allowed suffix, then

      // lower_bound will return that element.

      // If some element is prefix of 's', then lower_bound will

      // return the next element.

      std::set<std::string>::iterator i = allowed_prefixes.lower_bound(s);

      if (i != allowed_prefixes.end())

      {

        if (i->find(s) == 0)

          bad_prefixes = true;                    

      }

      if (i != allowed_prefixes.begin())

      {

        --i;

        if (s.find(*i) == 0)

          bad_prefixes = true;

      }

      if (bad_prefixes)

        boost::throw_exception(boost::program_options::error("bad prefixes"));

      allowed_prefixes.insert(s);

    }

  }

  // Returns true if 's' is a registered option name.

  bool allowed_option(const std::string& s) const

  {

    std::set<std::string>::const_iterator i = allowed_options.find(s);

    if (i != allowed_options.end())

      return true;        

    // If s is "pa" where "p" is allowed prefix then

    // lower_bound should find the element after "p". 

    // This depends on 'allowed_prefixes' invariant.

    i = allowed_prefixes.lower_bound(s);

    if (i != allowed_prefixes.begin() && s.find(*--i) == 0)

      return true;

    return false;

  }

  // That's probably too much data for iterator, since

  // it will be copied, but let's not bother for now.

  std::set<std::string> allowed_options;

  // Invariant: no element is prefix of other element.

  std::set<std::string> allowed_prefixes;

  std::string m_prefix;

  bool m_allow_unregistered;

};

template<class charT>

class basic_config_file_iterator :

  public common_config_file_iterator

{

public:

  basic_config_file_iterator()

  {

    found_eof();

  }

  /** Creates a config file parser for the specified stream. */

  basic_config_file_iterator(std::basic_istream<charT>& is, 

                             const std::set<std::string>& allowed_options,

                             bool allow_unregistered = false); 

private: // base overrides

  bool getline(std::string&);

private: // internal data

  boost::shared_ptr<std::basic_istream<charT> > is;

};

typedef basic_config_file_iterator<char> config_file_iterator;

typedef basic_config_file_iterator<wchar_t> wconfig_file_iterator;

struct null_deleter

{

  void operator()(void const *) const {}

};

template<class charT>

basic_config_file_iterator<charT>::

basic_config_file_iterator(std::basic_istream<charT>& in_is, 

                           const std::set<std::string>& in_allowed_options,

                           bool in_allow_unregistered) :

  common_config_file_iterator(in_allowed_options, in_allow_unregistered)

{

  this->is.reset(&in_is, null_deleter());                 

  get();

}

// Specializing this function for wchar_t causes problems on

// borland and vc7, as well as on metrowerks. On the first two

// I don't know a workaround, so make use of 'to_internal' to

// avoid specialization.

template<class charT>

bool

basic_config_file_iterator<charT>::getline(std::string& s)

{

  if (std::getline(*is, s))

  {

    return true;

  }

  else

  {

    return false;

  }

}

} /* namespace detail */

/** Parse a config file. 

  Read from given stream.

*/

template<class charT>

boost::program_options::basic_parsed_options<charT>

parse_config_file(std::basic_istream<charT>& is,

                  const boost::program_options::options_description& desc,

                  bool allow_unregistered = false)

{    

  std::set<std::string> allowed_options;

  const std::vector<boost::shared_ptr<boost::program_options::option_description> >& options = desc.options();

  for (unsigned i = 0; i < options.size(); ++i)

  {

    const boost::program_options::option_description& d= *options[i];

    if (d.long_name().empty())

      boost::throw_exception(boost::program_options::error("long name required for config file"));

    allowed_options.insert(d.long_name());

  }

  // Parser return char strings

  boost::program_options::parsed_options result(&desc);        

  std::copy(detail::basic_config_file_iterator<charT>(is,

                                                      allowed_options,

                                                      allow_unregistered), 

       detail::basic_config_file_iterator<charT>(), 

       std::back_inserter(result.options));

  // Convert char strings into desired type.

  return boost::program_options::basic_parsed_options<charT>(result);

}

/** Parse a config file. 

  Read from file with the given name. The character type is

  passed to the file stream. 

*/

template<class charT>

boost::program_options::basic_parsed_options<charT>

parse_config_file(const char* filename,

                  const boost::program_options::options_description& desc,

                  bool allow_unregistered = false)

{ 

  // Parser return char strings

  std::basic_ifstream< charT > strm(filename);

  if (!strm) 

  {

    boost::throw_exception("Couldn't open file");

  }

  return parse_config_file(strm, desc, allow_unregistered);

}

} /* namespace program_options */

} /* namespace drizzled */