utf8.h Reorder some bit flags

This changes the ordering of these bits (whose names are in the public
API, but whose values are perl's to set).  This is enables a future
commit which will replace a series of

if else if else ...

lines with a switch() statement, by placing the bit positions in the
order those existing clauses should be executed in.  The new ordering
will cause the switch() to preserve the current if clause execution
order.

Author: khwilliamson

ext/XS-APItest/t/utf8_setup.pl

@@ -64,33 +64,33 @@ ($)
                                     # representing a single code point
 
 # Copied from utf8.h
-$::UTF8_ALLOW_EMPTY            = 0x0001;
+$::UTF8_ALLOW_EMPTY            = 0x0002;
 $::UTF8_GOT_EMPTY              = $UTF8_ALLOW_EMPTY;
-$::UTF8_ALLOW_CONTINUATION     = 0x0002;
+$::UTF8_ALLOW_CONTINUATION     = 0x0004;
 $::UTF8_GOT_CONTINUATION       = $UTF8_ALLOW_CONTINUATION;
-$::UTF8_ALLOW_NON_CONTINUATION = 0x0004;
+$::UTF8_ALLOW_NON_CONTINUATION = 0x0010;
 $::UTF8_GOT_NON_CONTINUATION   = $UTF8_ALLOW_NON_CONTINUATION;
 $::UTF8_ALLOW_SHORT            = 0x0008;
 $::UTF8_GOT_SHORT              = $UTF8_ALLOW_SHORT;
-$::UTF8_ALLOW_LONG             = 0x0010;
-$::UTF8_ALLOW_LONG_AND_ITS_VALUE = $UTF8_ALLOW_LONG|0x0020;
+$::UTF8_ALLOW_LONG             = 0x2000;
+$::UTF8_ALLOW_LONG_AND_ITS_VALUE = $UTF8_ALLOW_LONG|0x4000;
 $::UTF8_GOT_LONG               = $UTF8_ALLOW_LONG;
-$::UTF8_ALLOW_OVERFLOW         = 0x0080;
+$::UTF8_ALLOW_OVERFLOW         = 0x0001;
 $::UTF8_GOT_OVERFLOW           = $UTF8_ALLOW_OVERFLOW;
-$::UTF8_DISALLOW_SURROGATE     = 0x0100;
+$::UTF8_DISALLOW_SURROGATE     = 0x0020;
 $::UTF8_GOT_SURROGATE          = $UTF8_DISALLOW_SURROGATE;
-$::UTF8_WARN_SURROGATE         = 0x0200;
-$::UTF8_DISALLOW_NONCHAR       = 0x0400;
+$::UTF8_WARN_SURROGATE         = 0x0040;
+$::UTF8_DISALLOW_NONCHAR       = 0x0800;
 $::UTF8_GOT_NONCHAR            = $UTF8_DISALLOW_NONCHAR;
-$::UTF8_WARN_NONCHAR           = 0x0800;
-$::UTF8_DISALLOW_SUPER         = 0x1000;
+$::UTF8_WARN_NONCHAR           = 0x1000;
+$::UTF8_DISALLOW_SUPER         = 0x0200;
 $::UTF8_GOT_SUPER              = $UTF8_DISALLOW_SUPER;
-$::UTF8_WARN_SUPER             = 0x2000;
-$::UTF8_DISALLOW_PERL_EXTENDED  = 0x4000;
+$::UTF8_WARN_SUPER             = 0x0400;
+$::UTF8_DISALLOW_PERL_EXTENDED  = 0x0080;
 $::UTF8_GOT_PERL_EXTENDED       = $UTF8_DISALLOW_PERL_EXTENDED;
-$::UTF8_WARN_PERL_EXTENDED      = 0x8000;
-$::UTF8_CHECK_ONLY             = 0x10000;
-$::UTF8_NO_CONFIDENCE_IN_CURLEN_ = 0x20000;
+$::UTF8_WARN_PERL_EXTENDED      = 0x0100;
+$::UTF8_CHECK_ONLY             = 0x8000;
+$::UTF8_NO_CONFIDENCE_IN_CURLEN_ = 0x10000;
 
 $::UTF8_DISALLOW_ILLEGAL_C9_INTERCHANGE
                              = $UTF8_DISALLOW_SUPER|$UTF8_DISALLOW_SURROGATE;

ext/XS-APItest/t/utf8_warn_base.pl

@@ -585,23 +585,24 @@ ($$)
 # Possible flag returns from utf8n_to_uvchr_error().  These should have G_,
 # instead of A_, D_, but the prefixes will be used in a later commit, so
 # minimize churn by having them here.
+# The ordering is important, sorted by lowest bit position first taken from
+# utf8.h
 my @utf8n_flags_to_text =  ( qw(
+        A_OVERFLOW
         A_EMPTY
         A_CONTINUATION
-        A_NON_CONTINUATION
         A_SHORT
-        A_LONG
-        A_LONG_AND_ITS_VALUE
-        PLACEHOLDER
-        A_OVERFLOW
+        A_NON_CONTINUATION
         D_SURROGATE
         W_SURROGATE
-        D_NONCHAR
-        W_NONCHAR
-        D_SUPER
-        W_SUPER
         D_PERL_EXTENDED
         W_PERL_EXTENDED
+        D_SUPER
+        W_SUPER
+        D_NONCHAR
+        W_NONCHAR
+        A_LONG
+        A_LONG_AND_ITS_VALUE
         CHECK_ONLY
         NO_CONFIDENCE_IN_CURLEN_
     ) );

utf8.h

@@ -1128,15 +1128,15 @@ point's representation.
 /* Largest code point we accept from external sources */
 #define MAX_LEGAL_CP  ((UV)IV_MAX)
 
-#define UTF8_ALLOW_EMPTY		0x0001	/* Allow a zero length string */
+#define UTF8_ALLOW_EMPTY		0x0002	/* Allow a zero length string */
 #define UTF8_GOT_EMPTY                  UTF8_ALLOW_EMPTY
 
 /* Allow first byte to be a continuation byte */
-#define UTF8_ALLOW_CONTINUATION		0x0002
+#define UTF8_ALLOW_CONTINUATION		0x0004
 #define UTF8_GOT_CONTINUATION		UTF8_ALLOW_CONTINUATION
 
 /* Unexpected non-continuation byte */
-#define UTF8_ALLOW_NON_CONTINUATION	0x0004
+#define UTF8_ALLOW_NON_CONTINUATION	0x0010
 #define UTF8_GOT_NON_CONTINUATION	UTF8_ALLOW_NON_CONTINUATION
 
 /* expecting more bytes than were available in the string */
@@ -1146,26 +1146,26 @@ point's representation.
 /* Overlong sequence; i.e., the code point can be specified in fewer bytes.
  * First one will convert the overlong to the REPLACEMENT CHARACTER; second
  * will return what the overlong evaluates to */
-#define UTF8_ALLOW_LONG                 0x0010
-#define UTF8_ALLOW_LONG_AND_ITS_VALUE   (UTF8_ALLOW_LONG|0x0020)
+#define UTF8_ALLOW_LONG                 0x2000
+#define UTF8_ALLOW_LONG_AND_ITS_VALUE   (UTF8_ALLOW_LONG|0x4000)
 #define UTF8_GOT_LONG                   UTF8_ALLOW_LONG
 
-#define UTF8_ALLOW_OVERFLOW             0x0080
+#define UTF8_ALLOW_OVERFLOW             0x0001
 #define UTF8_GOT_OVERFLOW               UTF8_ALLOW_OVERFLOW
 
-#define UTF8_DISALLOW_SURROGATE		0x0100	/* Unicode surrogates */
+#define UTF8_DISALLOW_SURROGATE		0x0020	/* Unicode surrogates */
 #define UTF8_GOT_SURROGATE		UTF8_DISALLOW_SURROGATE
-#define UTF8_WARN_SURROGATE		0x0200
+#define UTF8_WARN_SURROGATE		0x0040
 
 /* Unicode non-character  code points */
-#define UTF8_DISALLOW_NONCHAR           0x0400
+#define UTF8_DISALLOW_NONCHAR           0x0800
 #define UTF8_GOT_NONCHAR                UTF8_DISALLOW_NONCHAR
-#define UTF8_WARN_NONCHAR               0x0800
+#define UTF8_WARN_NONCHAR               0x1000
 
 /* Super-set of Unicode: code points above the legal max */
-#define UTF8_DISALLOW_SUPER		0x1000
+#define UTF8_DISALLOW_SUPER		0x0200
 #define UTF8_GOT_SUPER		        UTF8_DISALLOW_SUPER
-#define UTF8_WARN_SUPER		        0x2000
+#define UTF8_WARN_SUPER		        0x0400
 
 /* The original UTF-8 standard did not define UTF-8 with start bytes of 0xFE or
  * 0xFF, though UTF-EBCDIC did.  This allowed both versions to represent code
@@ -1176,9 +1176,9 @@ point's representation.
  * extensions, and not likely to be interchangeable with other languages.  Note
  * that on ASCII platforms, FE overflows a signed 32-bit word, and FF an
  * unsigned one. */
-#define UTF8_DISALLOW_PERL_EXTENDED     0x4000
+#define UTF8_DISALLOW_PERL_EXTENDED     0x0080
 #define UTF8_GOT_PERL_EXTENDED          UTF8_DISALLOW_PERL_EXTENDED
-#define UTF8_WARN_PERL_EXTENDED         0x8000
+#define UTF8_WARN_PERL_EXTENDED         0x0100
 
 /* For back compat, these old names are misleading for overlongs and
  * UTF_EBCDIC. */
@@ -1188,8 +1188,8 @@ point's representation.
 #define UTF8_DISALLOW_FE_FF             UTF8_DISALLOW_PERL_EXTENDED
 #define UTF8_WARN_FE_FF                 UTF8_WARN_PERL_EXTENDED
 
-#define UTF8_CHECK_ONLY			0x10000
-#define _UTF8_NO_CONFIDENCE_IN_CURLEN   0x20000  /* Internal core use only */
+#define UTF8_CHECK_ONLY			0x8000
+#define _UTF8_NO_CONFIDENCE_IN_CURLEN   0x10000  /* Internal core use only */
 
 /* For backwards source compatibility.  They do nothing, as the default now
  * includes what they used to mean.  The first one's meaning was to allow the