[libcxx] Remove use of uniform initialization from regex tests so that they compile in C++03.

[mclow.lists]

Fine with me.

test/re/re.alg/re.alg.match/lookahead_capture.pass.cpp

 int main()
 {
     {
-        std::regex re{"^(?=(.))a$"};
+        std::regex re("^(?=(.))a$");
         assert(re.mark_count() == 1);
 
-        std::string s{"a"};
+        std::string s("a");
         std::smatch m;
         assert(std::regex_match(s, m, re));
         assert(m.size() == 2);

     }
 
     {
-        std::regex re{"^(a)(?=(.))(b)$"};
+        std::regex re("^(a)(?=(.))(b)$");
         assert(re.mark_count() == 3);
 
-        std::string s{"ab"};
+        std::string s("ab");
         std::smatch m;
         assert(std::regex_match(s, m, re));
         assert(m.size() == 4);

     }
 
     {
-        std::regex re{"^(.)(?=(.)(?=.(.)))(...)$"};
+        std::regex re("^(.)(?=(.)(?=.(.)))(...)$");
         assert(re.mark_count() == 4);
 
-        std::string s{"abcd"};
+        std::string s("abcd");
         std::smatch m;
         assert(std::regex_match(s, m, re));
         assert(m.size() == 5);

     }
 
     {
-        std::regex re{"^(a)(?!([^b]))(.c)$"};
+        std::regex re("^(a)(?!([^b]))(.c)$");
         assert(re.mark_count() == 3);
 
-        std::string s{"abc"};
+        std::string s("abc");
         std::smatch m;
         assert(std::regex_match(s, m, re));
         assert(m.size() == 4);

     }
 
     {
-        std::regex re{"^(?!((b)))(?=(.))(?!(abc)).b$"};
+        std::regex re("^(?!((b)))(?=(.))(?!(abc)).b$");
         assert(re.mark_count() == 4);
 
-        std::string s{"ab"};
+        std::string s("ab");
         std::smatch m;
         assert(std::regex_match(s, m, re));
         assert(m.size() == 5);

test/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp

 void
 test1()
 {
-    std::string re{"\\{a\\}"};
-    std::string target{"{a}"};
-    std::regex regex{re};
+    std::string re("\\{a\\}");
+    std::string target("{a}");
+    std::regex regex(re);
     std::smatch smatch;
     assert((std::regex_match(target, smatch, regex)));
 }

 void
 test2()
 {
-    std::string re{"\\{a\\}"};
-    std::string target{"{a}"};
-    std::regex regex{re, std::regex::extended};
+    std::string re("\\{a\\}");
+    std::string target("{a}");
+    std::regex regex(re, std::regex::extended);
     std::smatch smatch;
     assert((std::regex_match(target, smatch, regex)));
 }

 void
 test3()
 {
-    std::string re{"\\{a\\}"};
-    std::string target{"{a}"};
-    std::regex regex{re, std::regex::awk};
+    std::string re("\\{a\\}");
+    std::string target("{a}");
+    std::regex regex(re, std::regex::awk);
     std::smatch smatch;
     assert((std::regex_match(target, smatch, regex)));
 }

 void
 test4()
 {
-    std::string re{"\\{a\\}"};
-    std::string target{"{a}"};
-    std::regex regex{re, std::regex::egrep};
+    std::string re("\\{a\\}");
+    std::string target("{a}");
+    std::regex regex(re, std::regex::egrep);
     std::smatch smatch;
     assert((std::regex_match(target, smatch, regex)));
 }

test/re/re.alg/re.alg.search/backup.pass.cpp

     // This regex_iterator uses regex_search(__wrap_iter<_Iter> __first, ...)
     // Test for http://llvm.org/bugs/show_bug.cgi?id=16240 fixed in r185273.
     {
-        std::string s{"aaaa a"};
-        std::regex re{"\\ba"};
-        std::sregex_iterator it{s.begin(), s.end(), re};
-        std::sregex_iterator end{};
+        std::string s("aaaa a");
+        std::regex re("\\ba");
+        std::sregex_iterator it(s.begin(), s.end(), re);
+        std::sregex_iterator end = std::sregex_iterator();
 
         assert(it->position(0) == 0);
         assert(it->length(0) == 1);

 
     // This regex_iterator uses regex_search(_BidirectionalIterator __first, ...)
     {
-        std::string s{"aaaa a"};
-        std::list<char> l{s.begin(), s.end()};
-        std::regex re{"\\ba"};
-        std::regex_iterator<std::list<char>::iterator> it{l.begin(), l.end(), re};
-        std::regex_iterator<std::list<char>::iterator> end{};
+        std::string s("aaaa a");
+        std::list<char> l(s.begin(), s.end());
+        std::regex re("\\ba");
+        std::regex_iterator<std::list<char>::iterator> it(l.begin(), l.end(), re);
+        std::regex_iterator<std::list<char>::iterator> end = std::regex_iterator<std::list<char>::iterator>();
 
         assert(it->position(0) == 0);
         assert(it->length(0) == 1);

test/re/re.alg/re.alg.search/no_update_pos.pass.cpp

     // of the text.
 
     const char *text = "aaa\naa";
-    std::regex re{"^a"};
-    std::cregex_iterator it{text, text+6, re};
-    std::cregex_iterator end{};
+    std::regex re("^a");
+    std::cregex_iterator it(text, text+6, re);
+    std::cregex_iterator end = std::cregex_iterator();
 
     assert(it->str() == "a");
     assert(it->position(0) == 0);

test/re/re.regex/re.regex.construct/awk_oct.pass.cpp

 {
     using std::regex_constants::awk;
 
-    assert(std::regex_match("\4", std::regex{"\\4", awk}));
-    assert(std::regex_match("\41", std::regex{"\\41", awk}));
-    assert(std::regex_match("\141", std::regex{"\\141", awk}));
-    assert(std::regex_match("\1411", std::regex{"\\1411", awk}));
+    assert(std::regex_match("\4", std::regex("\\4", awk)));
+    assert(std::regex_match("\41", std::regex("\\41", awk)));
+    assert(std::regex_match("\141", std::regex("\\141", awk)));
+    assert(std::regex_match("\1411", std::regex("\\1411", awk)));
 }