Fix some typos in the comment header for <regex>

[• Quuxplusone]

Summary

No functional change because all the changed "code" is actually inside comments.
I noticed these typos when I tried to uncomment the header and use it as a poor man's cleaned-up version of the library.
I'll need someone to land this for me.

[ldionne]

Thanks!

libcxx/include/regex

 #include <initializer_list>
 
 namespace std
 {
 
 namespace regex_constants
 {
 
-emum syntax_option_type
+enum syntax_option_type
 {
     icase      = unspecified,
     nosubs     = unspecified,
     optimize   = unspecified,
     collate    = unspecified,
     ECMAScript = unspecified,
     basic      = unspecified,
     extended   = unspecified,

 template <class OutputIterator, class BidirectionalIterator,
           class traits, class charT>
     OutputIterator
     regex_replace(OutputIterator out,
                   BidirectionalIterator first, BidirectionalIterator last,
                   const basic_regex<charT, traits>& e, const charT* fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
-template <class traits, class charT, class ST, class SA, class FST, class FSA>>
+template <class traits, class charT, class ST, class SA, class FST, class FSA>
     basic_string<charT, ST, SA>
     regex_replace(const basic_string<charT, ST, SA>& s,
                   const basic_regex<charT, traits>& e,
                   const basic_string<charT, FST, FSA>& fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class traits, class charT, class ST, class SA>
     basic_string<charT, ST, SA>
public:
     typedef const value_type*                    pointer;
     typedef const value_type&                    reference;
     typedef forward_iterator_tag                 iterator_category;
 
     regex_iterator();
     regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                    const regex_type& re,
                    regex_constants::match_flag_type m = regex_constants::match_default);
-    regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                   const regex_type&& __re,
-                   regex_constants::match_flag_type __m
+    regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
+                   const regex_type&& re,
+                   regex_constants::match_flag_type m
                                      = regex_constants::match_default) = delete; // C++14
     regex_iterator(const regex_iterator&);
     regex_iterator& operator=(const regex_iterator&);
 
     bool operator==(const regex_iterator&) const;
     bool operator!=(const regex_iterator&) const;
 
     const value_type& operator*() const;
     const value_type* operator->() const;
 
     regex_iterator& operator++();
     regex_iterator operator++(int);
 };
 
 typedef regex_iterator<const char*>             cregex_iterator;
 typedef regex_iterator<const wchar_t*>          wcregex_iterator;
 typedef regex_iterator<string::const_iterator>  sregex_iterator;
 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
 
 template <class BidirectionalIterator,
-          class charT = typename iterator_traits< BidirectionalIterator>::value_type,
+          class charT = typename iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT>>
 class regex_token_iterator
 {
 public:
     typedef basic_regex<charT, traits>       regex_type;
     typedef sub_match<BidirectionalIterator> value_type;
     typedef ptrdiff_t                        difference_type;
     typedef const value_type*                pointer;
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type&& re, initializer_list<int> submatches,
                          regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     template <size_t N>
         regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                              const regex_type& re, const int (&submatches)[N],
                              regex_constants::match_flag_type m = regex_constants::match_default);
     template <size_t N>
         regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
-                             const regex_type& re, const int (&submatches)[N],
-                             regex_constants::match_flag_type m = regex_constants::match_default) = delete // C++14;
+                             const regex_type&& re, const int (&submatches)[N],
+                             regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     regex_token_iterator(const regex_token_iterator&);
     regex_token_iterator& operator=(const regex_token_iterator&);
 
     bool operator==(const regex_token_iterator&) const;
     bool operator!=(const regex_token_iterator&) const;
 
     const value_type& operator*() const;
     const value_type* operator->() const;