[libc++] Add validation to Stage 2 of num_get

[vangyzen]

Summary

LWG 2381 clarifies that Stage 2 of num_get should check that the
to-be-accumulated character would be valid as the next character
in the accumulated sequence. This change adds the check (for
floating-point numbers) and a unit test with the example proposed
by LWG 2381. If this is approved, I'll see if integers need a
similar change.

I believe this fixes PR#17782:

https://llvm.org/bugs/show_bug.cgi?id=17782

We also hit this in the real world on FreeBSD 10.3.

[vangyzen]

include/locale

529

I suppose I could use "& 0x5F" to avoid the branches in these comparisons of __x.

[vangyzen]

On Fedora 24, all std/localization test results are as expected.

On FreeBSD 11, all std/.../category.numeric tests pass, and there are no additional unexpected results under std/localization.

While I'm on that topic: Under std/localization, the number of unexpected failures on FreeBSD is almost the same as the expected failures on Fedora. Perhaps they are due to hard-coded expectations about locale data. A proposed fix for some of these is in D26979.

[vangyzen]

Restore support for a sign character preceding a "nan"

I accidentally broke +nan and -nan. Add unit test cases for these,
and update my change to support them.

include/locale

if (__x == '-' || __x == '+')
         if (__a_end == __a || (__a_end[-1] & 0x5F) == (__exp & 0x7F))
         {
             *__a_end++ = __x;
             return 0;
         }
         return -1;
     }
     if (__x == 'x' || __x == 'X')
+    {
+        unsigned __sign = (*__a == '-') + (*__a == '+');
+        if (__a_end == __a + __sign + 1 && __a[__sign] == '0')
             __exp = 'P';
+        else
+            return -1;
+    }
     else if ((__x & 0x5F) == __exp)
     {
+        if (__exp & 0x80)
+            return -1;
         __exp |= 0x80;
         if (__in_units)
         {
             __in_units = false;
             if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz)
                 *__g_end++ = __dc;
         }
     }
+    else if (__f > 9)
+    {
+        if (__x == 'P' || __x == 'p')
+            return -1;
+        unsigned __sign = (*__a == '-') + (*__a == '+');
+        if (__x == 'I' || __x == 'i')
+        {
+            if (__a_end != __a + __sign)    // start of Inf
+                return -1;
+        }
+        else if (__x == 'N' || __x == 'n')
+        {
+            bool __ok =
+                (__a_end == __a + __sign)               // start of NaN
+                ||
+                (__a_end == __a + __sign + 2 &&         // end of NaN
+                    (__a[__sign  ] & 0x5F) == 'N' &&
+                    (__a[__sign+1] & 0x5F) == 'A')
+                ||
+                (__a_end == __a + __sign + 1 &&         // middle of Inf
+                    (__a[__sign] & 0x5F) == 'I');
+            if (!__ok)
+                return -1;
+        }
+        else
+        {
+            // Only hex remains.
+            bool __ok =
+                __exp == 'P'                            // in a hex mantissa
+                ||
+                ((__x == 'A' || __x == 'a') &&          // middle of NaN
+                    __a_end == __a + __sign + 1 &&
+                        (__a[__sign] & 0x5F) == 'N')
+                ||
+                ((__x == 'F' || __x == 'f') &&          // end of Inf
+                    __a_end == __a + __sign + 2 &&
+                        (__a[__sign  ] & 0x5F) == 'I' &&
+                        (__a[__sign+1] & 0x5F) == 'N');
+            if (!__ok)
+                return -1;
+        }
+    }
     *__a_end++ = __x;
     if (__f >= 22)
         return 0;
     ++__dc;
     return 0;
 }
 
 _LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>)

test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp

double v = -1;
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == INFINITY);
     }
     {
+        const char str[] = "+Inf";
+        hex(ios);
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.goodbit);
+        assert(v == INFINITY);
+    }
+    {
+        const char str[] = "+iNF";
+        hex(ios);
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.goodbit);
+        assert(v == INFINITY);
+    }
+    {
         const char str[] = "-inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
double v = -1;
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(std::isnan(v));
     }
     {
+        const char str[] = "+NaN";
+        hex(ios);
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.goodbit);
+        assert(std::isnan(v));
+    }
+    {
+        const char str[] = "-nAn";
+        hex(ios);
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(iter.base() == str+sizeof(str)-1);
+        assert(err == ios.goodbit);
+        assert(std::isnan(v));
+    }
+    {
         v = -1;
         const char str[] = "123_456_78_9;125";
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+3);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         v = -1;
         const char str[] = "2-";
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
         assert(v == 2);
     }
     {
+        // http://cplusplus.github.io/LWG/lwg-active.html#2381
+        v = -1;
+        const char str[] = "0x1a.bp+07p";
+        std::ios_base::iostate err = ios.goodbit;
+        input_iterator<const char*> iter =
+            f.get(input_iterator<const char*>(str),
+                  input_iterator<const char*>(str+sizeof(str)),
+                  ios, err, v);
+        assert(err == ios.goodbit);
+        assert(iter.base() == str+sizeof(str)-2);
+        assert(v == 0x1a.bp+07);
+    }
+    {
         v = -1;
         const char str[] = "1.79779e+309"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);