X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/d65654cb6cbb4fc9585a24b036a3a7a4cc1f1fa5..9438e34a18209b9d8c49e08487ada02053c754dd:/handy.h diff --git a/handy.h b/handy.h index c03853e..248b685 100644 --- a/handy.h +++ b/handy.h @@ -8,6 +8,12 @@ * */ +/* IMPORTANT NOTE: Everything whose name begins with an underscore is for + * internal core Perl use only. */ + +#ifndef HANDY_H /* Guard against nested #inclusion */ +#define HANDY_H + #if !defined(__STDC__) #ifdef NULL #undef NULL @@ -22,10 +28,11 @@ =head1 Handy Values =for apidoc AmU||Nullch -Null character pointer. (No longer available when C is defined.) +Null character pointer. (No longer available when C is +defined.) =for apidoc AmU||Nullsv -Null SV pointer. (No longer available when C is defined.) +Null SV pointer. (No longer available when C is defined.) =cut */ @@ -66,7 +73,7 @@ Null SV pointer. (No longer available when C is defined.) #define MUTABLE_IO(p) ((IO *)MUTABLE_PTR(p)) #define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p)) -#ifdef I_STDBOOL +#if defined(I_STDBOOL) && !defined(PERL_BOOL_AS_CHAR) # include # ifndef HAS_BOOL # define HAS_BOOL 1 @@ -82,38 +89,25 @@ Null SV pointer. (No longer available when C is defined.) Andy Dougherty February 2000 */ #ifdef __GNUG__ /* GNU g++ has bool built-in */ +# ifndef PERL_BOOL_AS_CHAR # ifndef HAS_BOOL # define HAS_BOOL 1 # endif +# endif #endif -/* The NeXT dynamic loader headers will not build with the bool macro - So declare them now to clear confusion. -*/ -#if defined(NeXT) || defined(__NeXT__) -# undef FALSE -# undef TRUE - typedef enum bool { FALSE = 0, TRUE = 1 } bool; -# define ENUM_BOOL 1 -# ifndef HAS_BOOL -# define HAS_BOOL 1 -# endif /* !HAS_BOOL */ -#endif /* NeXT || __NeXT__ */ - #ifndef HAS_BOOL -# if defined(VMS) -# define bool int -# else -# define bool char +# ifdef bool +# undef bool # endif +# 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. @@ -123,7 +117,7 @@ Null SV pointer. (No longer available when C is defined.) #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) || /* MSVC6 has neither __func__ nor __FUNCTION and no good workarounds, either. */ \ +# if (defined(USING_MSVC6)) || /* 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 @@ -179,37 +173,53 @@ typedef I16TYPE I16; typedef U16TYPE U16; typedef I32TYPE I32; typedef U32TYPE U32; -#ifdef PERL_CORE -# ifdef HAS_QUAD + +#ifdef HAS_QUAD typedef I64TYPE I64; typedef U64TYPE U64; -# endif -#endif /* PERL_CORE */ - -#if defined(HAS_QUAD) && defined(USE_64_BIT_INT) -# 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 PeRl_INT64_C(c) CAT2(c,L) -# define PeRl_UINT64_C(c) CAT2(c,UL) -# else -# 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 + +/* INT64_C/UINT64_C are C99 from (so they will not be + * available in strict C89 mode), but they are nice, so let's define + * them if necessary. */ +#if defined(HAS_QUAD) +# undef PeRl_INT64_C +# undef PeRl_UINT64_C +/* Prefer the native integer types (int and long) over long long + * (which is not C89) and Win32-specific __int64. */ +# if QUADKIND == QUAD_IS_INT && INTSIZE == 8 +# define PeRl_INT64_C(c) (c) +# define PeRl_UINT64_C(c) CAT2(c,U) +# endif +# if QUADKIND == QUAD_IS_LONG && LONGSIZE == 8 +# define PeRl_INT64_C(c) CAT2(c,L) +# define PeRl_UINT64_C(c) CAT2(c,UL) +# endif +# if QUADKIND == QUAD_IS_LONG_LONG && defined(HAS_LONG_LONG) +# define PeRl_INT64_C(c) CAT2(c,LL) +# define PeRl_UINT64_C(c) CAT2(c,ULL) +# endif +# if QUADKIND == QUAD_IS___INT64 +# define PeRl_INT64_C(c) CAT2(c,I64) +# define PeRl_UINT64_C(c) CAT2(c,UI64) +# endif +# ifndef PeRl_INT64_C +# define PeRl_INT64_C(c) ((I64)(c)) /* last resort */ +# define PeRl_UINT64_C(c) ((U64)(c)) +# endif +/* In OS X the INT64_C/UINT64_C are defined with LL/ULL, which will + * not fly with C89-pedantic gcc, so let's undefine them first so that + * we can redefine them with our native integer preferring versions. */ +# if defined(PERL_DARWIN) && defined(PERL_GCC_PEDANTIC) +# undef INT64_C +# undef UINT64_C +# endif +# ifndef INT64_C +# define INT64_C(c) PeRl_INT64_C(c) +# endif +# ifndef UINT64_C +# define UINT64_C(c) PeRl_UINT64_C(c) +# endif #endif #if defined(UINT8_MAX) && defined(INT16_MAX) && defined(INT32_MAX) @@ -264,25 +274,37 @@ typedef U64TYPE U64; #define TYPE_DIGITS(T) BIT_DIGITS(sizeof(T) * 8) #define TYPE_CHARS(T) (TYPE_DIGITS(T) + 2) /* sign, NUL */ +/* Unused by core; should be deprecated */ #define Ctl(ch) ((ch) & 037) +/* This is a helper macro to avoid preprocessor issues, replaced by nothing + * unless under DEBUGGING, where it expands to an assert of its argument, + * followed by a comma (hence the comma operator). If we just used a straight + * assert(), we would get a comma with nothing before it when not DEBUGGING */ +#ifdef DEBUGGING +# define __ASSERT_(statement) assert(statement), +#else +# define __ASSERT_(statement) +#endif + /* =head1 SV-Body Allocation =for apidoc Ama|SV*|newSVpvs|const char* s -Like C, but takes a literal string instead of a string/length pair. +Like C, but takes a literal C-terminated string instead of a +string/length pair. =for apidoc Ama|SV*|newSVpvs_flags|const char* s|U32 flags -Like C, but takes a literal string instead of a string/length -pair. +Like C, but takes a literal C-terminated string instead of +a string/length pair. =for apidoc Ama|SV*|newSVpvs_share|const char* s -Like C, but takes a literal string instead of a string/length -pair and omits the hash parameter. +Like C, but takes a literal C-terminated string instead of +a string/length pair and omits the hash parameter. =for apidoc Am|void|sv_catpvs_flags|SV* sv|const char* s|I32 flags -Like C, but takes a literal string instead of a -string/length pair. +Like C, but takes a literal C-terminated string instead +of a string/length pair. =for apidoc Am|void|sv_catpvs_nomg|SV* sv|const char* s Like C, but takes a literal string instead of a @@ -309,7 +331,8 @@ string/length pair. =head1 Memory Management =for apidoc Ama|char*|savepvs|const char* s -Like C, but takes a literal string instead of a string/length pair. +Like C, but takes a literal C-terminated string instead of a +string/length pair. =for apidoc Ama|char*|savesharedpvs|const char* s A version of C which allocates the duplicate string in memory @@ -339,12 +362,13 @@ string/length pair. =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 */ @@ -416,14 +440,24 @@ the second, C. Returns true or false. =for apidoc Am|bool|strnNE|char* s1|char* s2|STRLEN len Test two strings to see if they are different. The C parameter -indicates the number of bytes to compare. Returns true or false. (A +indicates the number of bytes to compare. Returns true or false. (A wrapper for C). =for apidoc Am|bool|strnEQ|char* s1|char* s2|STRLEN len Test two strings to see if they are equal. The C parameter indicates -the number of bytes to compare. Returns true or false. (A wrapper for +the number of bytes to compare. Returns true or false. (A wrapper for C). +=for apidoc Am|bool|memEQ|char* s1|char* s2|STRLEN len +Test two buffers (which may contain embedded C characters, to see if they +are equal. The C parameter indicates the number of bytes to compare. +Returns zero if equal, or non-zero if non-equal. + +=for apidoc Am|bool|memNE|char* s1|char* s2|STRLEN len +Test two buffers (which may contain embedded C characters, to see if they +are not equal. The C parameter indicates the number of bytes to compare. +Returns zero if non-equal, or non-zero if equal. + =cut */ @@ -469,99 +503,372 @@ C). /* -=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. - -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 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. +=head1 Character classification +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.) 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, and only the ones +with C in the name are affected by the current locale. + +The base function, e.g., C, takes an octet (either a C or a +C) 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 (e.g., C) is identical to the base function +with no suffix C<"_A">. + +Variant C 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 will return +true when called with the code point 0xDF, which is a word character in both +ASCII and EBCDIC (though it represents different characters in each). + +Variant C is like the C 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 returns TRUE, since 0x100 is LATIN CAPITAL LETTER A +WITH MACRON in Unicode, and is a word character. + +Variant C is like C, but the input is a pointer to a +(known to be well-formed) UTF-8 encoded string (C or C). The +classification of just the first (possibly multi-byte) character in the string +is tested. + +Variant C is like the C and C variants, but the +result is based on the current locale, which is what C in the name stands +for. If Perl can determine that the current locale is a UTF-8 locale, it uses +the published Unicode rules; otherwise, it uses the C library function that +gives the named classification. For example, C when not in a +UTF-8 locale returns the result of calling C. FALSE is always +returned if the input won't fit into an octet. On some platforms where the C +library function is known to be defective, Perl changes its result to follow +the POSIX standard's rules. + +Variant C is like C, but is defined on any UV. It +returns the same as C for input code points less than 256, and +returns the hard-coded, not-affected-by-locale, Unicode results for larger ones. + +Variant C is like C, but the input is a pointer +to a (known to be well-formed) UTF-8 encoded string (C or C). 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. -See the L for an explanation of variants -C and C. +alphabetic character, analogous to C. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. + +=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. +See the L for an explanation of +variants +C, C, C, +C, C, C, and +C. =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. +On non-ASCII platforms, it returns TRUE iff this character corresponds to an ASCII character. Variants C and C are identical to C. +See the L for an explanation of +variants +C, C, C, C, and +C. Note, however, that some platforms do not have the C +library routine C. In these cases, the variants whose names contain +C are the same as the corresponding ones without. + +Also note, that because all ASCII characters are UTF-8 invariant (meaning they +have the exact same representation (always a single byte) whether encoded in +UTF-8 or not), C will give the correct results when called with any +byte in any string encoded or not in UTF-8. And similarly C will +work properly on any string encoded or not in UTF-8. + +=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. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. Note, however, that some +platforms do not have the C library routine C. In these cases, the +variants whose names contain C 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. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C +On EBCDIC platforms, you almost always want to use the C 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. Variants C and C are identical to C. +See the L for an explanation of +variants +C, C, C, C, and +C. + +=for apidoc Am|bool|isGRAPH|char ch +Returns a boolean indicating whether the specified character is a +graphic character, analogous to C. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. =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. -See the L for an explanation of variants -C and C. +lowercase character, analogous to C. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. =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 and C are identical to C. +octal digit, [0-7]. +The only two variants are C and C; each is identical to +C. + +=for apidoc Am|bool|isPUNCT|char ch +Returns a boolean indicating whether the specified character is a +punctuation character, analogous to C. +Note that the definition of what is punctuation isn't as +straightforward as one might desire. See L for details. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. =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. -See the L for an explanation of variants -C and C. +whitespace character. This is analogous +to what C matches in a regular expression. Starting in Perl 5.18 +this also matches what C does. Prior to 5.18, only the +locale forms of this macro (the ones with C in their names) matched +precisely what C does. In those releases, the only difference, +in the non-locale variants, was that C did not match a vertical tab. +(See L for a macro that matches a vertical tab in all releases.) +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. + +=for apidoc Am|bool|isPSXSPC|char ch +(short for Posix Space) +Starting in 5.18, this is identical in all its forms to the +corresponding C macros. +The locale forms of this macro are identical to their corresponding +C forms in all Perl releases. In releases prior to 5.18, the +non-locale forms differ from their C forms only in that the +C forms don't match a Vertical Tab, and the C forms do. +Otherwise they are identical. Thus this macro is analogous to what +C matches in a regular expression. +See the L for an explanation of +variants C, C, C, C, +C, C, and C. =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. -See the L for an explanation of variants -C and C. +uppercase character, analogous to C. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. -=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 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. -See the L for an explanation of variants -C and C. +printable character, analogous to C. +See the L for an explanation of +variants +C, C, C, C, C, +C, and C. + +=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 and C 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 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 for an explanation of +variants +C, C, C, and C. +C, C, and C are also as +described there, but additionally include the platform's native underscore. =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 and C are -identical to C. +digit. In the ASCII range these are C<[0-9A-Fa-f]>. Variants C +and C are identical to C. +See the L for an explanation of +variants +C, C, C, C, and +C. + +=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. The difference is that this +returns true only if the input character also matches L. +See the L for an explanation of +variants +C, C, C, C, +C, C, and C. + +=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. The +difference is that this returns true only if the input character also matches +L. See the L for +an +explanation of variants C, C, C, +C, C, C, and +C. + +=head1 Miscellaneous Functions =for apidoc Am|U8|READ_XDIGIT|char str* -Returns the value of a hex digit and advances the string pointer. +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 is equivalent. + +=for apidoc Am|UV|toUPPER_uni|UV cp|U8* s|STRLEN* lenp +Converts the Unicode code point C to its uppercase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

to its uppercase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

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 is equivalent. (There is no equivalent C for the full +Latin1 range, as the full generality of L is needed there.) + +=for apidoc Am|UV|toFOLD_uni|UV cp|U8* s|STRLEN* lenp +Converts the Unicode code point C to its foldcase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

to its foldcase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

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 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 to its lowercase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

to its lowercase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

is assumed to be well-formed. + +=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 is equivalent. (There is no C for the full Latin1 +range, as the full generality of L 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 to its titlecase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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

to its titlecase version, and +stores that in UTF-8 in C, and its length in bytes in C. Note +that the buffer pointed to by C needs to be at least C +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|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 input character at C

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 @@ -586,59 +893,138 @@ patched there. The file as of this writing is cpan/Devel-PPPort/parts/inc/misc #define FITS_IN_8_BITS(c) ((sizeof(c) == 1) || !(((WIDEST_UTYPE)(c)) & ~0xFF)) #ifdef EBCDIC -# define isASCII(c) (FITS_IN_8_BITS(c) && (NATIVE_TO_UNI((U8) (c)) < 128)) +# ifndef _ALL_SOURCE + /* The native libc isascii() et.al. functions return the wrong results + * on at least z/OS unless this is defined. */ +# error _ALL_SOURCE should probably be defined +# endif #else + /* There is a simple definition of ASCII for ASCII platforms. But the + * EBCDIC one isn't so simple, so is defined using table look-up like the + * other macros below */ # define isASCII(c) ((WIDEST_UTYPE)(c) < 128) #endif -#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 */ -/* Character class numbers. For internal core Perl use only. These 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. 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_WORDCHAR 0 -# define _CC_SPACE 1 -# define _CC_DIGIT 2 -# define _CC_ALNUMC 3 -# define _CC_ALPHA 4 -# define _CC_ASCII 5 -# define _CC_CNTRL 6 -# define _CC_GRAPH 7 -# define _CC_LOWER 8 -# define _CC_PRINT 9 -# define _CC_PUNCT 10 -# define _CC_UPPER 11 -# define _CC_XDIGIT 12 -# define _CC_PSXSPC 13 -# define _CC_BLANK 14 -# define _CC_VERTSPACE 15 +/* 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. + * + * 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, [:space:] */ +# define _CC_BLANK 11 /* [:blank:] */ +# define _CC_XDIGIT 12 /* [:xdigit:] */ +# define _CC_CNTRL 13 /* [:cntrl:] */ +# define _CC_ASCII 14 /* [:ascii:] */ +# define _CC_VERTSPACE 15 /* \v */ + # define _HIGHEST_REGCOMP_DOT_H_SYNC _CC_VERTSPACE -# define _CC_IDFIRST 16 -# define _CC_CHARNAME_CONT 17 -# define _CC_NONLATIN1_FOLD 18 -# define _CC_QUOTEMETA 19 -# define _CC_NON_FINAL_FOLD 20 -# define _CC_IS_IN_SOME_FOLD 21 -/* Unused: 22-31 +/* 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 16 +# define _CC_CHARNAME_CONT 17 +# define _CC_NONLATIN1_FOLD 18 +# define _CC_NONLATIN1_SIMPLE_FOLD 19 +# define _CC_QUOTEMETA 20 +# define _CC_NON_FINAL_FOLD 21 +# define _CC_IS_IN_SOME_FOLD 22 +# define _CC_MNEMONIC_CNTRL 23 +/* Unused: 24-31 * 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 */ + * 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_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 +START_EXTERN_C # ifdef DOINIT EXTCONST U32 PL_charclass[] = { # include "l1_char_class_tab.h" @@ -647,404 +1033,715 @@ EXTCONST U32 PL_charclass[] = { # else /* ! DOINIT */ EXTCONST U32 PL_charclass[]; # endif +END_EXTERN_C /* 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))) + + /* For internal core Perl use only: the base macro for defining macros like + * isALPHA */ +# define _generic_isCC(c, classnum) cBOOL(FITS_IN_8_BITS(c) \ + && (PL_charclass[(U8) (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))) + /* For internal core Perl use only: the base macro for defining macros like + * isALPHA_A. The foo_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) (c)] & _CC_mask_A(classnum)) \ + == _CC_mask_A(classnum))) -# define isALNUMC_A(c) _generic_isCC_A(c, _CC_ALNUMC) # 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 isDIGIT_A(c) _generic_isCC(c, _CC_DIGIT) /* No non-ASCII digits */ # 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_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 isBLANK_A(c) (isASCII(c) && isBLANK(c)) -# define isCNTRL_A(c) (isASCII(c) && isCNTRL(c)) -# define isDIGIT_A(c) (isASCII(c) && isDIGIT(c)) -# define isGRAPH_A(c) (isASCII(c) && isGRAPH(c)) -# define isIDFIRST_A(c) (isASCII(c) && isIDFIRST(c)) -# define isLOWER_A(c) (isASCII(c) && isLOWER(c)) -# define isPRINT_A(c) (isASCII(c) && isPRINT(c)) -# define isPSXSPC_A(c) (isASCII(c) && isPSXSPC(c)) -# define isPUNCT_A(c) (isASCII(c) && isPUNCT(c)) -# define isSPACE_A(c) (isASCII(c) && isSPACE(c)) -# define isUPPER_A(c) (isASCII(c) && isUPPER(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 isBLANK_A(c) ((c) == ' ' || (c) == '\t') -# 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 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')) -# endif -#endif /* ASCII range definitions */ - -/* Latin1 definitions */ -#ifdef H_PERL -# define isALNUMC_L1(c) _generic_isCC(c, _CC_ALNUMC) +# define isXDIGIT_A(c) _generic_isCC(c, _CC_XDIGIT) /* No non-ASCII xdigits + */ +# define isIDFIRST_A(c) _generic_isCC_A(c, _CC_IDFIRST) # 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} */ + /* 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) # 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 isPSXSPC_L1(c) isSPACE_L1(c) # 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) == 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 +# ifdef EBCDIC +# define isASCII(c) _generic_isCC(c, _CC_ASCII) +# endif + /* Participates in a single-character fold with a character above 255 */ +# define _HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(c) ((! cBOOL(FITS_IN_8_BITS(c))) || (PL_charclass[(U8) (c)] & _CC_mask(_CC_NONLATIN1_SIMPLE_FOLD))) -/* 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) -/* 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) - -#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 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 isGRAPH_LC(c) NXIsGraph((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 toLOWER_LC(c) NXToLower((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 */ - -# 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 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)) + /* Like the above, but also can be part of 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) (c)] & _CC_mask(_CC_NONLATIN1_FOLD))) -# else +# 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) +# define _IS_MNEMONIC_CNTRL_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) \ + _generic_isCC(c, _CC_MNEMONIC_CNTRL) +#else /* else we don't have perl.h H_PERL */ + + /* If we don't have perl.h, we are compiling a utility program. Below we + * hard-code various macro definitions that wouldn't otherwise be available + * to it. Most are coded based on first principals. First some ones common + * to both ASCII and EBCDIC */ +# define isDIGIT_A(c) ((c) <= '9' && (c) >= '0') +# define isBLANK_A(c) ((c) == ' ' || (c) == '\t') +# define isSPACE_A(c) (isBLANK_A(c) \ + || (c) == '\n' \ + || (c) == '\r' \ + || (c) == '\v' \ + || (c) == '\f') +# ifdef EBCDIC /* There are gaps between 'i' and 'j'; 'r' and 's'. Same + for uppercase. This is ordered to exclude most things + early */ +# define isLOWER_A(c) ((c) >= 'a' && (c) <= 'z' \ + && ((c) <= 'i' \ + || ((c) >= 'j' && (c) <= 'r') \ + || (c) >= 's')) +# define isUPPER_A(c) ((c) >= 'A' && (c) <= 'Z' \ + && ((c) <= 'I' \ + || ((c) >= 'J' && (c) <= 'R') \ + || (c) >= 'S')) +# else /* ASCII platform. */ +# define isLOWER_A(c) ((c) >= 'a' && (c) <= 'z') +# define isUPPER_A(c) ((c) <= 'Z' && (c) >= 'A') +# endif -# 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)) -# 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 isGRAPH_LC(c) (isascii(c) && isgraph(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) + /* Some more ASCII, non-ASCII common definitions */ +# define isALPHA_A(c) (isUPPER_A(c) || isLOWER_A(c)) +# define isALPHANUMERIC_A(c) (isALPHA_A(c) || isDIGIT_A(c)) +# define isWORDCHAR_A(c) (isALPHANUMERIC_A(c) || (c) == '_') +# define isIDFIRST_A(c) (isALPHA_A(c) || (c) == '_') +# define isXDIGIT_A(c) (isDIGIT_A(c) \ + || ((c) >= 'a' && (c) <= 'f') \ + || ((c) <= 'F' && (c) >= 'A')) -# endif -#endif /* USE_NEXT_CTYPE */ +# ifdef EBCDIC +# define isPUNCT_A(c) ((c) == '-' || (c) == '!' || (c) == '"' \ + || (c) == '#' || (c) == '$' || (c) == '%' \ + || (c) == '&' || (c) == '\'' || (c) == '(' \ + || (c) == ')' || (c) == '*' || (c) == '+' \ + || (c) == ',' || (c) == '.' || (c) == '/' \ + || (c) == ':' || (c) == ';' || (c) == '<' \ + || (c) == '=' || (c) == '>' || (c) == '?' \ + || (c) == '@' || (c) == '[' || (c) == '\\' \ + || (c) == ']' || (c) == '^' || (c) == '_' \ + || (c) == '`' || (c) == '{' || (c) == '|' \ + || (c) == '}' || (c) == '~') +# define isGRAPH_A(c) (isALPHANUMERIC_A(c) || isPUNCT_A(c)) +# define isPRINT_A(c) (isGRAPH_A(c) || (c) == ' ') + +# ifdef QUESTION_MARK_CTRL +# define _isQMC(c) ((c) == QUESTION_MARK_CTRL) +# else +# define _isQMC(c) 0 +# endif + + /* I (khw) can't think of a way to define all the ASCII controls + * without resorting to a libc (locale-sensitive) call. But we know + * that all controls but the question-mark one are in the range 0-0x3f. + * This makes sure that all the controls that have names are included, + * and all controls that are also considered ASCII in the locale. This + * may include more or fewer than what it actually should, but the + * wrong ones are less-important controls, so likely won't impact + * things (keep in mind that this is compiled only if perl.h isn't + * available). The question mark control is included if available */ +# define isCNTRL_A(c) (((c) < 0x40 && isascii(c)) \ + || (c) == '\0' || (c) == '\a' || (c) == '\b' \ + || (c) == '\f' || (c) == '\n' || (c) == '\r' \ + || (c) == '\t' || (c) == '\v' || _isQMC(c)) + +# define isASCII(c) (isCNTRL_A(c) || isPRINT_A(c)) +# else /* ASCII platform; things are simpler, and isASCII has already + been defined */ +# define isGRAPH_A(c) (((c) > ' ' && (c) < 127)) +# define isPRINT_A(c) (isGRAPH_A(c) || (c) == ' ') +# define isPUNCT_A(c) (isGRAPH_A(c) && (! isALPHANUMERIC_A(c))) +# define isCNTRL_A(c) (isASCII(c) && (! isPRINT_A(c))) +# endif + + /* The _L1 macros may be unnecessary for the utilities; I (khw) added them + * during debugging, and it seems best to keep them. We may be called + * without NATIVE_TO_LATIN1 being defined. On ASCII platforms, it doesn't + * do anything anyway, so make it not a problem */ +# if ! defined(EBCDIC) && ! defined(NATIVE_TO_LATIN1) +# define NATIVE_TO_LATIN1(ch) (ch) +# endif +# 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 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_SIMPLE_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_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 H_PERL */ + +#define isALPHANUMERIC(c) isALPHANUMERIC_A(c) +#define isALPHA(c) isALPHA_A(c) +#define isASCII_A(c) isASCII(c) +#define isASCII_L1(c) isASCII(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_A(c) isSPACE_A(c) +#define isPSXSPC(c) isPSXSPC_A(c) +#define isPSXSPC_L1(c) isSPACE_L1(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) ? (U8)((c) + ('a' - 'A')) : (c)) +#define toUPPER(c) (isLOWER(c) ? (U8)((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 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; returns the input itself if is out-of-range */ +#define toLOWER_LATIN1(c) ((! FITS_IN_8_BITS(c)) \ + ? (c) \ + : PL_latin1_lc[ (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; returns the + * input itself if is out-of-range */ +#define toUPPER_LATIN1_MOD(c) ((! FITS_IN_8_BITS(c)) \ + ? (c) \ + : PL_mod_latin1_uc[ (U8) (c) ]) +#define IN_UTF8_CTYPE_LOCALE PL_in_utf8_CTYPE_locale + +/* Use foo_LC_uvchr() instead of these for beyond the Latin1 range */ + +/* For internal core Perl use only: the base macro for defining macros like + * isALPHA_LC, which uses the current LC_CTYPE locale. 'c' is the code point + * (0-255) to check. In a UTF-8 locale, the result is the same as calling + * isFOO_L1(); the 'utf8_locale_classnum' parameter is something like + * _CC_UPPER, which gives the class number for doing this. For non-UTF-8 + * locales, the code to actually do the test this is passed in 'non_utf8'. If + * 'c' is above 255, 0 is returned. For accessing the full range of possible + * code points under locale rules, use the macros based on _generic_LC_uvchr + * instead of this. */ +#define _generic_LC_base(c, utf8_locale_classnum, non_utf8) \ + (! FITS_IN_8_BITS(c) \ + ? 0 \ + : IN_UTF8_CTYPE_LOCALE \ + ? cBOOL(PL_charclass[(U8) (c)] & _CC_mask(utf8_locale_classnum)) \ + : cBOOL(non_utf8)) + +/* For internal core Perl use only: a helper macro for defining macros like + * isALPHA_LC. 'c' is the code point (0-255) to check. The function name to + * actually do this test is passed in 'non_utf8_func', which is called on 'c', + * casting 'c' to the macro _LC_CAST, which should not be parenthesized. See + * _generic_LC_base for more info */ +#define _generic_LC(c, utf8_locale_classnum, non_utf8_func) \ + _generic_LC_base(c,utf8_locale_classnum, \ + non_utf8_func( (_LC_CAST) (c))) + +/* For internal core Perl use only: like _generic_LC, but also returns TRUE if + * 'c' is the platform's native underscore character */ +#define _generic_LC_underscore(c,utf8_locale_classnum,non_utf8_func) \ + _generic_LC_base(c, utf8_locale_classnum, \ + (non_utf8_func( (_LC_CAST) (c)) \ + || (char)(c) == '_')) + +/* These next three are also for internal core Perl use only: case-change + * helper macros */ +#define _generic_toLOWER_LC(c, function, cast) (! FITS_IN_8_BITS(c) \ + ? (c) \ + : (IN_UTF8_CTYPE_LOCALE) \ + ? PL_latin1_lc[ (U8) (c) ] \ + : (cast)function((cast)(c))) + +/* Note that the result can be larger than a byte in a UTF-8 locale. It + * returns a single value, so can't adequately return the upper case of LATIN + * SMALL LETTER SHARP S in a UTF-8 locale (which should be a string of two + * values "SS"); instead it asserts against that under DEBUGGING, and + * otherwise returns its input */ +#define _generic_toUPPER_LC(c, function, cast) \ + (! FITS_IN_8_BITS(c) \ + ? (c) \ + : ((! IN_UTF8_CTYPE_LOCALE) \ + ? (cast)function((cast)(c)) \ + : ((((U8)(c)) == MICRO_SIGN) \ + ? GREEK_CAPITAL_LETTER_MU \ + : ((((U8)(c)) == LATIN_SMALL_LETTER_Y_WITH_DIAERESIS) \ + ? LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS \ + : ((((U8)(c)) == LATIN_SMALL_LETTER_SHARP_S) \ + ? (__ASSERT_(0) (c)) \ + : PL_mod_latin1_uc[ (U8) (c) ]))))) + +/* Note that the result can be larger than a byte in a UTF-8 locale. It + * returns a single value, so can't adequately return the fold case of LATIN + * SMALL LETTER SHARP S in a UTF-8 locale (which should be a string of two + * values "ss"); instead it asserts against that under DEBUGGING, and + * otherwise returns its input */ +#define _generic_toFOLD_LC(c, function, cast) \ + ((UNLIKELY((c) == MICRO_SIGN) && IN_UTF8_CTYPE_LOCALE) \ + ? GREEK_SMALL_LETTER_MU \ + : (__ASSERT_(! IN_UTF8_CTYPE_LOCALE \ + || (c) != LATIN_SMALL_LETTER_SHARP_S) \ + _generic_toLOWER_LC(c, function, cast))) + +/* Use the libc versions for these if available. */ +#if defined(HAS_ISASCII) +# define isASCII_LC(c) (FITS_IN_8_BITS(c) && isascii( (U8) (c))) +#else +# define isASCII_LC(c) isASCII(c) +#endif + +#if defined(HAS_ISBLANK) +# define isBLANK_LC(c) _generic_LC(c, _CC_BLANK, isblank) +#else /* Unlike isASCII, varies if in a UTF-8 locale */ +# define isBLANK_LC(c) ((IN_UTF8_CTYPE_LOCALE) ? isBLANK_L1(c) : isBLANK(c)) +#endif -#define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v') +#define _LC_CAST U8 + +#ifdef WIN32 + /* The Windows functions don't bother to follow the POSIX standard, which + * for example says that something can't both be a printable and a control. + * But Windows treats the \t control as a printable, and does such things + * as making superscripts into both digits and punctuation. This tames + * these flaws by assuming that the definitions of both controls and space + * are correct, and then making sure that other definitions don't have + * weirdnesses, by making sure that isalnum() isn't also ispunct(), etc. + * Not all possible weirdnesses are checked for, just the ones that were + * detected on actual Microsoft code pages */ + +# define isCNTRL_LC(c) _generic_LC(c, _CC_CNTRL, iscntrl) +# define isSPACE_LC(c) _generic_LC(c, _CC_SPACE, isspace) + +# define isALPHA_LC(c) (_generic_LC(c, _CC_ALPHA, isalpha) \ + && isALPHANUMERIC_LC(c)) +# define isALPHANUMERIC_LC(c) (_generic_LC(c, _CC_ALPHANUMERIC, isalnum) && \ + ! isPUNCT_LC(c)) +# define isDIGIT_LC(c) (_generic_LC(c, _CC_DIGIT, isdigit) && \ + isALPHANUMERIC_LC(c)) +# define isGRAPH_LC(c) (_generic_LC(c, _CC_GRAPH, isgraph) && isPRINT_LC(c)) +# define isIDFIRST_LC(c) (((c) == '_') \ + || (_generic_LC(c, _CC_IDFIRST, isalpha) && ! isPUNCT_LC(c))) +# define isLOWER_LC(c) (_generic_LC(c, _CC_LOWER, islower) && isALPHA_LC(c)) +# define isPRINT_LC(c) (_generic_LC(c, _CC_PRINT, isprint) && ! isCNTRL_LC(c)) +# define isPUNCT_LC(c) (_generic_LC(c, _CC_PUNCT, ispunct) && ! isCNTRL_LC(c)) +# define isUPPER_LC(c) (_generic_LC(c, _CC_UPPER, isupper) && isALPHA_LC(c)) +# define isWORDCHAR_LC(c) (((c) == '_') || isALPHANUMERIC_LC(c)) +# define isXDIGIT_LC(c) (_generic_LC(c, _CC_XDIGIT, isxdigit) \ + && isALPHANUMERIC_LC(c)) + +# define toLOWER_LC(c) _generic_toLOWER_LC((c), tolower, U8) +# define toUPPER_LC(c) _generic_toUPPER_LC((c), toupper, U8) +# define toFOLD_LC(c) _generic_toFOLD_LC((c), tolower, U8) + +#elif defined(CTYPE256) || (!defined(isascii) && !defined(HAS_ISASCII)) + /* For most other platforms */ + +# define isALPHA_LC(c) _generic_LC(c, _CC_ALPHA, isalpha) +# define isALPHANUMERIC_LC(c) _generic_LC(c, _CC_ALPHANUMERIC, isalnum) +# define isCNTRL_LC(c) _generic_LC(c, _CC_CNTRL, iscntrl) +# define isDIGIT_LC(c) _generic_LC(c, _CC_DIGIT, isdigit) +# define isGRAPH_LC(c) _generic_LC(c, _CC_GRAPH, isgraph) +# define isIDFIRST_LC(c) _generic_LC_underscore(c, _CC_IDFIRST, isalpha) +# define isLOWER_LC(c) _generic_LC(c, _CC_LOWER, islower) +# define isPRINT_LC(c) _generic_LC(c, _CC_PRINT, isprint) +# define isPUNCT_LC(c) _generic_LC(c, _CC_PUNCT, ispunct) +# define isSPACE_LC(c) _generic_LC(c, _CC_SPACE, isspace) +# define isUPPER_LC(c) _generic_LC(c, _CC_UPPER, isupper) +# define isWORDCHAR_LC(c) _generic_LC_underscore(c, _CC_WORDCHAR, isalnum) +# define isXDIGIT_LC(c) _generic_LC(c, _CC_XDIGIT, isxdigit) + + +# define toLOWER_LC(c) _generic_toLOWER_LC((c), tolower, U8) +# define toUPPER_LC(c) _generic_toUPPER_LC((c), toupper, U8) +# define toFOLD_LC(c) _generic_toFOLD_LC((c), tolower, U8) + +#else /* The final fallback position */ + +# define isALPHA_LC(c) (isascii(c) && isalpha(c)) +# define isALPHANUMERIC_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 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)) +# define toFOLD_LC(c) (isascii(c) ? tolower(c) : (c)) -/* For internal core Perl use only. If the input is Latin1, use the Latin1 - * 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. */ +#endif + +#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: the base macros for defining macros like + * isALPHA_uni. 'c' is the code point to check. 'classnum' is the POSIX class + * number defined earlier in this file. _generic_uni() is used for POSIX + * classes where there is a macro or function 'above_latin1' that takes the + * single argument 'c' and returns the desired value. These exist for those + * classes which have simple definitions, avoiding the overhead of a hash + * lookup or inversion list binary search. _generic_swash_uni() can be used + * for classes where that overhead is faster than a direct lookup. + * _generic_uni() won't compile if 'c' isn't unsigned, as it won't match the + * 'above_latin1' prototype. _generic_isCC() macro does 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. */ /* Note that all ignore 'use bytes' */ -#define _generic_uni(classnum, function, c) ((c) < 256 \ - ? _generic_isCC(c, classnum) \ - : function(c)) - -#define isWORDCHAR_uni(c) _generic_uni(_CC_WORDCHAR, is_uni_alnum, c) -#define isALNUM_uni(c) isWORDCHAR_uni(c) -#define isBLANK_uni(c) _generic_uni(_CC_BLANK, is_HORIZWS_cp_high, c) -#define isIDFIRST_uni(c) _generic_uni(_CC_IDFIRST, is_uni_idfirst, c) -#define isALPHA_uni(c) _generic_uni(_CC_ALPHA, is_uni_alpha, c) -#define isSPACE_uni(c) _generic_uni(_CC_SPACE, is_XPERLSPACE_cp_high, c) -#define isVERTWS_uni(c) _generic_uni(_CC_VERTSPACE, is_VERTWS_cp_high, c) -#define isDIGIT_uni(c) _generic_uni(_CC_DIGIT, is_uni_digit, c) -#define isUPPER_uni(c) _generic_uni(_CC_UPPER, is_uni_upper, c) -#define isLOWER_uni(c) _generic_uni(_CC_LOWER, is_uni_lower, c) -#define isASCII_uni(c) isASCII(c) - -/* All controls are in Latin1 */ -#define isCNTRL_uni(c) isCNTRL_L1(c) - -#define isGRAPH_uni(c) _generic_uni(_CC_GRAPH, is_uni_graph, c) -#define isPRINT_uni(c) _generic_uni(_CC_PRINT, is_uni_print, c) -#define isPUNCT_uni(c) _generic_uni(_CC_PUNCT, is_uni_punct, c) -#define isXDIGIT_uni(c) _generic_uni(_CC_XDIGIT, is_XDIGIT_cp_high, c) - -/* Posix and regular space differ only in U+000B, which is in Latin1 */ -#define isPSXSPC_uni(c) _generic_uni(_CC_PSXSPC, \ - is_XPERLSPACE_cp_high, c) +#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) + +#define isPUNCT_uni(c) _generic_swash_uni(_CC_PUNCT, c) +#define isSPACE_uni(c) _generic_uni(_CC_SPACE, is_XPERLSPACE_cp_high, c) +#define isPSXSPC_uni(c) isSPACE_uni(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 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) -#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 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_utf8(classnum, p, utf8) (UTF8_IS_INVARIANT(*(p)) \ +/* For internal core Perl use only: the base macros for defining macros like + * isALPHA_LC_uvchr. These are like isALPHA_LC, but the input can be any code + * point, not just 0-255. Like _generic_uni, there are two versions, one for + * simple class definitions; the other for more complex. These are like + * _generic_uni, so see it for more info. */ +#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) +#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)) + +/* For internal core Perl use only: the base macros for defining macros like + * isALPHA_utf8. These are like the earlier defined macros, but take an input + * UTF-8 encoded string 'p'. If the input is in the Latin1 range, use + * the Latin1 macro 'classnum' on 'p'. 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), \ + TWO_BYTE_UTF8_TO_NATIVE(*(p), \ *((p)+1 )), \ - classnum) \ + classnum) \ : utf8) -/* Like the above, but calls 'function(p)' to get the utf8 value */ -#define _generic_utf8(classnum, function, p) \ - _generic_utf8_utf8(classnum, p, function(p)) +/* 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 an + * '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 upper-Latin1 range (128-255 on ASCII platforms) 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) + +#ifdef EBCDIC + /* Because all controls are UTF-8 invariants in EBCDIC, we can use this + * more efficient macro instead of the more general one */ +# define isCNTRL_utf8(p) isCNTRL_L1(*(p)) +#else +# define isCNTRL_utf8(p) _generic_utf8(_CC_CNTRL, p, 0) +#endif -#define isWORDCHAR_utf8(p) _generic_utf8(_CC_WORDCHAR, is_utf8_alnum, p) -#define isALNUM_utf8(p) isWORDCHAR_utf8(p) /* back compat */ +#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) /* 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) _generic_utf8(_CC_IDFIRST, \ - _is_utf8_perl_idstart, p) - -#define isIDCONT_utf8(p) _generic_utf8(_CC_WORDCHAR, is_utf8_xidcont, p) -#define isALPHA_utf8(p) _generic_utf8(_CC_ALPHA, is_utf8_alpha, p) -#define isBLANK_utf8(p) _generic_utf8(_CC_BLANK, is_HORIZWS_high, p) -#define isSPACE_utf8(p) _generic_utf8(_CC_SPACE, is_XPERLSPACE_high, p) -#define isVERTWS_utf8(p) _generic_utf8(_CC_VERTSPACE, is_VERTWS_high, p) -#define isDIGIT_utf8(p) _generic_utf8(_CC_DIGIT, is_utf8_digit, p) -#define isUPPER_utf8(p) _generic_utf8(_CC_UPPER, is_utf8_upper, p) -#define isLOWER_utf8(p) _generic_utf8(_CC_LOWER, 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_utf8(_CC_CNTRL, p, 0) -#define isGRAPH_utf8(p) _generic_utf8(_CC_GRAPH, is_utf8_graph, p) -#define isPRINT_utf8(p) _generic_utf8(_CC_PRINT, is_utf8_print, p) -#define isPUNCT_utf8(p) _generic_utf8(_CC_PUNCT, is_utf8_punct, p) -#define isXDIGIT_utf8(p) _generic_utf8(_CC_XDIGIT, is_XDIGIT_high, 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) +#define isPSXSPC_utf8(p) isSPACE_utf8(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: the base macros for defining macros like + * isALPHA_LC_utf8. These are like _generic_utf8, but if the first code point + * in 'p' is within the 0-255 range, it uses locale rules from the passed-in + * 'macro' parameter */ +#define _generic_LC_utf8(macro, p, utf8) \ + (UTF8_IS_INVARIANT(*(p)) \ + ? macro(*(p)) \ + : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ + ? macro(TWO_BYTE_UTF8_TO_NATIVE(*(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) +#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) _generic_utf8(_CC_PSXSPC, is_XPERLSPACE_high, p) - -#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 isBLANK_LC_utf8(p) isBLANK_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') - -/* This conversion works both ways, strangely enough. On EBCDIC platforms, - * 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) +/* 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) + +/* On EBCDIC platforms, 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. + * '?' is special-cased on EBCDIC to APC, which is the control there that is + * the outlier from the block that contains the other controls, just like + * toCTRL('?') on ASCII yields DEL, the control that is the outlier from the C0 + * block. If it weren't special cased, it would yield a non-control. + * The conversion works both ways, so toCTRL('D') is 4, and toCTRL(4) is D, + * etc. */ +#ifndef EBCDIC +# define toCTRL(c) (__ASSERT_(FITS_IN_8_BITS(c)) toUPPER(((U8)(c))) ^ 64) +#else +# define toCTRL(c) (__ASSERT_(FITS_IN_8_BITS(c)) \ + ((isPRINT_A(c)) \ + ? (UNLIKELY((c) == '?') \ + ? QUESTION_MARK_CTRL \ + : (NATIVE_TO_LATIN1(toUPPER((U8) (c))) ^ 64)) \ + : (UNLIKELY((c) == QUESTION_MARK_CTRL) \ + ? '?' \ + : (LATIN1_TO_NATIVE(((U8) (c)) ^ 64))))) +#endif /* Line numbers are unsigned, 32 bits. */ typedef U32 line_t; @@ -1063,7 +1760,41 @@ typedef U32 line_t; } \ return a; -#define READ_XDIGIT(s) (isALPHA(*(s)) ? ((*(s)++ + 9) & 0xf) : (*(s)++ & 0xf)) +/* Converts a character known to represent a hexadecimal digit (0-9, A-F, or + * a-f) to its numeric value. READ_XDIGIT's argument is a string pointer, + * which is advanced. The input is validated only by an assert() in DEBUGGING + * builds. In both ASCII and EBCDIC the last 4 bits of the digits are 0-9; and + * the last 4 bits of A-F and a-f are 1-6, so adding 9 yields 10-15 */ +#define XDIGIT_VALUE(c) (__ASSERT_(isXDIGIT(c)) (0xf & (isDIGIT(c) \ + ? (c) \ + : ((c) + 9)))) +#define READ_XDIGIT(s) (__ASSERT_(isXDIGIT(*s)) (0xf & (isDIGIT(*(s)) \ + ? (*(s)++) \ + : (*(s)++ + 9)))) + +/* Converts a character known to represent an octal digit (0-7) to its numeric + * value. The input is validated only by an assert() in DEBUGGING builds. In + * both ASCII and EBCDIC the last 3 bits of the octal digits range from 0-7. */ +#define OCTAL_VALUE(c) (__ASSERT_(isOCTAL(c)) (7 & (c))) + +/* Efficiently returns a boolean as to if two native characters are equivalent + * case-insenstively. At least one of the characters must be one of [A-Za-z]; + * the ALPHA in the name is to remind you of that. This is asserted() in + * DEBUGGING builds. Because [A-Za-z] are invariant under UTF-8, this macro + * works (on valid input) for both non- and UTF-8-encoded bytes. + * + * When one of the inputs is a compile-time constant and gets folded by the + * compiler, this reduces to an AND and a TEST. On both EBCDIC and ASCII + * machines, 'A' and 'a' differ by a single bit; the same with the upper and + * lower case of all other ASCII-range alphabetics. On ASCII platforms, they + * are 32 apart; on EBCDIC, they are 64. At compile time, this uses an + * exclusive 'or' to find that bit and then inverts it to form a mask, with + * just a single 0, in the bit position where the upper- and lowercase differ. + * */ +#define isALPHA_FOLD_EQ(c1, c2) \ + (__ASSERT_(isALPHA_A(c1) || isALPHA_A(c2)) \ + ((c1) & ~('A' ^ 'a')) == ((c2) & ~('A' ^ 'a'))) +#define isALPHA_FOLD_NE(c1, c2) (! isALPHA_FOLD_EQ((c1), (c2))) /* =head1 Memory Management @@ -1071,6 +1802,8 @@ typedef U32 line_t; =for apidoc Am|void|Newx|void* ptr|int nitems|type The XSUB-writer's interface to the C C function. +Memory obtained by this should B be freed with L<"Safefree">. + In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, @@ -1081,37 +1814,49 @@ there for use in XS modules supporting older perls. The XSUB-writer's interface to the C C function, with cast. See also C. +Memory obtained by this should B be freed with L<"Safefree">. + =for apidoc Am|void|Newxz|void* ptr|int nitems|type The XSUB-writer's interface to the C C function. The allocated memory is zeroed with C. See also C. +Memory obtained by this should B be freed with L<"Safefree">. + =for apidoc Am|void|Renew|void* ptr|int nitems|type The XSUB-writer's interface to the C C function. +Memory obtained by this should B be freed with L<"Safefree">. + =for apidoc Am|void|Renewc|void* ptr|int nitems|type|cast The XSUB-writer's interface to the C C function, with cast. +Memory obtained by this should B be freed with L<"Safefree">. + =for apidoc Am|void|Safefree|void* ptr The XSUB-writer's interface to the C C function. +This should B be used on memory obtained using L<"Newx"> and friends. + =for apidoc Am|void|Move|void* src|void* dest|int nitems|type The XSUB-writer's interface to the C C function. The C is the -source, C is the destination, C is the number of items, and C is -the type. Can do overlapping moves. See also C. +source, C is the destination, C is the number of items, and +C is the type. Can do overlapping moves. See also C. =for apidoc Am|void *|MoveD|void* src|void* dest|int nitems|type -Like C but returns dest. Useful for encouraging compilers to tail-call +Like C but returns dest. Useful +for encouraging compilers to tail-call optimise. =for apidoc Am|void|Copy|void* src|void* dest|int nitems|type The XSUB-writer's interface to the C C function. The C is the -source, C is the destination, C is the number of items, and C is -the type. May fail on overlapping copies. See also C. +source, C is the destination, C is the number of items, and +C is the type. May fail on overlapping copies. See also C. =for apidoc Am|void *|CopyD|void* src|void* dest|int nitems|type -Like C but returns dest. Useful for encouraging compilers to tail-call +Like C but returns dest. Useful +for encouraging compilers to tail-call optimise. =for apidoc Am|void|Zero|void* dest|int nitems|type @@ -1121,7 +1866,8 @@ destination, C is the number of items, and C is the type. =for apidoc Am|void *|ZeroD|void* dest|int nitems|type -Like C but returns dest. Useful for encouraging compilers to tail-call +Like C but returns dest. Useful +for encouraging compilers to tail-call optimise. =for apidoc Am|void|StructCopy|type *src|type *dest|type @@ -1153,14 +1899,49 @@ PoisonWith(0xEF) for catching access to freed memory. #define MEM_SIZE_MAX ((MEM_SIZE)~0) -/* The +0.0 in MEM_WRAP_CHECK_ is an attempt to foil - * 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) \ - (void)(sizeof(t) > 1 && ((MEM_SIZE)(n)+0.0) > MEM_SIZE_MAX/sizeof(t) && (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)) + +/* This expression will be constant-folded at compile time. It checks + * whether or not the type of the count n is so small (e.g. U8 or U16, or + * U32 on 64-bit systems) that there's no way a wrap-around could occur. + * As well as avoiding the need for a run-time check in some cases, it's + * designed to avoid compiler warnings like: + * comparison is always false due to limited range of data type + */ + +# define _MEM_WRAP_NEEDS_RUNTIME_CHECK(n,t) \ + (sizeof(t) > ((MEM_SIZE)1 << 8*(sizeof(MEM_SIZE) - sizeof(n)))) + +/* This is written in a slightly odd way to avoid various spurious + * compiler warnings. We *want* to write the expression as + * _MEM_WRAP_NEEDS_RUNTIME_CHECK(n,t) && (n > C) + * (for some compile-time constant C), but even when the LHS + * constant-folds to false at compile-time, g++ insists on emitting + * warnings about the RHS (e.g. "comparison is always false"), so instead + * we write it as + * + * (cond ? n : X) > C + * + * where X is a constant with X > C always false. Choosing a value for X + * is tricky. If 0, some compilers will complain about 0 > C always being + * false; if 1, Coverity complains when n happens to be the constant value + * '1', that cond ? 1 : 1 has the same value on both branches; so use C + * for X and hope that nothing else whines. + */ + +# define _MEM_WRAP_WILL_WRAP(n,t) \ + ((_MEM_WRAP_NEEDS_RUNTIME_CHECK(n,t) ? (MEM_SIZE)(n) : \ + MEM_SIZE_MAX/sizeof(t)) > MEM_SIZE_MAX/sizeof(t)) + +# define MEM_WRAP_CHECK(n,t) \ + (void)(UNLIKELY(_MEM_WRAP_WILL_WRAP(n,t)) \ + && (croak_memory_wrap(),0)) + +# define MEM_WRAP_CHECK_1(n,t,a) \ + (void)(UNLIKELY(_MEM_WRAP_WILL_WRAP(n,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) ? (croak_memory_wrap(),0):0),((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1))) @@ -1208,11 +1989,11 @@ PoisonWith(0xEF) for catching access to freed memory. * - lots of ENV reads */ -PERL_EXPORT_C Malloc_t Perl_mem_log_alloc(const UV n, const UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +PERL_CALLCONV Malloc_t Perl_mem_log_alloc(const UV n, const UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); -PERL_EXPORT_C Malloc_t Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); +PERL_CALLCONV Malloc_t Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); -PERL_EXPORT_C Malloc_t Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); +PERL_CALLCONV Malloc_t Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); # ifdef PERL_CORE # ifndef PERL_MEM_LOG_NOIMPL @@ -1289,14 +2070,25 @@ void Perl_mem_log_del_sv(const SV *sv, const char *filename, const int linenumbe #define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) #define Poison(d,n,t) PoisonFree(d,n,t) +#ifdef PERL_POISON +# define PERL_POISON_EXPR(x) x +#else +# define PERL_POISON_EXPR(x) +#endif + #ifdef USE_STRUCT_COPY #define StructCopy(s,d,t) (*((t*)(d)) = *((t*)(s))) #else #define StructCopy(s,d,t) Copy(s,d,1,t) #endif +/* C_ARRAY_LENGTH is the number of elements in the C array (so you + * want your zero-based indices to be less than but not equal to). + * + * C_ARRAY_END is one past the last: half-open/half-closed range, + * not last-inclusive range. */ #define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) -#define C_ARRAY_END(a) (a) + (sizeof(a)/sizeof((a)[0])) +#define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a)) #ifdef NEED_VA_COPY # ifdef va_copy @@ -1331,15 +2123,43 @@ void Perl_mem_log_del_sv(const SV *sv, const char *filename, const int linenumbe shortcut macro defined without -DPERL_CORE. Neither codesearch.google.com nor CPAN::Unpack show any users outside the core. */ #ifdef PERL_CORE -# define deprecate(s) Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), "Use of " s " is deprecated") +# 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 - * c-basic-offset: 4 - * indent-tabs-mode: nil - * End: - * * ex: set ts=8 sts=4 sw=4 et: */