Regex backreference [2/3] Validate the entire regex is consumed.

[Mordante]

Summary

This change would have warned about the bug found in the previous patch.
No unit tests since the exception should never throw.

[mclow.lists]

This looks good to me.

libcxx/include/regex

969

Sadly, I think that placing it before 'unknown' *is* an ABI break, because we throw these error codes, and if people were to catch them - and dispatch on them, their code would break.

[Mordante]

Removed the ABI question in the comment

[Mordante]

Thanks for the review!

I don't have commit access, could you commit this patch?

libcxx/include/regex

969

I feared it would. Updated the patch to remove this comment

libcxx/include/regex

enum error_type
     error_badbrace,
     error_range,
     error_space,
     error_badrepeat,
     error_complexity,
     error_stack,
     __re_err_grammar,
     __re_err_empty,
-    __re_err_unknown
+    __re_err_unknown,
+    __re_err_parse
 };
 
 }  // regex_constants
 
 class _LIBCPP_EXCEPTION_ABI regex_error
     : public runtime_error
 {
     regex_constants::error_type __code_;
basic_regex()
         : __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {}
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
-        __parse(__p, __p + __traits_.length(__p));
+        __init(__p, __p + __traits_.length(__p));
         }
 
     _LIBCPP_INLINE_VISIBILITY
     basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
-        __parse(__p, __p + __len);
+        __init(__p, __p + __len);
         }
 
 //     basic_regex(const basic_regex&) = default;
 //     basic_regex(basic_regex&&) = default;
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
                              flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
-        __parse(__p.begin(), __p.end());
+        __init(__p.begin(), __p.end());
         }
 
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         basic_regex(_ForwardIterator __first, _ForwardIterator __last,
                     flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
-        __parse(__first, __last);
+        __init(__first, __last);
         }
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_regex(initializer_list<value_type> __il,
                 flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
-        __parse(__il.begin(), __il.end());
+        __init(__il.begin(), __il.end());
         }
 #endif  // _LIBCPP_CXX03_LANG
 
 //    ~basic_regex() = default;
 
 //     basic_regex& operator=(const basic_regex&) = default;
 //     basic_regex& operator=(basic_regex&&) = default;
     _LIBCPP_INLINE_VISIBILITY
#endif  // _LIBCPP_CXX03_LANG
     // swap:
     void swap(basic_regex& __r);
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     unsigned __loop_count() const {return __loop_count_;}
 
     template <class _ForwardIterator>
+        void
+        __init(_ForwardIterator __first, _ForwardIterator __last);
+    template <class _ForwardIterator>
         _ForwardIterator
         __parse(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
__lookahead<_CharT, _Traits>::__exec(__state& __s) const
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
+void
+basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last)
+{
+    if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+    _ForwardIterator __temp = __parse(__first, __last);
+    if ( __temp != __last)
+        __throw_regex_error<regex_constants::__re_err_parse>();
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
                                       _ForwardIterator __last)
 {
     {
         unique_ptr<__node> __h(new __end_state<_CharT>);
         __start_.reset(new __empty_state<_CharT>(__h.get()));
         __h.release();

libcxx/src/regex.cpp

case regex_constants::error_complexity:
                "expression exceeded a pre-set level.";
     case regex_constants::error_stack:
         return "There was insufficient memory to determine whether the regular "
                "expression could match the specified character sequence.";
     case regex_constants::__re_err_grammar:
         return "An invalid regex grammar has been requested.";
     case regex_constants::__re_err_empty:
         return "An empty regex is not allowed in the POSIX grammar.";
+    case regex_constants::__re_err_parse:
+        return "The parser did not consume the entire regular expression.";
     default:
         break;
     }
     return "Unknown error type";
 }
 
 regex_error::regex_error(regex_constants::error_type ecode)
     : runtime_error(make_error_type_string(ecode)),