/* handy.h
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000,
- * 2001, 2002, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
+ * 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2012 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
+#ifndef HANDY_H /* Guard against nested #inclusion */
+#define HANDY_H
+
#if !defined(__STDC__)
#ifdef NULL
#undef NULL
#endif
-#ifndef I286
# define NULL 0
-#else
-# define NULL 0L
-#endif
#endif
#ifndef PERL_CORE
#endif /* NeXT || __NeXT__ */
#ifndef HAS_BOOL
-# if defined(UTS) || defined(VMS)
+# if defined(VMS)
# define bool int
# else
# define bool char
# define HAS_BOOL 1
#endif
-/* 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
- */
-
+/* cast-to-bool. 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) ((cbool) ? (bool)1 : (bool)0)
/* Try to figure out __func__ or __FUNCTION__ equivalent, if any.
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined(__SUNPRO_C)) /* C99 or close enough. */
# define FUNCTION__ __func__
#else
-# if (defined(_MSC_VER) && _MSC_VER < 1300) || /* Pre-MSVC 7.0 has neither __func__ nor __FUNCTION and no good workarounds, either. */ \
+# if (defined(_MSC_VER) && _MSC_VER < 1300) || /* MSVC6 has neither __func__ nor __FUNCTION and no good workarounds, either. */ \
(defined(__DECC_VER)) /* Tru64 or VMS, and strict C89 being used, but not modern enough cc (in Tur64, -c99 not known, only -std1). */
# define FUNCTION__ ""
# else
#endif /* PERL_CORE */
#if defined(HAS_QUAD) && defined(USE_64_BIT_INT)
-# ifndef UINT64_C /* usually from <inttypes.h> */
-# if defined(HAS_LONG_LONG) && QUADKIND == QUAD_IS_LONG_LONG
-# define INT64_C(c) CAT2(c,LL)
-# define UINT64_C(c) CAT2(c,ULL)
+# if defined(HAS_LONG_LONG) && QUADKIND == QUAD_IS_LONG_LONG
+# define PeRl_INT64_C(c) CAT2(c,LL)
+# define PeRl_UINT64_C(c) CAT2(c,ULL)
+# else
+# if QUADKIND == QUAD_IS___INT64
+# define PeRl_INT64_C(c) CAT2(c,I64)
+# define PeRl_UINT64_C(c) CAT2(c,UI64)
# else
# if LONGSIZE == 8 && QUADKIND == QUAD_IS_LONG
-# define INT64_C(c) CAT2(c,L)
-# define UINT64_C(c) CAT2(c,UL)
+# define PeRl_INT64_C(c) CAT2(c,L)
+# define PeRl_UINT64_C(c) CAT2(c,UL)
# else
-# if defined(_WIN64) && defined(_MSC_VER)
-# define INT64_C(c) CAT2(c,I64)
-# define UINT64_C(c) CAT2(c,UI64)
-# else
-# define INT64_C(c) ((I64TYPE)(c))
-# define UINT64_C(c) ((U64TYPE)(c))
-# endif
+# define PeRl_INT64_C(c) ((I64TYPE)(c))
+# define PeRl_UINT64_C(c) ((U64TYPE)(c))
# endif
# endif
# endif
+# ifndef UINT64_C
+# define UINT64_C(c) PeRl_UINT64_C(c)
+# endif
+# ifndef INT64_C
+# define INT64_C(c) PeRl_INT64_C(c)
+# endif
#endif
#if defined(UINT8_MAX) && defined(INT16_MAX) && defined(INT32_MAX)
=cut
*/
-/* concatenating with "" ensures that only literal strings are accepted as argument */
+/* concatenating with "" ensures that only literal strings are accepted as
+ * argument */
#define STR_WITH_LEN(s) ("" s ""), (sizeof(s)-1)
-/* note that STR_WITH_LEN() can't be used as argument to macros or functions that
- * under some configurations might be macros, which means that it requires the full
- * Perl_xxx(aTHX_ ...) form for any API calls where it's used.
+/* note that STR_WITH_LEN() can't be used as argument to macros or functions
+ * that under some configurations might be macros, which means that it requires
+ * the full Perl_xxx(aTHX_ ...) form for any API calls where it's used.
*/
/* STR_WITH_LEN() shortcuts */
/*
=head1 Character classes
-There are three variants for all the functions in this section. The base ones
-operate using the character set of the platform Perl is running on. The ones
-with an C<_A> suffix operate on the ASCII character set, and the ones with an
-C<_L1> suffix operate on the full Latin1 character set. All are unaffected by
-locale and by C<use bytes>.
-
-For ASCII platforms, the base function with no suffix and the one with the
-C<_A> suffix are identical. The function with the C<_L1> suffix imposes the
-Latin-1 character set onto the platform. That is, the code points that are
-ASCII are unaffected, since ASCII is a subset of Latin-1. But the non-ASCII
-code points are treated as if they are Latin-1 characters. For example,
-C<isSPACE_L1()> will return true when called with the code point 0xA0, which is
-the Latin-1 NO-BREAK SPACE.
-
-For EBCDIC platforms, the base function with no suffix and the one with the
-C<_L1> suffix should be identical, since, as of this writing, the EBCDIC code
-pages that Perl knows about all are equivalent to Latin-1. The function that
-ends in an C<_A> suffix will not return true unless the specified character also
-has an ASCII equivalent.
+This section is about functions (really macros) that classify characters
+into types, such as punctuation versus alphabetic, etc. Most of these are
+analogous to regular expression character classes. (See
+L<perlrecharclass/POSIX Character Classes>.) There are several variants for
+each class. (Not all macros have all variants; each item below lists the
+ones valid for it.) None are affected by C<use bytes>, and only the ones
+with C<LC> in the name are affected by the current locale.
+
+The base function, e.g., C<isALPHA()>, takes an octet (either a C<char> or a
+C<U8>) as input and returns a boolean as to whether or not the character
+represented by that octet is (or on non-ASCII platforms, corresponds to) an
+ASCII character in the named class based on platform, Unicode, and Perl rules.
+If the input is a number that doesn't fit in an octet, FALSE is returned.
+
+Variant C<isFOO_A> (e.g., C<isALPHA_A()>) is identical to the base function
+with no suffix C<"_A">.
+
+Variant C<isFOO_L1> imposes the Latin-1 (or EBCDIC equivlalent) character set
+onto the platform. That is, the code points that are ASCII are unaffected,
+since ASCII is a subset of Latin-1. But the non-ASCII code points are treated
+as if they are Latin-1 characters. For example, C<isWORDCHAR_L1()> will return
+true when called with the code point 0xDF, which is a word character in both
+ASCII and EBCDIC (though it represent different characters in each).
+
+Variant C<isFOO_uni> is like the C<isFOO_L1> variant, but accepts any UV code
+point as input. If the code point is larger than 255, Unicode rules are used
+to determine if it is in the character class. For example,
+C<isWORDCHAR_uni(0x100)> returns TRUE, since 0x100 is LATIN CAPITAL LETTER A
+WITH MACRON in Unicode, and is a word character.
+
+Variant C<isFOO_utf8> is like C<isFOO_uni>, but the input is a pointer to a
+(known to be well-formed) UTF-8 encoded string (C<U8*> or C<char*>). The
+classification of just the first (possibly multi-byte) character in the string
+is tested.
+
+Variant C<isFOO_LC> is like the C<isFOO_A> and C<isFOO_L1> variants, but uses
+the C library function that gives the named classification instead of
+hard-coded rules. For example, C<isDIGIT_LC()> returns the result of calling
+C<isdigit()>. This means that the result is based on the current locale, which
+is what C<LC> in the name stands for. FALSE is always returned if the input
+won't fit into an octet.
+
+Variant C<isFOO_LC_uvchr> is like C<isFOO_LC>, but is defined on any UV. It
+returns the same as C<isFOO_LC> for input code points less than 256, and
+returns the hard-coded, not-affected-by-locale, Unicode results for larger ones.
+
+Variant C<isFOO_LC_utf8> is like C<isFOO_LC_uvchr>, but the input is a pointer to a
+(known to be well-formed) UTF-8 encoded string (C<U8*> or C<char*>). The
+classification of just the first (possibly multi-byte) character in the string
+is tested.
=for apidoc Am|bool|isALPHA|char ch
Returns a boolean indicating whether the specified character is an
-alphabetic character in the platform's native character set.
+alphabetic character, analogous to C<m/[[:alpha:]]/>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isALPHA_A>, C<isALPHA_L1>, C<isALPHA_uni>, C<isALPHA_utf8>, C<isALPHA_LC>,
+C<isALPHA_LC_uvchr>, and C<isALPHA_LC_utf8>.
+
+=for apidoc Am|bool|isALPHANUMERIC|char ch
+Returns a boolean indicating whether the specified character is a either an
+alphabetic character or decimal digit, analogous to C<m/[[:alnum:]]/>.
See the L<top of this section|/Character classes> for an explanation of variants
-C<isALPHA_A> and C<isALPHA_L1>.
+C<isALPHANUMERIC_A>, C<isALPHANUMERIC_L1>, C<isALPHANUMERIC_uni>,
+C<isALPHANUMERIC_utf8>, C<isALPHANUMERIC_LC>, C<isALPHANUMERIC_LC_uvchr>, and
+C<isALPHANUMERIC_LC_utf8>.
=for apidoc Am|bool|isASCII|char ch
Returns a boolean indicating whether the specified character is one of the 128
-characters in the ASCII character set. On non-ASCII platforms, it is if this
+characters in the ASCII character set, analogous to C<m/[[:ascii:]]/>.
+On non-ASCII platforms, it returns TRUE iff this
character corresponds to an ASCII character. Variants C<isASCII_A()> and
C<isASCII_L1()> are identical to C<isASCII()>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isASCII_uni>, C<isASCII_utf8>, C<isASCII_LC>, C<isASCII_LC_uvchr>, and
+C<isASCII_LC_utf8>. Note, however, that some platforms do not have the C
+library routine C<isascii()>. In these cases, the variants whose names contain
+C<LC> are the same as the corresponding ones without.
+
+=for apidoc Am|bool|isBLANK|char ch
+Returns a boolean indicating whether the specified character is a
+character considered to be a blank, analogous to C<m/[[:blank:]]/>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isBLANK_A>, C<isBLANK_L1>, C<isBLANK_uni>, C<isBLANK_utf8>, C<isBLANK_LC>,
+C<isBLANK_LC_uvchr>, and C<isBLANK_LC_utf8>. Note, however, that some
+platforms do not have the C library routine C<isblank()>. In these cases, the
+variants whose names contain C<LC> are the same as the corresponding ones
+without.
+
+=for apidoc Am|bool|isCNTRL|char ch
+Returns a boolean indicating whether the specified character is a
+control character, analogous to C<m/[[:cntrl:]]/>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isCNTRL_A>, C<isCNTRL_L1>, C<isCNTRL_uni>, C<isCNTRL_utf8>, C<isCNTRL_LC>,
+C<isCNTRL_LC_uvchr>, and C<isCNTRL_LC_utf8>
+On EBCDIC platforms, you almost always want to use the C<isCNTRL_L1> variant.
=for apidoc Am|bool|isDIGIT|char ch
Returns a boolean indicating whether the specified character is a
-digit in the platform's native character set.
+digit, analogous to C<m/[[:digit:]]/>.
Variants C<isDIGIT_A> and C<isDIGIT_L1> are identical to C<isDIGIT>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isDIGIT_uni>, C<isDIGIT_utf8>, C<isDIGIT_LC>, C<isDIGIT_LC_uvchr>, and
+C<isDIGIT_LC_utf8>.
+
+=for apidoc Am|bool|isGRAPH|char ch
+Returns a boolean indicating whether the specified character is a
+graphic character, analogous to C<m/[[:graph:]]/>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isGRAPH_A>, C<isGRAPH_L1>, C<isGRAPH_uni>, C<isGRAPH_utf8>, C<isGRAPH_LC>,
+C<isGRAPH_LC_uvchr>, and C<isGRAPH_LC_utf8>.
=for apidoc Am|bool|isLOWER|char ch
Returns a boolean indicating whether the specified character is a
-lowercase character in the platform's native character set.
+lowercase character, analogous to C<m/[[:lower:]]/>.
See the L<top of this section|/Character classes> for an explanation of variants
-C<isLOWER_A> and C<isLOWER_L1>.
+C<isLOWER_A>, C<isLOWER_L1>, C<isLOWER_uni>, C<isLOWER_utf8>, C<isLOWER_LC>,
+C<isLOWER_LC_uvchr>, and C<isLOWER_LC_utf8>.
=for apidoc Am|bool|isOCTAL|char ch
Returns a boolean indicating whether the specified character is an
-octal digit, [0-7] in the platform's native character set.
-Variants C<isOCTAL_A> and C<isOCTAL_L1> are identical to C<isOCTAL>.
+octal digit, [0-7].
+The only two variants are C<isOCTAL_A> and C<isOCTAL_L1>; each is identical to
+C<isOCTAL>.
+
+=for apidoc Am|bool|isPUNCT|char ch
+Returns a boolean indicating whether the specified character is a
+punctuation character, analogous to C<m/[[:punct:]]/>.
+Note that the definition of what is punctuation isn't as
+straightforward as one might desire. See L<perlrecharclass/POSIX Character
+Classes> for details.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isPUNCT_A>, C<isPUNCT_L1>, C<isPUNCT_uni>, C<isPUNCT_utf8>, C<isPUNCT_LC>,
+C<isPUNCT_LC_uvchr>, and C<isPUNCT_LC_utf8>.
=for apidoc Am|bool|isSPACE|char ch
Returns a boolean indicating whether the specified character is a
-whitespace character in the platform's native character set. This is the same
-as what C<\s> matches in a regular expression.
+whitespace character. This is analogous
+to what C<m/\s/> matches in a regular expression. Starting in Perl 5.18
+(experimentally), this also matches what C<m/[[:space:]]/> does.
+("Experimentally" means that this change may be backed out in 5.20 or 5.22 if
+field experience indicates that it was unwise.) Prior to 5.18, only the
+locale forms of this macro (the ones with C<LC> in their names) matched
+precisely what C<m/[[:space:]]/> does. In those releases, the only difference,
+in the non-locale variants, was that C<isSPACE()> did not match a vertical tab.
+(See L</isPSXSPC> for a macro that matches a vertical tab in all releases.)
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isSPACE_A>, C<isSPACE_L1>, C<isSPACE_uni>, C<isSPACE_utf8>, C<isSPACE_LC>,
+C<isSPACE_LC_uvchr>, and C<isSPACE_LC_utf8>.
+
+=for apidoc Am|bool|isPSXSPC|char ch
+(short for Posix Space)
+Starting in 5.18, this is identical (experimentally) in all its forms to the
+corresponding C<isSPACE()> macros. ("Experimentally" means that this change
+may be backed out in 5.20 or 5.22 if field experience indicates that it
+was unwise.)
+The locale forms of this macro are identical to their corresponding
+C<isSPACE()> forms in all Perl releases. In releases prior to 5.18, the
+non-locale forms differ from their C<isSPACE()> forms only in that the
+C<isSPACE()> forms don't match a Vertical Tab, and the C<isPSXSPC()> forms do.
+Otherwise they are identical. Thus this macro is analogous to what
+C<m/[[:space:]]/> matches in a regular expression.
See the L<top of this section|/Character classes> for an explanation of variants
-C<isSPACE_A> and C<isSPACE_L1>.
+C<isPSXSPC_A>, C<isPSXSPC_L1>, C<isPSXSPC_uni>, C<isPSXSPC_utf8>, C<isPSXSPC_LC>,
+C<isPSXSPC_LC_uvchr>, and C<isPSXSPC_LC_utf8>.
=for apidoc Am|bool|isUPPER|char ch
Returns a boolean indicating whether the specified character is an
-uppercase character in the platform's native character set.
+uppercase character, analogous to C<m/[[:upper:]]/>.
See the L<top of this section|/Character classes> for an explanation of variants
-C<isUPPER_A> and C<isUPPER_L1>.
+C<isUPPER_A>, C<isUPPER_L1>, C<isUPPER_uni>, C<isUPPER_utf8>, C<isUPPER_LC>,
+C<isUPPER_LC_uvchr>, and C<isUPPER_LC_utf8>.
-=for apidoc Am|bool|isWORDCHAR|char ch
+=for apidoc Am|bool|isPRINT|char ch
Returns a boolean indicating whether the specified character is a
-character that is any of: alphabetic, numeric, or an underscore. This is the
-same as what C<\w> matches in a regular expression.
-C<isALNUM()> is a synonym provided for backward compatibility. Note that it
-does not have the standard C language meaning of alphanumeric, since it matches
-an underscore and the standard meaning does not.
+printable character, analogous to C<m/[[:print:]]/>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isPRINT_A>, C<isPRINT_L1>, C<isPRINT_uni>, C<isPRINT_utf8>, C<isPRINT_LC>,
+C<isPRINT_LC_uvchr>, and C<isPRINT_LC_utf8>.
+
+=for apidoc Am|bool|isWORDCHAR|char ch
+Returns a boolean indicating whether the specified character is a character
+that is a word character, analogous to what C<m/\w/> and C<m/[[:word:]]/> match
+in a regular expression. A word character is an alphabetic character, a
+decimal digit, a connecting punctuation character (such as an underscore), or
+a "mark" character that attaches to one of those (like some sort of accent).
+C<isALNUM()> is a synonym provided for backward compatibility, even though a
+word character includes more than the standard C language meaning of
+alphanumeric.
See the L<top of this section|/Character classes> for an explanation of variants
-C<isWORDCHAR_A> and C<isWORDCHAR_L1>.
+C<isWORDCHAR_A>, C<isWORDCHAR_L1>, C<isWORDCHAR_uni>, C<isWORDCHAR_utf8>,
+C<isWORDCHAR_LC>, C<isWORDCHAR_LC_uvchr>, and C<isWORDCHAR_LC_utf8>.
=for apidoc Am|bool|isXDIGIT|char ch
Returns a boolean indicating whether the specified character is a hexadecimal
-digit, [0-9A-Fa-f]. Variants C<isXDIGIT_A()> and C<isXDIGIT_L1()> are
-identical to C<isXDIGIT()>.
+digit. In the ASCII range these are C<[0-9A-Fa-f]>. Variants C<isXDIGIT_A()>
+and C<isXDIGIT_L1()> are identical to C<isXDIGIT()>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isXDIGIT_uni>, C<isXDIGIT_utf8>, C<isXDIGIT_LC>, C<isXDIGIT_LC_uvchr>, and
+C<isXDIGIT_LC_utf8>.
+
+=for apidoc Am|bool|isIDFIRST|char ch
+Returns a boolean indicating whether the specified character can be the first
+character of an identifier. This is very close to, but not quite the same as
+the official Unicode property C<XID_Start>. The difference is that this
+returns true only if the input character also matches L</isWORDCHAR>.
+See the L<top of this section|/Character classes> for an explanation of variants
+C<isIDFIRST_A>, C<isIDFIRST_L1>, C<isIDFIRST_uni>, C<isIDFIRST_utf8>,
+C<isIDFIRST_LC>, C<isIDFIRST_LC_uvchr>, and C<isIDFIRST_LC_utf8>.
+
+=for apidoc Am|bool|isIDCONT|char ch
+Returns a boolean indicating whether the specified character can be the
+second or succeeding character of an identifier. This is very close to, but
+not quite the same as the official Unicode property C<XID_Continue>. The
+difference is that this returns true only if the input character also matches
+L</isWORDCHAR>. See the L<top of this section|/Character classes> for an
+explanation of variants C<isIDCONT_A>, C<isIDCONT_L1>, C<isIDCONT_uni>,
+C<isIDCONT_utf8>, C<isIDCONT_LC>, C<isIDCONT_LC_uvchr>, and
+C<isIDCONT_LC_utf8>.
+
+=head1 Miscellaneous Functions
+
+=for apidoc Am|U8|READ_XDIGIT|char str*
+Returns the value of an ASCII-range hex digit and advances the string pointer.
+Behaviour is only well defined when isXDIGIT(*str) is true.
=head1 Character case changing
-=for apidoc Am|char|toUPPER|char ch
-Converts the specified character to uppercase in the platform's native
-character set, if possible; otherwise returns the input character itself.
+=for apidoc Am|U8|toUPPER|U8 ch
+Converts the specified character to uppercase. If the input is anything but an
+ASCII lowercase character, that input character itself is returned. Variant
+C<toUPPER_A> is equivalent.
+
+=for apidoc Am|UV|toUPPER_uni|UV cp|U8* s|STRLEN* lenp
+Converts the Unicode code point C<cp> to its uppercase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the uppercase version may be longer than the original character.
+
+The first code point of the uppercased version is returned
+(but note, as explained just above, that there may be more.)
+
+=for apidoc Am|UV|toUPPER_utf8|U8* p|U8* s|STRLEN* lenp
+Converts the UTF-8 encoded character at C<p> to its uppercase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the uppercase version may be longer than the original character.
+
+The first code point of the uppercased version is returned
+(but note, as explained just above, that there may be more.)
+
+The input character at C<p> is assumed to be well-formed.
+
+=for apidoc Am|U8|toFOLD|U8 ch
+Converts the specified character to foldcase. If the input is anything but an
+ASCII uppercase character, that input character itself is returned. Variant
+C<toFOLD_A> is equivalent. (There is no equivalent C<to_FOLD_L1> for the full
+Latin1 range, as the full generality of L</toFOLD_uni> is needed there.)
+
+=for apidoc Am|UV|toFOLD_uni|UV cp|U8* s|STRLEN* lenp
+Converts the Unicode code point C<cp> to its foldcase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the foldcase version may be longer than the original character.
+
+The first code point of the foldcased version is returned
+(but note, as explained just above, that there may be more.)
+
+=for apidoc Am|UV|toFOLD_utf8|U8* p|U8* s|STRLEN* lenp
+Converts the UTF-8 encoded character at C<p> to its foldcase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the foldcase version may be longer than the original character.
+
+The first code point of the foldcased version is returned
+(but note, as explained just above, that there may be more.)
+
+The input character at C<p> is assumed to be well-formed.
+
+=for apidoc Am|U8|toLOWER|U8 ch
+Converts the specified character to lowercase. If the input is anything but an
+ASCII uppercase character, that input character itself is returned. Variant
+C<toLOWER_A> is equivalent.
+
+=for apidoc Am|U8|toLOWER_L1|U8 ch
+Converts the specified Latin1 character to lowercase. The results are undefined if
+the input doesn't fit in a byte.
+
+=for apidoc Am|U8|toLOWER_LC|U8 ch
+Converts the specified character to lowercase using the current locale's rules,
+if possible; otherwise returns the input character itself.
+
+=for apidoc Am|UV|toLOWER_uni|UV cp|U8* s|STRLEN* lenp
+Converts the Unicode code point C<cp> to its lowercase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the lowercase version may be longer than the original character.
+
+The first code point of the lowercased version is returned
+(but note, as explained just above, that there may be more.)
+
+=for apidoc Am|UV|toLOWER_utf8|U8* p|U8* s|STRLEN* lenp
+Converts the UTF-8 encoded character at C<p> to its lowercase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the lowercase version may be longer than the original character.
+
+The first code point of the lowercased version is returned
+(but note, as explained just above, that there may be more.)
+
+The input character at C<p> is assumed to be well-formed.
+
+=for apidoc Am|U8|toLOWER_LC|U8 ch
+Converts the specified character to lowercase using the current locale's rules,
+if possible; otherwise returns the input character itself.
+
+=for apidoc Am|U8|toTITLE|U8 ch
+Converts the specified character to titlecase. If the input is anything but an
+ASCII lowercase character, that input character itself is returned. Variant
+C<toTITLE_A> is equivalent. (There is no C<toTITLE_L1> for the full Latin1 range,
+as the full generality of L</toTITLE_uni> is needed there. Titlecase is not a
+concept used in locale handling, so there is no functionality for that.)
+
+=for apidoc Am|UV|toTITLE_uni|UV cp|U8* s|STRLEN* lenp
+Converts the Unicode code point C<cp> to its titlecase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the titlecase version may be longer than the original character.
+
+The first code point of the titlecased version is returned
+(but note, as explained just above, that there may be more.)
+
+=for apidoc Am|UV|toTITLE_utf8|U8* p|U8* s|STRLEN* lenp
+Converts the UTF-8 encoded character at C<p> to its titlecase version, and
+stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>. Note
+that the buffer pointed to by C<s> needs to be at least C<UTF8_MAXBYTES_CASE+1>
+bytes since the titlecase version may be longer than the original character.
-=for apidoc Am|char|toLOWER|char ch
-Converts the specified character to lowercase in the platform's native
-character set, if possible; otherwise returns the input character itself.
+The first code point of the titlecased version is returned
+(but note, as explained just above, that there may be more.)
+
+The input character at C<p> is assumed to be well-formed.
=cut
+XXX Still undocumented isVERTWS_uni and _utf8; it's unclear what their names
+really should be. Also toUPPER_LC and toFOLD_LC, which are subject to change.
+
Note that these macros are repeated in Devel::PPPort, so should also be
patched there. The file as of this writing is cpan/Devel-PPPort/parts/inc/misc
* 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
- * their actual definitions are here. If that has a name not used here, it
- * won't compile. */
-# define _CC_ALNUMC_A (1<<0)
-# define _CC_ALNUMC_L1 (1<<1)
-# define _CC_ALPHA_A (1<<2)
-# define _CC_ALPHA_L1 (1<<3)
-# define _CC_BLANK_A (1<<4)
-# define _CC_BLANK_L1 (1<<5)
-# define _CC_CHARNAME_CONT (1<<6)
-# define _CC_CNTRL_A (1<<7)
-# define _CC_CNTRL_L1 (1<<8)
-# define _CC_DIGIT_A (1<<9)
-# define _CC_GRAPH_A (1<<10)
-# define _CC_GRAPH_L1 (1<<11)
-# define _CC_IDFIRST_A (1<<12)
-# define _CC_IDFIRST_L1 (1<<13)
-# define _CC_LOWER_A (1<<14)
-# define _CC_LOWER_L1 (1<<15)
-# define _CC_PRINT_A (1<<17)
-# define _CC_PRINT_L1 (1<<18)
-# define _CC_PSXSPC_A (1<<19)
-# define _CC_PSXSPC_L1 (1<<20)
-# define _CC_PUNCT_A (1<<21)
-# define _CC_PUNCT_L1 (1<<22)
-# define _CC_SPACE_A (1<<23)
-# define _CC_SPACE_L1 (1<<24)
-# define _CC_UPPER_A (1<<25)
-# define _CC_UPPER_L1 (1<<26)
-# define _CC_WORDCHAR_A (1<<27)
-# define _CC_WORDCHAR_L1 (1<<28)
-# define _CC_XDIGIT_A (1<<29)
-# define _CC_NONLATIN1_FOLD (1<<30)
-# 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 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)))
+
+/* Character class numbers. For internal core Perl use only. The ones less
+ * than 32 are used in PL_charclass[] and the ones up through the one that
+ * corresponds to <_HIGHEST_REGCOMP_DOT_H_SYNC> are used by regcomp.h and
+ * related files. PL_charclass ones use names used in l1_char_class_tab.h but
+ * their actual definitions are here. If that file has a name not used here,
+ * it won't compile.
*
- * 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
- */
+ * The first group of these is ordered in what I (khw) estimate to be the
+ * frequency of their use. This gives a slight edge to exiting a loop earlier
+ * (in reginclass() in regexec.c) */
+# define _CC_WORDCHAR 0 /* \w and [:word:] */
+# define _CC_DIGIT 1 /* \d and [:digit:] */
+# define _CC_ALPHA 2 /* [:alpha:] */
+# define _CC_LOWER 3 /* [:lower:] */
+# define _CC_UPPER 4 /* [:upper:] */
+# define _CC_PUNCT 5 /* [:punct:] */
+# define _CC_PRINT 6 /* [:print:] */
+# define _CC_ALPHANUMERIC 7 /* [:alnum:] */
+# define _CC_GRAPH 8 /* [:graph:] */
+# define _CC_CASED 9 /* [:lower:] and [:upper:] under /i */
+
+#define _FIRST_NON_SWASH_CC 10
+/* The character classes above are implemented with swashes. The second group
+ * (just below) contains the ones implemented without. These are also sorted
+ * in rough order of the frequency of their use, except that \v should be last,
+ * as it isn't a real Posix character class, and some (small) inefficiencies in
+ * regular expression handling would be introduced by putting it in the middle
+ * of those that are. Also, cntrl and ascii come after the others as it may be
+ * useful to group these which have no members that match above Latin1, (or
+ * above ASCII in the latter case) */
+
+# define _CC_SPACE 10 /* \s */
+# define _CC_BLANK 11 /* [:blank:] */
+# define _CC_XDIGIT 12 /* [:xdigit:] */
+# define _CC_PSXSPC 13 /* [:space:] */
+# define _CC_CNTRL 14 /* [:cntrl:] */
+# define _CC_ASCII 15 /* [:ascii:] */
+# define _CC_VERTSPACE 16 /* \v */
+
+# define _HIGHEST_REGCOMP_DOT_H_SYNC _CC_VERTSPACE
+
+/* The members of the third group below do not need to be coordinated with data
+ * structures in regcomp.[ch] and regexec.c */
+# define _CC_IDFIRST 17
+# define _CC_CHARNAME_CONT 18
+# define _CC_NONLATIN1_FOLD 19
+# define _CC_QUOTEMETA 20
+# define _CC_NON_FINAL_FOLD 21
+# define _CC_IS_IN_SOME_FOLD 22
+# define _CC_BACKSLASH_FOO_LBRACE_IS_META 31 /* temp, see mk_PL_charclass.pl */
+/* Unused: 23-30
+ * If more bits are needed, one could add a second word for non-64bit
+ * QUAD_IS_INT systems, using some #ifdefs to distinguish between having a 2nd
+ * word or not. The IS_IN_SOME_FOLD bit is the most easily expendable, as it
+ * is used only for optimization (as of this writing), and differs in the
+ * Latin1 range from the ALPHA bit only in two relatively unimportant
+ * characters: the masculine and feminine ordinal indicators, so removing it
+ * would just cause /i regexes which match them to run less efficiently */
+
+#if defined(PERL_CORE) || defined(PERL_EXT)
+/* An enum version of the character class numbers, to help compilers
+ * optimize */
+typedef enum {
+ _CC_ENUM_ALPHA = _CC_ALPHA,
+ _CC_ENUM_ALPHANUMERIC = _CC_ALPHANUMERIC,
+ _CC_ENUM_ASCII = _CC_ASCII,
+ _CC_ENUM_BLANK = _CC_BLANK,
+ _CC_ENUM_CASED = _CC_CASED,
+ _CC_ENUM_CNTRL = _CC_CNTRL,
+ _CC_ENUM_DIGIT = _CC_DIGIT,
+ _CC_ENUM_GRAPH = _CC_GRAPH,
+ _CC_ENUM_LOWER = _CC_LOWER,
+ _CC_ENUM_PRINT = _CC_PRINT,
+ _CC_ENUM_PSXSPC = _CC_PSXSPC,
+ _CC_ENUM_PUNCT = _CC_PUNCT,
+ _CC_ENUM_SPACE = _CC_SPACE,
+ _CC_ENUM_UPPER = _CC_UPPER,
+ _CC_ENUM_VERTSPACE = _CC_VERTSPACE,
+ _CC_ENUM_WORDCHAR = _CC_WORDCHAR,
+ _CC_ENUM_XDIGIT = _CC_XDIGIT
+} _char_class_number;
+#endif
+
+#define POSIX_SWASH_COUNT _FIRST_NON_SWASH_CC
+#define POSIX_CC_COUNT (_HIGHEST_REGCOMP_DOT_H_SYNC + 1)
+
+#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
+# if _CC_WORDCHAR != 0 || _CC_DIGIT != 1 || _CC_ALPHA != 2 || _CC_LOWER != 3 \
+ || _CC_UPPER != 4 || _CC_PUNCT != 5 || _CC_PRINT != 6 \
+ || _CC_ALPHANUMERIC != 7 || _CC_GRAPH != 8 || _CC_CASED != 9
+ #error Need to adjust order of swash_property_names[]
+# endif
+
+/* This is declared static in each of the few files that this is #defined for
+ * to keep them from being publicly accessible. Hence there is a small amount
+ * of wasted space */
+
+static const char* const swash_property_names[] = {
+ "XPosixWord",
+ "XPosixDigit",
+ "XPosixAlpha",
+ "XPosixLower",
+ "XPosixUpper",
+ "XPosixPunct",
+ "XPosixPrint",
+ "XPosixAlnum",
+ "XPosixGraph",
+ "Cased"
+};
+#endif
# ifdef DOINIT
EXTCONST U32 PL_charclass[] = {
EXTCONST U32 PL_charclass[];
# endif
-# define isALNUMC_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALNUMC_A))
-# define isALPHA_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALPHA_A))
-# define isBLANK_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_BLANK_A))
-# define isCNTRL_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CNTRL_A))
-# define isDIGIT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_DIGIT_A))
-# 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 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))
-# define isSPACE_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_SPACE_A))
-# define isUPPER_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_UPPER_A))
-# define isWORDCHAR_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_WORDCHAR_A))
-# define isXDIGIT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_XDIGIT_A))
+ /* The 1U keeps Solaris from griping when shifting sets the uppermost bit */
+# define _CC_mask(classnum) (1U << (classnum))
+# define _generic_isCC(c, classnum) cBOOL(FITS_IN_8_BITS(c) \
+ && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_mask(classnum)))
+
+ /* The mask for the _A versions of the macros; it just adds in the bit for
+ * ASCII. */
+# define _CC_mask_A(classnum) (_CC_mask(classnum) | _CC_mask(_CC_ASCII))
+
+ /* The _A version makes sure that both the desired bit and the ASCII bit
+ * are present */
+# define _generic_isCC_A(c, classnum) (FITS_IN_8_BITS(c) \
+ && ((PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_mask_A(classnum)) \
+ == _CC_mask_A(classnum)))
+
+# define isALPHA_A(c) _generic_isCC_A(c, _CC_ALPHA)
+# define isALPHANUMERIC_A(c) _generic_isCC_A(c, _CC_ALPHANUMERIC)
+# define isBLANK_A(c) _generic_isCC_A(c, _CC_BLANK)
+# define isCNTRL_A(c) _generic_isCC_A(c, _CC_CNTRL)
+# define isDIGIT_A(c) _generic_isCC(c, _CC_DIGIT)
+# define isGRAPH_A(c) _generic_isCC_A(c, _CC_GRAPH)
+# define isLOWER_A(c) _generic_isCC_A(c, _CC_LOWER)
+# define isPRINT_A(c) _generic_isCC_A(c, _CC_PRINT)
+# define isPSXSPC_A(c) _generic_isCC_A(c, _CC_PSXSPC)
+# define isPUNCT_A(c) _generic_isCC_A(c, _CC_PUNCT)
+# define isSPACE_A(c) _generic_isCC_A(c, _CC_SPACE)
+# define isUPPER_A(c) _generic_isCC_A(c, _CC_UPPER)
+# define isWORDCHAR_A(c) _generic_isCC_A(c, _CC_WORDCHAR)
+# define isXDIGIT_A(c) _generic_isCC(c, _CC_XDIGIT)
+# define isIDFIRST_A(c) _generic_isCC_A(c, ( _CC_IDFIRST))
+
/* 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))
+# 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_mask(_CC_NONLATIN1_FOLD)))
+
+# define _isQUOTEMETA(c) _generic_isCC(c, _CC_QUOTEMETA)
+# define _IS_NON_FINAL_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) \
+ _generic_isCC(c, _CC_NON_FINAL_FOLD)
+# define _IS_IN_SOME_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) \
+ _generic_isCC(c, _CC_IS_IN_SOME_FOLD)
#else /* No perl.h. */
# ifdef EBCDIC
-# define isALNUMC_A(c) (isASCII(c) && isALNUMC(c))
# define isALPHA_A(c) (isASCII(c) && isALPHA(c))
+# define isALPHANUMERIC_A(c) (isASCII(c) && isALPHANUMERIC(c))
# define isBLANK_A(c) (isASCII(c) && isBLANK(c))
# define isCNTRL_A(c) (isASCII(c) && isCNTRL(c))
# define isDIGIT_A(c) (isASCII(c) && isDIGIT(c))
# define isWORDCHAR_A(c) (isASCII(c) && isWORDCHAR(c))
# define isXDIGIT_A(c) (isASCII(c) && isXDIGIT(c))
# else /* ASCII platform, no perl.h */
-# define isALNUMC_A(c) (isALPHA_A(c) || isDIGIT_A(c))
# define isALPHA_A(c) (isUPPER_A(c) || isLOWER_A(c))
+# define isALPHANUMERIC_A(c) (isALPHA_A(c) || isDIGIT_A(c))
# define isBLANK_A(c) ((c) == ' ' || (c) == '\t')
-# define isCNTRL_A(c) (FITS_IN_8_BITS(c) && ((U8) (c) < ' ' || (c) == 127))
+# define isCNTRL_A(c) (FITS_IN_8_BITS(c) && ((U8) (c) < ' ' || (c) == 127))
# define isDIGIT_A(c) ((c) <= '9' && (c) >= '0')
# define isGRAPH_A(c) (isWORDCHAR_A(c) || isPUNCT_A(c))
# define isIDFIRST_A(c) (isALPHA_A(c) || (c) == '_')
# define isLOWER_A(c) ((c) >= 'a' && (c) <= 'z')
# define isPRINT_A(c) (((c) >= 32 && (c) < 127))
# define isPSXSPC_A(c) (isSPACE_A(c) || (c) == '\v')
-# define isPUNCT_A(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
-# define isSPACE_A(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) =='\r' || (c) == '\f')
+# define isPUNCT_A(c) (((c) >= 33 && (c) <= 47) \
+ || ((c) >= 58 && (c) <= 64) \
+ || ((c) >= 91 && (c) <= 96) \
+ || ((c) >= 123 && (c) <= 126))
+# define isSPACE_A(c) ((c) == ' ' \
+ || (c) == '\t' \
+ || (c) == '\n' \
+ || (c) =='\r' \
+ || (c) == '\f')
# define isUPPER_A(c) ((c) <= 'Z' && (c) >= 'A')
# 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'))
+# 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) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALNUMC_L1))
-# define isALPHA_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALPHA_L1))
-# define isBLANK_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_BLANK_L1))
+# define isALPHA_L1(c) _generic_isCC(c, _CC_ALPHA)
+# define isALPHANUMERIC_L1(c) _generic_isCC(c, _CC_ALPHANUMERIC)
+# define isBLANK_L1(c) _generic_isCC(c, _CC_BLANK)
+
/* continuation character for legal NAME in \N{NAME} */
-# define isCHARNAME_CONT(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CHARNAME_CONT))
-# define isCNTRL_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CNTRL_L1))
-# define isGRAPH_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_GRAPH_L1))
-# define isIDFIRST_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_IDFIRST_L1))
-# define isLOWER_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_LOWER_L1))
-# define isPRINT_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PRINT_L1))
-# define isPSXSPC_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PSXSPC_L1))
-# define isPUNCT_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PUNCT_L1))
-# define isSPACE_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_SPACE_L1))
-# define isUPPER_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_UPPER_L1))
-# define isWORDCHAR_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_WORDCHAR_L1))
+# define isCHARNAME_CONT(c) _generic_isCC(c, _CC_CHARNAME_CONT)
+
+# define isCNTRL_L1(c) _generic_isCC(c, _CC_CNTRL)
+# define isGRAPH_L1(c) _generic_isCC(c, _CC_GRAPH)
+# define isLOWER_L1(c) _generic_isCC(c, _CC_LOWER)
+# define isPRINT_L1(c) _generic_isCC(c, _CC_PRINT)
+# define isPSXSPC_L1(c) _generic_isCC(c, _CC_PSXSPC)
+# define isPUNCT_L1(c) _generic_isCC(c, _CC_PUNCT)
+# define isSPACE_L1(c) _generic_isCC(c, _CC_SPACE)
+# define isUPPER_L1(c) _generic_isCC(c, _CC_UPPER)
+# define isWORDCHAR_L1(c) _generic_isCC(c, _CC_WORDCHAR)
+# define isIDFIRST_L1(c) _generic_isCC(c, _CC_IDFIRST)
#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) != 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)
+# define isCHARNAME_CONT(c) (isWORDCHAR_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
* 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 isALPHANUMERIC(c) isalnum(c)
# define isBLANK(c) ((c) == ' ' || (c) == '\t' || NATIVE_TO_UNI(c) == 0xA0)
# define isCNTRL(c) iscntrl(c)
# define isDIGIT(c) isdigit(c)
# define isPRINT(c) isprint(c)
# define isPSXSPC(c) isspace(c)
# define isPUNCT(c) ispunct(c)
-# define isSPACE(c) (isPSXSPC(c) && (c) != '\v')
+# define isSPACE(c) (isPSXSPC(c) /* && (c) != '\v' (Experimentally making
+ these macros identical) */)
# 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)
+# 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 toUPPER(c) (isLOWER(c) ? (c) - ('a' - 'A') : (c))
#endif
+/* 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)
/* Use table lookup for speed; return error character for input
* out-of-range */
-#define toLOWER_LATIN1(c) (FITS_IN_8_BITS(c) \
- ? UNI_TO_NATIVE(PL_latin1_lc[ \
- NATIVE_TO_UNI( (U8) (c)) ]) \
- : UNICODE_REPLACEMENT)
+#define toLOWER_LATIN1(c) ((! FITS_IN_8_BITS(c)) \
+ ? (c) \
+ : UNI_TO_NATIVE(PL_latin1_lc[ \
+ NATIVE_TO_UNI( (U8) (c)) ]))
+#define toLOWER_L1(c) toLOWER_LATIN1(c) /* Synonym for consistency */
+
/* Modified uc. Is correct uc except for three non-ascii chars which are
* all mapped to one of them, and these need special handling; error
* character for input out-of-range */
-#define toUPPER_LATIN1_MOD(c) (FITS_IN_8_BITS(c) \
- ? UNI_TO_NATIVE(PL_mod_latin1_uc[ \
- NATIVE_TO_UNI( (U8) (c)) ]) \
- : UNICODE_REPLACEMENT)
+#define toUPPER_LATIN1_MOD(c) ((! FITS_IN_8_BITS(c)) \
+ ? (c) \
+ : UNI_TO_NATIVE(PL_mod_latin1_uc[ \
+ NATIVE_TO_UNI( (U8) (c)) ]))
#ifdef USE_NEXT_CTYPE
-# define isALNUM_LC(c) \
- (NXIsAlNum((unsigned int)(c)) || (char)(c) == '_')
-# define isIDFIRST_LC(c) \
- (NXIsAlpha((unsigned int)(c)) || (char)(c) == '_')
+# define isALPHANUMERIC_LC(c) NXIsAlNum((unsigned int)(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))
-# define isLOWER_LC(c) NXIsLower((unsigned int)(c))
-# define isALNUMC_LC(c) NXIsAlNum((unsigned int)(c))
# define isCNTRL_LC(c) NXIsCntrl((unsigned int)(c))
+# define isDIGIT_LC(c) NXIsDigit((unsigned int)(c))
# define isGRAPH_LC(c) NXIsGraph((unsigned int)(c))
+# define isIDFIRST_LC(c) (NXIsAlpha((unsigned int)(c)) || (char)(c) == '_')
+# define isLOWER_LC(c) NXIsLower((unsigned int)(c))
# define isPRINT_LC(c) NXIsPrint((unsigned int)(c))
# define isPUNCT_LC(c) NXIsPunct((unsigned int)(c))
-# define toUPPER_LC(c) NXToUpper((unsigned int)(c))
+# define isSPACE_LC(c) NXIsSpace((unsigned int)(c))
+# define isUPPER_LC(c) NXIsUpper((unsigned int)(c))
+# define isWORDCHAR_LC(c) (NXIsAlNum((unsigned int)(c)) || (char)(c) == '_')
+# define isXDIGIT_LC(c) NXIsXDigit((unsigned int)(c))
# define toLOWER_LC(c) NXToLower((unsigned int)(c))
+# define toUPPER_LC(c) NXToUpper((unsigned int)(c))
#else /* !USE_NEXT_CTYPE */
# 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 */
+/* Use foo_LC_uvchr() instead of these for beyond the Latin1 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))
+# define isALPHA_LC(c) (FITS_IN_8_BITS(c) && isalpha((unsigned char)(c)))
+# define isALPHANUMERIC_LC(c) (FITS_IN_8_BITS(c) \
+ && isalnum((unsigned char)(c)))
# ifdef HAS_ISASCII
-# define isASCII_LC(c) isascii((unsigned char)(c))
+# define isASCII_LC(c) (FITS_IN_8_BITS(c) && isascii((unsigned char)(c)))
# else
-# define isASCII_LC(c) isASCII((unsigned char)(c))
+# define isASCII_LC(c) (FITS_IN_8_BITS(c) && isASCII((unsigned char)(c)))
# endif
# ifdef HAS_ISBLANK
-# define isBLANK_LC(c) isblank((unsigned char)(c))
+# define isBLANK_LC(c) (FITS_IN_8_BITS(c) && isblank((unsigned char)(c)))
# else
-# define isBLANK_LC(c) isBLANK((unsigned char)(c))
+# define isBLANK_LC(c) (FITS_IN_8_BITS(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 isLOWER_LC(c) islower((unsigned char)(c))
-# define isALNUMC_LC(c) isalnum((unsigned char)(c))
-# define isCNTRL_LC(c) iscntrl((unsigned char)(c))
-# define isGRAPH_LC(c) isgraph((unsigned char)(c))
-# define isPRINT_LC(c) isprint((unsigned char)(c))
-# define isPUNCT_LC(c) ispunct((unsigned char)(c))
-# define toUPPER_LC(c) toupper((unsigned char)(c))
-# define toLOWER_LC(c) tolower((unsigned char)(c))
+# define isCNTRL_LC(c) (FITS_IN_8_BITS(c) && iscntrl((unsigned char)(c)))
+# define isDIGIT_LC(c) (FITS_IN_8_BITS(c) && isdigit((unsigned char)(c)))
+# define isGRAPH_LC(c) (FITS_IN_8_BITS(c) && isgraph((unsigned char)(c)))
+# define isIDFIRST_LC(c) (FITS_IN_8_BITS(c) \
+ && (isalpha((unsigned char)(c)) || (char)(c) == '_'))
+# define isLOWER_LC(c) (FITS_IN_8_BITS(c) && islower((unsigned char)(c)))
+# define isPRINT_LC(c) (FITS_IN_8_BITS(c) && isprint((unsigned char)(c)))
+# define isPUNCT_LC(c) (FITS_IN_8_BITS(c) && ispunct((unsigned char)(c)))
+# define isSPACE_LC(c) (FITS_IN_8_BITS(c) && isspace((unsigned char)(c)))
+# define isUPPER_LC(c) (FITS_IN_8_BITS(c) && isupper((unsigned char)(c)))
+# define isWORDCHAR_LC(c) (FITS_IN_8_BITS(c) \
+ && (isalnum((unsigned char)(c)) || (char)(c) == '_'))
+# define isXDIGIT_LC(c) (FITS_IN_8_BITS(c) && isxdigit((unsigned char)(c)))
+# define toLOWER_LC(c) (FITS_IN_8_BITS(c) ? tolower((unsigned char)(c)) : (c))
+# define toUPPER_LC(c) (FITS_IN_8_BITS(c) ? toupper((unsigned char)(c)) : (c))
# else
-# 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 isALPHANUMERIC_LC(c) (isascii(c) && isalnum(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)
+# define isBLANK_LC(c) isBLANK_A(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))
-# define isLOWER_LC(c) (isascii(c) && islower(c))
-# define isALNUMC_LC(c) (isascii(c) && isalnum(c))
# define isCNTRL_LC(c) (isascii(c) && iscntrl(c))
+# define isDIGIT_LC(c) (isascii(c) && isdigit(c))
# define isGRAPH_LC(c) (isascii(c) && isgraph(c))
+# define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_'))
+# define isLOWER_LC(c) (isascii(c) && islower(c))
# define isPRINT_LC(c) (isascii(c) && isprint(c))
# define isPUNCT_LC(c) (isascii(c) && ispunct(c))
-# define toUPPER_LC(c) toupper(c)
-# define toLOWER_LC(c) tolower(c)
+# define isSPACE_LC(c) (isascii(c) && isspace(c))
+# define isUPPER_LC(c) (isascii(c) && isupper(c))
+# define isWORDCHAR_LC(c) (isascii(c) && (isalnum(c) || (c) == '_'))
+# define isXDIGIT_LC(c) (isascii(c) && isxdigit(c))
+# define toLOWER_LC(c) (isascii(c) ? tolower(c) : (c))
+# define toUPPER_LC(c) (isascii(c) ? toupper(c) : (c))
# endif
#endif /* USE_NEXT_CTYPE */
-#define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v')
+#define isIDCONT(c) isWORDCHAR(c)
+#define isIDCONT_A(c) isWORDCHAR_A(c)
+#define isIDCONT_L1(c) isWORDCHAR_L1(c)
+#define isIDCONT_LC(c) isWORDCHAR_LC(c)
+#define isPSXSPC_LC(c) isSPACE_LC(c)
+
+/* For internal core Perl use only. If the input is Latin1, use the Latin1
+ * macro; otherwise use the function 'above_latin1'. Won't compile if 'c' isn't unsigned, as
+ * won't match above_latin1 prototype. The macros do bounds checking, so have
+ * duplicate checks here, so could create versions of the macros that don't,
+ * but experiments show that gcc optimizes them out anyway. */
-/* 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
- * 'c' isn't unsigned, as won't match function prototype. The macros do bounds
- * checking, so have duplicate checks here, so could create versions of the
- * macros that don't, but experiments show that gcc optimizes them out anyway.
- */
-#define generic_uni(macro, function, c) ((c) < 256 \
- ? CAT2(macro, _L1)(c) \
- : function(c))
/* Note that all ignore 'use bytes' */
+#define _generic_uni(classnum, above_latin1, c) ((c) < 256 \
+ ? _generic_isCC(c, classnum) \
+ : above_latin1(c))
+#define _generic_swash_uni(classnum, c) ((c) < 256 \
+ ? _generic_isCC(c, classnum) \
+ : _is_uni_FOO(classnum, c))
+#define isALPHA_uni(c) _generic_swash_uni(_CC_ALPHA, c)
+#define isALPHANUMERIC_uni(c) _generic_swash_uni(_CC_ALPHANUMERIC, c)
+#define isASCII_uni(c) isASCII(c)
+#define isBLANK_uni(c) _generic_uni(_CC_BLANK, is_HORIZWS_cp_high, c)
+#define isCNTRL_uni(c) isCNTRL_L1(c) /* All controls are in Latin1 */
+#define isDIGIT_uni(c) _generic_swash_uni(_CC_DIGIT, c)
+#define isGRAPH_uni(c) _generic_swash_uni(_CC_GRAPH, c)
+#define isIDCONT_uni(c) _generic_uni(_CC_WORDCHAR, _is_uni_perl_idcont, c)
+#define isIDFIRST_uni(c) _generic_uni(_CC_IDFIRST, _is_uni_perl_idstart, c)
+#define isLOWER_uni(c) _generic_swash_uni(_CC_LOWER, c)
+#define isPRINT_uni(c) _generic_swash_uni(_CC_PRINT, c)
+
+/* Posix and regular space are identical above Latin1 */
+#define isPSXSPC_uni(c) _generic_uni(_CC_PSXSPC, is_XPERLSPACE_cp_high, c)
+
+#define isPUNCT_uni(c) _generic_swash_uni(_CC_PUNCT, c)
+#define isSPACE_uni(c) _generic_uni(_CC_SPACE, is_XPERLSPACE_cp_high, c)
+#define isUPPER_uni(c) _generic_swash_uni(_CC_UPPER, c)
+#define isVERTWS_uni(c) _generic_uni(_CC_VERTSPACE, is_VERTWS_cp_high, c)
+#define isWORDCHAR_uni(c) _generic_swash_uni(_CC_WORDCHAR, c)
+#define isXDIGIT_uni(c) _generic_uni(_CC_XDIGIT, is_XDIGIT_cp_high, c)
-#define isALNUM_uni(c) generic_uni(isWORDCHAR, is_uni_alnum, c)
-#define isIDFIRST_uni(c) generic_uni(isIDFIRST, is_uni_idfirst, c)
-#define isALPHA_uni(c) generic_uni(isALPHA, is_uni_alpha, c)
-#define isSPACE_uni(c) generic_uni(isSPACE, is_uni_space, c)
-#define isDIGIT_uni(c) generic_uni(isDIGIT, is_uni_digit, c)
-#define isUPPER_uni(c) generic_uni(isUPPER, is_uni_upper, c)
-#define isLOWER_uni(c) generic_uni(isLOWER, is_uni_lower, c)
-#define isASCII_uni(c) isASCII(c)
-/* All controls are in Latin1 */
-#define isCNTRL_uni(c) ((c) < 256 && isCNTRL_L1(c))
-#define isGRAPH_uni(c) generic_uni(isGRAPH, is_uni_graph, c)
-#define isPRINT_uni(c) generic_uni(isPRINT, is_uni_print, c)
-#define isPUNCT_uni(c) generic_uni(isPUNCT, is_uni_punct, c)
-#define isXDIGIT_uni(c) generic_uni(isXDIGIT, is_uni_xdigit, c)
-#define toUPPER_uni(c,s,l) to_uni_upper(c,s,l)
-#define toTITLE_uni(c,s,l) to_uni_title(c,s,l)
-#define toLOWER_uni(c,s,l) to_uni_lower(c,s,l)
#define toFOLD_uni(c,s,l) to_uni_fold(c,s,l)
+#define toLOWER_uni(c,s,l) to_uni_lower(c,s,l)
+#define toTITLE_uni(c,s,l) to_uni_title(c,s,l)
+#define toUPPER_uni(c,s,l) to_uni_upper(c,s,l)
-/* Posix and regular space differ only in U+000B, which is in Latin1 */
-#define isPSXSPC_uni(c) ((c) < 256 ? isPSXSPC_L1(c) : isSPACE_uni(c))
-#define isBLANK_uni(c) isBLANK(c) /* could be wrong */
-
-#define isALNUM_LC_uvchr(c) (c < 256 ? isALNUM_LC(c) : is_uni_alnum_lc(c))
-#define isIDFIRST_LC_uvchr(c) (c < 256 ? isIDFIRST_LC(c) : is_uni_idfirst_lc(c))
-#define isALPHA_LC_uvchr(c) (c < 256 ? isALPHA_LC(c) : is_uni_alpha_lc(c))
-#define isSPACE_LC_uvchr(c) (c < 256 ? isSPACE_LC(c) : is_uni_space_lc(c))
-#define isDIGIT_LC_uvchr(c) (c < 256 ? isDIGIT_LC(c) : is_uni_digit_lc(c))
-#define isUPPER_LC_uvchr(c) (c < 256 ? isUPPER_LC(c) : is_uni_upper_lc(c))
-#define isLOWER_LC_uvchr(c) (c < 256 ? isLOWER_LC(c) : is_uni_lower_lc(c))
-#define isCNTRL_LC_uvchr(c) (c < 256 ? isCNTRL_LC(c) : is_uni_cntrl_lc(c))
-#define isGRAPH_LC_uvchr(c) (c < 256 ? isGRAPH_LC(c) : is_uni_graph_lc(c))
-#define isPRINT_LC_uvchr(c) (c < 256 ? isPRINT_LC(c) : is_uni_print_lc(c))
-#define isPUNCT_LC_uvchr(c) (c < 256 ? isPUNCT_LC(c) : is_uni_punct_lc(c))
-
-#define isPSXSPC_LC_uni(c) (isSPACE_LC_uni(c) ||(c) == '\f')
-#define isBLANK_LC_uni(c) isBLANK(c) /* could be wrong */
-
-/* For use in the macros just below. If the input is ASCII, use the ASCII (_A)
- * version of the macro; if the input is in the upper Latin1 range, use the
- * Latin1 (_L1) version of the macro, after converting from utf8; otherwise use
- * 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(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 assume that the utf8 has been validated, and ignore 'use
+#define _generic_LC_uvchr(latin1, above_latin1, c) \
+ (c < 256 ? latin1(c) : above_latin1(c))
+#define _generic_LC_swash_uvchr(latin1, classnum, c) \
+ (c < 256 ? latin1(c) : _is_uni_FOO(classnum, c))
+
+#define isALPHA_LC_uvchr(c) _generic_LC_swash_uvchr(isALPHA_LC, _CC_ALPHA, c)
+#define isALPHANUMERIC_LC_uvchr(c) _generic_LC_swash_uvchr(isALPHANUMERIC_LC, \
+ _CC_ALPHANUMERIC, c)
+#define isASCII_LC_uvchr(c) isASCII_LC(c)
+#define isBLANK_LC_uvchr(c) _generic_LC_uvchr(isBLANK_LC, is_HORIZWS_cp_high, c)
+#define isCNTRL_LC_uvchr(c) (c < 256 ? isCNTRL_LC(c) : 0)
+#define isDIGIT_LC_uvchr(c) _generic_LC_swash_uvchr(isDIGIT_LC, _CC_DIGIT, c)
+#define isGRAPH_LC_uvchr(c) _generic_LC_swash_uvchr(isGRAPH_LC, _CC_GRAPH, c)
+#define isIDCONT_LC_uvchr(c) _generic_LC_uvchr(isIDCONT_LC, \
+ _is_uni_perl_idcont, c)
+#define isIDFIRST_LC_uvchr(c) _generic_LC_uvchr(isIDFIRST_LC, \
+ _is_uni_perl_idstart, c)
+#define isLOWER_LC_uvchr(c) _generic_LC_swash_uvchr(isLOWER_LC, _CC_LOWER, c)
+#define isPRINT_LC_uvchr(c) _generic_LC_swash_uvchr(isPRINT_LC, _CC_PRINT, c)
+#define isPSXSPC_LC_uvchr(c) isSPACE_LC_uvchr(c) /* space is identical to posix
+ space under locale */
+#define isPUNCT_LC_uvchr(c) _generic_LC_swash_uvchr(isPUNCT_LC, _CC_PUNCT, c)
+#define isSPACE_LC_uvchr(c) _generic_LC_uvchr(isSPACE_LC, \
+ is_XPERLSPACE_cp_high, c)
+#define isUPPER_LC_uvchr(c) _generic_LC_swash_uvchr(isUPPER_LC, _CC_UPPER, c)
+#define isWORDCHAR_LC_uvchr(c) _generic_LC_swash_uvchr(isWORDCHAR_LC, \
+ _CC_WORDCHAR, c)
+#define isXDIGIT_LC_uvchr(c) _generic_LC_uvchr(isXDIGIT_LC, is_XDIGIT_cp_high, c)
+
+
+#define isBLANK_LC_uni(c) isBLANK_LC_uvchr(UNI_TO_NATIVE(c))
+
+/* Everything whose name begins with an underscore is for internal core Perl
+ * use only. */
+
+/* If the input is in the Latin1 range, use
+ * the Latin1 macro 'classnum' on 'p' which is a pointer to a UTF-8 string.
+ * Otherwise use the value given by the 'utf8' parameter. This relies on the
+ * fact that ASCII characters have the same representation whether utf8 or not.
+ * Note that it assumes that the utf8 has been validated, and ignores 'use
* bytes' */
+#define _generic_utf8(classnum, p, utf8) (UTF8_IS_INVARIANT(*(p)) \
+ ? _generic_isCC(*(p), classnum) \
+ : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \
+ ? _generic_isCC( \
+ TWO_BYTE_UTF8_TO_UNI(*(p), \
+ *((p)+1 )), \
+ classnum) \
+ : utf8)
+/* Like the above, but calls 'above_latin1(p)' to get the utf8 value. 'above_latin1'
+ * can be a macro */
+#define _generic_func_utf8(classnum, above_latin1, p) \
+ _generic_utf8(classnum, p, above_latin1(p))
+/* Like the above, but passes classnum to _isFOO_utf8(), instead of having a
+ * 'above_latin1' parameter */
+#define _generic_swash_utf8(classnum, p) \
+ _generic_utf8(classnum, p, _is_utf8_FOO(classnum, p))
+
+/* Like the above, but should be used only when it is known that there are no
+ * characters in the range 128-255 which the class is TRUE for. Hence it can
+ * skip the tests for this range. 'above_latin1' should include its arguments */
+#define _generic_utf8_no_upper_latin1(classnum, p, above_latin1) \
+ (UTF8_IS_INVARIANT(*(p)) \
+ ? _generic_isCC(*(p), classnum) \
+ : (UTF8_IS_ABOVE_LATIN1(*(p))) \
+ ? above_latin1 \
+ : 0)
+
+/* NOTE that some of these macros have very similar ones in regcharclass.h.
+ * For example, there is (at the time of this writing) an 'is_SPACE_utf8()'
+ * there, differing in name only by an underscore from the one here
+ * 'isSPACE_utf8(). The difference is that the ones here are probably more
+ * efficient and smaller, using an O(1) array lookup for Latin1-range code
+ * points; the regcharclass.h ones are implemented as a series of
+ * "if-else-if-else ..." */
+
+#define isALPHA_utf8(p) _generic_swash_utf8(_CC_ALPHA, p)
+#define isALPHANUMERIC_utf8(p) _generic_swash_utf8(_CC_ALPHANUMERIC, p)
+#define isASCII_utf8(p) isASCII(*p) /* Because ASCII is invariant under
+ utf8, the non-utf8 macro works
+ */
+#define isBLANK_utf8(p) _generic_func_utf8(_CC_BLANK, is_HORIZWS_high, p)
+#define isCNTRL_utf8(p) _generic_utf8(_CC_CNTRL, p, 0)
+#define isDIGIT_utf8(p) _generic_utf8_no_upper_latin1(_CC_DIGIT, p, \
+ _is_utf8_FOO(_CC_DIGIT, p))
+#define isGRAPH_utf8(p) _generic_swash_utf8(_CC_GRAPH, p)
+#define isIDCONT_utf8(p) _generic_func_utf8(_CC_WORDCHAR, \
+ _is_utf8_perl_idcont, p)
-#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
* IDFIRST is an alnum. See
* http://rt.perl.org/rt3/Ticket/Display.html?id=74022 for more detail than you
- * ever wanted to know about. XXX It is unclear if this should extend to
- * isIDFIRST_uni() which it hasn't so far. (In the ASCII range, there isn't a
- * difference.) This used to be not the XID version, but we decided to go with
- * the more modern Unicode definition */
-#define isIDFIRST_utf8(p) (isASCII(*(p)) \
- ? isIDFIRST_A(*(p)) \
- : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \
- ? isIDFIRST_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \
- *((p)+1)))\
- : 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)
-#define isDIGIT_utf8(p) generic_utf8(isDIGIT, is_utf8_digit, p)
-#define isUPPER_utf8(p) generic_utf8(isUPPER, is_utf8_upper, p)
-#define isLOWER_utf8(p) generic_utf8(isLOWER, is_utf8_lower, p)
-/* Because ASCII is invariant under utf8, the non-utf8 macro works */
-#define isASCII_utf8(p) isASCII(p)
-#define isCNTRL_utf8(p) generic_utf8(isCNTRL, is_utf8_cntrl, p)
-#define isGRAPH_utf8(p) generic_utf8(isGRAPH, is_utf8_graph, p)
-#define isPRINT_utf8(p) generic_utf8(isPRINT, is_utf8_print, p)
-#define isPUNCT_utf8(p) generic_utf8(isPUNCT, is_utf8_punct, p)
-#define isXDIGIT_utf8(p) generic_utf8(isXDIGIT, is_utf8_xdigit, p)
-#define toUPPER_utf8(p,s,l) to_utf8_upper(p,s,l)
-#define toTITLE_utf8(p,s,l) to_utf8_title(p,s,l)
+ * ever wanted to know about. (In the ASCII range, there isn't a difference.)
+ * This used to be not the XID version, but we decided to go with the more
+ * modern Unicode definition */
+#define isIDFIRST_utf8(p) _generic_func_utf8(_CC_IDFIRST, \
+ _is_utf8_perl_idstart, p)
+
+#define isLOWER_utf8(p) _generic_swash_utf8(_CC_LOWER, p)
+#define isPRINT_utf8(p) _generic_swash_utf8(_CC_PRINT, p)
+
+/* Posix and regular space are identical above Latin1 */
+#define isPSXSPC_utf8(p) _generic_func_utf8(_CC_PSXSPC, is_XPERLSPACE_high, p)
+
+#define isPUNCT_utf8(p) _generic_swash_utf8(_CC_PUNCT, p)
+#define isSPACE_utf8(p) _generic_func_utf8(_CC_SPACE, is_XPERLSPACE_high, p)
+#define isUPPER_utf8(p) _generic_swash_utf8(_CC_UPPER, p)
+#define isVERTWS_utf8(p) _generic_func_utf8(_CC_VERTSPACE, is_VERTWS_high, p)
+#define isWORDCHAR_utf8(p) _generic_swash_utf8(_CC_WORDCHAR, p)
+#define isXDIGIT_utf8(p) _generic_utf8_no_upper_latin1(_CC_XDIGIT, p, \
+ is_XDIGIT_high(p))
+
+#define toFOLD_utf8(p,s,l) to_utf8_fold(p,s,l)
#define toLOWER_utf8(p,s,l) to_utf8_lower(p,s,l)
+#define toTITLE_utf8(p,s,l) to_utf8_title(p,s,l)
+#define toUPPER_utf8(p,s,l) to_utf8_upper(p,s,l)
+
+/* For internal core Perl use only. If the input is in the Latin1 range, use
+ * the macro 'macro' on 'p' which is a pointer to a UTF-8 string. Otherwise
+ * use the value given by the 'utf8' parameter. This relies on the fact that
+ * ASCII characters have the same representation whether utf8 or not. Note
+ * that it assumes that the utf8 has been validated, and ignores 'use bytes' */
+#define _generic_LC_utf8(macro, p, utf8) \
+ (UTF8_IS_INVARIANT(*(p)) \
+ ? macro(*(p)) \
+ : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \
+ ? macro(TWO_BYTE_UTF8_TO_UNI(*(p), *((p)+1))) \
+ : utf8)
+
+#define _generic_LC_swash_utf8(macro, classnum, p) \
+ _generic_LC_utf8(macro, p, _is_utf8_FOO(classnum, p))
+#define _generic_LC_func_utf8(macro, above_latin1, p) \
+ _generic_LC_utf8(macro, p, above_latin1(p))
+
+#define isALPHANUMERIC_LC_utf8(p) _generic_LC_swash_utf8(isALPHANUMERIC_LC, \
+ _CC_ALPHANUMERIC, p)
+#define isALPHA_LC_utf8(p) _generic_LC_swash_utf8(isALPHA_LC, _CC_ALPHA, p)
+#define isASCII_LC_utf8(p) isASCII_LC(*p)
+#define isBLANK_LC_utf8(p) _generic_LC_func_utf8(isBLANK_LC, is_HORIZWS_high, p)
+#define isCNTRL_LC_utf8(p) _generic_LC_utf8(isCNTRL_LC, p, 0)
+#define isDIGIT_LC_utf8(p) _generic_LC_swash_utf8(isDIGIT_LC, _CC_DIGIT, p)
+#define isGRAPH_LC_utf8(p) _generic_LC_swash_utf8(isGRAPH_LC, _CC_GRAPH, p)
+#define isIDCONT_LC_utf8(p) _generic_LC_func_utf8(isIDCONT_LC, _is_utf8_perl_idcont, p)
+#define isIDFIRST_LC_utf8(p) _generic_LC_func_utf8(isIDFIRST_LC, _is_utf8_perl_idstart, p)
+#define isLOWER_LC_utf8(p) _generic_LC_swash_utf8(isLOWER_LC, _CC_LOWER, p)
+#define isPRINT_LC_utf8(p) _generic_LC_swash_utf8(isPRINT_LC, _CC_PRINT, p)
+#define isPSXSPC_LC_utf8(p) isSPACE_LC_utf8(p) /* space is identical to posix
+ space under locale */
+#define isPUNCT_LC_utf8(p) _generic_LC_swash_utf8(isPUNCT_LC, _CC_PUNCT, p)
+#define isSPACE_LC_utf8(p) _generic_LC_func_utf8(isSPACE_LC, is_XPERLSPACE_high, p)
+#define isUPPER_LC_utf8(p) _generic_LC_swash_utf8(isUPPER_LC, _CC_UPPER, p)
+#define isWORDCHAR_LC_utf8(p) _generic_LC_swash_utf8(isWORDCHAR_LC, \
+ _CC_WORDCHAR, p)
+#define isXDIGIT_LC_utf8(p) _generic_LC_func_utf8(isXDIGIT_LC, is_XDIGIT_high, p)
-/* Posix and regular space differ only in U+000B, which is in ASCII (and hence
- * Latin1 */
-#define isPSXSPC_utf8(p) ((isASCII(*(p))) \
- ? isPSXSPC_A(*(p)) \
- : (UTF8_IS_DOWNGRADEABLE_START(*(p)) \
- ? isPSXSPC_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \
- *((p)+1)))\
- : isSPACE_utf8(p)))
-#define isBLANK_utf8(c) isBLANK(c) /* could be wrong */
-
-#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 */
+/* Macros for backwards compatibility and for completeness when the ASCII and
+ * Latin1 values are identical */
+#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)
+#define isALNUM(c) isWORDCHAR(c)
+#define isALNUMU(c) isWORDCHAR_L1(c)
+#define isALNUM_LC(c) isWORDCHAR_LC(c)
+#define isALNUM_uni(c) isWORDCHAR_uni(c)
+#define isALNUM_LC_uvchr(c) isWORDCHAR_LC_uvchr(c)
+#define isALNUM_utf8(p) isWORDCHAR_utf8(p)
+#define isALNUM_LC_utf8(p) isWORDCHAR_LC_utf8(p)
+#define isALNUMC_A(c) isALPHANUMERIC_A(c) /* Mnemonic: "C's alnum" */
+#define isALNUMC_L1(c) isALPHANUMERIC_L1(c)
+#define isALNUMC(c) isALPHANUMERIC(c)
+#define isALNUMC_LC(c) isALPHANUMERIC_LC(c)
+#define isALNUMC_uni(c) isALPHANUMERIC_uni(c)
+#define isALNUMC_LC_uvchr(c) isALPHANUMERIC_LC_uvchr(c)
+#define isALNUMC_utf8(p) isALPHANUMERIC_utf8(p)
+#define isALNUMC_LC_utf8(p) isALPHANUMERIC_LC_utf8(p)
/* This conversion works both ways, strangely enough. On EBCDIC platforms,
- * CTRL-@ is 0, CTRL-A is 1, etc, just like on ASCII */
+ * CTRL-@ is 0, CTRL-A is 1, etc, just like on ASCII, except that they don't
+ * necessarily mean the same characters, e.g. CTRL-D is 4 on both systems, but
+ * that is EOT on ASCII; ST on EBCDIC */
# define toCTRL(c) (toUPPER(NATIVE_TO_UNI(c)) ^ 64)
/* Line numbers are unsigned, 32 bits. */
typedef U32 line_t;
-#define NOLINE ((line_t) 4294967295UL)
+#define NOLINE ((line_t) 4294967295UL) /* = FFFFFFFF */
/* Helpful alias for version prescan */
#define is_LAX_VERSION(a,b) \
} \
return a;
+#define READ_XDIGIT(s) (isALPHA(*(s)) ? ((*(s)++ + 9) & 0xf) : (*(s)++ & 0xf))
+
/*
=head1 Memory Management
=for apidoc Am|void|Move|void* src|void* dest|int nitems|type
The XSUB-writer's interface to the C C<memmove> function. The C<src> is the
-source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is
-the type. Can do overlapping moves. See also C<Copy>.
+source, C<dest> is the destination, C<nitems> is the number of items, and
+C<type> is the type. Can do overlapping moves. See also C<Copy>.
=for apidoc Am|void *|MoveD|void* src|void* dest|int nitems|type
Like C<Move> but returns dest. Useful for encouraging compilers to tail-call
=for apidoc Am|void|Copy|void* src|void* dest|int nitems|type
The XSUB-writer's interface to the C C<memcpy> function. The C<src> is the
-source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is
-the type. May fail on overlapping copies. See also C<Move>.
+source, C<dest> is the destination, C<nitems> is the number of items, and
+C<type> is the type. May fail on overlapping copies. See also C<Move>.
=for apidoc Am|void *|CopyD|void* src|void* dest|int nitems|type
Like C<Zero> but returns dest. Useful for encouraging compilers to tail-call
optimise.
-=for apidoc Am|void|StructCopy|type src|type dest|type
+=for apidoc Am|void|StructCopy|type *src|type *dest|type
This is an architecture-independent macro to copy one structure to another.
=for apidoc Am|void|PoisonWith|void* dest|int nitems|type|U8 byte
* overly eager compilers that will bleat about e.g.
* (U16)n > (size_t)~0/sizeof(U16) always being false. */
#ifdef PERL_MALLOC_WRAP
-#define MEM_WRAP_CHECK(n,t) MEM_WRAP_CHECK_1(n,t,PL_memory_wrap)
+#define MEM_WRAP_CHECK(n,t) \
+ (void)(sizeof(t) > 1 && ((MEM_SIZE)(n)+0.0) > MEM_SIZE_MAX/sizeof(t) && (Perl_croak_memory_wrap(),0))
#define MEM_WRAP_CHECK_1(n,t,a) \
(void)(sizeof(t) > 1 && ((MEM_SIZE)(n)+0.0) > MEM_SIZE_MAX/sizeof(t) && (Perl_croak_nocontext("%s",(a)),0))
#define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t),
-#define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (Perl_croak_nocontext("%s",PL_memory_wrap),0):0),((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1)))
-
+#define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (Perl_croak_memory_wrap(),0):0),((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1)))
#else
#define MEM_WRAP_CHECK(n,t)
# define deprecate(s) Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), "Use of " s " is deprecated")
#endif
+/* Internal macros to deal with gids and uids */
+#ifdef PERL_CORE
+
+# if Uid_t_size > IVSIZE
+# define sv_setuid(sv, uid) sv_setnv((sv), (NV)(uid))
+# define SvUID(sv) SvNV(sv)
+# else
+# if Uid_t_sign <= 0
+# define sv_setuid(sv, uid) sv_setiv((sv), (IV)(uid))
+# define SvUID(sv) SvIV(sv)
+# else
+# define sv_setuid(sv, uid) sv_setuv((sv), (UV)(uid))
+# define SvUID(sv) SvUV(sv)
+# endif
+# endif /* Uid_t_size */
+
+# if Gid_t_size > IVSIZE
+# define sv_setgid(sv, gid) sv_setnv((sv), (NV)(gid))
+# define SvGID(sv) SvNV(sv)
+# else
+# if Gid_t_sign <= 0
+# define sv_setgid(sv, gid) sv_setiv((sv), (IV)(gid))
+# define SvGID(sv) SvIV(sv)
+# else
+# define sv_setgid(sv, gid) sv_setuv((sv), (UV)(gid))
+# define SvGID(sv) SvUV(sv)
+# endif
+# endif /* Gid_t_size */
+
+#endif
+
+#endif /* HANDY_H */
+
/*
* Local variables:
* c-indentation-style: bsd
https://perl5.git.perl.org / perl5.git / blobdiff