Fixes parsing of [default: x] in some cases on Win.

If the option definition spans over multiple lines, then
parsing of the [default: x] was not working on Windows -
tested on MS Visual Studio 2015.

This is due to the differences in regex's multiline property
implementation.

On some platforms - Linux libstd++ the multiline property is off,
on some platforms - msvc2015 the multiline property is on.

It cannot be changed programmatically AFAIK.

I was not able to come up with a regex expression which
would work on Linux and on Windows as well. So I tried to be
smart and replace '\n' by '\f' in the string beforehand.
The regex was easy and worked on Linux and Windows just fine
- up until I tried a longer option definition.
Then the msvc2015 regex failed with 'stack' exception. Hence
this change.

It splits the option definition section by a simple regex
which does not use the problematic '$'.

	modified:   docopt.cpp
	modified:   docopt_util.h

Author: rhorenov

docopt.cpp

@@ -521,31 +521,23 @@ static PatternList parse_argv(Tokens tokens, std::vector<Option>& options, bool
 	return ret;
 }
 
-static std::vector<Option> parse_defaults(std::string const& doc) {
-	// This pattern is a bit more complex than the python docopt one due to lack of
-	// re.split. Effectively, it grabs any line with leading whitespace and then a
-	// hyphen; it stops grabbing when it hits another line that also looks like that.
-	static std::regex const pattern {
+std::vector<Option> parse_defaults(std::string const& doc) {
+	// This pattern is a delimiter by which we split the options.
+	// The delimiter is a new line followed by a whitespace(s) followed by one or two hyphens.
+	static std::regex const re_delimiter{
 		"(?:^|\\n)[ \\t]*"  // a new line with leading whitespace
-		"(-(.|\\n)*?)"      // a hyphen, and then grab everything it can...
-		"(?=\\n[ \\t]*-|$)" //  .. until it hits another new line with space and a hyphen
+		"(?=-{1,2})"        // [split happens here] (positive lookahead) ... and followed by one or two hyphes
 	};
 
 	std::vector<Option> defaults;
+	for (auto s : parse_section("options:", doc)) {
+		s.erase(s.begin(), s.begin() + s.find(':') + 1); // get rid of "options:"
 
-	for(auto s : parse_section("options:", doc)) {
-		s.erase(s.begin(), s.begin()+static_cast<std::ptrdiff_t>(s.find(':'))+1); // get rid of "options:"
-
-		std::for_each(std::sregex_iterator{ s.begin(), s.end(), pattern },
-			      std::sregex_iterator{},
-			      [&](std::smatch const& m)
-		{
-			std::string opt = m[1].str();
-
+		for (const auto& opt : regex_split(s, re_delimiter)) {
 			if (starts_with(opt, "-")) {
 				defaults.emplace_back(Option::parse(opt));
 			}
-		});
+		}
 	}
 
 	return defaults;

docopt_util.h

@@ -9,6 +9,15 @@
 #ifndef docopt_docopt_util_h
 #define docopt_docopt_util_h
 
+#if DOCTOPT_USE_BOOST_REGEX
+#include <boost/regex.hpp>
+namespace std {
+    using boost::regex;
+    using boost::sregex_token_iterator;
+}
+#else
+#include <regex>
+#endif
 
 #pragma mark -
 #pragma mark General utility
@@ -21,46 +30,46 @@ namespace {
 		return std::equal(prefix.begin(), prefix.end(),
 				  str.begin());
 	}
-	
+
 	std::string trim(std::string&& str,
 			 const std::string& whitespace = " \t\n")
 	{
 		const auto strEnd = str.find_last_not_of(whitespace);
 		if (strEnd==std::string::npos)
 			return {}; // no content
 		str.erase(strEnd+1);
-		
+
 		const auto strBegin = str.find_first_not_of(whitespace);
 		str.erase(0, strBegin);
-		
+
 		return std::move(str);
 	}
-	
+
 	std::vector<std::string> split(std::string const& str, size_t pos = 0)
 	{
 		const char* const anySpace = " \t\r\n\v\f";
-		
+
 		std::vector<std::string> ret;
 		while (pos != std::string::npos) {
 			auto start = str.find_first_not_of(anySpace, pos);
 			if (start == std::string::npos) break;
-			
+
 			auto end = str.find_first_of(anySpace, start);
 			auto size = end==std::string::npos ? end : end-start;
 			ret.emplace_back(str.substr(start, size));
-			
+
 			pos = end;
 		}
-		
+
 		return ret;
 	}
-	
+
 	std::tuple<std::string, std::string, std::string> partition(std::string str, std::string const& point)
 	{
 		std::tuple<std::string, std::string, std::string> ret;
-		
+
 		auto i = str.find(point);
-		
+
 		if (i == std::string::npos) {
 			// no match: string goes in 0th spot only
 		} else {
@@ -69,22 +78,33 @@ namespace {
 			str.resize(i);
 		}
 		std::get<0>(ret) = std::move(str);
-		
+
 		return ret;
 	}
-	
+
 	template <typename I>
 	std::string join(I iter, I end, std::string const& delim) {
 		if (iter==end)
 			return {};
-		
+
 		std::string ret = *iter;
 		for(++iter; iter!=end; ++iter) {
 			ret.append(delim);
 			ret.append(*iter);
 		}
 		return ret;
 	}
+
+	std::vector<std::string> regex_split(std::string const& text, std::regex const& re)
+	{
+		std::vector<std::string> ret;
+		for (auto it = std::sregex_token_iterator(text.begin(), text.end(), re, -1);
+			it != std::sregex_token_iterator();
+			++it) {
+			ret.emplace_back(*it);
+		}
+		return ret;
+	}
 }
 
 namespace docopt {