Merge lp:~mordred/drizzle/bug669635 into lp:drizzle/7.0

[Monty Taylor]

Fixes boolean values in config files, and also size suffix processing.

[lp:~mordred/drizzle/bug669635]

1928. By Monty Taylor on 2010-11-13

Make sure we pop the pid-file path out to an absolute path in fix_paths,
else the chdir() will screw us up later.

[Brian Aker (brianaker)]

The formatting and the code style is a bit off. typedef on stl would also be nice.

Do you mind fixing it up before merge?

Thanks,
  -Brian

[Monty Taylor (mordred)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On 11/13/2010 02:02 PM, Brian Aker wrote:
> The formatting and the code style is a bit off. typedef on stl would also be nice.
>
> Do you mind fixing it up before merge?

That file is intended to be submitted upstream to boost once it's done,
so I've been keeping to boost codestyle for it... I could re-format it
for our style if you prefer.

Can totally add the typedef though.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iEYEARECAAYFAkzfPxcACgkQ2Jv7/VK1RgEQHgCghYDmzU6DenJYykcZDZQoGKHU
W20AniweNdIlD/w+wc426Ole7YFAnXUN
=aXU5
-----END PGP SIGNATURE-----

[lp:~mordred/drizzle/bug669635]

1929. By Monty Taylor on 2010-11-14

Cleaned up stylewq

[Monty Taylor (mordred)]

Ok. I went ahead and fixed the codestyle.

=== modified file 'drizzled/drizzled.cc'
--- drizzled/drizzled.cc	2010-11-09 17:12:40 +0000
+++ drizzled/drizzled.cc	2010-11-14 02:07:07 +0000
@@ -1046,62 +1046,6 @@
   global_system_variables.transaction_message_threshold= in_transaction_message_threshold;
 }
 
-static pair<string, string> parse_size_suffixes(string s)
-{
-  size_t equal_pos= s.find("=");
-  if (equal_pos != string::npos)
-  {
-    string arg_key(s.substr(0, equal_pos));
-    string arg_val(s.substr(equal_pos+1));
-
-    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];
-        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 make_pair(arg_key,
-                         boost::lexical_cast<string>(new_size));
-      }
-    }
-    catch (...)
-    {
-      /* Screw it, let the normal parser take over */
-    }
-  }
-
-  return make_pair(string(""), string(""));
-}
-
-static pair<string, string> parse_size_arg(string s)
-{
-  if (s.find("--") == 0)
-  {
-    return parse_size_suffixes(s.substr(2));
-  }
-  return make_pair(string(""), string(""));
-}
-
 static void process_defaults_files()
 {
   for (vector<string>::iterator iter= defaults_file_list.begin();
@@ -1502,7 +1446,7 @@
   {
     po::parsed_options final_parsed=
       po::command_line_parser(unknown_options).style(style).
-      options(full_options).extra_parser(parse_size_arg).run();
+      options(full_options).extra_parser(dpo::parse_size_arg).run();
 
     final_unknown_options=
       po::collect_unrecognized(final_parsed.options, po::include_positional);
@@ -2408,7 +2352,7 @@
     pid_file_path= getDataHome();
     pid_file_path /= pid_file;
   }
-  pid_file= pid_file_path;
+  pid_file= fs::system_complete(pid_file_path);
 
   if (not opt_help)
   {

=== modified file 'drizzled/program_options/config_file.h'
--- drizzled/program_options/config_file.h	2010-10-02 19:14:34 +0000
+++ drizzled/program_options/config_file.h	2010-11-14 02:07:07 +0000
@@ -1,5 +1,6 @@
 /*
  * 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
@@ -28,11 +29,80 @@
 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 (...)
+  { }
+
+  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 {
+  enum kind_t
+  {
     long_not_allowed = 30,
     long_adjacent_not_allowed,
     short_adjacent_not_allowed,
@@ -106,10 +176,10 @@
 
 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)
-{}
+  boost::program_options::error(error_message(in_kind).append(" in '").append(in_tokens).append("'")),
+  m_tokens(in_tokens),
+  m_kind(in_kind)
+{ }
 
 namespace detail
 {
@@ -185,15 +255,29 @@
 
       if (!s.empty()) {
         // Handle section name
-        if (*s.begin() == '[' && *s.rbegin() == ']') {
+        if (*s.begin() == '[' && *s.rbegin() == ']')
+        {
           m_prefix = s.substr(1, s.size()-2);
           if (*m_prefix.rbegin() != '.')
             m_prefix += '.';
         }
-        else if ((n = s.find('=')) != std::string::npos) {
-
-          std::string name = m_prefix + boost::trim_copy(s.substr(0, n));
-          std::string option_value = boost::trim_copy(s.substr(n+1));
+        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)
@@ -209,8 +293,6 @@
           this->value().original_tokens.push_back(option_value);
           break;
 
-        } else {
-          boost::throw_exception(invalid_syntax(s, invalid_syntax::unrecognized_line));
         }
       }
     }
@@ -236,7 +318,8 @@
   {
     std::string s(name);
     assert(!s.empty());
-    if (*s.rbegin() == '*') {
+    if (*s.rbegin() == '*')
+    {
       s.resize(s.size()-1);
       bool bad_prefixes(false);
       // If 's' is a prefix of one of allowed suffix, then
@@ -244,11 +327,13 @@
       // 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 != allowed_prefixes.end())
+      {
         if (i->find(s) == 0)
           bad_prefixes = true;                    
       }
-      if (i != allowed_prefixes.begin()) {
+      if (i != allowed_prefixes.begin())
+      {
         --i;
         if (s.find(*i) == 0)
           bad_prefixes = true;
@@ -338,9 +423,12 @@
 bool
 basic_config_file_iterator<charT>::getline(std::string& s)
 {
-  if (std::getline(*is, s)) {
+  if (std::getline(*is, s))
+  {
     return true;
-  } else {
+  }
+  else
+  {
     return false;
   }
 }
@@ -365,16 +453,16 @@
     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"));
+      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), 
+  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.