-# define isWORDCHAR_A(c) (isALPHA_A(c) || isDIGIT_A(c) || (c) == '_')
-# define isXDIGIT_A(c) (isDIGIT_A(c) || ((c) >= 'a' && (c) <= 'f') || ((c) <= 'F' && (c) >= 'A'))
-# endif
-#endif /* ASCII range definitions */
-
-/* Latin1 definitions */
-#ifdef H_PERL
-# define isALNUMC_L1(c) _generic_isCC(c, _CC_ALNUMC_L1)
-# define isALPHA_L1(c) _generic_isCC(c, _CC_ALPHA_L1)
-# define isBLANK_L1(c) _generic_isCC(c, _CC_BLANK_L1)
-/* continuation character for legal NAME in \N{NAME} */
-# define isCHARNAME_CONT(c) _generic_isCC(c, _CC_CHARNAME_CONT)
-# define isCNTRL_L1(c) _generic_isCC(c, _CC_CNTRL_L1)
-# define isGRAPH_L1(c) _generic_isCC(c, _CC_GRAPH_L1)
-# define isIDFIRST_L1(c) _generic_isCC(c, _CC_IDFIRST_L1)
-# define isLOWER_L1(c) _generic_isCC(c, _CC_LOWER_L1)
-# define isPRINT_L1(c) _generic_isCC(c, _CC_PRINT_L1)
-# define isPSXSPC_L1(c) _generic_isCC(c, _CC_PSXSPC_L1)
-# define isPUNCT_L1(c) _generic_isCC(c, _CC_PUNCT_L1)
-# define isSPACE_L1(c) _generic_isCC(c, _CC_SPACE_L1)
-# define isUPPER_L1(c) _generic_isCC(c, _CC_UPPER_L1)
-# define isWORDCHAR_L1(c) _generic_isCC(c, _CC_WORDCHAR_L1)
-#else /* No access to perl.h. Only a few provided here, just in case needed
- * for backwards compatibility */
- /* ALPHAU includes Unicode semantics for latin1 characters. It has an extra
- * >= AA test to speed up ASCII-only tests at the expense of the others */
-# define isALPHA_L1(c) (isALPHA(c) || (NATIVE_TO_UNI((U8) c) >= 0xAA \
- && ((NATIVE_TO_UNI((U8) c) >= 0xC0 \
- && NATIVE_TO_UNI((U8) c) != 0xD7 && NATIVE_TO_UNI((U8) c) != 0xF7) \
- || NATIVE_TO_UNI((U8) c) == 0xAA \
- || NATIVE_TO_UNI((U8) c) == 0xB5 \
- || NATIVE_TO_UNI((U8) c) == 0xBA)))
-# define isCHARNAME_CONT(c) (isALNUM_L1(c) || (c) == ' ' || (c) == '-' || (c) == '(' || (c) == ')' || (c) == ':' || NATIVE_TO_UNI((U8) c) == 0xA0)
-#endif
-
-/* Macros for backwards compatibility and for completeness when the ASCII and
- * Latin1 values are identical */
-#define isALNUM(c) isWORDCHAR(c)
-#define isALNUMU(c) isWORDCHAR_L1(c)
-#define isALPHAU(c) isALPHA_L1(c)
-#define isDIGIT_L1(c) isDIGIT_A(c)
-#define isOCTAL(c) isOCTAL_A(c)
-#define isOCTAL_L1(c) isOCTAL_A(c)
-#define isXDIGIT_L1(c) isXDIGIT_A(c)
-
-/* Macros that differ between EBCDIC and ASCII. Where C89 defines a function,
- * that is used in the EBCDIC form, because in EBCDIC we do not do locales:
- * therefore can use native functions. For those where C89 doesn't define a
- * function, use our function, assuming that the EBCDIC code page is isomorphic
- * with Latin1, which the three currently recognized by Perl are. Some libc's
- * have an isblank(), but it's not guaranteed. */
-#ifdef EBCDIC
-# define isALNUMC(c) isalnum(c)
-# define isALPHA(c) isalpha(c)
-# define isBLANK(c) ((c) == ' ' || (c) == '\t' || NATIVE_TO_UNI(c) == 0xA0)
-# define isCNTRL(c) iscntrl(c)
-# define isDIGIT(c) isdigit(c)
-# define isGRAPH(c) isgraph(c)
-# define isIDFIRST(c) (isALPHA(c) || (c) == '_')
-# define isLOWER(c) islower(c)
-# define isPRINT(c) isprint(c)
-# define isPSXSPC(c) isspace(c)
-# define isPUNCT(c) ispunct(c)
-# define isSPACE(c) (isPSXSPC(c) && (c) != '\v')
-# define isUPPER(c) isupper(c)
-# define isXDIGIT(c) isxdigit(c)
-# define isWORDCHAR(c) (isalnum(c) || (c) == '_')
-# define toLOWER(c) tolower(c)
-# define toUPPER(c) toupper(c)
-#else /* Not EBCDIC: ASCII-only matching */
-# define isALNUMC(c) isALNUMC_A(c) /* Mnemonic: "C's alnum" = alpha + digit */
-# define isALPHA(c) isALPHA_A(c)
-# define isBLANK(c) isBLANK_A(c)
-# define isCNTRL(c) isCNTRL_A(c)
-# define isDIGIT(c) isDIGIT_A(c)
-# define isGRAPH(c) isGRAPH_A(c)
-# define isIDFIRST(c) isIDFIRST_A(c)
-# define isLOWER(c) isLOWER_A(c)
-# define isPRINT(c) isPRINT_A(c)
-# define isPSXSPC(c) isPSXSPC_A(c)
-# define isPUNCT(c) isPUNCT_A(c)
-# define isSPACE(c) isSPACE_A(c)
-# define isUPPER(c) isUPPER_A(c)
-# define isWORDCHAR(c) isWORDCHAR_A(c)
-# define isXDIGIT(c) isXDIGIT_A(c)
-
- /* ASCII casing. These could also be written as
- #define toLOWER(c) (isASCII(c) ? toLOWER_LATIN1(c) : (c))
- #define toUPPER(c) (isASCII(c) ? toUPPER_LATIN1_MOD(c) : (c))
- which uses table lookup and mask instead of subtraction. (This would
- work because the _MOD does not apply in the ASCII range) */
-# define toLOWER(c) (isUPPER(c) ? (c) + ('a' - 'A') : (c))
-# define toUPPER(c) (isLOWER(c) ? (c) - ('a' - 'A') : (c))
-#endif
-
+# define isXDIGIT_A(c) (isDIGIT_A(c) \
+ || ((c) >= 'a' && (c) <= 'f') \
+ || ((c) <= 'F' && (c) >= 'A'))
+# endif /* Below are common definitions for ASCII and non-ASCII */
+# define isBLANK_A(c) ((c) == ' ' || (c) == '\t')
+# define isIDFIRST_A(c) (isALPHA_A(c) || (c) == '_')
+# define isWORDCHAR_A(c) (isALPHANUMERIC_A(c) || (c) == '_')
+
+ /* The _L1 macros may be unnecessary for both the utilities and for
+ * bootstrapping; I (khw) added them during debugging of bootstrapping, and
+ * it seems best to keep them. */
+# define isPSXSPC_A(c) isSPACE_A(c) /* XXX Assumes SPACE matches '\v' */
+# define isALPHA_L1(c) (isUPPER_L1(c) || isLOWER_L1(c))
+# define isALPHANUMERIC_L1(c) (isALPHA_L1(c) || isDIGIT_A(c))
+# define isBLANK_L1(c) (isBLANK_A(c) \
+ || (FITS_IN_8_BITS(c) \
+ && NATIVE_TO_LATIN1((U8) c) == 0xA0))
+# define isCNTRL_L1(c) (FITS_IN_8_BITS(c) && (! isPRINT_L1(c)))
+# define isGRAPH_L1(c) (isPRINT_L1(c) && (! isBLANK_L1(c)))
+# define isLOWER_L1(c) (isLOWER_A(c) \
+ || (FITS_IN_8_BITS(c) \
+ && ((NATIVE_TO_LATIN1((U8) c) >= 0xDF \
+ && NATIVE_TO_LATIN1((U8) c) != 0xF7) \
+ || NATIVE_TO_LATIN1((U8) c) == 0xAA \
+ || NATIVE_TO_LATIN1((U8) c) == 0xBA \
+ || NATIVE_TO_LATIN1((U8) c) == 0xB5)))
+# define isPRINT_L1(c) (isPRINT_A(c) \
+ || (FITS_IN_8_BITS(c) \
+ && NATIVE_TO_LATIN1((U8) c) >= 0xA0))
+# define isPSXSPC_L1(c) isSPACE_L1(c)
+# define isPUNCT_L1(c) (isPUNCT_A(c) \
+ || (FITS_IN_8_BITS(c) \
+ && (NATIVE_TO_LATIN1((U8) c) == 0xA1 \
+ || NATIVE_TO_LATIN1((U8) c) == 0xA7 \
+ || NATIVE_TO_LATIN1((U8) c) == 0xAB \
+ || NATIVE_TO_LATIN1((U8) c) == 0xB6 \
+ || NATIVE_TO_LATIN1((U8) c) == 0xB7 \
+ || NATIVE_TO_LATIN1((U8) c) == 0xBB \
+ || NATIVE_TO_LATIN1((U8) c) == 0xBF)))
+# define isSPACE_L1(c) (isSPACE_A(c) \
+ || (FITS_IN_8_BITS(c) \
+ && (NATIVE_TO_LATIN1((U8) c) == 0x85 \
+ || NATIVE_TO_LATIN1((U8) c) == 0xA0)))
+# define isUPPER_L1(c) (isUPPER_A(c) \
+ || (FITS_IN_8_BITS(c) \
+ && (NATIVE_TO_LATIN1((U8) c) >= 0xC0 \
+ && NATIVE_TO_LATIN1((U8) c) <= 0xDE \
+ && NATIVE_TO_LATIN1((U8) c) != 0xD7)))
+# define isWORDCHAR_L1(c) (isIDFIRST_L1(c) || isDIGIT_A(c))
+# define isIDFIRST_L1(c) (isALPHA_L1(c) || NATIVE_TO_LATIN1(c) == '_')
+# define isCHARNAME_CONT(c) (isWORDCHAR_L1(c) \
+ || isBLANK_L1(c) \
+ || (c) == '-' \
+ || (c) == '(' \
+ || (c) == ')')
+ /* The following are not fully accurate in the above-ASCII range. I (khw)
+ * don't think it's necessary to be so for the purposes where this gets
+ * compiled */
+# define _isQUOTEMETA(c) (FITS_IN_8_BITS(c) && ! isWORDCHAR_L1(c))
+# define _IS_IN_SOME_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) isALPHA_L1(c)
+
+ /* And these aren't accurate at all. They are useful only for above
+ * Latin1, which utilities and bootstrapping don't deal with */
+# define _IS_NON_FINAL_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) 0
+# define _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(c) 0
+
+ /* Many of the macros later in this file are defined in terms of these. By
+ * implementing them with a function, which converts the class number into
+ * a call to the desired macro, all of the later ones work. However, that
+ * function won't be actually defined when building a utility program (no
+ * perl.h), and so a compiler error will be generated if one is attempted
+ * to be used. And the above-Latin1 code points require Unicode tables to
+ * be present, something unlikely to be the case when bootstrapping */
+# define _generic_isCC(c, classnum) \
+ (FITS_IN_8_BITS(c) && S_bootstrap_ctype((U8) (c), (classnum), TRUE))
+# define _generic_isCC_A(c, classnum) \
+ (FITS_IN_8_BITS(c) && S_bootstrap_ctype((U8) (c), (classnum), FALSE))
+#endif /* End of no perl.h or have BOOTSTRAP_CHARSET */
+
+#define isALPHANUMERIC(c) isALPHANUMERIC_A(c)
+#define isALPHA(c) isALPHA_A(c)
+#define isBLANK(c) isBLANK_A(c)
+#define isCNTRL(c) isCNTRL_A(c)
+#define isDIGIT(c) isDIGIT_A(c)
+#define isGRAPH(c) isGRAPH_A(c)
+#define isIDFIRST(c) isIDFIRST_A(c)
+#define isLOWER(c) isLOWER_A(c)
+#define isPRINT(c) isPRINT_A(c)
+#define isPSXSPC(c) isPSXSPC_A(c)
+#define isPUNCT(c) isPUNCT_A(c)
+#define isSPACE(c) isSPACE_A(c)
+#define isUPPER(c) isUPPER_A(c)
+#define isWORDCHAR(c) isWORDCHAR_A(c)
+#define isXDIGIT(c) isXDIGIT_A(c)
+
+/* ASCII casing. These could also be written as
+ #define toLOWER(c) (isASCII(c) ? toLOWER_LATIN1(c) : (c))
+ #define toUPPER(c) (isASCII(c) ? toUPPER_LATIN1_MOD(c) : (c))
+ which uses table lookup and mask instead of subtraction. (This would
+ work because the _MOD does not apply in the ASCII range) */
+#define toLOWER(c) (isUPPER(c) ? (c) + ('a' - 'A') : (c))
+#define toUPPER(c) (isLOWER(c) ? (c) - ('a' - 'A') : (c))
+
+/* In the ASCII range, these are equivalent to what they're here defined to be.
+ * But by creating these definitions, other code doesn't have to be aware of
+ * this detail */
+#define toFOLD(c) toLOWER(c)
+#define toFOLD_LC(c) toLOWER_LC(c)
+#define toTITLE(c) toUPPER(c)
+
+#define toLOWER_A(c) toLOWER(c)
+#define toUPPER_A(c) toUPPER(c)
+#define toFOLD_A(c) toFOLD(c)
+#define toTITLE_A(c) toTITLE(c)