[Boost-commit] svn:boost r85391 - trunk/libs/log/src

Subject: [Boost-commit] svn:boost r85391 - trunk/libs/log/src
From: andrey.semashev_at_[hidden]
Date: 2013-08-18 11:10:27

Author: andysem
Date: 2013-08-18 11:10:24 EDT (Sun, 18 Aug 2013)
New Revision: 85391
URL: http://svn.boost.org/trac/boost/changeset/85391

Log:
Filter parser rewritten to avoid using Boost.Spirit to reduce compiled binary size. Refs #8773.

Text files modified: 
   trunk/libs/log/src/filter_parser.cpp    |   340 ++++++++++++++++++++++----------------- 
   trunk/libs/log/src/formatter_parser.cpp |   110 +++---------                            
   trunk/libs/log/src/parser_utils.cpp     |   159 +++++++++++++++++-                      
   trunk/libs/log/src/parser_utils.hpp     |    16 +                                       
   trunk/libs/log/src/settings_parser.cpp  |    78 ++------                                
   5 files changed, 408 insertions(+), 295 deletions(-)

Modified: trunk/libs/log/src/filter_parser.cpp
==============================================================================
--- trunk/libs/log/src/filter_parser.cpp	Sun Aug 18 06:04:46 2013	(r85390)
+++ trunk/libs/log/src/filter_parser.cpp	2013-08-18 11:10:24 EDT (Sun, 18 Aug 2013)	(r85391)
@@ -23,23 +23,14 @@
 #include <stdexcept>
 #include <utility>
 #include <boost/assert.hpp>
-#include <boost/bind.hpp>
 #include <boost/none.hpp>
 #include <boost/move/core.hpp>
 #include <boost/move/utility.hpp>
 #include <boost/optional/optional.hpp>
 #include <boost/utility/in_place_factory.hpp>
-#include <boost/spirit/include/qi_core.hpp>
-#include <boost/spirit/include/qi_char.hpp>
-#include <boost/spirit/include/qi_lit.hpp>
-#include <boost/spirit/include/qi_raw.hpp>
-#include <boost/spirit/include/qi_lexeme.hpp>
-#include <boost/spirit/include/qi_as.hpp>
-#include <boost/spirit/include/qi_symbols.hpp>
 #include <boost/phoenix/core.hpp>
 #include <boost/phoenix/bind/bind_function_object.hpp>
 #include <boost/phoenix/operator/logical.hpp>
-#include <boost/range/iterator_range_core.hpp>
 #include <boost/log/detail/singleton.hpp>
 #include <boost/log/exceptions.hpp>
 #include <boost/log/utility/setup/filter_parser.hpp>
@@ -54,8 +45,6 @@
 #include "spirit_encoding.hpp"
 #include <boost/log/detail/header.hpp>
 
-namespace qi = boost::spirit::qi;
-
 namespace boost {
 
 BOOST_LOG_OPEN_NAMESPACE
@@ -125,23 +114,17 @@
     }
 };
 
-//! Filter parsing grammar
+//! Filter parser
 template< typename CharT >
-class filter_grammar :
-    public qi::grammar<
-        const CharT*,
-        typename log::aux::encoding_specific< typename log::aux::encoding< CharT >::type >::space_type
-    >
+class filter_parser
 {
 private:
     typedef CharT char_type;
     typedef const char_type* iterator_type;
-    typedef log::aux::encoding_specific< typename log::aux::encoding< char_type >::type > encoding_specific;
+    typedef typename log::aux::encoding< char_type >::type encoding;
+    typedef log::aux::encoding_specific< encoding > encoding_specific;
     typedef std::basic_string< char_type > string_type;
     typedef log::aux::char_constants< char_type > constants;
-    typedef filter_grammar< char_type > this_type;
-    typedef qi::grammar< iterator_type, typename encoding_specific::space_type > base_type;
-    typedef typename base_type::start_type rule_type;
     typedef filter_factory< char_type > filter_factory_type;
 
     typedef filter (filter_factory_type::*comparison_relation_handler_t)(attribute_name const&, string_type const&);
@@ -159,147 +142,220 @@
     //! Filter subexpressions as they are parsed
     mutable std::stack< filter > m_Subexpressions;
 
-    //! A parser for an attribute name in a single relation
-    rule_type attr_name;
-    //! A parser for a quoted string
-    rule_type quoted_string_operand;
-    //! A parser for an operand in a single relation
-    rule_type operand;
-    //! A parser for a single relation that consists of two operands and an operation between them
-    rule_type relation;
-    //! A set of comparison relation symbols with corresponding pointers to callbacks
-    qi::symbols< char_type, comparison_relation_handler_t > comparison_relation;
-    //! A parser for a custom relation word
-    rule_type custom_relation;
-    //! A parser for a term, which can be a relation, an expression in parenthesis or a negation thereof
-    rule_type term;
-    //! A parser for the complete filter expression that consists of one or several terms with boolean operations between them
-    rule_type expression;
-
 public:
     //! Constructor
-    filter_grammar() :
-        base_type(expression),
+    filter_parser() :
         m_ComparisonRelation(NULL)
     {
-        attr_name = qi::lexeme
-        [
-            // An attribute name in form %name%
-            qi::as< string_type >()[ qi::lit(constants::char_percent) >> +(encoding_specific::print - constants::char_percent) >> qi::lit(constants::char_percent) ]
-                [boost::bind(&filter_grammar::on_attribute_name, this, _1)]
-        ];
-
-        quoted_string_operand = qi::raw
-        [
-            qi::lexeme
-            [
-                // A quoted string with C-style escape sequences support
-                qi::lit(constants::char_quote) >>
-                *(
-                     (qi::lit(constants::char_backslash) >> qi::char_) |
-                     (qi::char_ - qi::lit(constants::char_quote))
-                ) >>
-                qi::lit(constants::char_quote)
-            ]
-        ]
-            [boost::bind(&filter_grammar::on_quoted_string_operand, this, _1)];
-
-        operand =
-        (
-            quoted_string_operand |
-            // A single word, enclosed with white spaces. It cannot contain parenthesis, since it is used by the filter parser.
-            qi::raw[ qi::lexeme[ +(encoding_specific::graph - qi::lit(constants::char_paren_bracket_left) - qi::lit(constants::char_paren_bracket_right)) ] ]
-                [boost::bind(&filter_grammar::on_operand, this, _1)]
-        );
-
-        // Custom relation is a keyword that may contain either alphanumeric characters or an underscore
-        custom_relation = qi::as< string_type >()[ qi::lexeme[ +(encoding_specific::alnum | qi::char_(constants::char_underline)) ] ]
-            [boost::bind(&filter_grammar::set_custom_relation, this, _1)];
-
-        comparison_relation.add
-            (constants::equal_keyword(), &filter_factory_type::on_equality_relation)
-            (constants::not_equal_keyword(), &filter_factory_type::on_inequality_relation)
-            (constants::greater_keyword(), &filter_factory_type::on_greater_relation)
-            (constants::less_keyword(), &filter_factory_type::on_less_relation)
-            (constants::greater_or_equal_keyword(), &filter_factory_type::on_greater_or_equal_relation)
-            (constants::less_or_equal_keyword(), &filter_factory_type::on_less_or_equal_relation);
-
-        relation =
-        (
-            attr_name >> // The relation may be as simple as a sole attribute name, in which case the filter checks for the attribute value presence
-            -(
-                (comparison_relation[boost::bind(&filter_grammar::set_comparison_relation, this, _1)] >> operand) |
-                (custom_relation >> operand)
-            )
-        )
-            [boost::bind(&filter_grammar::on_relation_complete, this)];
-
-        term =
-        (
-            (qi::lit(constants::char_paren_bracket_left) >> expression >> constants::char_paren_bracket_right) |
-            ((qi::lit(constants::not_keyword()) | constants::char_exclamation) >> term)[boost::bind(&filter_grammar::on_negation, this)] |
-            relation
-        );
-
-        expression =
-        (
-            term >>
-            *(
-                ((qi::lit(constants::and_keyword()) | constants::char_and) >> term)[boost::bind(&filter_grammar::on_and, this)] |
-                ((qi::lit(constants::or_keyword()) | constants::char_or) >> term)[boost::bind(&filter_grammar::on_or, this)]
-            )
-        );
     }
 
     //! The method returns the constructed filter
     filter get_filter()
     {
-        BOOST_ASSERT(!m_Subexpressions.empty());
+        if (m_Subexpressions.empty())
+            return filter();
         return boost::move(m_Subexpressions.top());
     }
 
-private:
-    //! The attribute name handler
-    void on_attribute_name(string_type const& name)
+    //! The pethod parses filter from the string
+    void parse(iterator_type& begin, iterator_type end, unsigned int depth = 0)
     {
-        m_AttributeName = attribute_name(log::aux::to_narrow(name));
+        typedef void (filter_parser::*logical_op_t)();
+        logical_op_t logical_op = NULL;
+        iterator_type p = constants::trim_spaces_left(begin, end);
+        while (p != end)
+        {
+            // Parse subexpression
+            parse_subexpression(p, end, depth);
+            if (logical_op)
+            {
+                // This was the right-hand subexpression. Compose the two top subexpressions into a single filter.
+                (this->*logical_op)();
+                logical_op = NULL;
+            }
+
+            p = constants::trim_spaces_left(p, end);
+            if (p != end)
+            {
+                char_type c = *p;
+                iterator_type next = p + 1;
+                if (c == constants::char_paren_bracket_right)
+                {
+                    // The subexpression has ended
+                    if (depth == 0)
+                        BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: unmatched closing parenthesis");
+
+                    p = next;
+                    --depth;
+                    break;
+                }
+                else if (c == constants::char_and || scan_keyword(p, end, next, constants::and_keyword()))
+                {
+                    logical_op = &filter_parser::on_and;
+                }
+                else if (c == constants::char_or || scan_keyword(p, end, next, constants::or_keyword()))
+                {
+                    logical_op = &filter_parser::on_or;
+                }
+                else
+                {
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: unexpected character encountered");
+                }
+
+                p = constants::trim_spaces_left(next, end);
+            }
+            else
+                break;
+        }
+
+        if (logical_op)
+        {
+            BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: logical operation without the right-hand subexpression");
+        }
+
+        if (p == end && depth > 0)
+        {
+            BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: unterminated parenthesis");
+        }
+
+        begin = p;
     }
 
-    //! The operand string handler
-    void on_operand(iterator_range< iterator_type > const& arg)
+private:
+    //! The method parses a single subexpression
+    void parse_subexpression(iterator_type& begin, iterator_type end, unsigned int depth)
     {
-        // An attribute name should have been parsed at this point
-        if (!m_AttributeName)
-            BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: operand is not expected");
+        bool negated = false, negation_present = false;
+        iterator_type p = begin;
 
-        m_Operand = boost::in_place(arg.begin(), arg.end());
+        while (p != end)
+        {
+            char_type c = *p;
+            iterator_type next = p + 1;
+            if (c == constants::char_percent)
+            {
+                // We found an attribute placeholder
+                iterator_type start = constants::trim_spaces_left(next, end);
+                p = constants::scan_attr_placeholder(start, end);
+                if (p == end)
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the filter string");
+
+                on_attribute_name(start, p);
+
+                p = constants::trim_spaces_left(p, end);
+                if (p == end || *p != constants::char_percent)
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the filter string");
+
+                // Skip the closing char_percent
+                p = constants::trim_spaces_left(++p, end);
+
+                // If the filter has negation operator, do not expect a relation (i.e. "!%attr% > 1" is not valid because "!%attr%" is interpreted as an attribute presence test)
+                if (!negation_present)
+                    p = parse_relation(p, end);
+            }
+            else if (c == constants::char_exclamation || scan_keyword(p, end, next, constants::not_keyword()))
+            {
+                // We found negation operation. Parse the subexpression to be negated.
+                negated ^= true;
+                negation_present = true;
+                p = constants::trim_spaces_left(next, end);
+                continue;
+            }
+            else if (c == constants::char_paren_bracket_left)
+            {
+                // We found a nested subexpression
+                parse(next, end, depth + 1);
+                p = next;
+            }
+            else
+            {
+                BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: unexpected character");
+            }
+
+            if (negated)
+                on_negation();
+
+            break;
+        }
+
+        begin = p;
     }
 
-    //! The quoted string handler
-    void on_quoted_string_operand(iterator_range< iterator_type > const& arg)
+    //! Parses filtering relation
+    iterator_type parse_relation(iterator_type begin, iterator_type end)
     {
-        // An attribute name should have been parsed at this point
-        if (!m_AttributeName)
-            BOOST_LOG_THROW_DESCR(parse_error, "Invalid filter definition: quoted string operand is not expected");
+        iterator_type p = begin;
+        if (p != end)
+        {
+            iterator_type next = p;
+            if (scan_keyword(p, end, next, constants::equal_keyword()))
+                m_ComparisonRelation = &filter_factory_type::on_equality_relation;
+            else if (scan_keyword(p, end, next, constants::not_equal_keyword()))
+                m_ComparisonRelation = &filter_factory_type::on_inequality_relation;
+            else if (scan_keyword(p, end, next, constants::greater_keyword()))
+                m_ComparisonRelation = &filter_factory_type::on_greater_relation;
+            else if (scan_keyword(p, end, next, constants::less_keyword()))
+                m_ComparisonRelation = &filter_factory_type::on_less_relation;
+            else if (scan_keyword(p, end, next, constants::greater_or_equal_keyword()))
+                m_ComparisonRelation = &filter_factory_type::on_greater_or_equal_relation;
+            else if (scan_keyword(p, end, next, constants::less_or_equal_keyword()))
+                m_ComparisonRelation = &filter_factory_type::on_less_or_equal_relation;
+            else
+            {
+                // Check for custom relation
+                while (next != end && (encoding::isalnum(*next) || *next == constants::char_underline))
+                    ++next;
+                if (p == next)
+                    goto DoneL;
+                m_CustomRelation.assign(p, next);
+            }
+
+            // We have parsed a relation operator, there must be an operand
+            next = constants::trim_spaces_left(next, end);
+            string_type operand;
+            p = constants::parse_operand(next, end, operand);
+            if (next == p)
+                BOOST_LOG_THROW_DESCR(parse_error, "Missing operand for a relation in the filter string");
+
+            m_Operand = boost::in_place(operand);
+        }
 
-        // Cut off the quotes
-        string_type str(arg.begin() + 1, arg.end() - 1);
+    DoneL:
+        // The relation can be as simple as a sole attribute placeholder (which means that only attribute presence has to be checked).
+        // So regardless how we get here, the relation is parsed completely.
+        on_relation_complete();
 
-        // Translate escape sequences
-        constants::translate_escape_sequences(str);
-        m_Operand = str;
+        return p;
     }
 
-    //! The method saves the relation word into an internal string
-    void set_comparison_relation(comparison_relation_handler_t rel)
+    //! Checks if the string contains a keyword
+    static bool scan_keyword(iterator_type begin, iterator_type end, iterator_type& next, iterator_type keyword)
     {
-        m_ComparisonRelation = rel;
+        for (iterator_type p = begin; p != end; ++p, ++keyword)
+        {
+            char_type c1 = *p, c2 = *keyword;
+            if (c2 == 0)
+            {
+                if (encoding::isspace(c1))
+                {
+                    next = p;
+                    return true;
+                }
+                break;
+            }
+            if (c1 != c2)
+                break;
+        }
+
+        return false;
     }
 
-    //! The method saves the relation word into an internal string
-    void set_custom_relation(string_type const& rel)
+    //! The attribute name handler
+    void on_attribute_name(iterator_type begin, iterator_type end)
     {
-        m_CustomRelation = rel;
+        if (begin == end)
+            BOOST_LOG_THROW_DESCR(parse_error, "Empty attribute name encountered");
+        m_AttributeName = attribute_name(log::aux::to_narrow(string_type(begin, end)));
     }
 
     //! The comparison relation handler
@@ -401,8 +457,8 @@
     }
 
     //  Assignment and copying are prohibited
-    BOOST_DELETED_FUNCTION(filter_grammar(filter_grammar const&))
-    BOOST_DELETED_FUNCTION(filter_grammar& operator= (filter_grammar const&))
+    BOOST_DELETED_FUNCTION(filter_parser(filter_parser const&))
+    BOOST_DELETED_FUNCTION(filter_parser& operator= (filter_parser const&))
 };
 
 } // namespace
@@ -427,21 +483,15 @@
     typedef CharT char_type;
     typedef log::aux::encoding_specific< typename log::aux::encoding< char_type >::type > encoding_specific;
 
-    filter_grammar< char_type > gram;
+    filter_parser< char_type > parser;
     const char_type* p = begin;
 
     BOOST_LOG_EXPR_IF_MT(filters_repository< CharT >& repo = filters_repository< CharT >::get();)
     BOOST_LOG_EXPR_IF_MT(log::aux::shared_lock_guard< log::aux::light_rw_mutex > lock(repo.m_Mutex);)
 
-    bool result = qi::phrase_parse(p, end, gram, encoding_specific::space);
-    if (!result || p != end)
-    {
-        std::ostringstream strm;
-        strm << "Could not parse the filter, parsing stopped at position " << p - begin;
-        BOOST_LOG_THROW_DESCR(parse_error, strm.str());
-    }
+    parser.parse(p, end);
 
-    return gram.get_filter();
+    return parser.get_filter();
 }
 
 #ifdef BOOST_LOG_USE_CHAR

Modified: trunk/libs/log/src/formatter_parser.cpp
==============================================================================
--- trunk/libs/log/src/formatter_parser.cpp	Sun Aug 18 06:04:46 2013	(r85390)
+++ trunk/libs/log/src/formatter_parser.cpp	2013-08-18 11:10:24 EDT (Sun, 18 Aug 2013)	(r85391)
@@ -15,7 +15,6 @@
 
 #ifndef BOOST_LOG_WITHOUT_SETTINGS_PARSERS
 
-#include <ctime>
 #include <map>
 #include <string>
 #include <sstream>
@@ -201,7 +200,7 @@
                     // We found an escaped character
                     ++p;
                     if (p == end)
-                        BOOST_LOG_THROW_DESCR(parse_error, "Invalid escape sequence in the formatter string.");
+                        BOOST_LOG_THROW_DESCR(parse_error, "Invalid escape sequence in the formatter string");
                 }
                 else if (c == constants::char_percent)
                 {
@@ -216,22 +215,16 @@
             if (p != end)
             {
                 // We found an attribute placeholder
-                iterator_type start = p = constants::trim_spaces_left(++p, end);
-                while (p != end)
-                {
-                    char_type c = *p;
-                    if (!encoding::isalnum(c) && c != constants::char_underline)
-                        break;
-                    ++p;
-                }
+                iterator_type start = constants::trim_spaces_left(++p, end);
+                p = constants::scan_attr_placeholder(start, end);
                 if (p == end)
-                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string.");
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string");
 
-                on_attr_name(start, p);
+                on_attribute_name(start, p);
 
                 p = constants::trim_spaces_left(p, end);
                 if (p == end)
-                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string.");
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string");
 
                 if (*p == constants::char_paren_bracket_left)
                 {
@@ -239,11 +232,11 @@
                     p = parse_args(constants::trim_spaces_left(++p, end), end);
                     p = constants::trim_spaces_left(p, end);
                     if (p == end)
-                        BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string.");
+                        BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string");
                 }
 
                 if (*p != constants::char_percent)
-                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string.");
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder in the formatter string");
 
                 ++p;
 
@@ -272,7 +265,7 @@
     {
         iterator_type p = begin;
         if (p == end)
-            BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string.");
+            BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string");
         if (*p == constants::char_paren_bracket_right)
             return p;
 
@@ -283,76 +276,36 @@
             // Read argument name
             iterator_type start = p;
             if (!encoding::isalpha(*p))
-                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid.");
+                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid");
             for (++p; p != end; ++p)
             {
                 c = *p;
                 if (encoding::isspace(c) || c == constants::char_equal)
                     break;
                 if (!encoding::isalnum(c))
-                    BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid.");
+                    BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid");
             }
 
             if (start == p)
-                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is empty.");
+                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is empty");
 
             on_arg_name(start, p);
 
             p = constants::trim_spaces_left(p, end);
             if (p == end || *p != constants::char_equal)
-                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument description is not valid.");
+                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument description is not valid");
 
             // Read argument value
-            p = constants::trim_spaces_left(++p, end);
-
-            if (p == end)
-                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument value is empty.");
-
-            c = *p;
-            if (c == constants::char_quote)
-            {
-                // The value is specified as a quoted string
-                start = ++p;
-                for (; p != end; ++p)
-                {
-                    c = *p;
-                    if (c == constants::char_quote)
-                    {
-                        break;
-                    }
-                    else if (c == constants::char_backslash)
-                    {
-                        ++p;
-                        if (p == end)
-                            BOOST_LOG_THROW_DESCR(parse_error, "Invalid escape sequence in the argument value.");
-                    }
-                }
-                if (p == end)
-                    BOOST_LOG_THROW_DESCR(parse_error, "Unterminated quoted string in the argument value.");
-
-                on_quoted_string_arg_value(start, p);
-
-                ++p; // skip the closing quote
-            }
-            else
-            {
-                // The value is specified as a single word
-                start = p;
-                for (++p; p != end; ++p)
-                {
-                    c = *p;
-                    if (!encoding::isgraph(c) || c == constants::char_comma || c == constants::char_paren_bracket_left || c == constants::char_paren_bracket_right)
-                        break;
-                }
-
-                on_arg_value(start, p);
-            }
+            start = p = constants::trim_spaces_left(++p, end);
+            p = constants::parse_operand(p, end, m_ArgValue);
+            if (p == start)
+                BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument value is not specified");
 
             push_arg();
 
             p = constants::trim_spaces_left(p, end);
             if (p == end)
-                BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string.");
+                BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string");
 
             c = *p;
             if (c == constants::char_paren_bracket_right)
@@ -363,11 +316,11 @@
             {
                 p = constants::trim_spaces_left(++p, end);
                 if (p == end)
-                    BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid.");
+                    BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid");
             }
             else
             {
-                BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string.");
+                BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string");
             }
         }
 
@@ -379,18 +332,7 @@
     {
         m_ArgName.assign(begin, end);
     }
-    //! The method is called when an argument value is discovered
-    void on_quoted_string_arg_value(iterator_type begin, iterator_type end)
-    {
-        // Cut off the quotes
-        m_ArgValue.assign(begin, end);
-        constants::translate_escape_sequences(m_ArgValue);
-    }
-    //! The method is called when an argument value is discovered
-    void on_arg_value(iterator_type begin, iterator_type end)
-    {
-        m_ArgValue.assign(begin, end);
-    }
+
     //! The method is called when an argument is filled
     void push_arg()
     {
@@ -400,16 +342,22 @@
     }
 
     //! The method is called when an attribute name is discovered
-    void on_attr_name(iterator_type begin, iterator_type end)
+    void on_attribute_name(iterator_type begin, iterator_type end)
     {
         if (begin == end)
             BOOST_LOG_THROW_DESCR(parse_error, "Empty attribute name encountered");
 
         // For compatibility with Boost.Log v1 we recognize %_% as the message attribute name
-        if (std::char_traits< char_type >::compare(constants::message_text_keyword(), begin, end - begin) == 0)
+        const std::size_t len = end - begin;
+        if (std::char_traits< char_type >::length(constants::message_text_keyword()) == len &&
+            std::char_traits< char_type >::compare(constants::message_text_keyword(), begin, len) == 0)
+        {
             m_AttrName = log::aux::default_attribute_names::message();
+        }
         else
+        {
             m_AttrName = attribute_name(log::aux::to_narrow(string_type(begin, end)));
+        }
     }
     //! The method is called when an attribute is filled
     void push_attr()

Modified: trunk/libs/log/src/parser_utils.cpp
==============================================================================
--- trunk/libs/log/src/parser_utils.cpp	Sun Aug 18 06:04:46 2013	(r85390)
+++ trunk/libs/log/src/parser_utils.cpp	2013-08-18 11:10:24 EDT (Sun, 18 Aug 2013)	(r85391)
@@ -18,6 +18,7 @@
 #include <cctype>
 #include <iterator>
 #include <algorithm>
+#include <boost/log/exceptions.hpp>
 #include "parser_utils.hpp"
 #include <boost/log/detail/header.hpp>
 #ifdef BOOST_LOG_USE_WCHAR_T
@@ -72,12 +73,80 @@
     return end;
 }
 
+//! Scans for the attribute name placeholder in the input
+const char* char_constants< char >::scan_attr_placeholder(const char_type* begin, const char_type* end)
+{
+    using namespace std;
+    while (begin != end)
+    {
+        char_type c = *begin;
+        if (!isalnum(c) && c != char_underline)
+            break;
+        ++begin;
+    }
+
+    return begin;
+}
+
+//! Parses an operand string (possibly quoted) from the input
+const char* char_constants< char >::parse_operand(const char_type* begin, const char_type* end, string_type& operand)
+{
+    using namespace std; // to make sure we can use C functions unqualified
+
+    const char_type* p = begin;
+    if (p == end)
+        BOOST_LOG_THROW_DESCR(parse_error, "Operand value is empty");
+
+    char_type c = *p;
+    if (c == char_quote)
+    {
+        // The value is specified as a quoted string
+        const char_type* start = ++p;
+        for (; p != end; ++p)
+        {
+            c = *p;
+            if (c == char_quote)
+            {
+                break;
+            }
+            else if (c == char_backslash)
+            {
+                ++p;
+                if (p == end)
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid escape sequence in the argument value");
+            }
+        }
+        if (p == end)
+            BOOST_LOG_THROW_DESCR(parse_error, "Unterminated quoted string in the argument value");
+
+        operand.assign(start, p);
+        translate_escape_sequences(operand);
+
+        ++p; // skip the closing quote
+    }
+    else
+    {
+        // The value is specified as a single word
+        const char_type* start = p;
+        for (++p; p != end; ++p)
+        {
+            c = *p;
+            if (!isalnum(c) && c != '_' && c != '-' && c != '+' && c != '.')
+                break;
+        }
+
+        operand.assign(start, p);
+    }
+
+    return p;
+}
+
 //! Converts escape sequences to the corresponding characters
-void char_constants< char >::translate_escape_sequences(std::basic_string< char_type >& str)
+void char_constants< char >::translate_escape_sequences(string_type& str)
 {
     using namespace std; // to make sure we can use C functions unqualified
 
-    std::basic_string< char_type >::iterator it = str.begin();
+    string_type::iterator it = str.begin();
     while (it != str.end())
     {
         it = std::find(it, str.end(), '\\');
@@ -100,7 +169,7 @@
                 *it = '\b'; break;
             case 'x':
                 {
-                    std::basic_string< char_type >::iterator b = it;
+                    string_type::iterator b = it;
                     if (std::distance(++b, str.end()) >= 2)
                     {
                         char_type c1 = *b++, c2 = *b++;
@@ -116,7 +185,7 @@
                 {
                     if (*it >= '0' && *it <= '7')
                     {
-                        std::basic_string< char_type >::iterator b = it;
+                        string_type::iterator b = it;
                         int c = (*b++) - '0';
                         if (*b >= '0' && *b <= '7')
                             c = c * 8 + (*b++) - '0';
@@ -177,10 +246,80 @@
     return end;
 }
 
+//! Scans for the attribute name placeholder in the input
+const wchar_t* char_constants< wchar_t >::scan_attr_placeholder(const char_type* begin, const char_type* end)
+{
+    using namespace std;
+    while (begin != end)
+    {
+        char_type c = *begin;
+        if (!iswalnum(c) && c != char_underline)
+            break;
+        ++begin;
+    }
+
+    return begin;
+}
+
+//! Parses an operand string (possibly quoted) from the input
+const wchar_t* char_constants< wchar_t >::parse_operand(const char_type* begin, const char_type* end, string_type& operand)
+{
+    using namespace std; // to make sure we can use C functions unqualified
+
+    const char_type* p = begin;
+    if (p == end)
+        BOOST_LOG_THROW_DESCR(parse_error, "Operand value is empty");
+
+    char_type c = *p;
+    if (c == char_quote)
+    {
+        // The value is specified as a quoted string
+        const char_type* start = ++p;
+        for (; p != end; ++p)
+        {
+            c = *p;
+            if (c == char_quote)
+            {
+                break;
+            }
+            else if (c == char_backslash)
+            {
+                ++p;
+                if (p == end)
+                    BOOST_LOG_THROW_DESCR(parse_error, "Invalid escape sequence in the argument value");
+            }
+        }
+        if (p == end)
+            BOOST_LOG_THROW_DESCR(parse_error, "Unterminated quoted string in the argument value");
+
+        operand.assign(start, p);
+        translate_escape_sequences(operand);
+
+        ++p; // skip the closing quote
+    }
+    else
+    {
+        // The value is specified as a single word
+        const char_type* start = p;
+        for (++p; p != end; ++p)
+        {
+            c = *p;
+            if (!iswalnum(c) && c != L'_' && c != L'-' && c != L'+' && c != L'.')
+                break;
+        }
+
+        operand.assign(start, p);
+    }
+
+    return p;
+}
+
 //! Converts escape sequences to the corresponding characters
-void char_constants< wchar_t >::translate_escape_sequences(std::basic_string< char_type >& str)
+void char_constants< wchar_t >::translate_escape_sequences(string_type& str)
 {
-    std::basic_string< char_type >::iterator it = str.begin();
+    using namespace std; // to make sure we can use C functions unqualified
+
+    string_type::iterator it = str.begin();
     while (it != str.end())
     {
         it = std::find(it, str.end(), L'\\');
@@ -203,7 +342,7 @@
                 *it = L'\b'; break;
             case L'x':
                 {
-                    std::basic_string< char_type >::iterator b = it;
+                    string_type::iterator b = it;
                     if (std::distance(++b, str.end()) >= 2)
                     {
                         char_type c1 = *b++, c2 = *b++;
@@ -217,7 +356,7 @@
                 }
             case L'u':
                 {
-                    std::basic_string< char_type >::iterator b = it;
+                    string_type::iterator b = it;
                     if (std::distance(++b, str.end()) >= 4)
                     {
                         char_type c1 = *b++, c2 = *b++, c3 = *b++, c4 = *b++;
@@ -235,7 +374,7 @@
                 }
             case L'U':
                 {
-                    std::basic_string< char_type >::iterator b = it;
+                    string_type::iterator b = it;
                     if (std::distance(++b, str.end()) >= 8)
                     {
                         char_type c1 = *b++, c2 = *b++, c3 = *b++, c4 = *b++;
@@ -261,7 +400,7 @@
                 {
                     if (*it >= L'0' && *it <= L'7')
                     {
-                        std::basic_string< char_type >::iterator b = it;
+                        string_type::iterator b = it;
                         int c = (*b++) - L'0';
                         if (*b >= L'0' && *b <= L'7')
                             c = c * 8 + (*b++) - L'0';

Modified: trunk/libs/log/src/parser_utils.hpp
==============================================================================
--- trunk/libs/log/src/parser_utils.hpp	Sun Aug 18 06:04:46 2013	(r85390)
+++ trunk/libs/log/src/parser_utils.hpp	2013-08-18 11:10:24 EDT (Sun, 18 Aug 2013)	(r85391)
@@ -40,6 +40,8 @@
 struct char_constants< char >
 {
     typedef char char_type;
+    typedef std::basic_string< char_type > string_type;
+
     static const char_type char_comment = '#';
     static const char_type char_comma = ',';
     static const char_type char_dot = '.';
@@ -152,8 +154,12 @@
     static const char_type* trim_spaces_left(const char_type* begin, const char_type* end);
     //! Skips spaces in the end of the input
     static const char_type* trim_spaces_right(const char_type* begin, const char_type* end);
+    //! Scans for the attribute name placeholder in the input
+    static const char_type* scan_attr_placeholder(const char_type* begin, const char_type* end);
+    //! Parses an operand string (possibly quoted) from the input
+    static const char_type* parse_operand(const char_type* begin, const char_type* end, string_type& operand);
     //! Converts escape sequences to the corresponding characters
-    static void translate_escape_sequences(std::basic_string< char_type >& str);
+    static void translate_escape_sequences(string_type& str);
 };
 #endif
 
@@ -162,6 +168,8 @@
 struct char_constants< wchar_t >
 {
     typedef wchar_t char_type;
+    typedef std::basic_string< char_type > string_type;
+
     static const char_type char_comment = L'#';
     static const char_type char_comma = L',';
     static const char_type char_dot = L'.';
@@ -278,8 +286,12 @@
     static const char_type* trim_spaces_left(const char_type* begin, const char_type* end);
     //! Skips spaces in the end of the input
     static const char_type* trim_spaces_right(const char_type* begin, const char_type* end);
+    //! Scans for the attribute name placeholder in the input
+    static const char_type* scan_attr_placeholder(const char_type* begin, const char_type* end);
+    //! Parses an operand string (possibly quoted) from the input
+    static const char_type* parse_operand(const char_type* begin, const char_type* end, string_type& operand);
     //! Converts escape sequences to the corresponding characters
-    static void translate_escape_sequences(std::basic_string< char_type >& str);
+    static void translate_escape_sequences(string_type& str);
 };
 #endif
 

Modified: trunk/libs/log/src/settings_parser.cpp
==============================================================================
--- trunk/libs/log/src/settings_parser.cpp	Sun Aug 18 06:04:46 2013	(r85390)
+++ trunk/libs/log/src/settings_parser.cpp	2013-08-18 11:10:24 EDT (Sun, 18 Aug 2013)	(r85391)
@@ -21,6 +21,9 @@
 #include <stdexcept>
 #include <algorithm>
 #include <boost/throw_exception.hpp>
+#include <boost/exception/exception.hpp>
+#include <boost/exception/info.hpp>
+#include <boost/exception/errinfo_at_line.hpp>
 #include <boost/io/ios_state.hpp>
 #include <boost/move/core.hpp>
 #include <boost/move/utility.hpp>
@@ -88,7 +91,7 @@
                 start = constants::trim_spaces_left(start, end);
                 iterator_type stop = std::find(start, end, constants::char_section_bracket_right);
                 if (stop == end)
-                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Section header is invalid.", (m_LineCounter));
+                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Section header is invalid", (m_LineCounter));
 
                 p = stop + 1;
                 stop = constants::trim_spaces_right(start, stop);
@@ -100,7 +103,7 @@
                 // We have a parameter
                 iterator_type eq = std::find(p, end, constants::char_equal);
                 if (eq == end)
-                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter description is invalid.", (m_LineCounter));
+                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter description is invalid", (m_LineCounter));
 
                 // Parameter name
                 set_parameter_name(p, constants::trim_spaces_right(p, eq));
@@ -108,46 +111,17 @@
                 // Parameter value
                 p = constants::trim_spaces_left(eq + 1, end);
                 if (p == end || *p == constants::char_comment)
-                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter value is not specified.", (m_LineCounter));
+                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter value is not specified", (m_LineCounter));
 
-                c = *p;
-                if (c == constants::char_quote)
+                try
                 {
-                    // The value is specified as a quoted string
-                    iterator_type start = ++p;
-                    for (; p != end; ++p)
-                    {
-                        c = *p;
-                        if (c == constants::char_quote)
-                        {
-                            break;
-                        }
-                        else if (c == constants::char_backslash)
-                        {
-                            ++p;
-                            if (p == end)
-                                BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Invalid escape sequence in the parameter value.", (m_LineCounter));
-                        }
-                    }
-                    if (p == end)
-                        BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Unterminated quoted string in the parameter value.", (m_LineCounter));
-
-                    set_parameter_quoted_value(start, p);
-
-                    ++p; // skip the closing quote
+                    string_type value;
+                    p = constants::parse_operand(p, end, value);
+                    set_parameter_value(value);
                 }
-                else
+                catch (parse_error& e)
                 {
-                    // The value is specified as a single word
-                    iterator_type start = p;
-                    for (++p; p != end; ++p)
-                    {
-                        c = *p;
-                        if (c == constants::char_comment || !encoding::isgraph(c))
-                            break;
-                    }
-
-                    set_parameter_value(start, p);
+                    throw boost::enable_error_info(e) << boost::errinfo_at_line(m_LineCounter);
                 }
             }
 
@@ -163,7 +137,7 @@
                 }
                 else
                 {
-                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Unexpected characters in the end of the line.", (m_LineCounter));
+                    BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Unexpected characters in the end of the line", (m_LineCounter));
                 }
             }
         }
@@ -177,13 +151,13 @@
     {
         // Check that the section name is valid
         if (begin == end)
-            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Section name is empty.", (m_LineCounter));
+            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Section name is empty", (m_LineCounter));
 
         for (iterator_type p = begin; p != end; ++p)
         {
             char_type c = *p;
             if (c != constants::char_dot && !encoding::isalnum(c))
-                BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Section name is invalid.", (m_LineCounter));
+                BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Section name is invalid", (m_LineCounter));
         }
 
         m_SectionName = log::aux::to_narrow(string_type(begin, end), m_Locale);
@@ -200,40 +174,30 @@
         if (m_SectionName.empty())
         {
             // The parameter encountered before any section starter
-            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameters are only allowed within sections.", (m_LineCounter));
+            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameters are only allowed within sections", (m_LineCounter));
         }
 
         // Check that the parameter name is valid
         if (begin == end)
-            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter name is empty.", (m_LineCounter));
+            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter name is empty", (m_LineCounter));
 
         iterator_type p = begin;
         if (!encoding::isalpha(*p))
-            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter name is invalid.", (m_LineCounter));
+            BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter name is invalid", (m_LineCounter));
         for (++p; p != end; ++p)
         {
             char_type c = *p;
             if (!encoding::isgraph(c))
-                BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter name is invalid.", (m_LineCounter));
+                BOOST_LOG_THROW_DESCR_PARAMS(parse_error, "Parameter name is invalid", (m_LineCounter));
         }
 
         m_ParameterName = log::aux::to_narrow(string_type(begin, end), m_Locale);
     }
 
     //! The method sets the parsed parameter value (non-quoted)
-    void set_parameter_value(iterator_type begin, iterator_type end)
-    {
-        m_Settings[m_SectionName][m_ParameterName] = string_type(begin, end);
-        m_ParameterName.clear();
-    }
-
-    //! The method sets the parsed parameter value (quoted)
-    void set_parameter_quoted_value(iterator_type begin, iterator_type end)
+    void set_parameter_value(string_type const& value)
     {
-        // Cut off the quotes
-        string_type val(begin, end);
-        constants::translate_escape_sequences(val);
-        m_Settings[m_SectionName][m_ParameterName] = val;
+        m_Settings[m_SectionName][m_ParameterName] = value;
         m_ParameterName.clear();
     }