diff --git a/include/boost/program_options/detail/cmdline.hpp b/include/boost/program_options/detail/cmdline.hpp
index a8b4f72..d5c39d2 100644
--- a/include/boost/program_options/detail/cmdline.hpp
+++ b/include/boost/program_options/detail/cmdline.hpp
@@ -93,6 +93,9 @@ namespace boost { namespace program_options { namespace detail {
             std::vector<std::string>& args);
         std::vector<option> parse_terminator(
             std::vector<std::string>& args);
+        std::vector<option> handle_additional_parser(
+            std::vector<std::string>& args);
+
 
         /** Set additional parser. This will be called for each token
             of command line. If first string in pair is not empty,
@@ -111,10 +114,9 @@ namespace boost { namespace program_options { namespace detail {
 
         void init(const std::vector<std::string>& args, int style);
 
-        std::vector<option> 
-        cmdline::parse_option(const std::string& name,
-                              const std::string& adjacent_value,
-                              std::vector<std::string>& other_tokens);
+        void
+        finish_option(option& opt,
+                      std::vector<std::string>& other_tokens);
 
         // Copies of input.
         std::vector<std::string> args;
diff --git a/src/cmdline.cpp b/src/cmdline.cpp
index 422ddc5..3534dad 100644
--- a/src/cmdline.cpp
+++ b/src/cmdline.cpp
@@ -177,12 +177,17 @@ namespace boost { namespace program_options { namespace detail {
     cmdline::run()
     {
         // The parsing is done by having a set of 'style parsers'
-        // and trying then in order. Each 'style parser' can:
-        // - return a vector<option>
-        // - consume some input
+        // and trying then in order. Each parser is passed a vector
+        // of unparsed tokens and can consume some of them (by
+        // removing elements on front) and return a vector of options.
         //
-        // When some 'style parser' consumes some input 
-        // we start with the first style parser. 
+        // We try each style parser in turn, untill some input
+        // is consumed. The returned vector of option may contain the
+        // result of just syntactic parsing of token, say --foo will
+        // be parsed as option with name 'foo', and the style parser
+        // is not required to care if that option is defined, and how
+        // many tokens the value may take.
+        // So, after vector is returned, we validate them.
         assert(m_desc);
 
         vector<style_parser> style_parsers;      
@@ -190,6 +195,10 @@ namespace boost { namespace program_options { namespace detail {
         if (m_style_parser)
             style_parsers.push_back(m_style_parser);
 
+        if (m_additional_parser)
+            style_parsers.push_back(
+                bind(&cmdline::handle_additional_parser, this, _1));
+
         if (m_style & allow_long)
             style_parsers.push_back(
                 bind(&cmdline::parse_long_option, this, _1));
@@ -210,30 +219,32 @@ namespace boost { namespace program_options { namespace detail {
         vector<option> result;
         while(!args.empty())
         {
-            if (m_additional_parser) {
-                pair<string, string> r = m_additional_parser(args[0]);
-                if (!r.first.empty()) {
-                    option next;
-                    next.string_key = r.first;
-                    next.value.push_back(r.second);
-                    result.push_back(next);
-                    args.erase(args.begin());
-                    continue;
-                }
-            }
-
             bool ok = false;
             for(unsigned i = 0; i < style_parsers.size(); ++i)
             {
                 unsigned current_size = args.size();
                 vector<option> next = style_parsers[i](args);
-                for (unsigned j = 0; j < next.size(); ++j)
-                    result.push_back(next[j]);
 
+                // Check that option names
+                // are valid, and that all values are in place.
+                if (!next.empty())
+                {
+                    vector<string> e;
+                    for(unsigned k = 0; k < next.size()-1; ++k) {
+                        finish_option(next[k], e);
+                    }
+                    // For the last option, pass the unparsed tokens
+                    // so that they can be added to next.back()'s values
+                    // if appropriate.
+                    finish_option(next.back(), args);
+                    for (unsigned j = 0; j < next.size(); ++j)
+                        result.push_back(next[j]);                    
+                }
+                                
                 if (args.size() != current_size) {
                     ok = true;
                     break;                
-                }
+                } 
             }
             
             if (!ok) {
@@ -271,19 +282,20 @@ namespace boost { namespace program_options { namespace detail {
         return result;
     }
 
-    std::vector<option> 
-    cmdline::parse_option(const std::string& name,
-                          const std::string& adjacent_value,
-                          vector<string>& other_tokens)
+    void
+    cmdline::finish_option(option& opt,
+                           vector<string>& other_tokens)
     {                                    
-        std::vector<option> result;
+        if (opt.string_key.empty())
+            return;
 
+        // First check that the option is valid, and get its description.
         // TODO: case-sensitivity.
         const option_description& d = 
-            m_desc->find(name, (m_style & allow_guessing));
+            m_desc->find(opt.string_key, (m_style & allow_guessing));
 
-        option opt;
-        opt.string_key = d.key(name);
+        // Canonize the name
+        opt.string_key = d.key(opt.string_key);
 
         // We check that the min/max number of tokens for the option
         // agrees with the number of tokens we have. The 'adjacent_value'
@@ -296,30 +308,18 @@ namespace boost { namespace program_options { namespace detail {
         unsigned min_tokens = d.semantic()->min_tokens();
         unsigned max_tokens = d.semantic()->max_tokens();
         
-        unsigned present_tokens = other_tokens.size() 
-            + int(!adjacent_value.empty());
+        unsigned present_tokens = opt.value.size() + other_tokens.size();
         
         if (present_tokens >= min_tokens)
         {
-            if (!adjacent_value.empty() && max_tokens == 0) {
-                throw_exception(invalid_command_line_syntax(name,
+            if (!opt.value.empty() && max_tokens == 0) {
+                throw_exception(invalid_command_line_syntax(opt.string_key,
                     invalid_command_line_syntax::extra_parameter));                                                                
             }
-
-            // Everything's OK, move the values to the result.
-            if (!adjacent_value.empty())
-            {
-                opt.value.push_back(adjacent_value);
-                --min_tokens;
-                --max_tokens;
-            }
-            else if (min_tokens == 0 && max_tokens == 1)
-            {
-                // hack to handle implicit options.
-                max_tokens = 0;
-            }
-
             
+            max_tokens -= opt.value.size();
+
+            // Everything's OK, move the values to the result.            
             for(;!other_tokens.empty() && max_tokens--; ) {
                 opt.value.push_back(other_tokens[0]);
                 other_tokens.erase(other_tokens.begin());
@@ -327,17 +327,16 @@ namespace boost { namespace program_options { namespace detail {
         }
         else
         {
-            throw_exception(invalid_command_line_syntax(name,
+            throw_exception(invalid_command_line_syntax(opt.string_key,
                 invalid_command_line_syntax::missing_parameter));                                                                
 
         }
-        result.push_back(opt);
-        return result;
     }
 
     std::vector<option> 
     cmdline::parse_long_option(std::vector<string>& args)
     {
+        vector<option> result;
         const std::string& tok = args[0];
         if (tok.size() >= 3 && tok[0] == '-' && tok[1] == '-')
         {   
@@ -356,11 +355,14 @@ namespace boost { namespace program_options { namespace detail {
             {
                 name = tok.substr(2);
             }
+            option opt;
+            opt.string_key = name;
+            if (!adjacent.empty())
+                opt.value.push_back(adjacent);
+            result.push_back(opt);
             args.erase(args.begin());
-            return parse_option(name, adjacent, args);
-
         }
-        return vector<option>();
+        return result;
     }
 
 
@@ -388,10 +390,9 @@ namespace boost { namespace program_options { namespace detail {
                 if ((m_style & allow_sticky) &&
                     d.semantic()->max_tokens() == 0 && !adjacent.empty()) {
                     // 'adjacent' is in fact further option.
-                    vector<std::string> dummy;
-                    vector<option> n = parse_option(name, std::string(), dummy);
-                    for (unsigned i = 0; i < n.size(); ++i)
-                        result.push_back(n[i]);
+                    option opt;
+                    opt.string_key = name;
+                    result.push_back(opt);
 
                     if (adjacent.empty())
                     {
@@ -402,17 +403,14 @@ namespace boost { namespace program_options { namespace detail {
                     name = string("-") + adjacent[0];
                     adjacent.erase(adjacent.begin());
                 } else {
-
+                    
+                    option opt;
+                    opt.string_key = name;
+                    if (!adjacent.empty())
+                        opt.value.push_back(adjacent);
+                    result.push_back(opt);
                     args.erase(args.begin());                    
-                    // The current option accepts some tokens for value,
-                    // parse it in a regular way.
-                    vector<option> n = parse_option(name, adjacent,
-                                                    args);
-                    for (unsigned i = 0; i < n.size(); ++i)
-                        result.push_back(n[i]);
-
                     break;
-
                 }
             }
             return result;
@@ -423,18 +421,21 @@ namespace boost { namespace program_options { namespace detail {
     std::vector<option> 
     cmdline::parse_dos_option(std::vector<string>& args)
     {
+        vector<option> result;
         const std::string& tok = args[0];
         if (tok.size() >= 2 && tok[0] == '/')
         {   
-            vector<option> result;
-
             string name = "-" + tok.substr(1,1);
             string adjacent = tok.substr(2);
 
+            option opt;
+            opt.string_key = name;
+            if (!adjacent.empty())
+                opt.value.push_back(adjacent);
+            result.push_back(opt);
             args.erase(args.begin());
-            return parse_option(name, adjacent, args);
         }
-        return std::vector<option>();
+        return result;
     }
 
     std::vector<option> 
@@ -474,6 +475,21 @@ namespace boost { namespace program_options { namespace detail {
         return result;
     }
 
+    std::vector<option> 
+    cmdline::handle_additional_parser(std::vector<std::string>& args)
+    {
+        vector<option> result;
+        pair<string, string> r = m_additional_parser(args[0]);
+        if (!r.first.empty()) {
+            option next;
+            next.string_key = r.first;
+            next.value.push_back(r.second);
+            result.push_back(next);
+            args.erase(args.begin());
+        }
+        return result;
+    }
+
     void 
     cmdline::set_additional_parser(additional_parser p)
     {
diff --git a/test/cmdline_test.cpp b/test/cmdline_test.cpp
index cf0336b..d4ecbf0 100644
--- a/test/cmdline_test.cpp
+++ b/test/cmdline_test.cpp
@@ -440,6 +440,15 @@ pair<string, string> at_option_parser(string const&s)
         return pair<string, string>();
 }
 
+pair<string, string> at_option_parser_broken(string const&s)
+{
+    if ('@' == s[0])
+        return std::make_pair(string("some garbage"), s.substr(1));
+    else
+        return pair<string, string>();
+}
+
+
 
 void test_additional_parser()
 {
@@ -464,6 +473,15 @@ void test_additional_parser()
     BOOST_CHECK_EQUAL(result[0].value[0], "config");
     BOOST_CHECK_EQUAL(result[1].string_key, "foo");
     BOOST_CHECK_EQUAL(result[1].value[0], "1");    
+
+    // Test that invalid options returned by additional style
+    // parser are detected.
+    detail::cmdline cmd2(input, command_line_style::default_style);
+    cmd2.set_options_description(desc);
+    cmd2.set_additional_parser(at_option_parser_broken);
+
+    BOOST_CHECK_THROW(cmd2.run(), unknown_option);
+
 }
 
 vector<option> at_option_parser2(vector<string>& args)
@@ -503,7 +521,6 @@ void test_style_parser()
     BOOST_CHECK_EQUAL(result[1].value[0], "1");    
 }
 
-
 int test_main(int ac, char* av[])
 {
     test_long_options();