op/lex_assign.t: fix intermittent failures

[perl5.git] / utf8.h

diff --git a/utf8.h b/utf8.h
index c57576b..c954b42 100644 (file)
--- a/utf8.h
+++ b/utf8.h
@@ -134,10 +134,20 @@ EXTCONST unsigned char PL_utf8skip[];
 
 END_EXTERN_C
 
+#if defined(_MSC_VER) && _MSC_VER < 1400
+/* older MSVC versions have a smallish macro buffer */
+#define PERL_SMALL_MACRO_BUFFER
+#endif
+
 /* Native character to/from iso-8859-1.  Are the identity functions on ASCII
  * platforms */
+#ifdef PERL_SMALL_MACRO_BUFFER
+#define NATIVE_TO_LATIN1(ch)     ((U8)(ch))
+#define LATIN1_TO_NATIVE(ch)     ((U8)(ch))
+#else
 #define NATIVE_TO_LATIN1(ch)     (__ASSERT_(FITS_IN_8_BITS(ch)) ((U8) (ch)))
 #define LATIN1_TO_NATIVE(ch)     (__ASSERT_(FITS_IN_8_BITS(ch)) ((U8) (ch)))
+#endif
 
 /* I8 is an intermediate version of UTF-8 used only in UTF-EBCDIC.  We thus
  * consider it to be identical to UTF-8 on ASCII platforms.  Strictly speaking
@@ -145,8 +155,13 @@ END_EXTERN_C
  * because they are 8-bit encodings that serve the same purpose in Perl, and
  * rarely do we need to distinguish them.  The term "NATIVE_UTF8" applies to
  * whichever one is applicable on the current platform */
+#ifdef PERL_SMALL_MACRO_BUFFER
+#define NATIVE_UTF8_TO_I8(ch) (ch)
+#define I8_TO_NATIVE_UTF8(ch) (ch)
+#else
 #define NATIVE_UTF8_TO_I8(ch) (__ASSERT_(FITS_IN_8_BITS(ch)) ((U8) (ch)))
 #define I8_TO_NATIVE_UTF8(ch) (__ASSERT_(FITS_IN_8_BITS(ch)) ((U8) (ch)))
+#endif
 
 /* Transforms in wide UV chars */
 #define UNI_TO_NATIVE(ch)        ((UV) (ch))
@@ -213,31 +228,36 @@ Perl's extended UTF-8 means we can have start bytes up to FF.
 #define UTF_CONTINUATION_MARK          0x80
 
 /* Misleadingly named: is the UTF8-encoded byte 'c' part of a variant sequence
- * in UTF-8?  This is the inverse of UTF8_IS_INVARIANT */
-#define UTF8_IS_CONTINUED(c)        (((U8)c) &  UTF_CONTINUATION_MARK)
+ * in UTF-8?  This is the inverse of UTF8_IS_INVARIANT.  The |0 makes sure this
+ * isn't mistakenly called with a ptr argument */
+#define UTF8_IS_CONTINUED(c)        (((U8)((c) | 0)) &  UTF_CONTINUATION_MARK)
 
 /* Is the byte 'c' the first byte of a multi-byte UTF8-8 encoded sequence?
  * This doesn't catch invariants (they are single-byte).  It also excludes the
- * illegal overlong sequences that begin with C0 and C1. */
-#define UTF8_IS_START(c)            (((U8)c) >= 0xc2)
+ * illegal overlong sequences that begin with C0 and C1.  The |0 makes sure
+ * this isn't mistakenly called with a ptr argument */
+#define UTF8_IS_START(c)            (((U8)((c) | 0)) >= 0xc2)
 
 /* For use in UTF8_IS_CONTINUATION() below */
 #define UTF_IS_CONTINUATION_MASK    0xC0
 
 /* Is the byte 'c' part of a multi-byte UTF8-8 encoded sequence, and not the
- * first byte thereof?  */
+ * first byte thereof?  The |0 makes sure this isn't mistakenly called with a
+ * ptr argument */
 #define UTF8_IS_CONTINUATION(c)                                             \
-            ((((U8)c) & UTF_IS_CONTINUATION_MASK) == UTF_CONTINUATION_MARK)
+    ((((U8)((c) | 0)) & UTF_IS_CONTINUATION_MASK) == UTF_CONTINUATION_MARK)
 
 /* Is the UTF8-encoded byte 'c' the first byte of a two byte sequence?  Use
  * UTF8_IS_NEXT_CHAR_DOWNGRADEABLE() instead if the input isn't known to
  * be well-formed.  Masking with 0xfe allows the low bit to be 0 or 1; thus
- * this matches 0xc[23]. */
-#define UTF8_IS_DOWNGRADEABLE_START(c) (((U8)(c) & 0xfe) == 0xc2)
+ * this matches 0xc[23].  The |0 makes sure this isn't mistakenly called with a
+ * ptr argument */
+#define UTF8_IS_DOWNGRADEABLE_START(c) ((((U8)((c) | 0)) & 0xfe) == 0xc2)
 
 /* Is the UTF8-encoded byte 'c' the first byte of a sequence of bytes that
- * represent a code point > 255? */
-#define UTF8_IS_ABOVE_LATIN1(c)     ((U8)(c) >= 0xc4)
+ * represent a code point > 255?  The |0 makes sure this isn't mistakenly
+ * called with a ptr argument */
+#define UTF8_IS_ABOVE_LATIN1(c)     (((U8)((c) | 0)) >= 0xc4)
 
 /* This is the number of low-order bits a continuation byte in a UTF-8 encoded
  * sequence contributes to the specification of the code point.  In the bit
@@ -449,8 +469,9 @@ only) byte is pointed to by C<s>.
  * each for the exact same set of bit patterns.  It is valid on a subset of
  * what UVCHR_IS_INVARIANT is valid on, so can just use that; and the compiler
  * should optimize out anything extraneous given the implementation of the
- * latter */
-#define UTF8_IS_INVARIANT(c)   UVCHR_IS_INVARIANT(c)
+ * latter.  The |0 makes sure this isn't mistakenly called with a ptr argument.
+ * */
+#define UTF8_IS_INVARIANT(c)   UVCHR_IS_INVARIANT((c) | 0)
 
 /* Like the above, but its name implies a non-UTF8 input, which as the comments
  * above show, doesn't matter as to its implementation */
@@ -465,11 +486,13 @@ only) byte is pointed to by C<s>.
  * (which works for code points up through 0xFF) or NATIVE_TO_UNI which works
  * for any code point */
 #define __BASE_TWO_BYTE_HI(c, translate_function)                               \
+           (__ASSERT_(! UVCHR_IS_INVARIANT(c))                                  \
             I8_TO_NATIVE_UTF8((translate_function(c) >> UTF_ACCUMULATION_SHIFT) \
-                              | UTF_START_MARK(2))
+                              | UTF_START_MARK(2)))
 #define __BASE_TWO_BYTE_LO(c, translate_function)                               \
+             (__ASSERT_(! UVCHR_IS_INVARIANT(c))                                \
               I8_TO_NATIVE_UTF8((translate_function(c) & UTF_CONTINUATION_MASK) \
-                                 | UTF_CONTINUATION_MARK)
+                                 | UTF_CONTINUATION_MARK))
 
 /* The next two macros should not be used.  They were designed to be usable as
  * the case label of a switch statement, but this doesn't work for EBCDIC.  Use