/* a simple (bool) cast may not do the right thing: if bool is defined
* as char for example, then the cast from int is implementation-defined
+ * (bool)!!(cbool) in a ternary triggers a bug in xlc on AIX
*/
-#define cBOOL(cbool) ((bool)!!(cbool))
+#define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0)
/* Try to figure out __func__ or __FUNCTION__ equivalent, if any.
* XXX Should really be a Configure probe, with HAS__FUNCTION__
#define isASCII_A(c) isASCII(c)
#define isASCII_L1(c) isASCII(c)
+/* The lower 3 bits in both the ASCII and EBCDIC representations of '0' are 0,
+ * and the 8 possible permutations of those bits exactly comprise the 8 octal
+ * digits */
+#define isOCTAL_A(c) cBOOL(FITS_IN_8_BITS(c) && (0xF8 & (c)) == '0')
+
+
/* ASCII range only */
#ifdef H_PERL /* If have access to perl.h, lookup in its table */
/* Bits for PL_charclass[]. These use names used in l1_char_class_tab.h but
# define _CC_IDFIRST_L1 (1<<13)
# define _CC_LOWER_A (1<<14)
# define _CC_LOWER_L1 (1<<15)
-# define _CC_OCTAL_A (1<<16)
# define _CC_PRINT_A (1<<17)
# define _CC_PRINT_L1 (1<<18)
# define _CC_PSXSPC_A (1<<19)
# define _CC_WORDCHAR_L1 (1<<28)
# define _CC_XDIGIT_A (1<<29)
# define _CC_NONLATIN1_FOLD (1<<30)
-/* Unused
- * (1<<31)
+# define _CC_QUOTEMETA (1U<<31) /* 1U keeps Solaris from griping */
+/* Unused: (1<<16)
* If more are needed, can give up some of the above. The first ones to go
- * would be those that require just two tests to verify, either there are two
- * code points, like BLANK_A, or occupy a single range like OCTAL_A, DIGIT_A,
- * UPPER_A, and LOWER_A.
+ * would be those that require just two tests to verify; either there are two
+ * code points, like BLANK_A, or it occupies a single range like DIGIT_A,
+ * UPPER_A, and LOWER_A. Also consider the ones that can be replaced with two
+ * tests and an additional mask, so
+ *
+ * #define isCNTRL_A cBOOL(FITS_IN_8_BITS(c) \
+ * && (( ! (~0x1F & NATIVE_TO_UNI(c)])) \
+ * || UNLIKELY(NATIVE_TO_UNI(c) == 0x7f)))
+ *
+ * This takes advantage of the contiguous block of these with the first one's
+ * representation having the lower order bits all zero;, except the DELETE must
+ * be tested specially. A similar pattern can be used for for isCNTRL_L1,
+ * isPRINT_A, and isPRINT_L1
*/
# ifdef DOINIT
# define isGRAPH_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_GRAPH_A))
# define isIDFIRST_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_IDFIRST_A))
# define isLOWER_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_LOWER_A))
-# define isOCTAL_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_OCTAL_A))
# define isPRINT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PRINT_A))
# define isPSXSPC_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PSXSPC_A))
# define isPUNCT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PUNCT_A))
/* Either participates in a fold with a character above 255, or is a
* multi-char fold */
# define _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(c) ((! cBOOL(FITS_IN_8_BITS(c))) || (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_NONLATIN1_FOLD))
+# define _isQUOTEMETA(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_QUOTEMETA))
#else /* No perl.h. */
-# define isOCTAL_A(c) ((c) <= '7' && (c) >= '0')
# ifdef EBCDIC
# define isALNUMC_A(c) (isASCII(c) && isALNUMC(c))
# define isALPHA_A(c) (isASCII(c) && isALPHA(c))
# define isIDFIRST_LC(c) \
(NXIsAlpha((unsigned int)(c)) || (char)(c) == '_')
# define isALPHA_LC(c) NXIsAlpha((unsigned int)(c))
+# define isASCII_LC(c) isASCII((unsigned int)(c))
+# define isBLANK_LC(c) isBLANK((unsigned int)(c))
# define isSPACE_LC(c) NXIsSpace((unsigned int)(c))
# define isDIGIT_LC(c) NXIsDigit((unsigned int)(c))
# define isUPPER_LC(c) NXIsUpper((unsigned int)(c))
# if defined(CTYPE256) || (!defined(isascii) && !defined(HAS_ISASCII))
+/* Note that the foo_LC() macros in this case generally are defined only on
+ * code points 0-256, and give undefined, unwarned results if called with
+ * values outside that range */
+
# define isALNUM_LC(c) (isalnum((unsigned char)(c)) || (char)(c) == '_')
# define isIDFIRST_LC(c) (isalpha((unsigned char)(c)) || (char)(c) == '_')
# define isALPHA_LC(c) isalpha((unsigned char)(c))
+# ifdef HAS_ISASCII
+# define isASCII_LC(c) isascii((unsigned char)(c))
+# else
+# define isASCII_LC(c) isASCII((unsigned char)(c))
+# endif
+# ifdef HAS_ISBLANK
+# define isBLANK_LC(c) isblank((unsigned char)(c))
+# else
+# define isBLANK_LC(c) isBLANK((unsigned char)(c))
+# endif
# define isSPACE_LC(c) isspace((unsigned char)(c))
# define isDIGIT_LC(c) isdigit((unsigned char)(c))
# define isUPPER_LC(c) isupper((unsigned char)(c))
# define isALNUM_LC(c) (isascii(c) && (isalnum(c) || (c) == '_'))
# define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_'))
# define isALPHA_LC(c) (isascii(c) && isalpha(c))
+# define isASCII_LC(c) isascii(c)
+# ifdef HAS_ISBLANK
+# define isBLANK_LC(c) (isascii(c) && isblank(c))
+# else
+# define isBLANK_LC(c) isBLANK(c)
+# endif
# define isSPACE_LC(c) (isascii(c) && isspace(c))
# define isDIGIT_LC(c) (isascii(c) && isdigit(c))
# define isUPPER_LC(c) (isascii(c) && isupper(c))
#endif /* USE_NEXT_CTYPE */
#define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v')
-#define isBLANK_LC(c) isBLANK(c) /* could be wrong */
/* For use in the macros just below. If the input is Latin1, use the Latin1
* (_L1) version of the macro; otherwise use the function. Won't compile if
* the function. This relies on the fact that ASCII characters have the same
* representation whether utf8 or not */
#define generic_utf8(macro, function, p) (isASCII(*(p)) \
- ? CAT2(macro, _A)(*(p)) \
+ ? CAT2(CAT2(macro,_),A)(*(p)) \
: (UTF8_IS_DOWNGRADEABLE_START(*(p))) \
? CAT2(macro, _L1) \
(TWO_BYTE_UTF8_TO_UNI(*(p), \
*((p)+1))) \
: function(p))
-/* Note that all ignore 'use bytes' */
+/* Note that all assume that the utf8 has been validated, and ignore 'use
+ * bytes' */
#define isALNUM_utf8(p) generic_utf8(isWORDCHAR, is_utf8_alnum, p)
/* To prevent S_scan_word in toke.c from hanging, we have to make sure that
: (UTF8_IS_DOWNGRADEABLE_START(*(p))) \
? isIDFIRST_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \
*((p)+1)))\
- : _is_utf8__perl_idstart(p))
+ : Perl__is_utf8__perl_idstart(aTHX_ p))
#define isIDCONT_utf8(p) generic_utf8(isWORDCHAR, is_utf8_xidcont, p)
#define isALPHA_utf8(p) generic_utf8(isALPHA, is_utf8_alpha, p)
#define isSPACE_utf8(p) generic_utf8(isSPACE, is_utf8_space, p)
: isSPACE_utf8(p)))
#define isBLANK_utf8(c) isBLANK(c) /* could be wrong */
-#define isALNUM_LC_utf8(p) isALNUM_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isIDFIRST_LC_utf8(p) isIDFIRST_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isALPHA_LC_utf8(p) isALPHA_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isSPACE_LC_utf8(p) isSPACE_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isDIGIT_LC_utf8(p) isDIGIT_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isUPPER_LC_utf8(p) isUPPER_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isLOWER_LC_utf8(p) isLOWER_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isALNUMC_LC_utf8(p) isALNUMC_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isCNTRL_LC_utf8(p) isCNTRL_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isGRAPH_LC_utf8(p) isGRAPH_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isPRINT_LC_utf8(p) isPRINT_LC_uvchr(utf8_to_uvchr(p, 0))
-#define isPUNCT_LC_utf8(p) isPUNCT_LC_uvchr(utf8_to_uvchr(p, 0))
+#define isALNUM_LC_utf8(p) isALNUM_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isIDFIRST_LC_utf8(p) isIDFIRST_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isALPHA_LC_utf8(p) isALPHA_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isSPACE_LC_utf8(p) isSPACE_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isDIGIT_LC_utf8(p) isDIGIT_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isUPPER_LC_utf8(p) isUPPER_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isLOWER_LC_utf8(p) isLOWER_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isALNUMC_LC_utf8(p) isALNUMC_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isCNTRL_LC_utf8(p) isCNTRL_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isGRAPH_LC_utf8(p) isGRAPH_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isPRINT_LC_utf8(p) isPRINT_LC_uvchr(valid_utf8_to_uvchr(p, 0))
+#define isPUNCT_LC_utf8(p) isPUNCT_LC_uvchr(valid_utf8_to_uvchr(p, 0))
#define isPSXSPC_LC_utf8(c) (isSPACE_LC_utf8(c) ||(c) == '\f')
#define isBLANK_LC_utf8(c) isBLANK(c) /* could be wrong */
* Local variables:
* c-indentation-style: bsd
* c-basic-offset: 4
- * indent-tabs-mode: t
+ * indent-tabs-mode: nil
* End:
*
- * ex: set ts=8 sts=4 sw=4 noet:
+ * ex: set ts=8 sts=4 sw=4 et:
*/