diff options
author | Karl Berry <karl@freefriends.org> | 2014-04-23 21:46:20 +0000 |
---|---|---|
committer | Karl Berry <karl@freefriends.org> | 2014-04-23 21:46:20 +0000 |
commit | 300c1eb6d37d46078d448d6d58938d5a80cd68ff (patch) | |
tree | 23a0a8b9f8f5460b405119c4d3c163d2d488ca5e /Master/tlpkg/tlperl/lib/CORE | |
parent | ed55d86b7c5e18f6eccce80a1fb1423ca40a23b5 (diff) |
(tl)perl 5.18.2 for windows from siep
git-svn-id: svn://tug.org/texlive/trunk@33648 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/tlpkg/tlperl/lib/CORE')
68 files changed, 6330 insertions, 3821 deletions
diff --git a/Master/tlpkg/tlperl/lib/CORE/EXTERN.h b/Master/tlpkg/tlperl/lib/CORE/EXTERN.h index 58ca37a47ff..2aa77dbf8f3 100644 --- a/Master/tlpkg/tlperl/lib/CORE/EXTERN.h +++ b/Master/tlpkg/tlperl/lib/CORE/EXTERN.h @@ -29,16 +29,24 @@ # define dEXTCONST globaldef {"$GLOBAL_RO_VARS"} readonly #else # if (defined(WIN32) || defined(__SYMBIAN32__)) && !defined(PERL_STATIC_SYMS) -# if defined(PERLDLL) || defined(__SYMBIAN32__) -# define EXT extern __declspec(dllexport) + /* miniperl should not export anything */ +# if defined(PERL_IS_MINIPERL) && !defined(UNDER_CE) && defined(_MSC_VER) +# define EXT extern # define dEXT -# define EXTCONST extern __declspec(dllexport) const +# define EXTCONST extern const # define dEXTCONST const # else -# define EXT extern __declspec(dllimport) -# define dEXT -# define EXTCONST extern __declspec(dllimport) const -# define dEXTCONST const +# if defined(PERLDLL) || defined(__SYMBIAN32__) +# define EXT extern __declspec(dllexport) +# define dEXT +# define EXTCONST extern __declspec(dllexport) const +# define dEXTCONST const +# else +# define EXT extern __declspec(dllimport) +# define dEXT +# define EXTCONST extern __declspec(dllimport) const +# define dEXTCONST const +# endif # endif # else # if defined(__CYGWIN__) && defined(USEIMPORTLIB) diff --git a/Master/tlpkg/tlperl/lib/CORE/XSUB.h b/Master/tlpkg/tlperl/lib/CORE/XSUB.h index 4e439f17feb..e5614fb8457 100644 --- a/Master/tlpkg/tlperl/lib/CORE/XSUB.h +++ b/Master/tlpkg/tlperl/lib/CORE/XSUB.h @@ -159,7 +159,7 @@ is a lexical $_ in scope. #define dAXMARK \ I32 ax = POPMARK; \ - register SV **mark = PL_stack_base + ax++ + SV **mark = PL_stack_base + ax++ #define dITEMS I32 items = (I32)(SP - MARK) @@ -635,18 +635,16 @@ Rethrows a previously caught exception. See L<perlguts/"Exception Handling">. # define socketpair PerlSock_socketpair # endif /* NETWARE && USE_STDIO */ -# ifdef USE_SOCKETS_AS_HANDLES -# undef fd_set -# undef FD_SET -# undef FD_CLR -# undef FD_ISSET -# undef FD_ZERO -# define fd_set Perl_fd_set -# define FD_SET(n,p) PERL_FD_SET(n,p) -# define FD_CLR(n,p) PERL_FD_CLR(n,p) -# define FD_ISSET(n,p) PERL_FD_ISSET(n,p) -# define FD_ZERO(p) PERL_FD_ZERO(p) -# endif /* USE_SOCKETS_AS_HANDLES */ +# undef fd_set +# undef FD_SET +# undef FD_CLR +# undef FD_ISSET +# undef FD_ZERO +# define fd_set Perl_fd_set +# define FD_SET(n,p) PERL_FD_SET(n,p) +# define FD_CLR(n,p) PERL_FD_CLR(n,p) +# define FD_ISSET(n,p) PERL_FD_ISSET(n,p) +# define FD_ZERO(p) PERL_FD_ZERO(p) # endif /* NO_XSLOCKS */ #endif /* PERL_IMPLICIT_SYS && !PERL_CORE */ @@ -657,8 +655,8 @@ Rethrows a previously caught exception. See L<perlguts/"Exception Handling">. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/av.h b/Master/tlpkg/tlperl/lib/CORE/av.h index 8d18d25af15..391ae36d742 100644 --- a/Master/tlpkg/tlperl/lib/CORE/av.h +++ b/Master/tlpkg/tlperl/lib/CORE/av.h @@ -47,7 +47,10 @@ Null AV pointer. =head1 Array Manipulation Functions =for apidoc Am|int|AvFILL|AV* av -Same as C<av_len()>. Deprecated, use C<av_len()> instead. +Same as C<av_top_index()>. Deprecated, use C<av_top_index()> instead. + +=for apidoc Am|int|av_tindex|AV* av +Same as C<av_top_index()>. =cut */ @@ -75,6 +78,7 @@ Same as C<av_len()>. Deprecated, use C<av_len()> instead. #define AvFILL(av) ((SvRMAGICAL((const SV *) (av))) \ ? mg_size(MUTABLE_SV(av)) : AvFILLp(av)) +#define av_tindex(av) av_top_index(av) #define NEGATIVE_INDICES_VAR "NEGATIVE_INDICES" @@ -94,8 +98,8 @@ Perl equivalent: C<my @array;>. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/charclass_invlists.h b/Master/tlpkg/tlperl/lib/CORE/charclass_invlists.h index 368410fd378..b5d71afb16d 100644 --- a/Master/tlpkg/tlperl/lib/CORE/charclass_invlists.h +++ b/Master/tlpkg/tlperl/lib/CORE/charclass_invlists.h @@ -7,39 +7,57 @@ /* See the generating file for comments */ -UV Latin1_invlist[] = { +#ifndef PERL_IN_XSUB_RE + +static UV Latin1_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 256, 0 }; -UV AboveLatin1_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV AboveLatin1_invlist[] = { 1, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 256 }; -UV ASCII_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV ASCII_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 128, 0 }; -UV L1Cased_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1Cased_invlist[] = { 16, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, @@ -60,10 +78,15 @@ UV L1Cased_invlist[] = { 443 }; -UV VertSpace_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV VertSpace_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 10, @@ -74,29 +97,35 @@ UV VertSpace_invlist[] = { 8234 }; -UV PerlSpace_invlist[] = { - 6, /* Number of elements */ +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PerlSpace_invlist[] = { + 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, - 11, - 12, 14, 32, 33 }; -UV XPerlSpace_invlist[] = { - 24, /* Number of elements */ +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV XPerlSpace_invlist[] = { + 22, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, - 11, - 12, 14, 32, 33, @@ -120,10 +149,15 @@ UV XPerlSpace_invlist[] = { 12289 }; -UV PosixAlnum_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixAlnum_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, @@ -134,10 +168,15 @@ UV PosixAlnum_invlist[] = { 123 }; -UV L1PosixAlnum_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixAlnum_invlist[] = { 18, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, @@ -160,10 +199,15 @@ UV L1PosixAlnum_invlist[] = { 706 }; -UV PosixAlpha_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixAlpha_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, @@ -172,10 +216,15 @@ UV PosixAlpha_invlist[] = { 123 }; -UV L1PosixAlpha_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixAlpha_invlist[] = { 16, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, @@ -196,10 +245,15 @@ UV L1PosixAlpha_invlist[] = { 706 }; -UV PosixBlank_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixBlank_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, @@ -208,10 +262,15 @@ UV PosixBlank_invlist[] = { 33 }; -UV XPosixBlank_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV XPosixBlank_invlist[] = { 18, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, @@ -234,10 +293,15 @@ UV XPosixBlank_invlist[] = { 12289 }; -UV PosixCntrl_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixCntrl_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, @@ -246,10 +310,15 @@ UV PosixCntrl_invlist[] = { 0 }; -UV XPosixCntrl_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV XPosixCntrl_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, @@ -258,30 +327,45 @@ UV XPosixCntrl_invlist[] = { 0 }; -UV PosixDigit_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixDigit_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58 }; -UV PosixGraph_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixGraph_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, 127 }; -UV L1PosixGraph_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixGraph_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, @@ -290,20 +374,30 @@ UV L1PosixGraph_invlist[] = { 888 }; -UV PosixLower_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixLower_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 97, 123 }; -UV L1PosixLower_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixLower_invlist[] = { 12, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 97, @@ -320,20 +414,30 @@ UV L1PosixLower_invlist[] = { 256 }; -UV PosixPrint_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixPrint_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, 127 }; -UV L1PosixPrint_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixPrint_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, @@ -342,10 +446,15 @@ UV L1PosixPrint_invlist[] = { 888 }; -UV PosixPunct_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixPunct_invlist[] = { 8, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, @@ -358,10 +467,15 @@ UV PosixPunct_invlist[] = { 127 }; -UV L1PosixPunct_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixPunct_invlist[] = { 20, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, @@ -386,10 +500,15 @@ UV L1PosixPunct_invlist[] = { 192 }; -UV PosixSpace_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixSpace_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, @@ -398,10 +517,15 @@ UV PosixSpace_invlist[] = { 33 }; -UV XPosixSpace_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV XPosixSpace_invlist[] = { 22, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, @@ -428,20 +552,30 @@ UV XPosixSpace_invlist[] = { 12289 }; -UV PosixUpper_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixUpper_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, 91 }; -UV L1PosixUpper_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixUpper_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, @@ -452,10 +586,15 @@ UV L1PosixUpper_invlist[] = { 223 }; -UV PosixWord_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixWord_invlist[] = { 8, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, @@ -468,10 +607,15 @@ UV PosixWord_invlist[] = { 123 }; -UV L1PosixWord_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV L1PosixWord_invlist[] = { 20, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, @@ -496,10 +640,15 @@ UV L1PosixWord_invlist[] = { 706 }; -UV PosixXDigit_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV PosixXDigit_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, @@ -510,10 +659,15 @@ UV PosixXDigit_invlist[] = { 103 }; -UV XPosixXDigit_invlist[] = { +#endif + +#ifndef PERL_IN_XSUB_RE + +static UV XPosixXDigit_invlist[] = { 12, /* Number of elements */ 0, /* Current iteration position */ - 1064334010, /* Version and data structure type */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, @@ -530,4 +684,130 @@ UV XPosixXDigit_invlist[] = { 65351 }; +#endif + +static UV NonL1_Perl_Non_Final_Folds_invlist[] = { + 44, /* Number of elements */ + 0, /* Current iteration position */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ + 1, /* 0 if this is the first element of the list proper; + 1 if the next element is the first */ + 700, + 701, + 776, + 777, + 787, + 788, + 834, + 835, + 940, + 941, + 942, + 943, + 945, + 946, + 951, + 952, + 953, + 954, + 961, + 962, + 965, + 966, + 969, + 970, + 974, + 975, + 1381, + 1382, + 1396, + 1397, + 1406, + 1407, + 7936, + 7944, + 7968, + 7976, + 8032, + 8040, + 8048, + 8049, + 8052, + 8053, + 8060, + 8061 +}; + +#ifndef PERL_IN_XSUB_RE + +static UV _Perl_Multi_Char_Folds_invlist[] = { + 58, /* Number of elements */ + 0, /* Current iteration position */ + 0, /* Cache of previous search index result */ + 290655244, /* Version and data structure type */ + 1, /* 0 if this is the first element of the list proper; + 1 if the next element is the first */ + 223, + 224, + 304, + 305, + 329, + 330, + 496, + 497, + 912, + 913, + 944, + 945, + 1415, + 1416, + 7830, + 7835, + 7838, + 7839, + 8016, + 8017, + 8018, + 8019, + 8020, + 8021, + 8022, + 8023, + 8064, + 8112, + 8114, + 8117, + 8118, + 8120, + 8124, + 8125, + 8130, + 8133, + 8134, + 8136, + 8140, + 8141, + 8146, + 8148, + 8150, + 8152, + 8162, + 8165, + 8166, + 8168, + 8178, + 8181, + 8182, + 8184, + 8188, + 8189, + 64256, + 64263, + 64275, + 64280 +}; + +#endif + /* ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/config.h b/Master/tlpkg/tlperl/lib/CORE/config.h index c9fb7ad382f..8353e950f34 100644 --- a/Master/tlpkg/tlperl/lib/CORE/config.h +++ b/Master/tlpkg/tlperl/lib/CORE/config.h @@ -9,7 +9,7 @@ /* Package name : perl5 * Source directory : - * Configuration time: Fri Nov 16 21:24:42 2012 + * Configuration time: Tue Apr 22 14:55:05 2014 * Configured by : siepo * Target system : */ @@ -890,7 +890,7 @@ * feature tests from Configure are generally more reliable. */ #define OSNAME "MSWin32" /**/ -#define OSVERS "5.1" /**/ +#define OSVERS "4.0" /**/ /* USE_CROSS_COMPILE: * This symbol, if defined, indicates that Perl is being cross-compiled. @@ -916,13 +916,10 @@ /* MEM_ALIGNBYTES: * This symbol contains the number of bytes required to align a * double, or a long double when applicable. Usual values are 2, - * 4 and 8. The default is eight, for safety. + * 4 and 8. The default is eight, for safety. For cross-compiling + * or multiarch support, Configure will set a minimum of 8. */ -#if defined(USE_CROSS_COMPILE) || defined(MULTIARCH) -# define MEM_ALIGNBYTES 8 -#else #define MEM_ALIGNBYTES 8 -#endif /* ARCHLIB: * This variable, if defined, holds the name of the directory in @@ -962,7 +959,7 @@ */ #define BIN "c:\\perl\\bin" /**/ #define BIN_EXP "c:\\perl\\bin" /**/ -/*#define PERL_RELOCATABLE_INC / **/ +#define PERL_RELOCATABLE_INC "undef" /**/ /* INTSIZE: * This symbol contains the value of sizeof(int) so that the C @@ -984,7 +981,7 @@ * This symbol holds the hexadecimal constant defined in byteorder, * in a UV, i.e. 0x1234 or 0x4321 or 0x12345678, etc... * If the compiler supports cross-compiling or multiple-architecture - * binaries (eg. on NeXT systems), use compiler-defined macros to + * binaries (e.g. on NeXT systems), use compiler-defined macros to * determine the byte order. * On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture * Binaries (MAB) on either big endian or little endian machines. @@ -1952,7 +1949,7 @@ * C preprocessor can make decisions based on it. It is only * defined if the system supports long long. */ -/*#define HAS_LONG_LONG / **/ +#define HAS_LONG_LONG /**/ #ifdef HAS_LONG_LONG #define LONGLONGSIZE 8 /**/ #endif @@ -2359,10 +2356,22 @@ * This symbol, if defined, indicates that the struct sockaddr_in6 * structure has a member called sin6_scope_id. */ +/* HAS_IP_MREQ: + * This symbol, if defined, indicates the availability of + * struct ip_mreq; + */ +/* HAS_IP_MREQ_SOURCE: + * This symbol, if defined, indicates the availability of + * struct ip_mreq_source; + */ /* HAS_IPV6_MREQ: * This symbol, if defined, indicates the availability of * struct ipv6_mreq; */ +/* HAS_IPV6_MREQ_SOURCE: + * This symbol, if defined, indicates the availability of + * struct ipv6_mreq_source; + */ #define HAS_SOCKET /**/ /*#define HAS_SOCKETPAIR / **/ /*#define HAS_SOCKADDR_SA_LEN / **/ @@ -2374,7 +2383,10 @@ /*#define HAS_SCM_RIGHTS / **/ /*#define HAS_SOCKADDR_IN6 / **/ #define HAS_SIN6_SCOPE_ID /**/ +/*#define HAS_IP_MREQ / **/ +/*#define HAS_IP_MREQ_SOURCE / **/ /*#define HAS_IPV6_MREQ / **/ +/*#define HAS_IPV6_MREQ_SOURCE / **/ /* HAS_SRAND48_R: * This symbol, if defined, indicates that the srand48_r routine @@ -2661,10 +2673,17 @@ #define DOUBLESIZE 8 /**/ /* EBCDIC: - * This symbol, if defined, indicates that this system uses + * This symbol, if defined, indicates that this system uses * EBCDIC encoding. */ +/* BOOTSTRAP_CHARSET: + * This symbol, if defined, indicates that this system needs + * converting various files to the native character set before + * bringing up perl on a system that has a non-ASCII character + * set and no working perl. + */ /*#define EBCDIC / **/ +/*#define BOOTSTRAP_CHARSET / **/ /* Fpos_t: * This symbol holds the type used to declare file positions in libc. @@ -2679,7 +2698,7 @@ #define Gid_t_f "ld" /**/ /* Gid_t_sign: - * This symbol holds the signedess of a Gid_t. + * This symbol holds the signedness of a Gid_t. * 1 for unsigned, -1 for signed. */ #define Gid_t_sign -1 /* GID sign */ @@ -3238,7 +3257,7 @@ #define Uid_t_f "ld" /**/ /* Uid_t_sign: - * This symbol holds the signedess of a Uid_t. + * This symbol holds the signedness of a Uid_t. * 1 for unsigned, -1 for signed. */ #define Uid_t_sign -1 /* UID sign */ @@ -3701,7 +3720,7 @@ /*#define HAS_INT64_T / **/ /* HAS_ISBLANK: - * This manifest constant lets the C program know that isblank + * This manifest constant lets the C program know that isblank * is available. */ /*#define HAS_ISBLANK / **/ @@ -4581,7 +4600,7 @@ * This variable contains the size of struct stat's st_ino in bytes. */ /* ST_INO_SIGN: - * This symbol holds the signedess of struct stat's st_ino. + * This symbol holds the signedness of struct stat's st_ino. * 1 for unsigned, -1 for signed. */ #define ST_INO_SIGN 1 /* st_ino sign */ diff --git a/Master/tlpkg/tlperl/lib/CORE/cop.h b/Master/tlpkg/tlperl/lib/CORE/cop.h index 0cfeb447146..122e2d75e01 100644 --- a/Master/tlpkg/tlperl/lib/CORE/cop.h +++ b/Master/tlpkg/tlperl/lib/CORE/cop.h @@ -387,9 +387,9 @@ struct cop { line_t cop_line; /* line # of this command */ /* label for this construct is now stored in cop_hints_hash */ #ifdef USE_ITHREADS - char * cop_stashpv; /* package line was compiled in */ + PADOFFSET cop_stashoff; /* offset into PL_stashpad, for the + package the line was compiled in */ char * cop_file; /* file name the following line # is from */ - I32 cop_stashlen; /* negative for UTF8 */ #else HV * cop_stash; /* package line was compiled in */ GV * cop_filegv; /* file the following line # is from */ @@ -420,47 +420,16 @@ struct cop { ? GvSV(gv_fetchfile(CopFILE(c))) : NULL) # define CopFILEAV(c) (CopFILE(c) \ ? GvAV(gv_fetchfile(CopFILE(c))) : NULL) -# ifdef DEBUGGING -# define CopFILEAVx(c) (assert(CopFILE(c)), \ +# define CopFILEAVx(c) (assert_(CopFILE(c)) \ GvAV(gv_fetchfile(CopFILE(c)))) -# else -# define CopFILEAVx(c) (GvAV(gv_fetchfile(CopFILE(c)))) -# endif -# define CopSTASHPV(c) ((c)->cop_stashpv) +# define CopSTASH(c) PL_stashpad[(c)->cop_stashoff] +# define CopSTASH_set(c,hv) ((c)->cop_stashoff = (hv) \ + ? alloccopstash(hv) \ + : 0) # ifdef NETWARE -# define CopSTASHPV_set(c,pv,n) ((c)->cop_stashpv = \ - ((pv) ? savepvn(pv,n) : NULL)) -# else -# define CopSTASHPV_set(c,pv,n) ((c)->cop_stashpv = (pv) \ - ? savesharedpvn(pv,n) : NULL) -# endif - -# define CopSTASH_len_set(c,n) ((c)->cop_stashlen = (n)) -# define CopSTASH_len(c) ((c)->cop_stashlen) - -# define CopSTASH(c) (CopSTASHPV(c) \ - ? gv_stashpvn(CopSTASHPV(c), \ - CopSTASH_len(c) < 0 \ - ? -CopSTASH_len(c) \ - : CopSTASH_len(c), \ - GV_ADD|SVf_UTF8*(CopSTASH_len(c) < 0) \ - ) \ - : NULL) -# define CopSTASH_set(c,hv) (CopSTASHPV_set(c, \ - (hv) ? HvNAME_get(hv) : NULL, \ - (hv) ? HvNAMELEN(hv) : 0), \ - CopSTASH_len_set(c, \ - (hv) ? HvNAMEUTF8(hv) \ - ? -HvNAMELEN(hv) \ - : HvNAMELEN(hv) \ - : 0)) -# define CopSTASH_eq(c,hv) ((hv) && stashpv_hvname_match(c,hv)) -# ifdef NETWARE -# define CopSTASH_free(c) SAVECOPSTASH_FREE(c) # define CopFILE_free(c) SAVECOPFILE_FREE(c) # else -# define CopSTASH_free(c) PerlMemShared_free(CopSTASHPV(c)) # define CopFILE_free(c) (PerlMemShared_free(CopFILE(c)),(CopFILE(c) = NULL)) # endif #else @@ -479,15 +448,15 @@ struct cop { ? SvPVX(GvSV(CopFILEGV(c))) : NULL) # define CopSTASH(c) ((c)->cop_stash) # define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) -# define CopSTASHPV(c) (CopSTASH(c) ? HvNAME_get(CopSTASH(c)) : NULL) - /* cop_stash is not refcounted */ -# define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) -# define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) -# define CopSTASH_free(c) # define CopFILE_free(c) (SvREFCNT_dec(CopFILEGV(c)),(CopFILEGV(c) = NULL)) #endif /* USE_ITHREADS */ +#define CopSTASHPV(c) (CopSTASH(c) ? HvNAME_get(CopSTASH(c)) : NULL) + /* cop_stash is not refcounted */ +#define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) +#define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) + #define CopHINTHASH_get(c) ((COPHH*)((c)->cop_hints_hash)) #define CopHINTHASH_set(c,h) ((c)->cop_hints_hash = (h)) @@ -575,7 +544,6 @@ be zero. /* OutCopFILE() is CopFILE for output (caller, die, warn, etc.) */ #define OutCopFILE(c) CopFILE(c) -/* FIXME NATIVE_HINTS if this is changed from op_private (see perl.h) */ #define CopHINTS_get(c) ((c)->cop_hints + 0) #define CopHINTS_set(c, h) STMT_START { \ (c)->cop_hints = (h); \ @@ -613,7 +581,9 @@ struct block_format { * decremented by LEAVESUB, the other by LEAVE. */ #define PUSHSUB_BASE(cx) \ - ENTRY_PROBE(GvENAME(CvGV(cv)), \ + ENTRY_PROBE(CvNAMED(cv) \ + ? HEK_KEY(CvNAME_HEK(cv)) \ + : GvENAME(CvGV(cv)), \ CopFILE((const COP *)CvSTART(cv)), \ CopLINE((const COP *)CvSTART(cv)), \ CopSTASHPV((const COP *)CvSTART(cv))); \ @@ -628,16 +598,19 @@ struct block_format { SAVEFREESV(cv); \ } - -#define PUSHSUB(cx) \ - { \ +#define PUSHSUB_GET_LVALUE_MASK(func) \ /* If the context is indeterminate, then only the lvalue */ \ /* flags that the caller also has are applicable. */ \ - U8 phlags = \ + ( \ (PL_op->op_flags & OPf_WANT) \ ? OPpENTERSUB_LVAL_MASK \ : !(PL_op->op_private & OPpENTERSUB_LVAL_MASK) \ - ? 0 : Perl_was_lvalue_sub(aTHX); \ + ? 0 : (U8)func(aTHX) \ + ) + +#define PUSHSUB(cx) \ + { \ + U8 phlags = PUSHSUB_GET_LVALUE_MASK(Perl_was_lvalue_sub); \ PUSHSUB_BASE(cx) \ cx->blk_u16 = PL_op->op_private & \ (phlags|OPpDEREF); \ @@ -654,6 +627,8 @@ struct block_format { cx->blk_format.gv = gv; \ cx->blk_format.retop = (retop); \ cx->blk_format.dfoutgv = PL_defoutgv; \ + if (!CvDEPTH(cv)) SvREFCNT_inc_simple_void_NN(cv); \ + CvDEPTH(cv)++; \ SvREFCNT_inc_void(cx->blk_format.dfoutgv) #define POP_SAVEARRAY() \ @@ -673,7 +648,9 @@ struct block_format { #define POPSUB(cx,sv) \ STMT_START { \ - RETURN_PROBE(GvENAME(CvGV((const CV*)cx->blk_sub.cv)), \ + RETURN_PROBE(CvNAMED(cx->blk_sub.cv) \ + ? HEK_KEY(CvNAME_HEK(cx->blk_sub.cv)) \ + : GvENAME(CvGV(cx->blk_sub.cv)), \ CopFILE((COP*)CvSTART((const CV*)cx->blk_sub.cv)), \ CopLINE((COP*)CvSTART((const CV*)cx->blk_sub.cv)), \ CopSTASHPV((COP*)CvSTART((const CV*)cx->blk_sub.cv))); \ @@ -683,7 +660,7 @@ struct block_format { /* abandon @_ if it got reified */ \ if (AvREAL(cx->blk_sub.argarray)) { \ const SSize_t fill = AvFILLp(cx->blk_sub.argarray); \ - SvREFCNT_dec(cx->blk_sub.argarray); \ + SvREFCNT_dec_NN(cx->blk_sub.argarray); \ cx->blk_sub.argarray = newAV(); \ av_extend(cx->blk_sub.argarray, fill); \ AvREIFY_only(cx->blk_sub.argarray); \ @@ -700,13 +677,15 @@ struct block_format { #define LEAVESUB(sv) \ STMT_START { \ - if (sv) \ - SvREFCNT_dec(sv); \ + SvREFCNT_dec(sv); \ } STMT_END #define POPFORMAT(cx) \ setdefout(cx->blk_format.dfoutgv); \ - SvREFCNT_dec(cx->blk_format.dfoutgv); + CvDEPTH(cx->blk_format.cv)--; \ + if (!CvDEPTH(cx->blk_format.cv)) \ + SvREFCNT_dec_NN(cx->blk_format.cv); \ + SvREFCNT_dec_NN(cx->blk_format.dfoutgv); /* eval context */ struct block_eval { @@ -744,6 +723,8 @@ struct block_eval { PL_in_eval = CxOLD_IN_EVAL(cx); \ optype = CxOLD_OP_TYPE(cx); \ PL_eval_root = cx->blk_eval.old_eval_root; \ + if (cx->blk_eval.cur_text && SvSCREAM(cx->blk_eval.cur_text)) \ + SvREFCNT_dec_NN(cx->blk_eval.cur_text); \ if (cx->blk_eval.old_namesv) \ sv_2mortal(cx->blk_eval.old_namesv); \ } STMT_END @@ -809,8 +790,8 @@ struct block_loop { #define POPLOOP(cx) \ if (CxTYPE(cx) == CXt_LOOP_LAZYSV) { \ - SvREFCNT_dec(cx->blk_loop.state_u.lazysv.cur); \ - SvREFCNT_dec(cx->blk_loop.state_u.lazysv.end); \ + SvREFCNT_dec_NN(cx->blk_loop.state_u.lazysv.cur); \ + SvREFCNT_dec_NN(cx->blk_loop.state_u.lazysv.end); \ } \ if (CxTYPE(cx) == CXt_LOOP_FOR) \ SvREFCNT_dec(cx->blk_loop.state_u.ary.ary); @@ -994,6 +975,8 @@ struct context { /* private flags for CXt_SUB and CXt_FORMAT */ #define CXp_HASARGS 0x20 +#define CXp_SUB_RE 0x40 /* code called within regex, i.e. (?{}) */ +#define CXp_SUB_RE_FAKE 0x80 /* fake sub CX for (?{}) in current scope */ /* private flags for CXt_EVAL */ #define CXp_REAL 0x20 /* truly eval'', not a lookalike */ @@ -1074,6 +1057,7 @@ L<perlcall>. Perl_magic_methcall(). */ #define G_WRITING_TO_STDERR 1024 /* Perl_write_to_stderr() is calling Perl_magic_methcall(). */ +#define G_RE_REPARSING 0x800 /* compiling a run-time /(?{..})/ */ /* flag bits for PL_in_eval */ #define EVAL_NULL 0 /* not in an eval */ @@ -1081,6 +1065,7 @@ L<perlcall>. #define EVAL_WARNONLY 2 /* used by yywarn() when calling yyerror() */ #define EVAL_KEEPERR 4 /* set by Perl_call_sv if G_KEEPERR */ #define EVAL_INREQUIRE 8 /* The code is being required. */ +#define EVAL_RE_REPARSING 0x10 /* eval_sv() called with G_RE_REPARSING */ /* Support for switching (stack and block) contexts. * This ensures magic doesn't invalidate local stack and cx pointers. @@ -1159,8 +1144,7 @@ typedef struct stackinfo PERL_SI; Perl_deb(aTHX_ "pop STACKINFO %d at %s:%d\n", \ i, __FILE__, __LINE__);}) \ if (!prev) { \ - PerlIO_printf(Perl_error_log, "panic: POPSTACK\n"); \ - my_exit(1); \ + Perl_croak_popstack(); \ } \ SWITCHSTACK(PL_curstack,prev->si_stack); \ /* don't free prev here, free them all at the END{} */ \ @@ -1207,18 +1191,26 @@ See L<perlcall/LIGHTWEIGHT CALLBACKS>. U8 hasargs = 0 /* used by PUSHSUB */ #define PUSH_MULTICALL(the_cv) \ + PUSH_MULTICALL_FLAGS(the_cv, 0) + +/* Like PUSH_MULTICALL, but allows you to specify extra flags + * for the CX stack entry (this isn't part of the public API) */ + +#define PUSH_MULTICALL_FLAGS(the_cv, flags) \ STMT_START { \ CV * const _nOnclAshIngNamE_ = the_cv; \ CV * const cv = _nOnclAshIngNamE_; \ - AV * const padlist = CvPADLIST(cv); \ + PADLIST * const padlist = CvPADLIST(cv); \ ENTER; \ multicall_oldcatch = CATCH_GET; \ SAVETMPS; SAVEVPTR(PL_op); \ CATCH_SET(TRUE); \ PUSHSTACKi(PERLSI_SORT); \ - PUSHBLOCK(cx, CXt_SUB|CXp_MULTICALL, PL_stack_sp); \ + PUSHBLOCK(cx, (CXt_SUB|CXp_MULTICALL|flags), PL_stack_sp); \ PUSHSUB(cx); \ - if (++CvDEPTH(cv) >= 2) { \ + if (!(flags & CXp_SUB_RE_FAKE)) \ + CvDEPTH(cv)++; \ + if (CvDEPTH(cv) >= 2) { \ PERL_STACK_OVERFLOW_CHECK(); \ Perl_pad_push(aTHX_ padlist, CvDEPTH(cv)); \ } \ @@ -1236,8 +1228,10 @@ See L<perlcall/LIGHTWEIGHT CALLBACKS>. #define POP_MULTICALL \ STMT_START { \ - if (! --CvDEPTH(multicall_cv)) \ - LEAVESUB(multicall_cv); \ + cx = &cxstack[cxstack_ix]; \ + if (! ((CvDEPTH(multicall_cv) = cx->blk_sub.olddepth)) ) { \ + LEAVESUB(multicall_cv); \ + } \ POPBLOCK(cx,PL_curpm); \ POPSTACK; \ CATCH_SET(multicall_oldcatch); \ @@ -1245,12 +1239,38 @@ See L<perlcall/LIGHTWEIGHT CALLBACKS>. SPAGAIN; \ } STMT_END +/* Change the CV of an already-pushed MULTICALL CxSUB block. + * (this isn't part of the public API) */ + +#define CHANGE_MULTICALL_FLAGS(the_cv, flags) \ + STMT_START { \ + CV * const _nOnclAshIngNamE_ = the_cv; \ + CV * const cv = _nOnclAshIngNamE_; \ + PADLIST * const padlist = CvPADLIST(cv); \ + cx = &cxstack[cxstack_ix]; \ + assert(cx->cx_type & CXp_MULTICALL); \ + if (! ((CvDEPTH(multicall_cv) = cx->blk_sub.olddepth)) ) { \ + LEAVESUB(multicall_cv); \ + } \ + cx->cx_type = (CXt_SUB|CXp_MULTICALL|flags); \ + PUSHSUB(cx); \ + if (!(flags & CXp_SUB_RE_FAKE)) \ + CvDEPTH(cv)++; \ + if (CvDEPTH(cv) >= 2) { \ + PERL_STACK_OVERFLOW_CHECK(); \ + Perl_pad_push(aTHX_ padlist, CvDEPTH(cv)); \ + } \ + SAVECOMPPAD(); \ + PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv)); \ + multicall_cv = cv; \ + multicall_cop = CvSTART(cv); \ + } STMT_END /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/cv.h b/Master/tlpkg/tlperl/lib/CORE/cv.h index a3b9865c48e..5da9a502f53 100644 --- a/Master/tlpkg/tlperl/lib/CORE/cv.h +++ b/Master/tlpkg/tlperl/lib/CORE/cv.h @@ -13,7 +13,6 @@ struct xpvcv { _XPV_HEAD; _XPVCV_COMMON; - I32 xcv_depth; /* >= 2 indicates recursive call */ }; /* @@ -50,7 +49,7 @@ See L<perlguts/Autoloading with XSUBs>. #define CvROOT(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_root #define CvXSUB(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_xsub #define CvXSUBANY(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_xsubany -#define CvGV(sv) (0+((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv) +#define CvGV(sv) S_CvGV((CV *)(sv)) #define CvGV_set(cv,gv) Perl_cvgv_set(aTHX_ cv, gv) #define CvFILE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_file #ifdef USE_ITHREADS @@ -61,14 +60,7 @@ See L<perlguts/Autoloading with XSUBs>. (CvFILE(sv) = CopFILE(cop), CvDYNFILE_off(sv)) #endif #define CvFILEGV(sv) (gv_fetchfile(CvFILE(sv))) -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define CvDEPTH(sv) (*({const CV *const _cvdepth = (const CV *)sv; \ - assert(SvTYPE(_cvdepth) == SVt_PVCV); \ - &((XPVCV*)SvANY(_cvdepth))->xcv_depth; \ - })) -#else -# define CvDEPTH(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth -#endif +#define CvDEPTH(sv) (*S_CvDEPTHp((const CV *)sv)) #define CvPADLIST(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist #define CvOUTSIDE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside #define CvFLAGS(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_flags @@ -105,8 +97,13 @@ See L<perlguts/Autoloading with XSUBs>. #define CVf_NODEBUG 0x0200 /* no DB::sub indirection for this CV (esp. useful for special XSUBs) */ #define CVf_CVGV_RC 0x0400 /* CvGV is reference counted */ +#ifdef PERL_CORE +# define CVf_SLABBED 0x0800 /* Holds refcount on op slab */ +#endif #define CVf_DYNFILE 0x1000 /* The filename isn't static */ #define CVf_AUTOLOAD 0x2000 /* SvPVX contains AUTOLOADed sub name */ +#define CVf_HASEVAL 0x4000 /* contains string eval */ +#define CVf_NAMED 0x8000 /* Has a name HEK */ /* This symbol for optimised communication between toke.c and op.c: */ #define CVf_BUILTIN_ATTRS (CVf_METHOD|CVf_LVALUE) @@ -123,6 +120,7 @@ See L<perlguts/Autoloading with XSUBs>. #define CvANON_on(cv) (CvFLAGS(cv) |= CVf_ANON) #define CvANON_off(cv) (CvFLAGS(cv) &= ~CVf_ANON) +/* CvEVAL or CvSPECIAL */ #define CvUNIQUE(cv) (CvFLAGS(cv) & CVf_UNIQUE) #define CvUNIQUE_on(cv) (CvFLAGS(cv) |= CVf_UNIQUE) #define CvUNIQUE_off(cv) (CvFLAGS(cv) &= ~CVf_UNIQUE) @@ -139,6 +137,7 @@ See L<perlguts/Autoloading with XSUBs>. #define CvLVALUE_on(cv) (CvFLAGS(cv) |= CVf_LVALUE) #define CvLVALUE_off(cv) (CvFLAGS(cv) &= ~CVf_LVALUE) +/* eval or PL_main_cv */ #define CvEVAL(cv) (CvUNIQUE(cv) && !SvFAKE(cv)) #define CvEVAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_off(cv)) #define CvEVAL_off(cv) CvUNIQUE_off(cv) @@ -164,6 +163,12 @@ See L<perlguts/Autoloading with XSUBs>. #define CvCVGV_RC_on(cv) (CvFLAGS(cv) |= CVf_CVGV_RC) #define CvCVGV_RC_off(cv) (CvFLAGS(cv) &= ~CVf_CVGV_RC) +#ifdef PERL_CORE +# define CvSLABBED(cv) (CvFLAGS(cv) & CVf_SLABBED) +# define CvSLABBED_on(cv) (CvFLAGS(cv) |= CVf_SLABBED) +# define CvSLABBED_off(cv) (CvFLAGS(cv) &= ~CVf_SLABBED) +#endif + #define CvDYNFILE(cv) (CvFLAGS(cv) & CVf_DYNFILE) #define CvDYNFILE_on(cv) (CvFLAGS(cv) |= CVf_DYNFILE) #define CvDYNFILE_off(cv) (CvFLAGS(cv) &= ~CVf_DYNFILE) @@ -172,9 +177,41 @@ See L<perlguts/Autoloading with XSUBs>. #define CvAUTOLOAD_on(cv) (CvFLAGS(cv) |= CVf_AUTOLOAD) #define CvAUTOLOAD_off(cv) (CvFLAGS(cv) &= ~CVf_AUTOLOAD) +#define CvHASEVAL(cv) (CvFLAGS(cv) & CVf_HASEVAL) +#define CvHASEVAL_on(cv) (CvFLAGS(cv) |= CVf_HASEVAL) +#define CvHASEVAL_off(cv) (CvFLAGS(cv) &= ~CVf_HASEVAL) + +#define CvNAMED(cv) (CvFLAGS(cv) & CVf_NAMED) +#define CvNAMED_on(cv) (CvFLAGS(cv) |= CVf_NAMED) +#define CvNAMED_off(cv) (CvFLAGS(cv) &= ~CVf_NAMED) + /* Flags for newXS_flags */ #define XS_DYNAMIC_FILENAME 0x01 /* The filename isn't static */ +PERL_STATIC_INLINE GV * +S_CvGV(CV *sv) +{ + return CvNAMED(sv) + ? 0 + : ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_gv; +} +PERL_STATIC_INLINE HEK * +CvNAME_HEK(CV *sv) +{ + return CvNAMED(sv) + ? ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_hek + : 0; +} +/* This lowers the refernce count of the previous value, but does *not* + increment the reference count of the new value. */ +#define CvNAME_HEK_set(cv, hek) ( \ + CvNAME_HEK((CV *)(cv)) \ + ? unshare_hek(SvANY((CV *)(cv))->xcv_gv_u.xcv_hek) \ + : (void)0, \ + ((XPVCV*)MUTABLE_PTR(SvANY(cv)))->xcv_gv_u.xcv_hek = (hek), \ + CvNAMED_on(cv) \ + ) + /* =head1 CV reference counts and CvOUTSIDE @@ -236,8 +273,8 @@ typedef OP *(*Perl_call_checker)(pTHX_ OP *, GV *, SV *); * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/dosish.h b/Master/tlpkg/tlperl/lib/CORE/dosish.h index e9c59fa5468..8c3917b510d 100644 --- a/Master/tlpkg/tlperl/lib/CORE/dosish.h +++ b/Master/tlpkg/tlperl/lib/CORE/dosish.h @@ -204,8 +204,8 @@ * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/embed.h b/Master/tlpkg/tlperl/lib/CORE/embed.h index f7db1e06135..71456cbe205 100644 --- a/Master/tlpkg/tlperl/lib/CORE/embed.h +++ b/Master/tlpkg/tlperl/lib/CORE/embed.h @@ -27,6 +27,13 @@ /* Hide global symbols */ #define Gv_AMupdate(a,b) Perl_Gv_AMupdate(aTHX_ a,b) +#define _is_uni_FOO(a,b) Perl__is_uni_FOO(aTHX_ a,b) +#define _is_uni_perl_idcont(a) Perl__is_uni_perl_idcont(aTHX_ a) +#define _is_uni_perl_idstart(a) Perl__is_uni_perl_idstart(aTHX_ a) +#define _is_utf8_FOO(a,b) Perl__is_utf8_FOO(aTHX_ a,b) +#define _is_utf8_mark(a) Perl__is_utf8_mark(aTHX_ a) +#define _is_utf8_perl_idcont(a) Perl__is_utf8_perl_idcont(aTHX_ a) +#define _is_utf8_perl_idstart(a) Perl__is_utf8_perl_idstart(aTHX_ a) #define _to_uni_fold_flags(a,b,c,d) Perl__to_uni_fold_flags(aTHX_ a,b,c,d) #define _to_utf8_fold_flags(a,b,c,d,e) Perl__to_utf8_fold_flags(aTHX_ a,b,c,d,e) #define _to_utf8_lower_flags(a,b,c,d,e) Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e) @@ -49,6 +56,7 @@ #define av_push(a,b) Perl_av_push(aTHX_ a,b) #define av_shift(a) Perl_av_shift(aTHX_ a) #define av_store(a,b,c) Perl_av_store(aTHX_ a,b,c) +#define av_top_index(a) S_av_top_index(aTHX_ a) #define av_undef(a) Perl_av_undef(aTHX_ a) #define av_unshift(a,b) Perl_av_unshift(aTHX_ a,b) #define block_gimme() Perl_block_gimme(aTHX) @@ -76,9 +84,9 @@ #ifndef PERL_IMPLICIT_CONTEXT #define croak Perl_croak #endif -#define croak_no_modify() Perl_croak_no_modify(aTHX) +#define croak_no_modify Perl_croak_no_modify #define croak_sv(a) Perl_croak_sv(aTHX_ a) -#define croak_xs_usage(a,b) Perl_croak_xs_usage(aTHX_ a,b) +#define croak_xs_usage Perl_croak_xs_usage #define custom_op_desc(a) Perl_custom_op_desc(aTHX_ a) #define custom_op_name(a) Perl_custom_op_name(aTHX_ a) #define cv_clone(a) Perl_cv_clone(aTHX_ a) @@ -212,6 +220,7 @@ #define hv_iterval(a,b) Perl_hv_iterval(aTHX_ a,b) #define hv_ksplit(a,b) Perl_hv_ksplit(aTHX_ a,b) #define hv_name_set(a,b,c,d) Perl_hv_name_set(aTHX_ a,b,c,d) +#define hv_rand_set(a,b) Perl_hv_rand_set(aTHX_ a,b) #define hv_scalar(a) Perl_hv_scalar(aTHX_ a) #define init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) #define init_i18nl14n(a) Perl_init_i18nl14n(aTHX_ a) @@ -222,10 +231,14 @@ #define is_lvalue_sub() Perl_is_lvalue_sub(aTHX) #define is_uni_alnum(a) Perl_is_uni_alnum(aTHX_ a) #define is_uni_alnum_lc(a) Perl_is_uni_alnum_lc(aTHX_ a) +#define is_uni_alnumc(a) Perl_is_uni_alnumc(aTHX_ a) +#define is_uni_alnumc_lc(a) Perl_is_uni_alnumc_lc(aTHX_ a) #define is_uni_alpha(a) Perl_is_uni_alpha(aTHX_ a) #define is_uni_alpha_lc(a) Perl_is_uni_alpha_lc(aTHX_ a) #define is_uni_ascii(a) Perl_is_uni_ascii(aTHX_ a) #define is_uni_ascii_lc(a) Perl_is_uni_ascii_lc(aTHX_ a) +#define is_uni_blank(a) Perl_is_uni_blank(aTHX_ a) +#define is_uni_blank_lc(a) Perl_is_uni_blank_lc(aTHX_ a) #define is_uni_cntrl(a) Perl_is_uni_cntrl(aTHX_ a) #define is_uni_cntrl_lc(a) Perl_is_uni_cntrl_lc(aTHX_ a) #define is_uni_digit(a) Perl_is_uni_digit(aTHX_ a) @@ -247,8 +260,10 @@ #define is_uni_xdigit(a) Perl_is_uni_xdigit(aTHX_ a) #define is_uni_xdigit_lc(a) Perl_is_uni_xdigit_lc(aTHX_ a) #define is_utf8_alnum(a) Perl_is_utf8_alnum(aTHX_ a) +#define is_utf8_alnumc(a) Perl_is_utf8_alnumc(aTHX_ a) #define is_utf8_alpha(a) Perl_is_utf8_alpha(aTHX_ a) #define is_utf8_ascii(a) Perl_is_utf8_ascii(aTHX_ a) +#define is_utf8_blank(a) Perl_is_utf8_blank(aTHX_ a) #define is_utf8_char Perl_is_utf8_char #define is_utf8_char_buf Perl_is_utf8_char_buf #define is_utf8_cntrl(a) Perl_is_utf8_cntrl(aTHX_ a) @@ -343,6 +358,7 @@ #define newLOGOP(a,b,c,d) Perl_newLOGOP(aTHX_ a,b,c,d) #define newLOOPEX(a,b) Perl_newLOOPEX(aTHX_ a,b) #define newLOOPOP(a,b,c,d) Perl_newLOOPOP(aTHX_ a,b,c,d) +#define newMYSUB(a,b,c,d,e) Perl_newMYSUB(aTHX_ a,b,c,d,e) #define newNULLLIST() Perl_newNULLLIST(aTHX) #define newOP(a,b) Perl_newOP(aTHX_ a,b) #define newPMOP(a,b) Perl_newPMOP(aTHX_ a,b) @@ -437,6 +453,10 @@ #define re_compile(a,b) Perl_re_compile(aTHX_ a,b) #define re_intuit_start(a,b,c,d,e,f) Perl_re_intuit_start(aTHX_ a,b,c,d,e,f) #define re_intuit_string(a) Perl_re_intuit_string(aTHX_ a) +#define reentrant_free() Perl_reentrant_free(aTHX) +#define reentrant_init() Perl_reentrant_init(aTHX) +#define reentrant_retry Perl_reentrant_retry +#define reentrant_size() Perl_reentrant_size(aTHX) #define reg_named_buff_all(a,b) Perl_reg_named_buff_all(aTHX_ a,b) #define reg_named_buff_exists(a,b,c) Perl_reg_named_buff_exists(aTHX_ a,b,c) #define reg_named_buff_fetch(a,b,c) Perl_reg_named_buff_fetch(aTHX_ a,b,c) @@ -445,7 +465,6 @@ #define reg_named_buff_scalar(a,b) Perl_reg_named_buff_scalar(aTHX_ a,b) #define regclass_swash(a,b,c,d,e) Perl_regclass_swash(aTHX_ a,b,c,d,e) #define regdump(a) Perl_regdump(aTHX_ a) -#define regdump(a) Perl_regdump(aTHX_ a) #define regexec_flags(a,b,c,d,e,f,g,h) Perl_regexec_flags(aTHX_ a,b,c,d,e,f,g,h) #define regfree_internal(a) Perl_regfree_internal(aTHX_ a) #define reginitcolors() Perl_reginitcolors(aTHX) @@ -527,7 +546,6 @@ #define sortsv_flags(a,b,c,d) Perl_sortsv_flags(aTHX_ a,b,c,d) #define stack_grow(a,b,c) Perl_stack_grow(aTHX_ a,b,c) #define start_subparse(a,b) Perl_start_subparse(aTHX_ a,b) -#define stashpv_hvname_match(a,b) Perl_stashpv_hvname_match(aTHX_ a,b) #define str_to_version(a) Perl_str_to_version(aTHX_ a) #define sv_2bool_flags(a,b) Perl_sv_2bool_flags(aTHX_ a,b) #define sv_2cv(a,b,c,d) Perl_sv_2cv(aTHX_ a,b,c,d) @@ -555,8 +573,7 @@ #define sv_clear(a) Perl_sv_clear(aTHX_ a) #define sv_cmp_flags(a,b,c) Perl_sv_cmp_flags(aTHX_ a,b,c) #define sv_cmp_locale_flags(a,b,c) Perl_sv_cmp_locale_flags(aTHX_ a,b,c) -#define sv_compile_2op(a,b,c,d) Perl_sv_compile_2op(aTHX_ a,b,c,d) -#define sv_copypv(a,b) Perl_sv_copypv(aTHX_ a,b) +#define sv_copypv_flags(a,b,c) Perl_sv_copypv_flags(aTHX_ a,b,c) #define sv_dec(a) Perl_sv_dec(aTHX_ a) #define sv_dec_nomg(a) Perl_sv_dec_nomg(aTHX_ a) #define sv_derived_from(a,b) Perl_sv_derived_from(aTHX_ a,b) @@ -584,7 +601,6 @@ #define sv_len_utf8(a) Perl_sv_len_utf8(aTHX_ a) #define sv_magic(a,b,c,d,e) Perl_sv_magic(aTHX_ a,b,c,d,e) #define sv_magicext(a,b,c,d,e,f) Perl_sv_magicext(aTHX_ a,b,c,d,e,f) -#define sv_mortalcopy(a) Perl_sv_mortalcopy(aTHX_ a) #define sv_newmortal() Perl_sv_newmortal(aTHX) #define sv_newref(a) Perl_sv_newref(aTHX_ a) #define sv_nosharing(a) Perl_sv_nosharing(aTHX_ a) @@ -646,6 +662,7 @@ #define sv_vcatpvf(a,b,c) Perl_sv_vcatpvf(aTHX_ a,b,c) #define sv_vcatpvf_mg(a,b,c) Perl_sv_vcatpvf_mg(aTHX_ a,b,c) #define sv_vcatpvfn(a,b,c,d,e,f,g) Perl_sv_vcatpvfn(aTHX_ a,b,c,d,e,f,g) +#define sv_vcatpvfn_flags(a,b,c,d,e,f,g,h) Perl_sv_vcatpvfn_flags(aTHX_ a,b,c,d,e,f,g,h) #define sv_vsetpvf(a,b,c) Perl_sv_vsetpvf(aTHX_ a,b,c) #define sv_vsetpvf_mg(a,b,c) Perl_sv_vsetpvf_mg(aTHX_ a,b,c) #define sv_vsetpvfn(a,b,c,d,e,f,g) Perl_sv_vsetpvfn(aTHX_ a,b,c,d,e,f,g) @@ -678,7 +695,6 @@ #define utf8n_to_uvuni(a,b,c,d) Perl_utf8n_to_uvuni(aTHX_ a,b,c,d) #define uvchr_to_utf8_flags(a,b,c) Perl_uvchr_to_utf8_flags(aTHX_ a,b,c) #define uvuni_to_utf8_flags(a,b,c) Perl_uvuni_to_utf8_flags(aTHX_ a,b,c) -#define valid_utf8_to_uvchr(a,b) Perl_valid_utf8_to_uvchr(aTHX_ a,b) #define valid_utf8_to_uvuni(a,b) Perl_valid_utf8_to_uvuni(aTHX_ a,b) #define vcmp(a,b) Perl_vcmp(aTHX_ a,b) #define vcroak(a,b) Perl_vcroak(aTHX_ a,b) @@ -712,7 +728,6 @@ #endif #if !(defined(PERL_MAD)) #define newFORM(a,b,c) Perl_newFORM(aTHX_ a,b,c) -#define newMYSUB(a,b,c,d,e) Perl_newMYSUB(aTHX_ a,b,c,d,e) #endif #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) #define my_bzero Perl_my_bzero @@ -743,6 +758,7 @@ #if defined(EBCDIC) #define utf8n_to_uvchr(a,b,c,d) Perl_utf8n_to_uvchr(aTHX_ a,b,c,d) #define uvchr_to_utf8(a,b) Perl_uvchr_to_utf8(aTHX_ a,b) +#define valid_utf8_to_uvchr(a,b) Perl_valid_utf8_to_uvchr(aTHX_ a,b) #endif #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) #define csighandler Perl_csighandler @@ -785,21 +801,14 @@ #define warn_nocontext Perl_warn_nocontext #define warner_nocontext Perl_warner_nocontext #endif -#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) -#define _is_utf8_quotemeta(a) Perl__is_utf8_quotemeta(aTHX_ a) -#endif #if defined(PERL_MAD) #define newFORM(a,b,c) Perl_newFORM(aTHX_ a,b,c) -#define newMYSUB(a,b,c,d,e) Perl_newMYSUB(aTHX_ a,b,c,d,e) -#endif -#if defined(PL_OP_SLAB_ALLOC) -#define Slab_Alloc(a) Perl_Slab_Alloc(aTHX_ a) -#define Slab_Free(a) Perl_Slab_Free(aTHX_ a) #endif #if defined(UNLINK_ALL_VERSIONS) #define unlnk(a) Perl_unlnk(aTHX_ a) #endif #if defined(USE_ITHREADS) +#define alloccopstash(a) Perl_alloccopstash(aTHX_ a) #define any_dup(a,b) Perl_any_dup(aTHX_ a,b) #define cx_dup(a,b,c,d) Perl_cx_dup(aTHX_ a,b,c,d) #define dirp_dup(a,b) Perl_dirp_dup(aTHX_ a,b) @@ -845,30 +854,14 @@ #define PerlIO_unread(a,b,c) Perl_PerlIO_unread(aTHX_ a,b,c) #define PerlIO_write(a,b,c) Perl_PerlIO_write(aTHX_ a,b,c) #endif -#if defined(USE_REENTRANT_API) -#define reentrant_free() Perl_reentrant_free(aTHX) -#define reentrant_init() Perl_reentrant_init(aTHX) -#define reentrant_retry Perl_reentrant_retry -#define reentrant_size() Perl_reentrant_size(aTHX) -#endif #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) #define do_aspawn(a,b,c) Perl_do_aspawn(aTHX_ a,b,c) #define do_spawn(a) Perl_do_spawn(aTHX_ a) #define do_spawn_nowait(a) Perl_do_spawn_nowait(aTHX_ a) #endif #if defined(PERL_CORE) || defined(PERL_EXT) -#define _is_utf8__perl_idstart(a) Perl__is_utf8__perl_idstart(aTHX_ a) #define av_reify(a) Perl_av_reify(aTHX_ a) -#define is_utf8_X_L(a) Perl_is_utf8_X_L(aTHX_ a) -#define is_utf8_X_LV(a) Perl_is_utf8_X_LV(aTHX_ a) -#define is_utf8_X_LVT(a) Perl_is_utf8_X_LVT(aTHX_ a) -#define is_utf8_X_LV_LVT_V(a) Perl_is_utf8_X_LV_LVT_V(aTHX_ a) -#define is_utf8_X_T(a) Perl_is_utf8_X_T(aTHX_ a) -#define is_utf8_X_V(a) Perl_is_utf8_X_V(aTHX_ a) -#define is_utf8_X_begin(a) Perl_is_utf8_X_begin(aTHX_ a) -#define is_utf8_X_extend(a) Perl_is_utf8_X_extend(aTHX_ a) -#define is_utf8_X_non_hangul(a) Perl_is_utf8_X_non_hangul(aTHX_ a) -#define is_utf8_X_prepend(a) Perl_is_utf8_X_prepend(aTHX_ a) +#define current_re_engine() Perl_current_re_engine(aTHX) #define op_clear(a) Perl_op_clear(aTHX_ a) #define qerror(a) Perl_qerror(aTHX_ a) #define reg_named_buff(a,b,c,d) Perl_reg_named_buff(aTHX_ a,b,c,d) @@ -897,44 +890,48 @@ #define dump_exec_pos(a,b,c,d,e,f) S_dump_exec_pos(aTHX_ a,b,c,d,e,f) # endif # endif -# if defined(PERL_IN_DQUOTE_STATIC_C) -#define grok_bslash_c(a,b,c) S_grok_bslash_c(aTHX_ a,b,c) -#define grok_bslash_o(a,b,c,d,e) S_grok_bslash_o(aTHX_ a,b,c,d,e) -#define regcurly(a) S_regcurly(aTHX_ a) +# if defined(PERL_ANY_COW) +#define sv_setsv_cow(a,b) Perl_sv_setsv_cow(aTHX_ a,b) # endif # if defined(PERL_IN_REGCOMP_C) #define _append_range_to_invlist(a,b,c) S__append_range_to_invlist(aTHX_ a,b,c) #define _invlist_array_init(a,b) S__invlist_array_init(aTHX_ a,b) #define _new_invlist_C_array(a) S__new_invlist_C_array(aTHX_ a) -#define add_alternate(a,b,c) S_add_alternate(aTHX_ a,b,c) #define add_cp_to_invlist(a,b) S_add_cp_to_invlist(aTHX_ a,b) #define add_data S_add_data -#define checkposixcc(a) S_checkposixcc(aTHX_ a) +#define alloc_maybe_populate_EXACT(a,b,c,d,e) S_alloc_maybe_populate_EXACT(aTHX_ a,b,c,d,e) #define cl_and S_cl_and #define cl_anything S_cl_anything #define cl_init S_cl_init #define cl_is_anything S_cl_is_anything #define cl_or S_cl_or +#define compute_EXACTish(a) S_compute_EXACTish(aTHX_ a) +#define could_it_be_a_POSIX_class(a) S_could_it_be_a_POSIX_class(aTHX_ a) #define get_invlist_iter_addr(a) S_get_invlist_iter_addr(aTHX_ a) -#define get_invlist_len_addr(a) S_get_invlist_len_addr(aTHX_ a) +#define get_invlist_previous_index_addr(a) S_get_invlist_previous_index_addr(aTHX_ a) #define get_invlist_version_id_addr(a) S_get_invlist_version_id_addr(aTHX_ a) #define get_invlist_zero_addr(a) S_get_invlist_zero_addr(aTHX_ a) +#define grok_bslash_N(a,b,c,d,e,f,g) S_grok_bslash_N(aTHX_ a,b,c,d,e,f,g) +#define handle_regex_sets(a,b,c,d,e) S_handle_regex_sets(aTHX_ a,b,c,d,e) #define invlist_array(a) S_invlist_array(aTHX_ a) #define invlist_clone(a) S_invlist_clone(aTHX_ a) #define invlist_extend(a,b) S_invlist_extend(aTHX_ a,b) +#define invlist_highest(a) S_invlist_highest(aTHX_ a) +#define invlist_is_iterating(a) S_invlist_is_iterating(aTHX_ a) +#define invlist_iterfinish(a) S_invlist_iterfinish(aTHX_ a) #define invlist_iterinit(a) S_invlist_iterinit(aTHX_ a) #define invlist_iternext(a,b,c) S_invlist_iternext(aTHX_ a,b,c) -#define invlist_len(a) S_invlist_len(aTHX_ a) #define invlist_max(a) S_invlist_max(aTHX_ a) -#define invlist_search(a,b) S_invlist_search(aTHX_ a,b) +#define invlist_previous_index(a) S_invlist_previous_index(aTHX_ a) #define invlist_set_len(a,b) S_invlist_set_len(aTHX_ a,b) +#define invlist_set_previous_index(a,b) S_invlist_set_previous_index(aTHX_ a,b) #define invlist_trim(a) S_invlist_trim(aTHX_ a) #define join_exact(a,b,c,d,e,f,g) S_join_exact(aTHX_ a,b,c,d,e,f,g) #define make_trie(a,b,c,d,e,f,g,h) S_make_trie(aTHX_ a,b,c,d,e,f,g,h) #define make_trie_failtable(a,b,c,d) S_make_trie_failtable(aTHX_ a,b,c,d) #define nextchar(a) S_nextchar(aTHX_ a) +#define parse_lparen_question_flags(a) S_parse_lparen_question_flags(aTHX_ a) #define reg(a,b,c,d) S_reg(aTHX_ a,b,c,d) -#define reg_namedseq(a,b,c,d) S_reg_namedseq(aTHX_ a,b,c,d) #define reg_node(a,b) S_reg_node(aTHX_ a,b) #define reg_recode(a,b) S_reg_recode(aTHX_ a,b) #define reg_scan_name(a,b) S_reg_scan_name(aTHX_ a,b) @@ -942,21 +939,35 @@ #define reganode(a,b,c) S_reganode(aTHX_ a,b,c) #define regatom(a,b,c) S_regatom(aTHX_ a,b,c) #define regbranch(a,b,c,d) S_regbranch(aTHX_ a,b,c,d) -#define regclass(a,b) S_regclass(aTHX_ a,b) +#define regclass(a,b,c,d,e,f,g) S_regclass(aTHX_ a,b,c,d,e,f,g) #define reginsert(a,b,c,d) S_reginsert(aTHX_ a,b,c,d) +#define regpatws S_regpatws #define regpiece(a,b,c) S_regpiece(aTHX_ a,b,c) -#define regpposixcc(a,b) S_regpposixcc(aTHX_ a,b) +#define regpposixcc(a,b,c) S_regpposixcc(aTHX_ a,b,c) #define regtail(a,b,c,d) S_regtail(aTHX_ a,b,c,d) #define reguni(a,b,c) S_reguni(aTHX_ a,b,c) #define regwhite S_regwhite #define scan_commit(a,b,c,d) S_scan_commit(aTHX_ a,b,c,d) -#define set_regclass_bit(a,b,c,d,e) S_set_regclass_bit(aTHX_ a,b,c,d,e) -#define set_regclass_bit_fold(a,b,c,d,e) S_set_regclass_bit_fold(aTHX_ a,b,c,d,e) #define study_chunk(a,b,c,d,e,f,g,h,i,j,k) S_study_chunk(aTHX_ a,b,c,d,e,f,g,h,i,j,k) # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) -#define _core_swash_init(a,b,c,d,e,f,g,h) Perl__core_swash_init(aTHX_ a,b,c,d,e,f,g,h) +#define _get_invlist_len_addr(a) S__get_invlist_len_addr(aTHX_ a) +#define _get_swash_invlist(a) Perl__get_swash_invlist(aTHX_ a) +#define _invlist_contains_cp(a,b) S__invlist_contains_cp(aTHX_ a,b) #define _invlist_contents(a) Perl__invlist_contents(aTHX_ a) +#define _invlist_len(a) S__invlist_len(aTHX_ a) +#define _invlist_search(a,b) Perl__invlist_search(aTHX_ a,b) +#define _swash_inversion_hash(a) Perl__swash_inversion_hash(aTHX_ a) +# endif +# if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C) +#define _core_swash_init(a,b,c,d,e,f,g) Perl__core_swash_init(aTHX_ a,b,c,d,e,f,g) +# endif +# if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) +#define form_short_octal_warning(a,b) S_form_short_octal_warning(aTHX_ a,b) +#define grok_bslash_c(a,b,c) S_grok_bslash_c(aTHX_ a,b,c) +#define grok_bslash_o(a,b,c,d,e,f,g) S_grok_bslash_o(aTHX_ a,b,c,d,e,f,g) +#define grok_bslash_x(a,b,c,d,e,f,g) S_grok_bslash_x(aTHX_ a,b,c,d,e,f,g) +#define regcurly(a,b) S_regcurly(aTHX_ a,b) # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) #define _add_range_to_invlist(a,b,c) Perl__add_range_to_invlist(aTHX_ a,b,c) @@ -966,20 +977,21 @@ #define _invlist_populate_swatch(a,b,c,d) Perl__invlist_populate_swatch(aTHX_ a,b,c,d) #define _invlist_union_maybe_complement_2nd(a,b,c,d) Perl__invlist_union_maybe_complement_2nd(aTHX_ a,b,c,d) #define _new_invlist(a) Perl__new_invlist(aTHX_ a) -#define _swash_inversion_hash(a) Perl__swash_inversion_hash(aTHX_ a) #define _swash_to_invlist(a) Perl__swash_to_invlist(aTHX_ a) # endif # if defined(PERL_IN_REGEXEC_C) -#define core_regclass_swash(a,b,c,d,e) S_core_regclass_swash(aTHX_ a,b,c,d,e) -#define find_byclass(a,b,c,d,e) S_find_byclass(aTHX_ a,b,c,d,e) +#define core_regclass_swash(a,b,c,d) S_core_regclass_swash(aTHX_ a,b,c,d) +#define find_byclass(a,b,c,d,e,f) S_find_byclass(aTHX_ a,b,c,d,e,f) +#define isFOO_lc(a,b) S_isFOO_lc(aTHX_ a,b) +#define isFOO_utf8_lc(a,b) S_isFOO_utf8_lc(aTHX_ a,b) #define reg_check_named_buff_matched(a,b) S_reg_check_named_buff_matched(aTHX_ a,b) -#define regcppop(a) S_regcppop(aTHX_ a) -#define regcppush(a) S_regcppush(aTHX_ a) +#define regcppop(a,b) S_regcppop(aTHX_ a,b) +#define regcppush(a,b,c) S_regcppush(aTHX_ a,b,c) #define reghop3 S_reghop3 #define reghopmaybe3 S_reghopmaybe3 -#define reginclass(a,b,c,d,e) S_reginclass(aTHX_ a,b,c,d,e) -#define regmatch(a,b) S_regmatch(aTHX_ a,b) -#define regrepeat(a,b,c,d) S_regrepeat(aTHX_ a,b,c,d) +#define reginclass(a,b,c,d) S_reginclass(aTHX_ a,b,c,d) +#define regmatch(a,b,c) S_regmatch(aTHX_ a,b,c) +#define regrepeat(a,b,c,d,e,f) S_regrepeat(aTHX_ a,b,c,d,e,f) #define regtry(a,b) S_regtry(aTHX_ a,b) #define to_byte_substr(a) S_to_byte_substr(aTHX_ a) #define to_utf8_substr(a) S_to_utf8_substr(aTHX_ a) @@ -990,14 +1002,14 @@ # if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) #define _to_fold_latin1(a,b,c,d) Perl__to_fold_latin1(aTHX_ a,b,c,d) # endif -# if defined(PERL_OLD_COPY_ON_WRITE) -#define sv_setsv_cow(a,b) Perl_sv_setsv_cow(aTHX_ a,b) -# endif #endif #ifdef PERL_CORE +#define Slab_Alloc(a) Perl_Slab_Alloc(aTHX_ a) +#define Slab_Free(a) Perl_Slab_Free(aTHX_ a) #define allocmy(a,b,c) Perl_allocmy(aTHX_ a,b,c) #define amagic_is_enabled(a) Perl_amagic_is_enabled(aTHX_ a) #define apply(a,b,c) Perl_apply(aTHX_ a,b,c) +#define av_extend_guts(a,b,c,d,e) Perl_av_extend_guts(aTHX_ a,b,c,d,e) #define bind_match(a,b,c) Perl_bind_match(aTHX_ a,b,c) #define block_end(a,b) Perl_block_end(aTHX_ a,b) #define block_start(a) Perl_block_start(aTHX_ a) @@ -1008,7 +1020,6 @@ #define check_utf8_print(a,b) Perl_check_utf8_print(aTHX_ a,b) #define ck_anoncode(a) Perl_ck_anoncode(aTHX_ a) #define ck_bitop(a) Perl_ck_bitop(aTHX_ a) -#define ck_chdir(a) Perl_ck_chdir(aTHX_ a) #define ck_cmp(a) Perl_ck_cmp(aTHX_ a) #define ck_concat(a) Perl_ck_concat(aTHX_ a) #define ck_defined(a) Perl_ck_defined(aTHX_ a) @@ -1055,7 +1066,11 @@ #define core_prototype(a,b,c,d) Perl_core_prototype(aTHX_ a,b,c,d) #define coresub_op(a,b,c) Perl_coresub_op(aTHX_ a,b,c) #define create_eval_scope(a) Perl_create_eval_scope(aTHX_ a) +#define croak_no_mem Perl_croak_no_mem +#define croak_popstack Perl_croak_popstack #define cv_ckproto_len_flags(a,b,c,d,e) Perl_cv_ckproto_len_flags(aTHX_ a,b,c,d,e) +#define cv_clone_into(a,b) Perl_cv_clone_into(aTHX_ a,b) +#define cv_forget_slab(a) Perl_cv_forget_slab(aTHX_ a) #define cvgv_set(a,b) Perl_cvgv_set(aTHX_ a,b) #define cvstash_set(a,b) Perl_cvstash_set(aTHX_ a,b) #define deb_stack_all() Perl_deb_stack_all(aTHX) @@ -1080,31 +1095,38 @@ #define dump_packsubs_perl(a,b) Perl_dump_packsubs_perl(aTHX_ a,b) #define dump_sub_perl(a,b) Perl_dump_sub_perl(aTHX_ a,b) #define finalize_optree(a) Perl_finalize_optree(aTHX_ a) +#define find_lexical_cv(a) Perl_find_lexical_cv(aTHX_ a) +#define find_runcv_where(a,b,c) Perl_find_runcv_where(aTHX_ a,b,c) #define find_rundefsv2(a,b) Perl_find_rundefsv2(aTHX_ a,b) #define find_script(a,b,c,d) Perl_find_script(aTHX_ a,b,c,d) #define free_tied_hv_pool() Perl_free_tied_hv_pool(aTHX) -#define get_hash_seed() Perl_get_hash_seed(aTHX) +#define get_hash_seed(a) Perl_get_hash_seed(aTHX_ a) #define get_no_modify() Perl_get_no_modify(aTHX) #define get_opargs() Perl_get_opargs(aTHX) #define gv_try_downgrade(a) Perl_gv_try_downgrade(aTHX_ a) #define hv_ename_add(a,b,c,d) Perl_hv_ename_add(aTHX_ a,b,c,d) #define hv_ename_delete(a,b,c,d) Perl_hv_ename_delete(aTHX_ a,b,c,d) #define init_argv_symbols(a,b) Perl_init_argv_symbols(aTHX_ a,b) +#define init_constants() Perl_init_constants(aTHX) #define init_debugger() Perl_init_debugger(aTHX) #define intro_my() Perl_intro_my(aTHX) #define invert(a) Perl_invert(aTHX_ a) #define io_close(a,b) Perl_io_close(aTHX_ a,b) +#define isALNUM_lazy(a) S_isALNUM_lazy(aTHX_ a) +#define isIDFIRST_lazy(a) S_isIDFIRST_lazy(aTHX_ a) #define jmaybe(a) Perl_jmaybe(aTHX_ a) #define keyword(a,b,c) Perl_keyword(aTHX_ a,b,c) #define list(a) Perl_list(aTHX_ a) #define localize(a,b) Perl_localize(aTHX_ a,b) #define magic_clear_all_env(a,b) Perl_magic_clear_all_env(aTHX_ a,b) +#define magic_cleararylen_p(a,b) Perl_magic_cleararylen_p(aTHX_ a,b) #define magic_clearenv(a,b) Perl_magic_clearenv(aTHX_ a,b) #define magic_clearhint(a,b) Perl_magic_clearhint(aTHX_ a,b) #define magic_clearhints(a,b) Perl_magic_clearhints(aTHX_ a,b) #define magic_clearisa(a,b) Perl_magic_clearisa(aTHX_ a,b) #define magic_clearpack(a,b) Perl_magic_clearpack(aTHX_ a,b) #define magic_clearsig(a,b) Perl_magic_clearsig(aTHX_ a,b) +#define magic_copycallchecker(a,b,c,d,e) Perl_magic_copycallchecker(aTHX_ a,b,c,d,e) #define magic_existspack(a,b) Perl_magic_existspack(aTHX_ a,b) #define magic_freearylen_p(a,b) Perl_magic_freearylen_p(aTHX_ a,b) #define magic_freeovrld(a,b) Perl_magic_freeovrld(aTHX_ a,b) @@ -1120,15 +1142,12 @@ #define magic_getuvar(a,b) Perl_magic_getuvar(aTHX_ a,b) #define magic_getvec(a,b) Perl_magic_getvec(aTHX_ a,b) #define magic_killbackrefs(a,b) Perl_magic_killbackrefs(aTHX_ a,b) -#define magic_len(a,b) Perl_magic_len(aTHX_ a,b) #define magic_nextpack(a,b,c) Perl_magic_nextpack(aTHX_ a,b,c) #define magic_regdata_cnt(a,b) Perl_magic_regdata_cnt(aTHX_ a,b) #define magic_regdatum_get(a,b) Perl_magic_regdatum_get(aTHX_ a,b) -#define magic_regdatum_set(a,b) Perl_magic_regdatum_set(aTHX_ a,b) #define magic_scalarpack(a,b) Perl_magic_scalarpack(aTHX_ a,b) #define magic_set(a,b) Perl_magic_set(aTHX_ a,b) #define magic_set_all_env(a,b) Perl_magic_set_all_env(aTHX_ a,b) -#define magic_setamagic(a,b) Perl_magic_setamagic(aTHX_ a,b) #define magic_setarylen(a,b) Perl_magic_setarylen(aTHX_ a,b) #define magic_setdbline(a,b) Perl_magic_setdbline(aTHX_ a,b) #define magic_setdefelem(a,b) Perl_magic_setdefelem(aTHX_ a,b) @@ -1146,14 +1165,12 @@ #define magic_setutf8(a,b) Perl_magic_setutf8(aTHX_ a,b) #define magic_setuvar(a,b) Perl_magic_setuvar(aTHX_ a,b) #define magic_setvec(a,b) Perl_magic_setvec(aTHX_ a,b) -#define magic_setvstring(a,b) Perl_magic_setvstring(aTHX_ a,b) #define magic_sizepack(a,b) Perl_magic_sizepack(aTHX_ a,b) #define magic_wipepack(a,b) Perl_magic_wipepack(aTHX_ a,b) #define mg_localize(a,b,c) Perl_mg_localize(aTHX_ a,b,c) #define mode_from_discipline(a,b) Perl_mode_from_discipline(aTHX_ a,b) #define mro_isa_changed_in(a) Perl_mro_isa_changed_in(aTHX_ a) #define mro_package_moved(a,b,c,d) Perl_mro_package_moved(aTHX_ a,b,c,d) -#define munge_qwlist_to_paren_list(a) Perl_munge_qwlist_to_paren_list(aTHX_ a) #define my_attrs(a,b) Perl_my_attrs(aTHX_ a,b) #define my_clearenv() Perl_my_clearenv(aTHX) #define my_lstat_flags(a) Perl_my_lstat_flags(aTHX_ a) @@ -1161,11 +1178,13 @@ #define my_swabn Perl_my_swabn #define my_unexec() Perl_my_unexec(aTHX) #define newATTRSUB_flags(a,b,c,d,e,f) Perl_newATTRSUB_flags(aTHX_ a,b,c,d,e,f) +#define newSTUB(a,b) Perl_newSTUB(aTHX_ a,b) #define newXS_len_flags(a,b,c,d,e,f,g) Perl_newXS_len_flags(aTHX_ a,b,c,d,e,f,g) #define nextargv(a) Perl_nextargv(aTHX_ a) #define oopsAV(a) Perl_oopsAV(aTHX_ a) #define oopsHV(a) Perl_oopsHV(aTHX_ a) #define op_const_sv(a,b) Perl_op_const_sv(aTHX_ a,b) +#define op_unscope(a) Perl_op_unscope(aTHX_ a) #define package_version(a) Perl_package_version(aTHX_ a) #define pad_block_start(a) Perl_pad_block_start(aTHX_ a) #define pad_fixup_inner_anons(a,b,c) Perl_pad_fixup_inner_anons(aTHX_ a,b,c) @@ -1173,10 +1192,12 @@ #define pad_leavemy() Perl_pad_leavemy(aTHX) #define pad_push(a,b) Perl_pad_push(aTHX_ a,b) #define pad_swipe(a,b) Perl_pad_swipe(aTHX_ a,b) +#define padlist_store(a,b,c) Perl_padlist_store(aTHX_ a,b,c) #define parse_unicode_opts(a) Perl_parse_unicode_opts(aTHX_ a) #define parser_free(a) Perl_parser_free(aTHX_ a) #define peep(a) Perl_peep(aTHX_ a) -#define pmruntime(a,b,c) Perl_pmruntime(aTHX_ a,b,c) +#define pmruntime(a,b,c,d) Perl_pmruntime(aTHX_ a,b,c,d) +#define re_op_compile(a,b,c,d,e,f,g,h) Perl_re_op_compile(aTHX_ a,b,c,d,e,f,g,h) #define refcounted_he_chain_2hv(a,b) Perl_refcounted_he_chain_2hv(aTHX_ a,b) #define refcounted_he_fetch_pv(a,b,c,d) Perl_refcounted_he_fetch_pv(aTHX_ a,b,c,d) #define refcounted_he_fetch_pvn(a,b,c,d,e) Perl_refcounted_he_fetch_pvn(aTHX_ a,b,c,d,e) @@ -1201,7 +1222,10 @@ #define sv_clean_objs() Perl_sv_clean_objs(aTHX) #define sv_del_backref(a,b) Perl_sv_del_backref(aTHX_ a,b) #define sv_free_arenas() Perl_sv_free_arenas(aTHX) +#define sv_len_utf8_nomg(a) Perl_sv_len_utf8_nomg(aTHX_ a) +#define sv_mortalcopy_flags(a,b) Perl_sv_mortalcopy_flags(aTHX_ a,b) #define sv_ref(a,b,c) Perl_sv_ref(aTHX_ a,b,c) +#define sv_resetpvn(a,b,c) Perl_sv_resetpvn(aTHX_ a,b,c) #define sv_sethek(a,b) Perl_sv_sethek(aTHX_ a,b) #ifndef PERL_IMPLICIT_CONTEXT #define tied_method Perl_tied_method @@ -1233,6 +1257,9 @@ #define package(a) Perl_package(aTHX_ a) #define utilize(a,b,c,d,e) Perl_utilize(aTHX_ a,b,c,d,e) # endif +# if !(defined(_MSC_VER)) +#define magic_regdatum_set(a,b) Perl_magic_regdatum_set(aTHX_ a,b) +# endif # if !defined(HAS_GETENV_LEN) #define getenv_len(a,b) Perl_getenv_len(aTHX_ a,b) # endif @@ -1301,19 +1328,22 @@ #define malloc_good_size Perl_malloc_good_size #define malloced_size Perl_malloced_size # endif +# if defined(PERL_CORE) +#define opslab_force_free(a) Perl_opslab_force_free(aTHX_ a) +#define opslab_free(a) Perl_opslab_free(aTHX_ a) +#define opslab_free_nopad(a) Perl_opslab_free_nopad(aTHX_ a) +#define parser_free_nexttoke_ops(a,b) Perl_parser_free_nexttoke_ops(aTHX_ a,b) +# if defined(PERL_DEBUG_READONLY_OPS) +#define Slab_to_ro(a) Perl_Slab_to_ro(aTHX_ a) +#define Slab_to_rw(a) Perl_Slab_to_rw(aTHX_ a) +# endif +# endif # if defined(PERL_CR_FILTER) # if defined(PERL_IN_TOKE_C) #define cr_textfilter(a,b,c) S_cr_textfilter(aTHX_ a,b,c) #define strip_return(a) S_strip_return(aTHX_ a) # endif # endif -# if defined(PERL_DEBUG_READONLY_OPS) -# if defined(PERL_IN_OP_C) -# if defined(PL_OP_SLAB_ALLOC) -#define Slab_to_rw(a) S_Slab_to_rw(aTHX_ a) -# endif -# endif -# endif # if defined(PERL_IN_AV_C) #define get_aux_mg(a) S_get_aux_mg(aTHX_ a) # endif @@ -1339,22 +1369,21 @@ #define sequence_num(a) S_sequence_num(aTHX_ a) # endif # if defined(PERL_IN_GV_C) -#define gv_get_super_pkg(a,b,c) S_gv_get_super_pkg(aTHX_ a,b,c) #define gv_init_svtype(a,b) S_gv_init_svtype(aTHX_ a,b) #define gv_magicalize_isa(a) S_gv_magicalize_isa(aTHX_ a) -#define gv_magicalize_overload(a) S_gv_magicalize_overload(aTHX_ a) #define require_tie_mod(a,b,c,d,e) S_require_tie_mod(aTHX_ a,b,c,d,e) # endif # if defined(PERL_IN_HV_C) #define clear_placeholders(a,b) S_clear_placeholders(aTHX_ a,b) #define hfreeentries(a) S_hfreeentries(aTHX_ a) -#define hsplit(a) S_hsplit(aTHX_ a) -#define hv_auxinit S_hv_auxinit +#define hsplit(a,b,c) S_hsplit(aTHX_ a,b,c) +#define hv_auxinit(a) S_hv_auxinit(aTHX_ a) #define hv_delete_common(a,b,c,d,e,f,g) S_hv_delete_common(aTHX_ a,b,c,d,e,f,g) #define hv_free_ent_ret(a,b) S_hv_free_ent_ret(aTHX_ a,b) #define hv_magic_check S_hv_magic_check #define hv_notallowed(a,b,c,d) S_hv_notallowed(aTHX_ a,b,c,d) #define new_he() S_new_he(aTHX) +#define ptr_hash S_ptr_hash #define refcounted_he_value(a) S_refcounted_he_value(aTHX_ a) #define save_hek_flags S_save_hek_flags #define share_hek_flags(a,b,c,d) S_share_hek_flags(aTHX_ a,b,c,d) @@ -1385,7 +1414,7 @@ # endif # if defined(PERL_IN_OP_C) #define aassign_common_vars(a) S_aassign_common_vars(aTHX_ a) -#define apply_attrs(a,b,c,d) S_apply_attrs(aTHX_ a,b,c,d) +#define apply_attrs(a,b,c) S_apply_attrs(aTHX_ a,b,c) #define apply_attrs_my(a,b,c,d) S_apply_attrs_my(aTHX_ a,b,c,d) #define bad_type_pv(a,b,c,d,e) S_bad_type_pv(aTHX_ a,b,c,d,e) #define bad_type_sv(a,b,c,d,e) S_bad_type_sv(aTHX_ a,b,c,d,e) @@ -1395,6 +1424,7 @@ #define find_and_forget_pmops(a) S_find_and_forget_pmops(aTHX_ a) #define fold_constants(a) S_fold_constants(aTHX_ a) #define force_list(a) S_force_list(aTHX_ a) +#define forget_pmop(a) S_forget_pmop(aTHX_ a) #define gen_constant_list(a) S_gen_constant_list(aTHX_ a) #define gv_ename(a) S_gv_ename(aTHX_ a) #define inplace_aassign(a) S_inplace_aassign(aTHX_ a) @@ -1411,9 +1441,8 @@ #define no_fh_allowed(a) S_no_fh_allowed(aTHX_ a) #define op_integerize(a) S_op_integerize(aTHX_ a) #define op_std_init(a) S_op_std_init(aTHX_ a) -#define opt_scalarhv(a) S_opt_scalarhv(aTHX_ a) #define pmtrans(a,b,c) S_pmtrans(aTHX_ a,b,c) -#define process_special_blocks(a,b,c) S_process_special_blocks(aTHX_ a,b,c) +#define process_special_blocks(a,b,c,d) S_process_special_blocks(aTHX_ a,b,c,d) #define ref_array_or_hash(a) S_ref_array_or_hash(aTHX_ a) #define refkids(a,b) S_refkids(aTHX_ a,b) #define scalar_mod_type S_scalar_mod_type @@ -1467,7 +1496,7 @@ #define destroy_matcher(a) S_destroy_matcher(aTHX_ a) #define do_smartmatch(a,b,c) S_do_smartmatch(aTHX_ a,b,c) #define docatch(a) S_docatch(aTHX_ a) -#define doeval(a,b,c,d,e) S_doeval(aTHX_ a,b,c,d,e) +#define doeval(a,b,c,d) S_doeval(aTHX_ a,b,c,d) #define dofindlabel(a,b,c,d,e,f) S_dofindlabel(aTHX_ a,b,c,d,e,f) #define doparseform(a) S_doparseform(aTHX_ a) #define dopoptoeval(a) S_dopoptoeval(aTHX_ a) @@ -1486,7 +1515,7 @@ #define save_lines(a,b) S_save_lines(aTHX_ a,b) # endif # if defined(PERL_IN_PP_HOT_C) -#define do_oddball(a,b,c) S_do_oddball(aTHX_ a,b,c) +#define do_oddball(a,b) S_do_oddball(aTHX_ a,b) #define method_common(a,b) S_method_common(aTHX_ a,b) # endif # if defined(PERL_IN_PP_PACK_C) @@ -1570,16 +1599,20 @@ #define filter_gets(a,b) S_filter_gets(aTHX_ a,b) #define find_in_my_stash(a,b) S_find_in_my_stash(aTHX_ a,b) #define force_ident(a,b) S_force_ident(aTHX_ a,b) +#define force_ident_maybe_lex(a) S_force_ident_maybe_lex(aTHX_ a) #define force_next(a) S_force_next(aTHX_ a) #define force_strict_version(a) S_force_strict_version(aTHX_ a) #define force_version(a,b) S_force_version(aTHX_ a,b) #define force_word(a,b,c,d,e) S_force_word(aTHX_ a,b,c,d,e) +#define get_and_check_backslash_N_name(a,b) S_get_and_check_backslash_N_name(aTHX_ a,b) #define incline(a) S_incline(aTHX_ a) #define intuit_method(a,b,c) S_intuit_method(aTHX_ a,b,c) #define intuit_more(a) S_intuit_more(aTHX_ a) #define lop(a,b,c) S_lop(aTHX_ a,b,c) #define missingterm(a) S_missingterm(aTHX_ a) #define no_op(a,b) S_no_op(aTHX_ a,b) +#define parse_ident(a,b,c,d,e) S_parse_ident(aTHX_ a,b,c,d,e) +#define pending_ident() S_pending_ident(aTHX) #define readpipe_override() S_readpipe_override(aTHX) #define scan_const(a) S_scan_const(aTHX_ a) #define scan_formline(a) S_scan_formline(aTHX_ a) @@ -1587,7 +1620,7 @@ #define scan_ident(a,b,c,d,e) S_scan_ident(aTHX_ a,b,c,d,e) #define scan_inputsymbol(a) S_scan_inputsymbol(aTHX_ a) #define scan_pat(a,b) S_scan_pat(aTHX_ a,b) -#define scan_str(a,b,c) S_scan_str(aTHX_ a,b,c) +#define scan_str(a,b,c,d,e) S_scan_str(aTHX_ a,b,c,d,e) #define scan_subst(a) S_scan_subst(aTHX_ a) #define scan_trans(a) S_scan_trans(aTHX_ a) #define scan_word(a,b,c,d,e) S_scan_word(aTHX_ a,b,c,d,e) @@ -1627,7 +1660,6 @@ #define invoke_exception_hook(a,b) S_invoke_exception_hook(aTHX_ a,b) #define mess_alloc() S_mess_alloc(aTHX) #define with_queued_errors(a) S_with_queued_errors(aTHX_ a) -#define write_no_mem() S_write_no_mem(aTHX) # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) #define mem_log_common S_mem_log_common # endif @@ -1753,6 +1785,9 @@ #define magic_setcollxfrm(a,b) Perl_magic_setcollxfrm(aTHX_ a,b) #define mem_collxfrm(a,b,c) Perl_mem_collxfrm(aTHX_ a,b,c) # endif +# if defined(_MSC_VER) +#define magic_regdatum_set(a,b) Perl_magic_regdatum_set(aTHX_ a,b) +# endif #endif #endif /* #ifndef PERL_NO_SHORT_NAMES */ diff --git a/Master/tlpkg/tlperl/lib/CORE/embedvar.h b/Master/tlpkg/tlperl/lib/CORE/embedvar.h index 24d99e96104..e689c5e4fbd 100644 --- a/Master/tlpkg/tlperl/lib/CORE/embedvar.h +++ b/Master/tlpkg/tlperl/lib/CORE/embedvar.h @@ -53,49 +53,21 @@ #define PL_DBtrace (vTHX->IDBtrace) #define PL_Dir (vTHX->IDir) #define PL_Env (vTHX->IEnv) -#define PL_L1Cased (vTHX->IL1Cased) -#define PL_L1PosixAlnum (vTHX->IL1PosixAlnum) -#define PL_L1PosixAlpha (vTHX->IL1PosixAlpha) -#define PL_L1PosixGraph (vTHX->IL1PosixGraph) -#define PL_L1PosixLower (vTHX->IL1PosixLower) -#define PL_L1PosixPrint (vTHX->IL1PosixPrint) -#define PL_L1PosixPunct (vTHX->IL1PosixPunct) -#define PL_L1PosixUpper (vTHX->IL1PosixUpper) -#define PL_L1PosixWord (vTHX->IL1PosixWord) +#define PL_HasMultiCharFold (vTHX->IHasMultiCharFold) +#define PL_L1Posix_ptrs (vTHX->IL1Posix_ptrs) #define PL_LIO (vTHX->ILIO) #define PL_Latin1 (vTHX->ILatin1) #define PL_Mem (vTHX->IMem) #define PL_MemParse (vTHX->IMemParse) #define PL_MemShared (vTHX->IMemShared) -#define PL_OpPtr (vTHX->IOpPtr) -#define PL_OpSlab (vTHX->IOpSlab) -#define PL_OpSpace (vTHX->IOpSpace) -#define PL_PerlSpace (vTHX->IPerlSpace) -#define PL_PosixAlnum (vTHX->IPosixAlnum) -#define PL_PosixAlpha (vTHX->IPosixAlpha) -#define PL_PosixBlank (vTHX->IPosixBlank) -#define PL_PosixCntrl (vTHX->IPosixCntrl) -#define PL_PosixDigit (vTHX->IPosixDigit) -#define PL_PosixGraph (vTHX->IPosixGraph) -#define PL_PosixLower (vTHX->IPosixLower) -#define PL_PosixPrint (vTHX->IPosixPrint) -#define PL_PosixPunct (vTHX->IPosixPunct) -#define PL_PosixSpace (vTHX->IPosixSpace) -#define PL_PosixUpper (vTHX->IPosixUpper) -#define PL_PosixWord (vTHX->IPosixWord) -#define PL_PosixXDigit (vTHX->IPosixXDigit) +#define PL_NonL1NonFinalFold (vTHX->INonL1NonFinalFold) +#define PL_Posix_ptrs (vTHX->IPosix_ptrs) #define PL_Proc (vTHX->IProc) #define PL_Sock (vTHX->ISock) #define PL_StdIO (vTHX->IStdIO) #define PL_Sv (vTHX->ISv) -#define PL_VertSpace (vTHX->IVertSpace) -#define PL_XPerlSpace (vTHX->IXPerlSpace) -#define PL_XPosixBlank (vTHX->IXPosixBlank) -#define PL_XPosixCntrl (vTHX->IXPosixCntrl) -#define PL_XPosixSpace (vTHX->IXPosixSpace) -#define PL_XPosixXDigit (vTHX->IXPosixXDigit) +#define PL_XPosix_ptrs (vTHX->IXPosix_ptrs) #define PL_Xpv (vTHX->IXpv) -#define PL_amagic_generation (vTHX->Iamagic_generation) #define PL_an (vTHX->Ian) #define PL_apiversion (vTHX->Iapiversion) #define PL_argvgv (vTHX->Iargvgv) @@ -177,14 +149,13 @@ #define PL_filemode (vTHX->Ifilemode) #define PL_firstgv (vTHX->Ifirstgv) #define PL_forkprocess (vTHX->Iforkprocess) -#define PL_formfeed (vTHX->Iformfeed) #define PL_formtarget (vTHX->Iformtarget) #define PL_generation (vTHX->Igeneration) #define PL_gensym (vTHX->Igensym) -#define PL_glob_index (vTHX->Iglob_index) #define PL_globalstash (vTHX->Iglobalstash) #define PL_globhook (vTHX->Iglobhook) -#define PL_hash_seed (vTHX->Ihash_seed) +#define PL_hash_rand_bits (vTHX->Ihash_rand_bits) +#define PL_hash_rand_bits_enabled (vTHX->Ihash_rand_bits_enabled) #define PL_hintgv (vTHX->Ihintgv) #define PL_hints (vTHX->Ihints) #define PL_hv_fetch_ent_mh (vTHX->Ihv_fetch_ent_mh) @@ -278,12 +249,9 @@ #define PL_regdummy (vTHX->Iregdummy) #define PL_regex_pad (vTHX->Iregex_pad) #define PL_regex_padav (vTHX->Iregex_padav) -#define PL_reginterp_cnt (vTHX->Ireginterp_cnt) #define PL_registered_mros (vTHX->Iregistered_mros) #define PL_regmatch_slab (vTHX->Iregmatch_slab) #define PL_regmatch_state (vTHX->Iregmatch_state) -#define PL_rehash_seed (vTHX->Irehash_seed) -#define PL_rehash_seed_set (vTHX->Irehash_seed_set) #define PL_replgv (vTHX->Ireplgv) #define PL_restartjmpenv (vTHX->Irestartjmpenv) #define PL_restartop (vTHX->Irestartop) @@ -294,7 +262,9 @@ #define PL_savestack (vTHX->Isavestack) #define PL_savestack_ix (vTHX->Isavestack_ix) #define PL_savestack_max (vTHX->Isavestack_max) +#ifndef PL_sawampersand #define PL_sawampersand (vTHX->Isawampersand) +#endif #define PL_scopestack (vTHX->Iscopestack) #define PL_scopestack_ix (vTHX->Iscopestack_ix) #define PL_scopestack_max (vTHX->Iscopestack_max) @@ -305,8 +275,6 @@ #define PL_sighandlerp (vTHX->Isighandlerp) #define PL_signalhook (vTHX->Isignalhook) #define PL_signals (vTHX->Isignals) -#define PL_slab_count (vTHX->Islab_count) -#define PL_slabs (vTHX->Islabs) #define PL_sort_RealCmp (vTHX->Isort_RealCmp) #define PL_sortcop (vTHX->Isortcop) #define PL_sortstash (vTHX->Isortstash) @@ -317,6 +285,9 @@ #define PL_stack_sp (vTHX->Istack_sp) #define PL_start_env (vTHX->Istart_env) #define PL_stashcache (vTHX->Istashcache) +#define PL_stashpad (vTHX->Istashpad) +#define PL_stashpadix (vTHX->Istashpadix) +#define PL_stashpadmax (vTHX->Istashpadmax) #define PL_statbuf (vTHX->Istatbuf) #define PL_statcache (vTHX->Istatcache) #define PL_statgv (vTHX->Istatgv) @@ -355,37 +326,22 @@ #define PL_unitcheckav_save (vTHX->Iunitcheckav_save) #define PL_unlockhook (vTHX->Iunlockhook) #define PL_unsafe (vTHX->Iunsafe) -#define PL_utf8_X_L (vTHX->Iutf8_X_L) -#define PL_utf8_X_LV (vTHX->Iutf8_X_LV) -#define PL_utf8_X_LVT (vTHX->Iutf8_X_LVT) -#define PL_utf8_X_LV_LVT_V (vTHX->Iutf8_X_LV_LVT_V) -#define PL_utf8_X_T (vTHX->Iutf8_X_T) -#define PL_utf8_X_V (vTHX->Iutf8_X_V) -#define PL_utf8_X_begin (vTHX->Iutf8_X_begin) #define PL_utf8_X_extend (vTHX->Iutf8_X_extend) -#define PL_utf8_X_non_hangul (vTHX->Iutf8_X_non_hangul) -#define PL_utf8_X_prepend (vTHX->Iutf8_X_prepend) -#define PL_utf8_alnum (vTHX->Iutf8_alnum) -#define PL_utf8_alpha (vTHX->Iutf8_alpha) -#define PL_utf8_digit (vTHX->Iutf8_digit) +#define PL_utf8_X_regular_begin (vTHX->Iutf8_X_regular_begin) +#define PL_utf8_charname_begin (vTHX->Iutf8_charname_begin) +#define PL_utf8_charname_continue (vTHX->Iutf8_charname_continue) #define PL_utf8_foldable (vTHX->Iutf8_foldable) #define PL_utf8_foldclosures (vTHX->Iutf8_foldclosures) -#define PL_utf8_graph (vTHX->Iutf8_graph) #define PL_utf8_idcont (vTHX->Iutf8_idcont) #define PL_utf8_idstart (vTHX->Iutf8_idstart) -#define PL_utf8_lower (vTHX->Iutf8_lower) #define PL_utf8_mark (vTHX->Iutf8_mark) +#define PL_utf8_perl_idcont (vTHX->Iutf8_perl_idcont) #define PL_utf8_perl_idstart (vTHX->Iutf8_perl_idstart) -#define PL_utf8_print (vTHX->Iutf8_print) -#define PL_utf8_punct (vTHX->Iutf8_punct) -#define PL_utf8_quotemeta (vTHX->Iutf8_quotemeta) -#define PL_utf8_space (vTHX->Iutf8_space) +#define PL_utf8_swash_ptrs (vTHX->Iutf8_swash_ptrs) #define PL_utf8_tofold (vTHX->Iutf8_tofold) #define PL_utf8_tolower (vTHX->Iutf8_tolower) #define PL_utf8_totitle (vTHX->Iutf8_totitle) #define PL_utf8_toupper (vTHX->Iutf8_toupper) -#define PL_utf8_upper (vTHX->Iutf8_upper) -#define PL_utf8_xdigit (vTHX->Iutf8_xdigit) #define PL_utf8_xidcont (vTHX->Iutf8_xidcont) #define PL_utf8_xidstart (vTHX->Iutf8_xidstart) #define PL_utf8cache (vTHX->Iutf8cache) @@ -415,6 +371,10 @@ #define PL_Gdollarzero_mutex (my_vars->Gdollarzero_mutex) #define PL_fold_locale (my_vars->Gfold_locale) #define PL_Gfold_locale (my_vars->Gfold_locale) +#define PL_hash_seed (my_vars->Ghash_seed) +#define PL_Ghash_seed (my_vars->Ghash_seed) +#define PL_hash_seed_set (my_vars->Ghash_seed_set) +#define PL_Ghash_seed_set (my_vars->Ghash_seed_set) #define PL_hints_mutex (my_vars->Ghints_mutex) #define PL_Ghints_mutex (my_vars->Ghints_mutex) #define PL_keyword_plugin (my_vars->Gkeyword_plugin) diff --git a/Master/tlpkg/tlperl/lib/CORE/fakesdio.h b/Master/tlpkg/tlperl/lib/CORE/fakesdio.h index 614438096e0..094fd006c3e 100644 --- a/Master/tlpkg/tlperl/lib/CORE/fakesdio.h +++ b/Master/tlpkg/tlperl/lib/CORE/fakesdio.h @@ -126,8 +126,8 @@ * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/fakethr.h b/Master/tlpkg/tlperl/lib/CORE/fakethr.h index 7c82aa6d691..643806de26f 100644 --- a/Master/tlpkg/tlperl/lib/CORE/fakethr.h +++ b/Master/tlpkg/tlperl/lib/CORE/fakethr.h @@ -68,8 +68,8 @@ struct thread_intern { * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/feature.h b/Master/tlpkg/tlperl/lib/CORE/feature.h index dc9696ec9c3..215a4d50465 100644 --- a/Master/tlpkg/tlperl/lib/CORE/feature.h +++ b/Master/tlpkg/tlperl/lib/CORE/feature.h @@ -81,6 +81,12 @@ FEATURE_IS_ENABLED("__SUB__")) \ ) +#define FEATURE_LEXSUBS_IS_ENABLED \ + ( \ + CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ + FEATURE_IS_ENABLED("lexsubs") \ + ) + #define FEATURE_UNIEVAL_IS_ENABLED \ ( \ CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_515 \ diff --git a/Master/tlpkg/tlperl/lib/CORE/gv.h b/Master/tlpkg/tlperl/lib/CORE/gv.h index a3932620163..1e17f35d463 100644 --- a/Master/tlpkg/tlperl/lib/CORE/gv.h +++ b/Master/tlpkg/tlperl/lib/CORE/gv.h @@ -83,6 +83,18 @@ struct gp { Return the SV from the GV. +=for apidoc Am|AV*|GvAV|GV* gv + +Return the AV from the GV. + +=for apidoc Am|HV*|GvHV|GV* gv + +Return the HV from the GV. + +=for apidoc Am|CV*|GvCV|GV* gv + +Return the CV from the GV. + =cut */ @@ -223,6 +235,9 @@ Return the SV from the GV. #define GV_NO_SVGMAGIC 0x800 /* Skip get-magic on an SV argument; used only by gv_fetchsv(_nomg) */ +/* Flags for gv_fetchmeth_pvn and gv_autoload_pvn*/ +#define GV_SUPER 0x1000 /* SUPER::method */ + /* Flags for gv_autoload_*/ #define GV_AUTOLOAD_ISMETHOD 1 /* autoloading a method? */ @@ -249,6 +264,13 @@ Return the SV from the GV. #define gv_autoload4(stash, name, len, method) \ gv_autoload_pvn(stash, name, len, !!(method)) #define newGVgen(pack) newGVgen_flags(pack, 0) +#define gv_method_changed(gv) \ + ( \ + assert_(isGV_with_GP(gv)) \ + GvREFCNT(gv) > 1 \ + ? (void)++PL_sub_generation \ + : mro_method_changed_in(GvSTASH(gv)) \ + ) #define gv_AVadd(gv) gv_add_by_type((gv), SVt_PVAV) #define gv_HVadd(gv) gv_add_by_type((gv), SVt_PVHV) @@ -259,8 +281,8 @@ Return the SV from the GV. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/handy.h b/Master/tlpkg/tlperl/lib/CORE/handy.h index c90a8764dd3..582cea638c9 100644 --- a/Master/tlpkg/tlperl/lib/CORE/handy.h +++ b/Master/tlpkg/tlperl/lib/CORE/handy.h @@ -1,22 +1,21 @@ /* handy.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, - * 2001, 2002, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others + * 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2012 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ +#ifndef HANDY_H /* Guard against nested #inclusion */ +#define HANDY_H + #if !defined(__STDC__) #ifdef NULL #undef NULL #endif -#ifndef I286 # define NULL 0 -#else -# define NULL 0L -#endif #endif #ifndef PERL_CORE @@ -105,7 +104,7 @@ Null SV pointer. (No longer available when C<PERL_CORE> is defined.) #endif /* NeXT || __NeXT__ */ #ifndef HAS_BOOL -# if defined(UTS) || defined(VMS) +# if defined(VMS) # define bool int # else # define bool char @@ -127,7 +126,7 @@ Null SV pointer. (No longer available when C<PERL_CORE> 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) || /* Pre-MSVC 7.0 has neither __func__ nor __FUNCTION and no good workarounds, either. */ \ +# if (defined(_MSC_VER) && _MSC_VER < 1300) || /* MSVC6 has neither __func__ nor __FUNCTION and no good workarounds, either. */ \ (defined(__DECC_VER)) /* Tru64 or VMS, and strict C89 being used, but not modern enough cc (in Tur64, -c99 not known, only -std1). */ # define FUNCTION__ "" # else @@ -191,25 +190,29 @@ typedef U64TYPE U64; #endif /* PERL_CORE */ #if defined(HAS_QUAD) && defined(USE_64_BIT_INT) -# ifndef UINT64_C /* usually from <inttypes.h> */ -# if defined(HAS_LONG_LONG) && QUADKIND == QUAD_IS_LONG_LONG -# define INT64_C(c) CAT2(c,LL) -# define UINT64_C(c) CAT2(c,ULL) +# if defined(HAS_LONG_LONG) && QUADKIND == QUAD_IS_LONG_LONG +# define PeRl_INT64_C(c) CAT2(c,LL) +# define PeRl_UINT64_C(c) CAT2(c,ULL) +# else +# if QUADKIND == QUAD_IS___INT64 +# define PeRl_INT64_C(c) CAT2(c,I64) +# define PeRl_UINT64_C(c) CAT2(c,UI64) # else # if LONGSIZE == 8 && QUADKIND == QUAD_IS_LONG -# define INT64_C(c) CAT2(c,L) -# define UINT64_C(c) CAT2(c,UL) +# define PeRl_INT64_C(c) CAT2(c,L) +# define PeRl_UINT64_C(c) CAT2(c,UL) # else -# if defined(_WIN64) && defined(_MSC_VER) -# define INT64_C(c) CAT2(c,I64) -# define UINT64_C(c) CAT2(c,UI64) -# else -# define INT64_C(c) ((I64TYPE)(c)) -# define UINT64_C(c) ((U64TYPE)(c)) -# endif +# define PeRl_INT64_C(c) ((I64TYPE)(c)) +# define PeRl_UINT64_C(c) ((U64TYPE)(c)) # endif # endif # endif +# ifndef UINT64_C +# define UINT64_C(c) PeRl_UINT64_C(c) +# endif +# ifndef INT64_C +# define INT64_C(c) PeRl_INT64_C(c) +# endif #endif #if defined(UINT8_MAX) && defined(INT16_MAX) && defined(INT32_MAX) @@ -339,12 +342,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 */ @@ -470,94 +474,245 @@ C<strncmp>). /* =head1 Character classes -There are three variants for all the functions in this section. The base ones -operate using the character set of the platform Perl is running on. The ones -with an C<_A> suffix operate on the ASCII character set, and the ones with an -C<_L1> suffix operate on the full Latin1 character set. All are unaffected by -locale and by C<use bytes>. - -For ASCII platforms, the base function with no suffix and the one with the -C<_A> suffix are identical. The function with the C<_L1> suffix imposes the -Latin-1 character set onto the platform. That is, the code points that are -ASCII are unaffected, since ASCII is a subset of Latin-1. But the non-ASCII -code points are treated as if they are Latin-1 characters. For example, -C<isSPACE_L1()> will return true when called with the code point 0xA0, which is -the Latin-1 NO-BREAK SPACE. - -For EBCDIC platforms, the base function with no suffix and the one with the -C<_L1> suffix should be identical, since, as of this writing, the EBCDIC code -pages that Perl knows about all are equivalent to Latin-1. The function that -ends in an C<_A> suffix will not return true unless the specified character also -has an ASCII equivalent. +This section is about functions (really macros) that classify characters +into types, such as punctuation versus alphabetic, etc. Most of these are +analogous to regular expression character classes. (See +L<perlrecharclass/POSIX Character Classes>.) There are several variants for +each class. (Not all macros have all variants; each item below lists the +ones valid for it.) None are affected by C<use bytes>, and only the ones +with C<LC> in the name are affected by the current locale. + +The base function, e.g., C<isALPHA()>, takes an octet (either a C<char> or a +C<U8>) as input and returns a boolean as to whether or not the character +represented by that octet is (or on non-ASCII platforms, corresponds to) an +ASCII character in the named class based on platform, Unicode, and Perl rules. +If the input is a number that doesn't fit in an octet, FALSE is returned. + +Variant C<isFOO_A> (e.g., C<isALPHA_A()>) is identical to the base function +with no suffix C<"_A">. + +Variant C<isFOO_L1> imposes the Latin-1 (or EBCDIC equivlalent) character set +onto the platform. That is, the code points that are ASCII are unaffected, +since ASCII is a subset of Latin-1. But the non-ASCII code points are treated +as if they are Latin-1 characters. For example, C<isWORDCHAR_L1()> will return +true when called with the code point 0xDF, which is a word character in both +ASCII and EBCDIC (though it represent different characters in each). + +Variant C<isFOO_uni> is like the C<isFOO_L1> variant, but accepts any UV code +point as input. If the code point is larger than 255, Unicode rules are used +to determine if it is in the character class. For example, +C<isWORDCHAR_uni(0x100)> returns TRUE, since 0x100 is LATIN CAPITAL LETTER A +WITH MACRON in Unicode, and is a word character. + +Variant C<isFOO_utf8> is like C<isFOO_uni>, but the input is a pointer to a +(known to be well-formed) UTF-8 encoded string (C<U8*> or C<char*>). The +classification of just the first (possibly multi-byte) character in the string +is tested. + +Variant C<isFOO_LC> is like the C<isFOO_A> and C<isFOO_L1> variants, but uses +the C library function that gives the named classification instead of +hard-coded rules. For example, C<isDIGIT_LC()> returns the result of calling +C<isdigit()>. This means that the result is based on the current locale, which +is what C<LC> in the name stands for. FALSE is always returned if the input +won't fit into an octet. + +Variant C<isFOO_LC_uvchr> is like C<isFOO_LC>, but is defined on any UV. It +returns the same as C<isFOO_LC> for input code points less than 256, and +returns the hard-coded, not-affected-by-locale, Unicode results for larger ones. + +Variant C<isFOO_LC_utf8> is like C<isFOO_LC_uvchr>, but the input is a pointer to a +(known to be well-formed) UTF-8 encoded string (C<U8*> or C<char*>). The +classification of just the first (possibly multi-byte) character in the string +is tested. =for apidoc Am|bool|isALPHA|char ch Returns a boolean indicating whether the specified character is an -alphabetic character in the platform's native character set. +alphabetic character, analogous to C<m/[[:alpha:]]/>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isALPHA_A>, C<isALPHA_L1>, C<isALPHA_uni>, C<isALPHA_utf8>, C<isALPHA_LC>, +C<isALPHA_LC_uvchr>, and C<isALPHA_LC_utf8>. + +=for apidoc Am|bool|isALPHANUMERIC|char ch +Returns a boolean indicating whether the specified character is a either an +alphabetic character or decimal digit, analogous to C<m/[[:alnum:]]/>. See the L<top of this section|/Character classes> for an explanation of variants -C<isALPHA_A> and C<isALPHA_L1>. +C<isALPHANUMERIC_A>, C<isALPHANUMERIC_L1>, C<isALPHANUMERIC_uni>, +C<isALPHANUMERIC_utf8>, C<isALPHANUMERIC_LC>, C<isALPHANUMERIC_LC_uvchr>, and +C<isALPHANUMERIC_LC_utf8>. =for apidoc Am|bool|isASCII|char ch Returns a boolean indicating whether the specified character is one of the 128 -characters in the ASCII character set. On non-ASCII platforms, it is if this +characters in the ASCII character set, analogous to C<m/[[:ascii:]]/>. +On non-ASCII platforms, it returns TRUE iff this character corresponds to an ASCII character. Variants C<isASCII_A()> and C<isASCII_L1()> are identical to C<isASCII()>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isASCII_uni>, C<isASCII_utf8>, C<isASCII_LC>, C<isASCII_LC_uvchr>, and +C<isASCII_LC_utf8>. Note, however, that some platforms do not have the C +library routine C<isascii()>. In these cases, the variants whose names contain +C<LC> are the same as the corresponding ones without. + +=for apidoc Am|bool|isBLANK|char ch +Returns a boolean indicating whether the specified character is a +character considered to be a blank, analogous to C<m/[[:blank:]]/>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isBLANK_A>, C<isBLANK_L1>, C<isBLANK_uni>, C<isBLANK_utf8>, C<isBLANK_LC>, +C<isBLANK_LC_uvchr>, and C<isBLANK_LC_utf8>. Note, however, that some +platforms do not have the C library routine C<isblank()>. In these cases, the +variants whose names contain C<LC> are the same as the corresponding ones +without. + +=for apidoc Am|bool|isCNTRL|char ch +Returns a boolean indicating whether the specified character is a +control character, analogous to C<m/[[:cntrl:]]/>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isCNTRL_A>, C<isCNTRL_L1>, C<isCNTRL_uni>, C<isCNTRL_utf8>, C<isCNTRL_LC>, +C<isCNTRL_LC_uvchr>, and C<isCNTRL_LC_utf8> +On EBCDIC platforms, you almost always want to use the C<isCNTRL_L1> variant. =for apidoc Am|bool|isDIGIT|char ch Returns a boolean indicating whether the specified character is a -digit in the platform's native character set. +digit, analogous to C<m/[[:digit:]]/>. Variants C<isDIGIT_A> and C<isDIGIT_L1> are identical to C<isDIGIT>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isDIGIT_uni>, C<isDIGIT_utf8>, C<isDIGIT_LC>, C<isDIGIT_LC_uvchr>, and +C<isDIGIT_LC_utf8>. + +=for apidoc Am|bool|isGRAPH|char ch +Returns a boolean indicating whether the specified character is a +graphic character, analogous to C<m/[[:graph:]]/>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isGRAPH_A>, C<isGRAPH_L1>, C<isGRAPH_uni>, C<isGRAPH_utf8>, C<isGRAPH_LC>, +C<isGRAPH_LC_uvchr>, and C<isGRAPH_LC_utf8>. =for apidoc Am|bool|isLOWER|char ch Returns a boolean indicating whether the specified character is a -lowercase character in the platform's native character set. +lowercase character, analogous to C<m/[[:lower:]]/>. See the L<top of this section|/Character classes> for an explanation of variants -C<isLOWER_A> and C<isLOWER_L1>. +C<isLOWER_A>, C<isLOWER_L1>, C<isLOWER_uni>, C<isLOWER_utf8>, C<isLOWER_LC>, +C<isLOWER_LC_uvchr>, and C<isLOWER_LC_utf8>. =for apidoc Am|bool|isOCTAL|char ch Returns a boolean indicating whether the specified character is an -octal digit, [0-7] in the platform's native character set. -Variants C<isOCTAL_A> and C<isOCTAL_L1> are identical to C<isOCTAL>. +octal digit, [0-7]. +The only two variants are C<isOCTAL_A> and C<isOCTAL_L1>; each is identical to +C<isOCTAL>. + +=for apidoc Am|bool|isPUNCT|char ch +Returns a boolean indicating whether the specified character is a +punctuation character, analogous to C<m/[[:punct:]]/>. +Note that the definition of what is punctuation isn't as +straightforward as one might desire. See L<perlrecharclass/POSIX Character +Classes> for details. +See the L<top of this section|/Character classes> for an explanation of variants +C<isPUNCT_A>, C<isPUNCT_L1>, C<isPUNCT_uni>, C<isPUNCT_utf8>, C<isPUNCT_LC>, +C<isPUNCT_LC_uvchr>, and C<isPUNCT_LC_utf8>. =for apidoc Am|bool|isSPACE|char ch Returns a boolean indicating whether the specified character is a -whitespace character in the platform's native character set. This is the same -as what C<\s> matches in a regular expression. +whitespace character. This is analogous +to what C<m/\s/> matches in a regular expression. Starting in Perl 5.18 +(experimentally), this also matches what C<m/[[:space:]]/> does. +("Experimentally" means that this change may be backed out in 5.20 or 5.22 if +field experience indicates that it was unwise.) Prior to 5.18, only the +locale forms of this macro (the ones with C<LC> in their names) matched +precisely what C<m/[[:space:]]/> does. In those releases, the only difference, +in the non-locale variants, was that C<isSPACE()> did not match a vertical tab. +(See L</isPSXSPC> for a macro that matches a vertical tab in all releases.) See the L<top of this section|/Character classes> for an explanation of variants -C<isSPACE_A> and C<isSPACE_L1>. +C<isSPACE_A>, C<isSPACE_L1>, C<isSPACE_uni>, C<isSPACE_utf8>, C<isSPACE_LC>, +C<isSPACE_LC_uvchr>, and C<isSPACE_LC_utf8>. + +=for apidoc Am|bool|isPSXSPC|char ch +(short for Posix Space) +Starting in 5.18, this is identical (experimentally) in all its forms to the +corresponding C<isSPACE()> macros. ("Experimentally" means that this change +may be backed out in 5.20 or 5.22 if field experience indicates that it +was unwise.) +The locale forms of this macro are identical to their corresponding +C<isSPACE()> forms in all Perl releases. In releases prior to 5.18, the +non-locale forms differ from their C<isSPACE()> forms only in that the +C<isSPACE()> forms don't match a Vertical Tab, and the C<isPSXSPC()> forms do. +Otherwise they are identical. Thus this macro is analogous to what +C<m/[[:space:]]/> matches in a regular expression. +See the L<top of this section|/Character classes> for an explanation of variants +C<isPSXSPC_A>, C<isPSXSPC_L1>, C<isPSXSPC_uni>, C<isPSXSPC_utf8>, C<isPSXSPC_LC>, +C<isPSXSPC_LC_uvchr>, and C<isPSXSPC_LC_utf8>. =for apidoc Am|bool|isUPPER|char ch Returns a boolean indicating whether the specified character is an -uppercase character in the platform's native character set. +uppercase character, analogous to C<m/[[:upper:]]/>. See the L<top of this section|/Character classes> for an explanation of variants -C<isUPPER_A> and C<isUPPER_L1>. +C<isUPPER_A>, C<isUPPER_L1>, C<isUPPER_uni>, C<isUPPER_utf8>, C<isUPPER_LC>, +C<isUPPER_LC_uvchr>, and C<isUPPER_LC_utf8>. -=for apidoc Am|bool|isWORDCHAR|char ch +=for apidoc Am|bool|isPRINT|char ch Returns a boolean indicating whether the specified character is a -character that is any of: alphabetic, numeric, or an underscore. This is the -same as what C<\w> matches in a regular expression. -C<isALNUM()> is a synonym provided for backward compatibility. Note that it -does not have the standard C language meaning of alphanumeric, since it matches -an underscore and the standard meaning does not. +printable character, analogous to C<m/[[:print:]]/>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isPRINT_A>, C<isPRINT_L1>, C<isPRINT_uni>, C<isPRINT_utf8>, C<isPRINT_LC>, +C<isPRINT_LC_uvchr>, and C<isPRINT_LC_utf8>. + +=for apidoc Am|bool|isWORDCHAR|char ch +Returns a boolean indicating whether the specified character is a character +that is a word character, analogous to what C<m/\w/> and C<m/[[:word:]]/> match +in a regular expression. A word character is an alphabetic character, a +decimal digit, a connecting punctuation character (such as an underscore), or +a "mark" character that attaches to one of those (like some sort of accent). +C<isALNUM()> is a synonym provided for backward compatibility, even though a +word character includes more than the standard C language meaning of +alphanumeric. See the L<top of this section|/Character classes> for an explanation of variants -C<isWORDCHAR_A> and C<isWORDCHAR_L1>. +C<isWORDCHAR_A>, C<isWORDCHAR_L1>, C<isWORDCHAR_uni>, C<isWORDCHAR_utf8>, +C<isWORDCHAR_LC>, C<isWORDCHAR_LC_uvchr>, and C<isWORDCHAR_LC_utf8>. =for apidoc Am|bool|isXDIGIT|char ch Returns a boolean indicating whether the specified character is a hexadecimal -digit, [0-9A-Fa-f]. Variants C<isXDIGIT_A()> and C<isXDIGIT_L1()> are -identical to C<isXDIGIT()>. +digit. In the ASCII range these are C<[0-9A-Fa-f]>. Variants C<isXDIGIT_A()> +and C<isXDIGIT_L1()> are identical to C<isXDIGIT()>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isXDIGIT_uni>, C<isXDIGIT_utf8>, C<isXDIGIT_LC>, C<isXDIGIT_LC_uvchr>, and +C<isXDIGIT_LC_utf8>. + +=for apidoc Am|bool|isIDFIRST|char ch +Returns a boolean indicating whether the specified character can be the first +character of an identifier. This is very close to, but not quite the same as +the official Unicode property C<XID_Start>. The difference is that this +returns true only if the input character also matches L</isWORDCHAR>. +See the L<top of this section|/Character classes> for an explanation of variants +C<isIDFIRST_A>, C<isIDFIRST_L1>, C<isIDFIRST_uni>, C<isIDFIRST_utf8>, +C<isIDFIRST_LC>, C<isIDFIRST_LC_uvchr>, and C<isIDFIRST_LC_utf8>. + +=for apidoc Am|bool|isIDCONT|char ch +Returns a boolean indicating whether the specified character can be the +second or succeeding character of an identifier. This is very close to, but +not quite the same as the official Unicode property C<XID_Continue>. The +difference is that this returns true only if the input character also matches +L</isWORDCHAR>. See the L<top of this section|/Character classes> for an +explanation of variants C<isIDCONT_A>, C<isIDCONT_L1>, C<isIDCONT_uni>, +C<isIDCONT_utf8>, C<isIDCONT_LC>, C<isIDCONT_LC_uvchr>, and +C<isIDCONT_LC_utf8>. + +=head1 Miscellaneous Functions + +=for apidoc Am|U8|READ_XDIGIT|char str* +Returns the value of an ASCII-range hex digit and advances the string pointer. +Behaviour is only well defined when isXDIGIT(*str) is true. =head1 Character case changing =for apidoc Am|char|toUPPER|char ch -Converts the specified character to uppercase in the platform's native -character set, if possible; otherwise returns the input character itself. +Converts the specified character to uppercase, if possible; otherwise returns +the input character itself. =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. +Converts the specified character to lowercase, if possible; otherwise returns +the input character itself. =cut +XXX Still undocumented isVERTWS_uni and _utf8, and the other toUPPER etc functions + 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 @@ -590,49 +745,124 @@ patched there. The file as of this writing is cpan/Devel-PPPort/parts/inc/misc #define isASCII_A(c) isASCII(c) #define isASCII_L1(c) isASCII(c) +/* The lower 3 bits in both the ASCII and EBCDIC representations of '0' are 0, + * and the 8 possible permutations of those bits exactly comprise the 8 octal + * digits */ +#define isOCTAL_A(c) cBOOL(FITS_IN_8_BITS(c) && (0xF8 & (c)) == '0') + /* ASCII range only */ #ifdef H_PERL /* If have access to perl.h, lookup in its table */ -/* Bits for PL_charclass[]. These use names used in l1_char_class_tab.h but - * their actual definitions are here. If that has a name not used here, it - * won't compile. */ -# define _CC_ALNUMC_A (1<<0) -# define _CC_ALNUMC_L1 (1<<1) -# define _CC_ALPHA_A (1<<2) -# define _CC_ALPHA_L1 (1<<3) -# define _CC_BLANK_A (1<<4) -# define _CC_BLANK_L1 (1<<5) -# define _CC_CHARNAME_CONT (1<<6) -# define _CC_CNTRL_A (1<<7) -# define _CC_CNTRL_L1 (1<<8) -# define _CC_DIGIT_A (1<<9) -# define _CC_GRAPH_A (1<<10) -# define _CC_GRAPH_L1 (1<<11) -# define _CC_IDFIRST_A (1<<12) -# define _CC_IDFIRST_L1 (1<<13) -# define _CC_LOWER_A (1<<14) -# define _CC_LOWER_L1 (1<<15) -# define _CC_OCTAL_A (1<<16) -# define _CC_PRINT_A (1<<17) -# define _CC_PRINT_L1 (1<<18) -# define _CC_PSXSPC_A (1<<19) -# define _CC_PSXSPC_L1 (1<<20) -# define _CC_PUNCT_A (1<<21) -# define _CC_PUNCT_L1 (1<<22) -# define _CC_SPACE_A (1<<23) -# define _CC_SPACE_L1 (1<<24) -# define _CC_UPPER_A (1<<25) -# define _CC_UPPER_L1 (1<<26) -# define _CC_WORDCHAR_A (1<<27) -# define _CC_WORDCHAR_L1 (1<<28) -# define _CC_XDIGIT_A (1<<29) -# define _CC_NONLATIN1_FOLD (1<<30) -# define _CC_QUOTEMETA (1U<<31) /* 1U keeps Solaris from griping */ -/* Unused: None - * If more are needed, can give up some of the above. The first ones to go - * would be those that require just two tests to verify, either there are two - * code points, like BLANK_A, or occupy a single range like OCTAL_A, DIGIT_A, - * UPPER_A, and LOWER_A. - */ + +/* 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 */ +# define _CC_BLANK 11 /* [:blank:] */ +# define _CC_XDIGIT 12 /* [:xdigit:] */ +# define _CC_PSXSPC 13 /* [:space:] */ +# define _CC_CNTRL 14 /* [:cntrl:] */ +# define _CC_ASCII 15 /* [:ascii:] */ +# define _CC_VERTSPACE 16 /* \v */ + +# define _HIGHEST_REGCOMP_DOT_H_SYNC _CC_VERTSPACE + +/* The members of the third group below do not need to be coordinated with data + * structures in regcomp.[ch] and regexec.c */ +# define _CC_IDFIRST 17 +# define _CC_CHARNAME_CONT 18 +# define _CC_NONLATIN1_FOLD 19 +# define _CC_QUOTEMETA 20 +# define _CC_NON_FINAL_FOLD 21 +# define _CC_IS_IN_SOME_FOLD 22 +# define _CC_BACKSLASH_FOO_LBRACE_IS_META 31 /* temp, see mk_PL_charclass.pl */ +/* Unused: 23-30 + * If more bits are needed, one could add a second word for non-64bit + * QUAD_IS_INT systems, using some #ifdefs to distinguish between having a 2nd + * word or not. The IS_IN_SOME_FOLD bit is the most easily expendable, as it + * is used only for optimization (as of this writing), and differs in the + * Latin1 range from the ALPHA bit only in two relatively unimportant + * characters: the masculine and feminine ordinal indicators, so removing it + * would just cause /i regexes which match them to run less efficiently */ + +#if defined(PERL_CORE) || defined(PERL_EXT) +/* An enum version of the character class numbers, to help compilers + * optimize */ +typedef enum { + _CC_ENUM_ALPHA = _CC_ALPHA, + _CC_ENUM_ALPHANUMERIC = _CC_ALPHANUMERIC, + _CC_ENUM_ASCII = _CC_ASCII, + _CC_ENUM_BLANK = _CC_BLANK, + _CC_ENUM_CASED = _CC_CASED, + _CC_ENUM_CNTRL = _CC_CNTRL, + _CC_ENUM_DIGIT = _CC_DIGIT, + _CC_ENUM_GRAPH = _CC_GRAPH, + _CC_ENUM_LOWER = _CC_LOWER, + _CC_ENUM_PRINT = _CC_PRINT, + _CC_ENUM_PSXSPC = _CC_PSXSPC, + _CC_ENUM_PUNCT = _CC_PUNCT, + _CC_ENUM_SPACE = _CC_SPACE, + _CC_ENUM_UPPER = _CC_UPPER, + _CC_ENUM_VERTSPACE = _CC_VERTSPACE, + _CC_ENUM_WORDCHAR = _CC_WORDCHAR, + _CC_ENUM_XDIGIT = _CC_XDIGIT +} _char_class_number; +#endif + +#define POSIX_SWASH_COUNT _FIRST_NON_SWASH_CC +#define POSIX_CC_COUNT (_HIGHEST_REGCOMP_DOT_H_SYNC + 1) + +#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) +# if _CC_WORDCHAR != 0 || _CC_DIGIT != 1 || _CC_ALPHA != 2 || _CC_LOWER != 3 \ + || _CC_UPPER != 4 || _CC_PUNCT != 5 || _CC_PRINT != 6 \ + || _CC_ALPHANUMERIC != 7 || _CC_GRAPH != 8 || _CC_CASED != 9 + #error Need to adjust order of swash_property_names[] +# endif + +/* This is declared static in each of the few files that this is #defined for + * to keep them from being publicly accessible. Hence there is a small amount + * of wasted space */ + +static const char* const swash_property_names[] = { + "XPosixWord", + "XPosixDigit", + "XPosixAlpha", + "XPosixLower", + "XPosixUpper", + "XPosixPunct", + "XPosixPrint", + "XPosixAlnum", + "XPosixGraph", + "Cased" +}; +#endif # ifdef DOINIT EXTCONST U32 PL_charclass[] = { @@ -643,31 +873,50 @@ EXTCONST U32 PL_charclass[] = { EXTCONST U32 PL_charclass[]; # endif -# define isALNUMC_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALNUMC_A)) -# define isALPHA_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALPHA_A)) -# define isBLANK_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_BLANK_A)) -# define isCNTRL_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CNTRL_A)) -# define isDIGIT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_DIGIT_A)) -# define isGRAPH_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_GRAPH_A)) -# define isIDFIRST_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_IDFIRST_A)) -# define isLOWER_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_LOWER_A)) -# define isOCTAL_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_OCTAL_A)) -# define isPRINT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PRINT_A)) -# define isPSXSPC_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PSXSPC_A)) -# define isPUNCT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PUNCT_A)) -# define isSPACE_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_SPACE_A)) -# define isUPPER_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_UPPER_A)) -# define isWORDCHAR_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_WORDCHAR_A)) -# define isXDIGIT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_XDIGIT_A)) + /* The 1U keeps Solaris from griping when shifting sets the uppermost bit */ +# define _CC_mask(classnum) (1U << (classnum)) +# define _generic_isCC(c, classnum) cBOOL(FITS_IN_8_BITS(c) \ + && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_mask(classnum))) + + /* The mask for the _A versions of the macros; it just adds in the bit for + * ASCII. */ +# define _CC_mask_A(classnum) (_CC_mask(classnum) | _CC_mask(_CC_ASCII)) + + /* The _A version makes sure that both the desired bit and the ASCII bit + * are present */ +# define _generic_isCC_A(c, classnum) (FITS_IN_8_BITS(c) \ + && ((PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_mask_A(classnum)) \ + == _CC_mask_A(classnum))) + +# define isALPHA_A(c) _generic_isCC_A(c, _CC_ALPHA) +# define isALPHANUMERIC_A(c) _generic_isCC_A(c, _CC_ALPHANUMERIC) +# define isBLANK_A(c) _generic_isCC_A(c, _CC_BLANK) +# define isCNTRL_A(c) _generic_isCC_A(c, _CC_CNTRL) +# define isDIGIT_A(c) _generic_isCC(c, _CC_DIGIT) +# define isGRAPH_A(c) _generic_isCC_A(c, _CC_GRAPH) +# define isLOWER_A(c) _generic_isCC_A(c, _CC_LOWER) +# define isPRINT_A(c) _generic_isCC_A(c, _CC_PRINT) +# define isPSXSPC_A(c) _generic_isCC_A(c, _CC_PSXSPC) +# define isPUNCT_A(c) _generic_isCC_A(c, _CC_PUNCT) +# define isSPACE_A(c) _generic_isCC_A(c, _CC_SPACE) +# define isUPPER_A(c) _generic_isCC_A(c, _CC_UPPER) +# define isWORDCHAR_A(c) _generic_isCC_A(c, _CC_WORDCHAR) +# define isXDIGIT_A(c) _generic_isCC(c, _CC_XDIGIT) +# define isIDFIRST_A(c) _generic_isCC_A(c, ( _CC_IDFIRST)) + /* Either participates in a fold with a character above 255, or is a * multi-char fold */ -# define _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(c) ((! cBOOL(FITS_IN_8_BITS(c))) || (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_NONLATIN1_FOLD)) -# define _isQUOTEMETA(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_QUOTEMETA)) +# define _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(c) ((! cBOOL(FITS_IN_8_BITS(c))) || (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_mask(_CC_NONLATIN1_FOLD))) + +# define _isQUOTEMETA(c) _generic_isCC(c, _CC_QUOTEMETA) +# define _IS_NON_FINAL_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) \ + _generic_isCC(c, _CC_NON_FINAL_FOLD) +# define _IS_IN_SOME_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c) \ + _generic_isCC(c, _CC_IS_IN_SOME_FOLD) #else /* No perl.h. */ -# define isOCTAL_A(c) ((c) <= '7' && (c) >= '0') # ifdef EBCDIC -# define isALNUMC_A(c) (isASCII(c) && isALNUMC(c)) # define isALPHA_A(c) (isASCII(c) && isALPHA(c)) +# define isALPHANUMERIC_A(c) (isASCII(c) && isALPHANUMERIC(c)) # define isBLANK_A(c) (isASCII(c) && isBLANK(c)) # define isCNTRL_A(c) (isASCII(c) && isCNTRL(c)) # define isDIGIT_A(c) (isASCII(c) && isDIGIT(c)) @@ -682,64 +931,71 @@ EXTCONST U32 PL_charclass[]; # define isWORDCHAR_A(c) (isASCII(c) && isWORDCHAR(c)) # define isXDIGIT_A(c) (isASCII(c) && isXDIGIT(c)) # else /* ASCII platform, no perl.h */ -# define isALNUMC_A(c) (isALPHA_A(c) || isDIGIT_A(c)) # define isALPHA_A(c) (isUPPER_A(c) || isLOWER_A(c)) +# define isALPHANUMERIC_A(c) (isALPHA_A(c) || isDIGIT_A(c)) # define isBLANK_A(c) ((c) == ' ' || (c) == '\t') -# define isCNTRL_A(c) (FITS_IN_8_BITS(c) && ((U8) (c) < ' ' || (c) == 127)) +# define isCNTRL_A(c) (FITS_IN_8_BITS(c) && ((U8) (c) < ' ' || (c) == 127)) # define isDIGIT_A(c) ((c) <= '9' && (c) >= '0') # define isGRAPH_A(c) (isWORDCHAR_A(c) || isPUNCT_A(c)) # define isIDFIRST_A(c) (isALPHA_A(c) || (c) == '_') # define isLOWER_A(c) ((c) >= 'a' && (c) <= 'z') # define isPRINT_A(c) (((c) >= 32 && (c) < 127)) # define isPSXSPC_A(c) (isSPACE_A(c) || (c) == '\v') -# define isPUNCT_A(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) -# define isSPACE_A(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) =='\r' || (c) == '\f') +# define isPUNCT_A(c) (((c) >= 33 && (c) <= 47) \ + || ((c) >= 58 && (c) <= 64) \ + || ((c) >= 91 && (c) <= 96) \ + || ((c) >= 123 && (c) <= 126)) +# define isSPACE_A(c) ((c) == ' ' \ + || (c) == '\t' \ + || (c) == '\n' \ + || (c) =='\r' \ + || (c) == '\f') # define isUPPER_A(c) ((c) <= 'Z' && (c) >= 'A') # define isWORDCHAR_A(c) (isALPHA_A(c) || isDIGIT_A(c) || (c) == '_') -# define isXDIGIT_A(c) (isDIGIT_A(c) || ((c) >= 'a' && (c) <= 'f') || ((c) <= 'F' && (c) >= 'A')) +# define isXDIGIT_A(c) (isDIGIT_A(c) \ + || ((c) >= 'a' && (c) <= 'f') \ + || ((c) <= 'F' && (c) >= 'A')) # endif #endif /* ASCII range definitions */ /* Latin1 definitions */ #ifdef H_PERL -# define isALNUMC_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALNUMC_L1)) -# define isALPHA_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALPHA_L1)) -# define isBLANK_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_BLANK_L1)) +# define isALPHA_L1(c) _generic_isCC(c, _CC_ALPHA) +# define isALPHANUMERIC_L1(c) _generic_isCC(c, _CC_ALPHANUMERIC) +# define isBLANK_L1(c) _generic_isCC(c, _CC_BLANK) + /* continuation character for legal NAME in \N{NAME} */ -# define isCHARNAME_CONT(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CHARNAME_CONT)) -# define isCNTRL_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CNTRL_L1)) -# define isGRAPH_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_GRAPH_L1)) -# define isIDFIRST_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_IDFIRST_L1)) -# define isLOWER_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_LOWER_L1)) -# define isPRINT_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PRINT_L1)) -# define isPSXSPC_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PSXSPC_L1)) -# define isPUNCT_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PUNCT_L1)) -# define isSPACE_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_SPACE_L1)) -# define isUPPER_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_UPPER_L1)) -# define isWORDCHAR_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_WORDCHAR_L1)) +# define isCHARNAME_CONT(c) _generic_isCC(c, _CC_CHARNAME_CONT) + +# define isCNTRL_L1(c) _generic_isCC(c, _CC_CNTRL) +# define isGRAPH_L1(c) _generic_isCC(c, _CC_GRAPH) +# define isLOWER_L1(c) _generic_isCC(c, _CC_LOWER) +# define isPRINT_L1(c) _generic_isCC(c, _CC_PRINT) +# define isPSXSPC_L1(c) _generic_isCC(c, _CC_PSXSPC) +# define isPUNCT_L1(c) _generic_isCC(c, _CC_PUNCT) +# define isSPACE_L1(c) _generic_isCC(c, _CC_SPACE) +# define isUPPER_L1(c) _generic_isCC(c, _CC_UPPER) +# define isWORDCHAR_L1(c) _generic_isCC(c, _CC_WORDCHAR) +# define isIDFIRST_L1(c) _generic_isCC(c, _CC_IDFIRST) #else /* No access to perl.h. Only a few provided here, just in case needed * for backwards compatibility */ /* ALPHAU includes Unicode semantics for latin1 characters. It has an extra * >= AA test to speed up ASCII-only tests at the expense of the others */ # define isALPHA_L1(c) (isALPHA(c) || (NATIVE_TO_UNI((U8) c) >= 0xAA \ && ((NATIVE_TO_UNI((U8) c) >= 0xC0 \ - && NATIVE_TO_UNI((U8) c) != 0xD7 && NATIVE_TO_UNI((U8) c) != 0xF7) \ + && NATIVE_TO_UNI((U8) c) != 0xD7 && NATIVE_TO_UNI((U8) c) != 0xF7) \ || NATIVE_TO_UNI((U8) c) == 0xAA \ || NATIVE_TO_UNI((U8) c) == 0xB5 \ || NATIVE_TO_UNI((U8) c) == 0xBA))) -# define isCHARNAME_CONT(c) (isALNUM_L1(c) || (c) == ' ' || (c) == '-' || (c) == '(' || (c) == ')' || (c) == ':' || NATIVE_TO_UNI((U8) c) == 0xA0) +# define isCHARNAME_CONT(c) (isWORDCHAR_L1(c) \ + || (c) == ' ' \ + || (c) == '-' \ + || (c) == '(' \ + || (c) == ')' \ + || (c) == ':' \ + || NATIVE_TO_UNI((U8) c) == 0xA0) #endif -/* Macros for backwards compatibility and for completeness when the ASCII and - * Latin1 values are identical */ -#define isALNUM(c) isWORDCHAR(c) -#define isALNUMU(c) isWORDCHAR_L1(c) -#define isALPHAU(c) isALPHA_L1(c) -#define isDIGIT_L1(c) isDIGIT_A(c) -#define isOCTAL(c) isOCTAL_A(c) -#define isOCTAL_L1(c) isOCTAL_A(c) -#define isXDIGIT_L1(c) isXDIGIT_A(c) - /* Macros that differ between EBCDIC and ASCII. Where C89 defines a function, * that is used in the EBCDIC form, because in EBCDIC we do not do locales: * therefore can use native functions. For those where C89 doesn't define a @@ -747,8 +1003,8 @@ EXTCONST U32 PL_charclass[]; * with Latin1, which the three currently recognized by Perl are. Some libc's * have an isblank(), but it's not guaranteed. */ #ifdef EBCDIC -# define isALNUMC(c) isalnum(c) # define isALPHA(c) isalpha(c) +# define isALPHANUMERIC(c) isalnum(c) # define isBLANK(c) ((c) == ' ' || (c) == '\t' || NATIVE_TO_UNI(c) == 0xA0) # define isCNTRL(c) iscntrl(c) # define isDIGIT(c) isdigit(c) @@ -758,14 +1014,15 @@ EXTCONST U32 PL_charclass[]; # define isPRINT(c) isprint(c) # define isPSXSPC(c) isspace(c) # define isPUNCT(c) ispunct(c) -# define isSPACE(c) (isPSXSPC(c) && (c) != '\v') +# define isSPACE(c) (isPSXSPC(c) /* && (c) != '\v' (Experimentally making + these macros identical) */) # define isUPPER(c) isupper(c) # define isXDIGIT(c) isxdigit(c) # define isWORDCHAR(c) (isalnum(c) || (c) == '_') # define toLOWER(c) tolower(c) # define toUPPER(c) toupper(c) #else /* Not EBCDIC: ASCII-only matching */ -# define isALNUMC(c) isALNUMC_A(c) +# define isALPHANUMERIC(c) isALPHANUMERIC_A(c) # define isALPHA(c) isALPHA_A(c) # define isBLANK(c) isBLANK_A(c) # define isCNTRL(c) isCNTRL_A(c) @@ -807,215 +1064,318 @@ EXTCONST U32 PL_charclass[]; #ifdef USE_NEXT_CTYPE -# define isALNUM_LC(c) \ - (NXIsAlNum((unsigned int)(c)) || (char)(c) == '_') -# define isIDFIRST_LC(c) \ - (NXIsAlpha((unsigned int)(c)) || (char)(c) == '_') +# define isALPHANUMERIC_LC(c) NXIsAlNum((unsigned int)(c)) # define isALPHA_LC(c) NXIsAlpha((unsigned int)(c)) # define isASCII_LC(c) isASCII((unsigned int)(c)) # define isBLANK_LC(c) isBLANK((unsigned int)(c)) -# define isSPACE_LC(c) NXIsSpace((unsigned int)(c)) -# define isDIGIT_LC(c) NXIsDigit((unsigned int)(c)) -# define isUPPER_LC(c) NXIsUpper((unsigned int)(c)) -# define isLOWER_LC(c) NXIsLower((unsigned int)(c)) -# define isALNUMC_LC(c) NXIsAlNum((unsigned int)(c)) # define isCNTRL_LC(c) NXIsCntrl((unsigned int)(c)) +# define isDIGIT_LC(c) NXIsDigit((unsigned int)(c)) # define isGRAPH_LC(c) NXIsGraph((unsigned int)(c)) +# define isIDFIRST_LC(c) (NXIsAlpha((unsigned int)(c)) || (char)(c) == '_') +# define isLOWER_LC(c) NXIsLower((unsigned int)(c)) # define isPRINT_LC(c) NXIsPrint((unsigned int)(c)) # define isPUNCT_LC(c) NXIsPunct((unsigned int)(c)) -# define toUPPER_LC(c) NXToUpper((unsigned int)(c)) +# define isSPACE_LC(c) NXIsSpace((unsigned int)(c)) +# define isUPPER_LC(c) NXIsUpper((unsigned int)(c)) +# define isWORDCHAR_LC(c) (NXIsAlNum((unsigned int)(c)) || (char)(c) == '_') +# define isXDIGIT_LC(c) NXIsXDigit((unsigned int)(c)) # define toLOWER_LC(c) NXToLower((unsigned int)(c)) +# define toUPPER_LC(c) NXToUpper((unsigned int)(c)) #else /* !USE_NEXT_CTYPE */ # if defined(CTYPE256) || (!defined(isascii) && !defined(HAS_ISASCII)) -/* Note that the foo_LC() macros in this case generally are defined only on - * code points 0-256, and give undefined, unwarned results if called with - * values outside that range */ +/* Use foo_LC_uvchr() instead of these for beyond the Latin1 range */ -# define isALNUM_LC(c) (isalnum((unsigned char)(c)) || (char)(c) == '_') -# define isIDFIRST_LC(c) (isalpha((unsigned char)(c)) || (char)(c) == '_') -# define isALPHA_LC(c) isalpha((unsigned char)(c)) +# define isALPHA_LC(c) (FITS_IN_8_BITS(c) && isalpha((unsigned char)(c))) +# define isALPHANUMERIC_LC(c) (FITS_IN_8_BITS(c) \ + && isalnum((unsigned char)(c))) # ifdef HAS_ISASCII -# define isASCII_LC(c) isascii((unsigned char)(c)) +# define isASCII_LC(c) (FITS_IN_8_BITS(c) && isascii((unsigned char)(c))) # else -# define isASCII_LC(c) isASCII((unsigned char)(c)) +# define isASCII_LC(c) (FITS_IN_8_BITS(c) && isASCII((unsigned char)(c))) # endif # ifdef HAS_ISBLANK -# define isBLANK_LC(c) isblank((unsigned char)(c)) +# define isBLANK_LC(c) (FITS_IN_8_BITS(c) && isblank((unsigned char)(c))) # else -# define isBLANK_LC(c) isBLANK((unsigned char)(c)) +# define isBLANK_LC(c) (FITS_IN_8_BITS(c) && isBLANK((unsigned char)(c))) # endif -# define isSPACE_LC(c) isspace((unsigned char)(c)) -# define isDIGIT_LC(c) isdigit((unsigned char)(c)) -# define isUPPER_LC(c) isupper((unsigned char)(c)) -# define isLOWER_LC(c) islower((unsigned char)(c)) -# define isALNUMC_LC(c) isalnum((unsigned char)(c)) -# define isCNTRL_LC(c) iscntrl((unsigned char)(c)) -# define isGRAPH_LC(c) isgraph((unsigned char)(c)) -# define isPRINT_LC(c) isprint((unsigned char)(c)) -# define isPUNCT_LC(c) ispunct((unsigned char)(c)) -# define toUPPER_LC(c) toupper((unsigned char)(c)) -# define toLOWER_LC(c) tolower((unsigned char)(c)) +# define isCNTRL_LC(c) (FITS_IN_8_BITS(c) && iscntrl((unsigned char)(c))) +# define isDIGIT_LC(c) (FITS_IN_8_BITS(c) && isdigit((unsigned char)(c))) +# define isGRAPH_LC(c) (FITS_IN_8_BITS(c) && isgraph((unsigned char)(c))) +# define isIDFIRST_LC(c) (FITS_IN_8_BITS(c) \ + && (isalpha((unsigned char)(c)) || (char)(c) == '_')) +# define isLOWER_LC(c) (FITS_IN_8_BITS(c) && islower((unsigned char)(c))) +# define isPRINT_LC(c) (FITS_IN_8_BITS(c) && isprint((unsigned char)(c))) +# define isPUNCT_LC(c) (FITS_IN_8_BITS(c) && ispunct((unsigned char)(c))) +# define isSPACE_LC(c) (FITS_IN_8_BITS(c) && isspace((unsigned char)(c))) +# define isUPPER_LC(c) (FITS_IN_8_BITS(c) && isupper((unsigned char)(c))) +# define isWORDCHAR_LC(c) (FITS_IN_8_BITS(c) \ + && (isalnum((unsigned char)(c)) || (char)(c) == '_')) +# define isXDIGIT_LC(c) (FITS_IN_8_BITS(c) && isxdigit((unsigned char)(c))) +# define toLOWER_LC(c) (FITS_IN_8_BITS(c) ? tolower((unsigned char)(c)) : (c)) +# define toUPPER_LC(c) (FITS_IN_8_BITS(c) ? toupper((unsigned char)(c)) : (c)) # else -# define isALNUM_LC(c) (isascii(c) && (isalnum(c) || (c) == '_')) -# define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_')) # define isALPHA_LC(c) (isascii(c) && isalpha(c)) +# define isALPHANUMERIC_LC(c) (isascii(c) && isalnum(c)) # define isASCII_LC(c) isascii(c) # ifdef HAS_ISBLANK # define isBLANK_LC(c) (isascii(c) && isblank(c)) # else -# define isBLANK_LC(c) isBLANK(c) +# define isBLANK_LC(c) isBLANK_A(c) # endif -# define isSPACE_LC(c) (isascii(c) && isspace(c)) -# define isDIGIT_LC(c) (isascii(c) && isdigit(c)) -# define isUPPER_LC(c) (isascii(c) && isupper(c)) -# define isLOWER_LC(c) (isascii(c) && islower(c)) -# define isALNUMC_LC(c) (isascii(c) && isalnum(c)) # define isCNTRL_LC(c) (isascii(c) && iscntrl(c)) +# define isDIGIT_LC(c) (isascii(c) && isdigit(c)) # define isGRAPH_LC(c) (isascii(c) && isgraph(c)) +# define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_')) +# define isLOWER_LC(c) (isascii(c) && islower(c)) # define isPRINT_LC(c) (isascii(c) && isprint(c)) # define isPUNCT_LC(c) (isascii(c) && ispunct(c)) -# define toUPPER_LC(c) toupper(c) -# define toLOWER_LC(c) tolower(c) +# define isSPACE_LC(c) (isascii(c) && isspace(c)) +# define isUPPER_LC(c) (isascii(c) && isupper(c)) +# define isWORDCHAR_LC(c) (isascii(c) && (isalnum(c) || (c) == '_')) +# define isXDIGIT_LC(c) (isascii(c) && isxdigit(c)) +# define toLOWER_LC(c) (isascii(c) ? tolower(c) : (c)) +# define toUPPER_LC(c) (isascii(c) ? toupper(c) : (c)) # endif #endif /* USE_NEXT_CTYPE */ -#define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v') +#define isIDCONT(c) isWORDCHAR(c) +#define isIDCONT_A(c) isWORDCHAR_A(c) +#define isIDCONT_L1(c) isWORDCHAR_L1(c) +#define isIDCONT_LC(c) isWORDCHAR_LC(c) +#define isPSXSPC_LC(c) isSPACE_LC(c) + +/* For internal core Perl use only. If the input is Latin1, use the Latin1 + * macro; otherwise use the function 'above_latin1'. Won't compile if 'c' isn't unsigned, as + * won't match above_latin1 prototype. The macros do bounds checking, so have + * duplicate checks here, so could create versions of the macros that don't, + * but experiments show that gcc optimizes them out anyway. */ -/* For use in the macros just below. If the input is Latin1, use the Latin1 - * (_L1) version of the macro; otherwise use the function. Won't compile if - * 'c' isn't unsigned, as won't match function prototype. The macros do bounds - * checking, so have duplicate checks here, so could create versions of the - * macros that don't, but experiments show that gcc optimizes them out anyway. - */ -#define generic_uni(macro, function, c) ((c) < 256 \ - ? CAT2(macro, _L1)(c) \ - : function(c)) /* Note that all ignore 'use bytes' */ +#define _generic_uni(classnum, above_latin1, c) ((c) < 256 \ + ? _generic_isCC(c, classnum) \ + : above_latin1(c)) +#define _generic_swash_uni(classnum, c) ((c) < 256 \ + ? _generic_isCC(c, classnum) \ + : _is_uni_FOO(classnum, c)) +#define isALPHA_uni(c) _generic_swash_uni(_CC_ALPHA, c) +#define isALPHANUMERIC_uni(c) _generic_swash_uni(_CC_ALPHANUMERIC, c) +#define isASCII_uni(c) isASCII(c) +#define isBLANK_uni(c) _generic_uni(_CC_BLANK, is_HORIZWS_cp_high, c) +#define isCNTRL_uni(c) isCNTRL_L1(c) /* All controls are in Latin1 */ +#define isDIGIT_uni(c) _generic_swash_uni(_CC_DIGIT, c) +#define isGRAPH_uni(c) _generic_swash_uni(_CC_GRAPH, c) +#define isIDCONT_uni(c) _generic_uni(_CC_WORDCHAR, _is_uni_perl_idcont, c) +#define isIDFIRST_uni(c) _generic_uni(_CC_IDFIRST, _is_uni_perl_idstart, c) +#define isLOWER_uni(c) _generic_swash_uni(_CC_LOWER, c) +#define isPRINT_uni(c) _generic_swash_uni(_CC_PRINT, c) + +/* Posix and regular space are identical above Latin1 */ +#define isPSXSPC_uni(c) _generic_uni(_CC_PSXSPC, is_XPERLSPACE_cp_high, c) + +#define isPUNCT_uni(c) _generic_swash_uni(_CC_PUNCT, c) +#define isSPACE_uni(c) _generic_uni(_CC_SPACE, is_XPERLSPACE_cp_high, c) +#define isUPPER_uni(c) _generic_swash_uni(_CC_UPPER, c) +#define isVERTWS_uni(c) _generic_uni(_CC_VERTSPACE, is_VERTWS_cp_high, c) +#define isWORDCHAR_uni(c) _generic_swash_uni(_CC_WORDCHAR, c) +#define isXDIGIT_uni(c) _generic_uni(_CC_XDIGIT, is_XDIGIT_cp_high, c) -#define isALNUM_uni(c) generic_uni(isWORDCHAR, is_uni_alnum, c) -#define isIDFIRST_uni(c) generic_uni(isIDFIRST, is_uni_idfirst, c) -#define isALPHA_uni(c) generic_uni(isALPHA, is_uni_alpha, c) -#define isSPACE_uni(c) generic_uni(isSPACE, is_uni_space, c) -#define isDIGIT_uni(c) generic_uni(isDIGIT, is_uni_digit, c) -#define isUPPER_uni(c) generic_uni(isUPPER, is_uni_upper, c) -#define isLOWER_uni(c) generic_uni(isLOWER, is_uni_lower, c) -#define isASCII_uni(c) isASCII(c) -/* All controls are in Latin1 */ -#define isCNTRL_uni(c) ((c) < 256 && isCNTRL_L1(c)) -#define isGRAPH_uni(c) generic_uni(isGRAPH, is_uni_graph, c) -#define isPRINT_uni(c) generic_uni(isPRINT, is_uni_print, c) -#define isPUNCT_uni(c) generic_uni(isPUNCT, is_uni_punct, c) -#define isXDIGIT_uni(c) generic_uni(isXDIGIT, is_uni_xdigit, c) -#define toUPPER_uni(c,s,l) to_uni_upper(c,s,l) -#define toTITLE_uni(c,s,l) to_uni_title(c,s,l) -#define toLOWER_uni(c,s,l) to_uni_lower(c,s,l) #define toFOLD_uni(c,s,l) to_uni_fold(c,s,l) +#define toLOWER_uni(c,s,l) to_uni_lower(c,s,l) +#define toTITLE_uni(c,s,l) to_uni_title(c,s,l) +#define toUPPER_uni(c,s,l) to_uni_upper(c,s,l) -/* Posix and regular space differ only in U+000B, which is in Latin1 */ -#define isPSXSPC_uni(c) ((c) < 256 ? isPSXSPC_L1(c) : isSPACE_uni(c)) -#define isBLANK_uni(c) isBLANK(c) /* could be wrong */ - -#define isALNUM_LC_uvchr(c) (c < 256 ? isALNUM_LC(c) : is_uni_alnum_lc(c)) -#define isIDFIRST_LC_uvchr(c) (c < 256 ? isIDFIRST_LC(c) : is_uni_idfirst_lc(c)) -#define isALPHA_LC_uvchr(c) (c < 256 ? isALPHA_LC(c) : is_uni_alpha_lc(c)) -#define isSPACE_LC_uvchr(c) (c < 256 ? isSPACE_LC(c) : is_uni_space_lc(c)) -#define isDIGIT_LC_uvchr(c) (c < 256 ? isDIGIT_LC(c) : is_uni_digit_lc(c)) -#define isUPPER_LC_uvchr(c) (c < 256 ? isUPPER_LC(c) : is_uni_upper_lc(c)) -#define isLOWER_LC_uvchr(c) (c < 256 ? isLOWER_LC(c) : is_uni_lower_lc(c)) -#define isCNTRL_LC_uvchr(c) (c < 256 ? isCNTRL_LC(c) : is_uni_cntrl_lc(c)) -#define isGRAPH_LC_uvchr(c) (c < 256 ? isGRAPH_LC(c) : is_uni_graph_lc(c)) -#define isPRINT_LC_uvchr(c) (c < 256 ? isPRINT_LC(c) : is_uni_print_lc(c)) -#define isPUNCT_LC_uvchr(c) (c < 256 ? isPUNCT_LC(c) : is_uni_punct_lc(c)) - -#define isPSXSPC_LC_uni(c) (isSPACE_LC_uni(c) ||(c) == '\f') -#define isBLANK_LC_uni(c) isBLANK(c) /* could be wrong */ - -/* For use in the macros just below. If the input is ASCII, use the ASCII (_A) - * version of the macro; if the input is in the upper Latin1 range, use the - * Latin1 (_L1) version of the macro, after converting from utf8; otherwise use - * the function. This relies on the fact that ASCII characters have the same - * representation whether utf8 or not */ -#define generic_utf8(macro, function, p) (isASCII(*(p)) \ - ? CAT2(CAT2(macro,_),A)(*(p)) \ - : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ - ? CAT2(macro, _L1) \ - (TWO_BYTE_UTF8_TO_UNI(*(p), \ - *((p)+1))) \ - : function(p)) - -/* Note that all assume that the utf8 has been validated, and ignore 'use +#define _generic_LC_uvchr(latin1, above_latin1, c) \ + (c < 256 ? latin1(c) : above_latin1(c)) +#define _generic_LC_swash_uvchr(latin1, classnum, c) \ + (c < 256 ? latin1(c) : _is_uni_FOO(classnum, c)) + +#define isALPHA_LC_uvchr(c) _generic_LC_swash_uvchr(isALPHA_LC, _CC_ALPHA, c) +#define isALPHANUMERIC_LC_uvchr(c) _generic_LC_swash_uvchr(isALPHANUMERIC_LC, \ + _CC_ALPHANUMERIC, c) +#define isASCII_LC_uvchr(c) isASCII_LC(c) +#define isBLANK_LC_uvchr(c) _generic_LC_uvchr(isBLANK_LC, is_HORIZWS_cp_high, c) +#define isCNTRL_LC_uvchr(c) (c < 256 ? isCNTRL_LC(c) : 0) +#define isDIGIT_LC_uvchr(c) _generic_LC_swash_uvchr(isDIGIT_LC, _CC_DIGIT, c) +#define isGRAPH_LC_uvchr(c) _generic_LC_swash_uvchr(isGRAPH_LC, _CC_GRAPH, c) +#define isIDCONT_LC_uvchr(c) _generic_LC_uvchr(isIDCONT_LC, \ + _is_uni_perl_idcont, c) +#define isIDFIRST_LC_uvchr(c) _generic_LC_uvchr(isIDFIRST_LC, \ + _is_uni_perl_idstart, c) +#define isLOWER_LC_uvchr(c) _generic_LC_swash_uvchr(isLOWER_LC, _CC_LOWER, c) +#define isPRINT_LC_uvchr(c) _generic_LC_swash_uvchr(isPRINT_LC, _CC_PRINT, c) +#define isPSXSPC_LC_uvchr(c) isSPACE_LC_uvchr(c) /* space is identical to posix + space under locale */ +#define isPUNCT_LC_uvchr(c) _generic_LC_swash_uvchr(isPUNCT_LC, _CC_PUNCT, c) +#define isSPACE_LC_uvchr(c) _generic_LC_uvchr(isSPACE_LC, \ + is_XPERLSPACE_cp_high, c) +#define isUPPER_LC_uvchr(c) _generic_LC_swash_uvchr(isUPPER_LC, _CC_UPPER, c) +#define isWORDCHAR_LC_uvchr(c) _generic_LC_swash_uvchr(isWORDCHAR_LC, \ + _CC_WORDCHAR, c) +#define isXDIGIT_LC_uvchr(c) _generic_LC_uvchr(isXDIGIT_LC, is_XDIGIT_cp_high, c) + + +#define isBLANK_LC_uni(c) isBLANK_LC_uvchr(UNI_TO_NATIVE(c)) + +/* Everything whose name begins with an underscore is for internal core Perl + * use only. */ + +/* If the input is in the Latin1 range, use + * the Latin1 macro 'classnum' on 'p' which is a pointer to a UTF-8 string. + * Otherwise use the value given by the 'utf8' parameter. This relies on the + * fact that ASCII characters have the same representation whether utf8 or not. + * Note that it assumes that the utf8 has been validated, and ignores 'use * bytes' */ +#define _generic_utf8(classnum, p, utf8) (UTF8_IS_INVARIANT(*(p)) \ + ? _generic_isCC(*(p), classnum) \ + : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ + ? _generic_isCC( \ + TWO_BYTE_UTF8_TO_UNI(*(p), \ + *((p)+1 )), \ + classnum) \ + : utf8) +/* Like the above, but calls 'above_latin1(p)' to get the utf8 value. 'above_latin1' + * can be a macro */ +#define _generic_func_utf8(classnum, above_latin1, p) \ + _generic_utf8(classnum, p, above_latin1(p)) +/* Like the above, but passes classnum to _isFOO_utf8(), instead of having a + * 'above_latin1' parameter */ +#define _generic_swash_utf8(classnum, p) \ + _generic_utf8(classnum, p, _is_utf8_FOO(classnum, p)) + +/* Like the above, but should be used only when it is known that there are no + * characters in the range 128-255 which the class is TRUE for. Hence it can + * skip the tests for this range. 'above_latin1' should include its arguments */ +#define _generic_utf8_no_upper_latin1(classnum, p, above_latin1) \ + (UTF8_IS_INVARIANT(*(p)) \ + ? _generic_isCC(*(p), classnum) \ + : (UTF8_IS_ABOVE_LATIN1(*(p))) \ + ? above_latin1 \ + : 0) + +/* NOTE that some of these macros have very similar ones in regcharclass.h. + * For example, there is (at the time of this writing) an 'is_SPACE_utf8()' + * there, differing in name only by an underscore from the one here + * 'isSPACE_utf8(). The difference is that the ones here are probably more + * efficient and smaller, using an O(1) array lookup for Latin1-range code + * points; the regcharclass.h ones are implemented as a series of + * "if-else-if-else ..." */ + +#define isALPHA_utf8(p) _generic_swash_utf8(_CC_ALPHA, p) +#define isALPHANUMERIC_utf8(p) _generic_swash_utf8(_CC_ALPHANUMERIC, p) +#define isASCII_utf8(p) isASCII(*p) /* Because ASCII is invariant under + utf8, the non-utf8 macro works + */ +#define isBLANK_utf8(p) _generic_func_utf8(_CC_BLANK, is_HORIZWS_high, p) +#define isCNTRL_utf8(p) _generic_utf8(_CC_CNTRL, p, 0) +#define isDIGIT_utf8(p) _generic_utf8_no_upper_latin1(_CC_DIGIT, p, \ + _is_utf8_FOO(_CC_DIGIT, p)) +#define isGRAPH_utf8(p) _generic_swash_utf8(_CC_GRAPH, p) +#define isIDCONT_utf8(p) _generic_func_utf8(_CC_WORDCHAR, \ + _is_utf8_perl_idcont, p) -#define isALNUM_utf8(p) generic_utf8(isWORDCHAR, is_utf8_alnum, p) /* To prevent S_scan_word in toke.c from hanging, we have to make sure that * IDFIRST is an alnum. See * http://rt.perl.org/rt3/Ticket/Display.html?id=74022 for more detail than you - * ever wanted to know about. XXX It is unclear if this should extend to - * isIDFIRST_uni() which it hasn't so far. (In the ASCII range, there isn't a - * difference.) This used to be not the XID version, but we decided to go with - * the more modern Unicode definition */ -#define isIDFIRST_utf8(p) (isASCII(*(p)) \ - ? isIDFIRST_A(*(p)) \ - : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ - ? isIDFIRST_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \ - *((p)+1)))\ - : Perl__is_utf8__perl_idstart(aTHX_ p)) -#define isIDCONT_utf8(p) generic_utf8(isWORDCHAR, is_utf8_xidcont, p) -#define isALPHA_utf8(p) generic_utf8(isALPHA, is_utf8_alpha, p) -#define isSPACE_utf8(p) generic_utf8(isSPACE, is_utf8_space, p) -#define isDIGIT_utf8(p) generic_utf8(isDIGIT, is_utf8_digit, p) -#define isUPPER_utf8(p) generic_utf8(isUPPER, is_utf8_upper, p) -#define isLOWER_utf8(p) generic_utf8(isLOWER, is_utf8_lower, p) -/* Because ASCII is invariant under utf8, the non-utf8 macro works */ -#define isASCII_utf8(p) isASCII(p) -#define isCNTRL_utf8(p) generic_utf8(isCNTRL, is_utf8_cntrl, p) -#define isGRAPH_utf8(p) generic_utf8(isGRAPH, is_utf8_graph, p) -#define isPRINT_utf8(p) generic_utf8(isPRINT, is_utf8_print, p) -#define isPUNCT_utf8(p) generic_utf8(isPUNCT, is_utf8_punct, p) -#define isXDIGIT_utf8(p) generic_utf8(isXDIGIT, is_utf8_xdigit, p) -#define toUPPER_utf8(p,s,l) to_utf8_upper(p,s,l) -#define toTITLE_utf8(p,s,l) to_utf8_title(p,s,l) + * ever wanted to know about. (In the ASCII range, there isn't a difference.) + * This used to be not the XID version, but we decided to go with the more + * modern Unicode definition */ +#define isIDFIRST_utf8(p) _generic_func_utf8(_CC_IDFIRST, \ + _is_utf8_perl_idstart, p) + +#define isLOWER_utf8(p) _generic_swash_utf8(_CC_LOWER, p) +#define isPRINT_utf8(p) _generic_swash_utf8(_CC_PRINT, p) + +/* Posix and regular space are identical above Latin1 */ +#define isPSXSPC_utf8(p) _generic_func_utf8(_CC_PSXSPC, is_XPERLSPACE_high, p) + +#define isPUNCT_utf8(p) _generic_swash_utf8(_CC_PUNCT, p) +#define isSPACE_utf8(p) _generic_func_utf8(_CC_SPACE, is_XPERLSPACE_high, p) +#define isUPPER_utf8(p) _generic_swash_utf8(_CC_UPPER, p) +#define isVERTWS_utf8(p) _generic_func_utf8(_CC_VERTSPACE, is_VERTWS_high, p) +#define isWORDCHAR_utf8(p) _generic_swash_utf8(_CC_WORDCHAR, p) +#define isXDIGIT_utf8(p) _generic_utf8_no_upper_latin1(_CC_XDIGIT, p, \ + is_XDIGIT_high(p)) + #define 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) -/* Posix and regular space differ only in U+000B, which is in ASCII (and hence - * Latin1 */ -#define isPSXSPC_utf8(p) ((isASCII(*(p))) \ - ? isPSXSPC_A(*(p)) \ - : (UTF8_IS_DOWNGRADEABLE_START(*(p)) \ - ? isPSXSPC_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \ - *((p)+1)))\ - : isSPACE_utf8(p))) -#define isBLANK_utf8(c) isBLANK(c) /* could be wrong */ - -#define isALNUM_LC_utf8(p) isALNUM_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isIDFIRST_LC_utf8(p) isIDFIRST_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isALPHA_LC_utf8(p) isALPHA_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isSPACE_LC_utf8(p) isSPACE_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isDIGIT_LC_utf8(p) isDIGIT_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isUPPER_LC_utf8(p) isUPPER_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isLOWER_LC_utf8(p) isLOWER_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isALNUMC_LC_utf8(p) isALNUMC_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isCNTRL_LC_utf8(p) isCNTRL_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isGRAPH_LC_utf8(p) isGRAPH_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isPRINT_LC_utf8(p) isPRINT_LC_uvchr(valid_utf8_to_uvchr(p, 0)) -#define isPUNCT_LC_utf8(p) isPUNCT_LC_uvchr(valid_utf8_to_uvchr(p, 0)) - -#define isPSXSPC_LC_utf8(c) (isSPACE_LC_utf8(c) ||(c) == '\f') -#define isBLANK_LC_utf8(c) isBLANK(c) /* could be wrong */ +/* For internal core Perl use only. If the input is in the Latin1 range, use + * the macro 'macro' on 'p' which is a pointer to a UTF-8 string. Otherwise + * use the value given by the 'utf8' parameter. This relies on the fact that + * ASCII characters have the same representation whether utf8 or not. Note + * that it assumes that the utf8 has been validated, and ignores 'use bytes' */ +#define _generic_LC_utf8(macro, p, utf8) \ + (UTF8_IS_INVARIANT(*(p)) \ + ? macro(*(p)) \ + : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ + ? macro(TWO_BYTE_UTF8_TO_UNI(*(p), *((p)+1))) \ + : utf8) + +#define _generic_LC_swash_utf8(macro, classnum, p) \ + _generic_LC_utf8(macro, p, _is_utf8_FOO(classnum, p)) +#define _generic_LC_func_utf8(macro, above_latin1, p) \ + _generic_LC_utf8(macro, p, above_latin1(p)) + +#define isALPHANUMERIC_LC_utf8(p) _generic_LC_swash_utf8(isALPHANUMERIC_LC, \ + _CC_ALPHANUMERIC, p) +#define isALPHA_LC_utf8(p) _generic_LC_swash_utf8(isALPHA_LC, _CC_ALPHA, p) +#define isASCII_LC_utf8(p) isASCII_LC(*p) +#define isBLANK_LC_utf8(p) _generic_LC_func_utf8(isBLANK_LC, is_HORIZWS_high, p) +#define isCNTRL_LC_utf8(p) _generic_LC_utf8(isCNTRL_LC, p, 0) +#define isDIGIT_LC_utf8(p) _generic_LC_swash_utf8(isDIGIT_LC, _CC_DIGIT, p) +#define isGRAPH_LC_utf8(p) _generic_LC_swash_utf8(isGRAPH_LC, _CC_GRAPH, p) +#define isIDCONT_LC_utf8(p) _generic_LC_func_utf8(isIDCONT_LC, _is_utf8_perl_idcont, p) +#define isIDFIRST_LC_utf8(p) _generic_LC_func_utf8(isIDFIRST_LC, _is_utf8_perl_idstart, p) +#define isLOWER_LC_utf8(p) _generic_LC_swash_utf8(isLOWER_LC, _CC_LOWER, p) +#define isPRINT_LC_utf8(p) _generic_LC_swash_utf8(isPRINT_LC, _CC_PRINT, p) +#define isPSXSPC_LC_utf8(p) isSPACE_LC_utf8(p) /* space is identical to posix + space under locale */ +#define isPUNCT_LC_utf8(p) _generic_LC_swash_utf8(isPUNCT_LC, _CC_PUNCT, p) +#define isSPACE_LC_utf8(p) _generic_LC_func_utf8(isSPACE_LC, is_XPERLSPACE_high, p) +#define isUPPER_LC_utf8(p) _generic_LC_swash_utf8(isUPPER_LC, _CC_UPPER, p) +#define isWORDCHAR_LC_utf8(p) _generic_LC_swash_utf8(isWORDCHAR_LC, \ + _CC_WORDCHAR, p) +#define isXDIGIT_LC_utf8(p) _generic_LC_func_utf8(isXDIGIT_LC, is_XDIGIT_high, p) + +/* Macros for backwards compatibility and for completeness when the ASCII and + * Latin1 values are identical */ +#define isALPHAU(c) isALPHA_L1(c) +#define isDIGIT_L1(c) isDIGIT_A(c) +#define isOCTAL(c) isOCTAL_A(c) +#define isOCTAL_L1(c) isOCTAL_A(c) +#define isXDIGIT_L1(c) isXDIGIT_A(c) +#define isALNUM(c) isWORDCHAR(c) +#define isALNUMU(c) isWORDCHAR_L1(c) +#define isALNUM_LC(c) isWORDCHAR_LC(c) +#define isALNUM_uni(c) isWORDCHAR_uni(c) +#define isALNUM_LC_uvchr(c) isWORDCHAR_LC_uvchr(c) +#define isALNUM_utf8(p) isWORDCHAR_utf8(p) +#define isALNUM_LC_utf8(p) isWORDCHAR_LC_utf8(p) +#define isALNUMC_A(c) isALPHANUMERIC_A(c) /* Mnemonic: "C's alnum" */ +#define isALNUMC_L1(c) isALPHANUMERIC_L1(c) +#define isALNUMC(c) isALPHANUMERIC(c) +#define isALNUMC_LC(c) isALPHANUMERIC_LC(c) +#define isALNUMC_uni(c) isALPHANUMERIC_uni(c) +#define isALNUMC_LC_uvchr(c) isALPHANUMERIC_LC_uvchr(c) +#define isALNUMC_utf8(p) isALPHANUMERIC_utf8(p) +#define isALNUMC_LC_utf8(p) isALPHANUMERIC_LC_utf8(p) /* This conversion works both ways, strangely enough. On EBCDIC platforms, - * CTRL-@ is 0, CTRL-A is 1, etc, just like on ASCII */ + * CTRL-@ is 0, CTRL-A is 1, etc, just like on ASCII, except that they don't + * necessarily mean the same characters, e.g. CTRL-D is 4 on both systems, but + * that is EOT on ASCII; ST on EBCDIC */ # define toCTRL(c) (toUPPER(NATIVE_TO_UNI(c)) ^ 64) /* Line numbers are unsigned, 32 bits. */ typedef U32 line_t; -#define NOLINE ((line_t) 4294967295UL) +#define NOLINE ((line_t) 4294967295UL) /* = FFFFFFFF */ /* Helpful alias for version prescan */ #define is_LAX_VERSION(a,b) \ @@ -1030,6 +1390,8 @@ typedef U32 line_t; } \ return a; +#define READ_XDIGIT(s) (isALPHA(*(s)) ? ((*(s)++ + 9) & 0xf) : (*(s)++ & 0xf)) + /* =head1 Memory Management @@ -1062,8 +1424,8 @@ The XSUB-writer's interface to the C C<free> function. =for apidoc Am|void|Move|void* src|void* dest|int nitems|type The XSUB-writer's interface to the C C<memmove> function. The C<src> is the -source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is -the type. Can do overlapping moves. See also C<Copy>. +source, C<dest> is the destination, C<nitems> is the number of items, and +C<type> is the type. Can do overlapping moves. See also C<Copy>. =for apidoc Am|void *|MoveD|void* src|void* dest|int nitems|type Like C<Move> but returns dest. Useful for encouraging compilers to tail-call @@ -1071,8 +1433,8 @@ optimise. =for apidoc Am|void|Copy|void* src|void* dest|int nitems|type The XSUB-writer's interface to the C C<memcpy> function. The C<src> is the -source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is -the type. May fail on overlapping copies. See also C<Move>. +source, C<dest> is the destination, C<nitems> is the number of items, and +C<type> is the type. May fail on overlapping copies. See also C<Move>. =for apidoc Am|void *|CopyD|void* src|void* dest|int nitems|type @@ -1089,7 +1451,7 @@ destination, C<nitems> is the number of items, and C<type> is the type. Like C<Zero> but returns dest. Useful for encouraging compilers to tail-call optimise. -=for apidoc Am|void|StructCopy|type src|type dest|type +=for apidoc Am|void|StructCopy|type *src|type *dest|type This is an architecture-independent macro to copy one structure to another. =for apidoc Am|void|PoisonWith|void* dest|int nitems|type|U8 byte @@ -1122,13 +1484,13 @@ PoisonWith(0xEF) for catching access to freed memory. * overly eager compilers that will bleat about e.g. * (U16)n > (size_t)~0/sizeof(U16) always being false. */ #ifdef PERL_MALLOC_WRAP -#define MEM_WRAP_CHECK(n,t) MEM_WRAP_CHECK_1(n,t,PL_memory_wrap) +#define MEM_WRAP_CHECK(n,t) \ + (void)(sizeof(t) > 1 && ((MEM_SIZE)(n)+0.0) > MEM_SIZE_MAX/sizeof(t) && (Perl_croak_memory_wrap(),0)) #define MEM_WRAP_CHECK_1(n,t,a) \ (void)(sizeof(t) > 1 && ((MEM_SIZE)(n)+0.0) > MEM_SIZE_MAX/sizeof(t) && (Perl_croak_nocontext("%s",(a)),0)) #define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t), -#define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (Perl_croak_nocontext("%s",PL_memory_wrap),0):0),((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1))) - +#define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (Perl_croak_memory_wrap(),0):0),((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1))) #else #define MEM_WRAP_CHECK(n,t) @@ -1299,12 +1661,14 @@ void Perl_mem_log_del_sv(const SV *sv, const char *filename, const int linenumbe # define deprecate(s) Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), "Use of " s " is deprecated") #endif +#endif /* HANDY_H */ + /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/hv.h b/Master/tlpkg/tlperl/lib/CORE/hv.h index 05245d58a7f..be7717d3d59 100644 --- a/Master/tlpkg/tlperl/lib/CORE/hv.h +++ b/Master/tlpkg/tlperl/lib/CORE/hv.h @@ -8,6 +8,26 @@ * */ +/* These control hash traversal randomization and the environment variable PERL_PERTURB_KEYS. + * Currently disabling this functionality will break a few tests, but should otherwise work fine. + * See perlrun for more details. */ + +#if defined(PERL_PERTURB_KEYS_DISABLED) +# define PL_HASH_RAND_BITS_ENABLED 0 +# define PERL_HASH_ITER_BUCKET(iter) ((iter)->xhv_riter) +#else +# define PERL_HASH_RANDOMIZE_KEYS 1 +# if defined(PERL_PERTURB_KEYS_RANDOM) +# define PL_HASH_RAND_BITS_ENABLED 1 +# elif defined(PERL_PERTURB_KEYS_DETERMINISTIC) +# define PL_HASH_RAND_BITS_ENABLED 2 +# else +# define USE_PERL_PERTURB_KEYS 1 +# define PL_HASH_RAND_BITS_ENABLED PL_hash_rand_bits_enabled +# endif +# define PERL_HASH_ITER_BUCKET(iter) (((iter)->xhv_riter) ^ ((iter)->xhv_rand)) +#endif + /* entry in hash value chain */ struct he { /* Keep hent_next first in this structure, because sv_free_arenas take @@ -61,6 +81,7 @@ struct mro_meta { U32 pkg_gen; /* Bumps when local methods/@ISA change */ const struct mro_alg *mro_which; /* which mro alg is in use? */ HV *isa; /* Everything this class @ISA */ + U32 destroy_gen; /* Generation number of DESTROY cache */ }; #define MRO_GET_PRIVATE_DATA(smeta, which) \ @@ -82,6 +103,7 @@ struct xpvhv_aux { AV *xhv_backreferences; /* back references for weak references */ HE *xhv_eiter; /* current entry of iterator */ I32 xhv_riter; /* current root of iterator */ + /* Concerning xhv_name_count: When non-zero, xhv_name_u contains a pointer * to an array of HEK pointers, this being the length. The first element is * the name of the stash, which may be NULL. If xhv_name_count is positive, @@ -90,6 +112,12 @@ struct xpvhv_aux { */ I32 xhv_name_count; struct mro_meta *xhv_mro_meta; + HV * xhv_super; /* SUPER method cache */ +#ifdef PERL_HASH_RANDOMIZE_KEYS + U32 xhv_rand; /* random value for hash traversal */ + U32 xhv_last_rand; /* last random value for hash traversal, + used to detect each() after insert for warnings */ +#endif }; /* hash structure: */ @@ -101,59 +129,6 @@ struct xpvhv { STRLEN xhv_max; /* subscript of last element of xhv_array */ }; -/* hash a key */ -/* FYI: This is the "One-at-a-Time" algorithm by Bob Jenkins - * from requirements by Colin Plumb. - * (http://burtleburtle.net/bob/hash/doobs.html) */ -/* The use of a temporary pointer and the casting games - * is needed to serve the dual purposes of - * (a) the hashed data being interpreted as "unsigned char" (new since 5.8, - * a "char" can be either signed or unsigned, depending on the compiler) - * (b) catering for old code that uses a "char" - * - * The "hash seed" feature was added in Perl 5.8.1 to perturb the results - * to avoid "algorithmic complexity attacks". - * - * If USE_HASH_SEED is defined, hash randomisation is done by default - * If USE_HASH_SEED_EXPLICIT is defined, hash randomisation is done - * only if the environment variable PERL_HASH_SEED is set. - * For maximal control, one can define PERL_HASH_SEED. - * (see also perl.c:perl_parse()). - */ -#ifndef PERL_HASH_SEED -# if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT) -# define PERL_HASH_SEED PL_hash_seed -# else -# define PERL_HASH_SEED 0 -# endif -#endif - -#define PERL_HASH(hash,str,len) PERL_HASH_INTERNAL_(hash,str,len,0) - -/* Only hv.c and mod_perl should be doing this. */ -#ifdef PERL_HASH_INTERNAL_ACCESS -#define PERL_HASH_INTERNAL(hash,str,len) PERL_HASH_INTERNAL_(hash,str,len,1) -#endif - -/* Common base for PERL_HASH and PERL_HASH_INTERNAL that parameterises - * the source of the seed. Not for direct use outside of hv.c. */ - -#define PERL_HASH_INTERNAL_(hash,str,len,internal) \ - STMT_START { \ - register const char * const s_PeRlHaSh_tmp = str; \ - register const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \ - register I32 i_PeRlHaSh = len; \ - register U32 hash_PeRlHaSh = (internal ? PL_rehash_seed : PERL_HASH_SEED); \ - while (i_PeRlHaSh--) { \ - hash_PeRlHaSh += *s_PeRlHaSh++; \ - hash_PeRlHaSh += (hash_PeRlHaSh << 10); \ - hash_PeRlHaSh ^= (hash_PeRlHaSh >> 6); \ - } \ - hash_PeRlHaSh += (hash_PeRlHaSh << 3); \ - hash_PeRlHaSh ^= (hash_PeRlHaSh >> 11); \ - (hash) = (hash_PeRlHaSh + (hash_PeRlHaSh << 15)); \ - } STMT_END - /* =head1 Hash Manipulation Functions @@ -208,7 +183,12 @@ be assigned to. The C<HePV()> macro is usually preferable for finding key lengths. =for apidoc Am|SV*|HeVAL|HE* he -Returns the value slot (type C<SV*>) stored in the hash entry. +Returns the value slot (type C<SV*>) stored in the hash entry. Can be assigned +to. + + SV *foo= HeVAL(hv); + HeVAL(hv)= sv; + =for apidoc Am|U32|HeHASH|HE* he Returns the computed hash stored in the hash entry. @@ -251,6 +231,8 @@ C<SV*>. =cut */ +#define PERL_HASH_DEFAULT_HvMAX 7 + /* these hash entry flags ride on hent_klen (for use only in magic/tied HVs) */ #define HEf_SVKEY -2 /* hent_key is an SV* */ @@ -269,6 +251,9 @@ C<SV*>. #define HvEITER_set(hv,e) Perl_hv_eiter_set(aTHX_ MUTABLE_HV(hv), e) #define HvRITER_get(hv) (SvOOK(hv) ? HvAUX(hv)->xhv_riter : -1) #define HvEITER_get(hv) (SvOOK(hv) ? HvAUX(hv)->xhv_eiter : NULL) +#define HvRAND_get(hv) (SvOOK(hv) ? HvAUX(hv)->xhv_rand : 0) +#define HvLASTRAND_get(hv) (SvOOK(hv) ? HvAUX(hv)->xhv_last_rand : 0) + #define HvNAME(hv) HvNAME_get(hv) #define HvNAMELEN(hv) HvNAMELEN_get(hv) #define HvENAME(hv) HvENAME_get(hv) @@ -352,10 +337,6 @@ C<SV*>. #define HvLAZYDEL_on(hv) (SvFLAGS(hv) |= SVphv_LAZYDEL) #define HvLAZYDEL_off(hv) (SvFLAGS(hv) &= ~SVphv_LAZYDEL) -#define HvREHASH(hv) (SvFLAGS(hv) & SVphv_REHASH) -#define HvREHASH_on(hv) (SvFLAGS(hv) |= SVphv_REHASH) -#define HvREHASH_off(hv) (SvFLAGS(hv) &= ~SVphv_REHASH) - #ifndef PERL_CORE # define Nullhe Null(HE*) #endif @@ -366,7 +347,6 @@ C<SV*>. #define HeKLEN(he) HEK_LEN(HeKEY_hek(he)) #define HeKUTF8(he) HEK_UTF8(HeKEY_hek(he)) #define HeKWASUTF8(he) HEK_WASUTF8(HeKEY_hek(he)) -#define HeKREHASH(he) HEK_REHASH(HeKEY_hek(he)) #define HeKLEN_UTF8(he) (HeKUTF8(he) ? -HeKLEN(he) : HeKLEN(he)) #define HeKFLAGS(he) HEK_FLAGS(HeKEY_hek(he)) #define HeVAL(he) (he)->he_valu.hent_val @@ -401,7 +381,6 @@ C<SV*>. #define HVhek_UTF8 0x01 /* Key is utf8 encoded. */ #define HVhek_WASUTF8 0x02 /* Key is bytes here, but was supplied as utf8. */ -#define HVhek_REHASH 0x04 /* This key is in an hv using a custom HASH . */ #define HVhek_UNSHARED 0x08 /* This key isn't a shared hash key. */ #define HVhek_FREEKEY 0x100 /* Internal flag to say key is malloc()ed. */ #define HVhek_PLACEHOLD 0x200 /* Internal flag to create placeholder. @@ -411,16 +390,7 @@ C<SV*>. converted to bytes. */ #define HVhek_MASK 0xFF -/* Which flags enable HvHASKFLAGS? Somewhat a hack on a hack, as - HVhek_REHASH is only needed because the rehash flag has to be duplicated - into all keys as hv_iternext has no access to the hash flags. At this - point Storable's tests get upset, because sometimes hashes are "keyed" - and sometimes not, depending on the order of data insertion, and whether - it triggered rehashing. So currently HVhek_REHASH is exempt. - Similarly UNSHARED -*/ - -#define HVhek_ENABLEHVKFLAGS (HVhek_MASK & ~(HVhek_REHASH|HVhek_UNSHARED)) +#define HVhek_ENABLEHVKFLAGS (HVhek_MASK & ~(HVhek_UNSHARED)) #define HEK_UTF8(hek) (HEK_FLAGS(hek) & HVhek_UTF8) #define HEK_UTF8_on(hek) (HEK_FLAGS(hek) |= HVhek_UTF8) @@ -428,8 +398,6 @@ C<SV*>. #define HEK_WASUTF8(hek) (HEK_FLAGS(hek) & HVhek_WASUTF8) #define HEK_WASUTF8_on(hek) (HEK_FLAGS(hek) |= HVhek_WASUTF8) #define HEK_WASUTF8_off(hek) (HEK_FLAGS(hek) &= ~HVhek_WASUTF8) -#define HEK_REHASH(hek) (HEK_FLAGS(hek) & HVhek_REHASH) -#define HEK_REHASH_on(hek) (HEK_FLAGS(hek) |= HVhek_REHASH) /* calculate HV array allocation */ #ifndef PERL_USE_LARGE_HV_ALLOC @@ -622,12 +590,14 @@ Creates a new HV. The reference count is set to 1. #define newHV() MUTABLE_HV(newSV_type(SVt_PVHV)) +#include "hv_func.h" + /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/hv_func.h b/Master/tlpkg/tlperl/lib/CORE/hv_func.h new file mode 100755 index 00000000000..7678807d883 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/CORE/hv_func.h @@ -0,0 +1,560 @@ +/* hash a key + *-------------------------------------------------------------------------------------- + * The "hash seed" feature was added in Perl 5.8.1 to perturb the results + * to avoid "algorithmic complexity attacks". + * + * If USE_HASH_SEED is defined, hash randomisation is done by default + * If USE_HASH_SEED_EXPLICIT is defined, hash randomisation is done + * only if the environment variable PERL_HASH_SEED is set. + * (see also perl.c:perl_parse() and S_init_tls_and_interp() and util.c:get_hash_seed()) + */ + +#ifndef PERL_SEEN_HV_FUNC_H /* compile once */ +#define PERL_SEEN_HV_FUNC_H + +#if !( 0 \ + || defined(PERL_HASH_FUNC_SIPHASH) \ + || defined(PERL_HASH_FUNC_SDBM) \ + || defined(PERL_HASH_FUNC_DJB2) \ + || defined(PERL_HASH_FUNC_SUPERFAST) \ + || defined(PERL_HASH_FUNC_MURMUR3) \ + || defined(PERL_HASH_FUNC_ONE_AT_A_TIME) \ + || defined(PERL_HASH_FUNC_ONE_AT_A_TIME_HARD) \ + || defined(PERL_HASH_FUNC_ONE_AT_A_TIME_OLD) \ + ) +#define PERL_HASH_FUNC_ONE_AT_A_TIME_HARD +#endif + +#if defined(PERL_HASH_FUNC_SIPHASH) +# define PERL_HASH_FUNC "SIPHASH_2_4" +# define PERL_HASH_SEED_BYTES 16 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_siphash_2_4(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_SUPERFAST) +# define PERL_HASH_FUNC "SUPERFAST" +# define PERL_HASH_SEED_BYTES 4 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_superfast(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_MURMUR3) +# define PERL_HASH_FUNC "MURMUR3" +# define PERL_HASH_SEED_BYTES 4 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_murmur3(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_DJB2) +# define PERL_HASH_FUNC "DJB2" +# define PERL_HASH_SEED_BYTES 4 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_djb2(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_SDBM) +# define PERL_HASH_FUNC "SDBM" +# define PERL_HASH_SEED_BYTES 4 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_sdbm(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_ONE_AT_A_TIME_HARD) +# define PERL_HASH_FUNC "ONE_AT_A_TIME_HARD" +# define PERL_HASH_SEED_BYTES 8 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_one_at_a_time_hard(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_ONE_AT_A_TIME) +# define PERL_HASH_FUNC "ONE_AT_A_TIME" +# define PERL_HASH_SEED_BYTES 4 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_one_at_a_time(PERL_HASH_SEED,(U8*)(str),(len)) +#elif defined(PERL_HASH_FUNC_ONE_AT_A_TIME_OLD) +# define PERL_HASH_FUNC "ONE_AT_A_TIME_OLD" +# define PERL_HASH_SEED_BYTES 4 +# define PERL_HASH(hash,str,len) (hash)= S_perl_hash_old_one_at_a_time(PERL_HASH_SEED,(U8*)(str),(len)) +#endif + +#ifndef PERL_HASH +#error "No hash function defined!" +#endif +#ifndef PERL_HASH_SEED_BYTES +#error "PERL_HASH_SEED_BYTES not defined" +#endif +#ifndef PERL_HASH_FUNC +#error "PERL_HASH_FUNC not defined" +#endif + +#ifndef PERL_HASH_SEED +# if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT) +# define PERL_HASH_SEED PL_hash_seed +# elif PERL_HASH_SEED_BYTES == 4 +# define PERL_HASH_SEED "PeRl" +# elif PERL_HASH_SEED_BYTES == 16 +# define PERL_HASH_SEED "PeRlHaShhAcKpErl" +# else +# error "No PERL_HASH_SEED definition for " PERL_HASH_FUNC +# endif +#endif + +/*----------------------------------------------------------------------------- + * Endianess, misalignment capabilities and util macros + * + * The following 3 macros are defined in this section. The other macros defined + * are only needed to help derive these 3. + * + * U8TO32_LE(x) Read a little endian unsigned 32-bit int + * UNALIGNED_SAFE Defined if READ_UINT32 works on non-word boundaries + * ROTL32(x,r) Rotate x left by r bits + */ + +#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \ + || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__) +#define U8TO16_LE(d) (*((const U16 *) (d))) +#endif + +#if !defined (U8TO16_LE) +#define U8TO16_LE(d) ((((const U8 *)(d))[1] << 8)\ + +((const U8 *)(d))[0]) +#endif + + +/* Now find best way we can to READ_UINT32 */ +#if (BYTEORDER == 0x1234 || BYTEORDER == 0x12345678) && U32SIZE == 4 + /* CPU endian matches murmurhash algorithm, so read 32-bit word directly */ + #define U8TO32_LE(ptr) (*((U32*)(ptr))) +#elif BYTEORDER == 0x4321 || BYTEORDER == 0x87654321 + /* TODO: Add additional cases below where a compiler provided bswap32 is available */ + #if defined(__GNUC__) && (__GNUC__>4 || (__GNUC__==4 && __GNUC_MINOR__>=3)) + #define U8TO32_LE(ptr) (__builtin_bswap32(*((U32*)(ptr)))) + #else + /* Without a known fast bswap32 we're just as well off doing this */ + #define U8TO32_LE(ptr) (ptr[0]|ptr[1]<<8|ptr[2]<<16|ptr[3]<<24) + #define UNALIGNED_SAFE + #endif +#else + /* Unknown endianess so last resort is to read individual bytes */ + #define U8TO32_LE(ptr) (ptr[0]|ptr[1]<<8|ptr[2]<<16|ptr[3]<<24) + /* Since we're not doing word-reads we can skip the messing about with realignment */ + #define UNALIGNED_SAFE +#endif + +#ifdef HAS_QUAD +#ifndef U64TYPE +/* This probably isn't going to work, but failing with a compiler error due to + lack of uint64_t is no worse than failing right now with an #error. */ +#define U64TYPE uint64_t +#endif +#endif + +/* Find best way to ROTL32/ROTL64 */ +#if defined(_MSC_VER) + #include <stdlib.h> /* Microsoft put _rotl declaration in here */ + #define ROTL32(x,r) _rotl(x,r) + #ifdef HAS_QUAD + #define ROTL64(x,r) _rotl64(x,r) + #endif +#else + /* gcc recognises this code and generates a rotate instruction for CPUs with one */ + #define ROTL32(x,r) (((U32)x << r) | ((U32)x >> (32 - r))) + #ifdef HAS_QUAD + #define ROTL64(x,r) (((U64TYPE)x << r) | ((U64TYPE)x >> (64 - r))) + #endif +#endif + + +#ifdef UV_IS_QUAD +#define ROTL_UV(x,r) ROTL64(x,r) +#else +#define ROTL_UV(x,r) ROTL32(x,r) +#endif + +/* This is SipHash by Jean-Philippe Aumasson and Daniel J. Bernstein. + * The authors claim it is relatively secure compared to the alternatives + * and that performance wise it is a suitable hash for languages like Perl. + * See: + * + * https://www.131002.net/siphash/ + * + * This implementation seems to perform slightly slower than one-at-a-time for + * short keys, but degrades slower for longer keys. Murmur Hash outperforms it + * regardless of keys size. + * + * It is 64 bit only. + */ + +#ifdef HAS_QUAD + +#define U8TO64_LE(p) \ + (((U64TYPE)((p)[0]) ) | \ + ((U64TYPE)((p)[1]) << 8) | \ + ((U64TYPE)((p)[2]) << 16) | \ + ((U64TYPE)((p)[3]) << 24) | \ + ((U64TYPE)((p)[4]) << 32) | \ + ((U64TYPE)((p)[5]) << 40) | \ + ((U64TYPE)((p)[6]) << 48) | \ + ((U64TYPE)((p)[7]) << 56)) + +#define SIPROUND \ + do { \ + v0 += v1; v1=ROTL64(v1,13); v1 ^= v0; v0=ROTL64(v0,32); \ + v2 += v3; v3=ROTL64(v3,16); v3 ^= v2; \ + v0 += v3; v3=ROTL64(v3,21); v3 ^= v0; \ + v2 += v1; v1=ROTL64(v1,17); v1 ^= v2; v2=ROTL64(v2,32); \ + } while(0) + +/* SipHash-2-4 */ + +PERL_STATIC_INLINE U32 +S_perl_hash_siphash_2_4(const unsigned char * const seed, const unsigned char *in, const STRLEN inlen) { + /* "somepseudorandomlygeneratedbytes" */ + U64TYPE v0 = 0x736f6d6570736575ULL; + U64TYPE v1 = 0x646f72616e646f6dULL; + U64TYPE v2 = 0x6c7967656e657261ULL; + U64TYPE v3 = 0x7465646279746573ULL; + + U64TYPE b; + U64TYPE k0 = ((U64TYPE*)seed)[0]; + U64TYPE k1 = ((U64TYPE*)seed)[1]; + U64TYPE m; + const int left = inlen & 7; + const U8 *end = in + inlen - left; + + b = ( ( U64TYPE )(inlen) ) << 56; + v3 ^= k1; + v2 ^= k0; + v1 ^= k1; + v0 ^= k0; + + for ( ; in != end; in += 8 ) + { + m = U8TO64_LE( in ); + v3 ^= m; + SIPROUND; + SIPROUND; + v0 ^= m; + } + + switch( left ) + { + case 7: b |= ( ( U64TYPE )in[ 6] ) << 48; + case 6: b |= ( ( U64TYPE )in[ 5] ) << 40; + case 5: b |= ( ( U64TYPE )in[ 4] ) << 32; + case 4: b |= ( ( U64TYPE )in[ 3] ) << 24; + case 3: b |= ( ( U64TYPE )in[ 2] ) << 16; + case 2: b |= ( ( U64TYPE )in[ 1] ) << 8; + case 1: b |= ( ( U64TYPE )in[ 0] ); break; + case 0: break; + } + + v3 ^= b; + SIPROUND; + SIPROUND; + v0 ^= b; + + v2 ^= 0xff; + SIPROUND; + SIPROUND; + SIPROUND; + SIPROUND; + b = v0 ^ v1 ^ v2 ^ v3; + return (U32)(b & U32_MAX); +} +#endif /* defined(HAS_QUAD) */ + +/* FYI: This is the "Super-Fast" algorithm mentioned by Bob Jenkins in + * (http://burtleburtle.net/bob/hash/doobs.html) + * It is by Paul Hsieh (c) 2004 and is analysed here + * http://www.azillionmonkeys.com/qed/hash.html + * license terms are here: + * http://www.azillionmonkeys.com/qed/weblicense.html + */ + + +PERL_STATIC_INLINE U32 +S_perl_hash_superfast(const unsigned char * const seed, const unsigned char *str, STRLEN len) { + U32 hash = *((U32*)seed) + len; + U32 tmp; + int rem= len & 3; + len >>= 2; + + for (;len > 0; len--) { + hash += U8TO16_LE (str); + tmp = (U8TO16_LE (str+2) << 11) ^ hash; + hash = (hash << 16) ^ tmp; + str += 2 * sizeof (U16); + hash += hash >> 11; + } + + /* Handle end cases */ + switch (rem) { \ + case 3: hash += U8TO16_LE (str); + hash ^= hash << 16; + hash ^= str[sizeof (U16)] << 18; + hash += hash >> 11; + break; + case 2: hash += U8TO16_LE (str); + hash ^= hash << 11; + hash += hash >> 17; + break; + case 1: hash += *str; + hash ^= hash << 10; + hash += hash >> 1; + } + /* Force "avalanching" of final 127 bits */ + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + return (hash + (hash >> 6)); +} + + +/*----------------------------------------------------------------------------- + * MurmurHash3 was written by Austin Appleby, and is placed in the public + * domain. + * + * This implementation was originally written by Shane Day, and is also public domain, + * and was modified to function as a macro similar to other perl hash functions by + * Yves Orton. + * + * This is a portable ANSI C implementation of MurmurHash3_x86_32 (Murmur3A) + * with support for progressive processing. + * + * If you want to understand the MurmurHash algorithm you would be much better + * off reading the original source. Just point your browser at: + * http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp + * + * How does it work? + * + * We can only process entire 32 bit chunks of input, except for the very end + * that may be shorter. + * + * To handle endianess I simply use a macro that reads a U32 and define + * that macro to be a direct read on little endian machines, a read and swap + * on big endian machines, or a byte-by-byte read if the endianess is unknown. + */ + + +/*----------------------------------------------------------------------------- + * Core murmurhash algorithm macros */ + +#define MURMUR_C1 (0xcc9e2d51) +#define MURMUR_C2 (0x1b873593) +#define MURMUR_C3 (0xe6546b64) +#define MURMUR_C4 (0x85ebca6b) +#define MURMUR_C5 (0xc2b2ae35) + +/* This is the main processing body of the algorithm. It operates + * on each full 32-bits of input. */ +#define MURMUR_DOBLOCK(h1, k1) STMT_START { \ + k1 *= MURMUR_C1; \ + k1 = ROTL32(k1,15); \ + k1 *= MURMUR_C2; \ + \ + h1 ^= k1; \ + h1 = ROTL32(h1,13); \ + h1 = h1 * 5 + MURMUR_C3; \ +} STMT_END + + +/* Append unaligned bytes to carry, forcing hash churn if we have 4 bytes */ +/* cnt=bytes to process, h1=name of h1 var, c=carry, n=bytes in c, ptr/len=payload */ +#define MURMUR_DOBYTES(cnt, h1, c, n, ptr, len) STMT_START { \ + int MURMUR_DOBYTES_i = cnt; \ + while(MURMUR_DOBYTES_i--) { \ + c = c>>8 | *ptr++<<24; \ + n++; len--; \ + if(n==4) { \ + MURMUR_DOBLOCK(h1, c); \ + n = 0; \ + } \ + } \ +} STMT_END + + +/* now we create the hash function */ +PERL_STATIC_INLINE U32 +S_perl_hash_murmur3(const unsigned char * const seed, const unsigned char *ptr, STRLEN len) { + U32 h1 = *((U32*)seed); + U32 k1; + U32 carry = 0; + + const unsigned char *end; + int bytes_in_carry = 0; /* bytes in carry */ + I32 total_length= len; + +#if defined(UNALIGNED_SAFE) + /* Handle carry: commented out as its only used in incremental mode - it never fires for us + int i = (4-n) & 3; + if(i && i <= len) { + MURMUR_DOBYTES(i, h1, carry, bytes_in_carry, ptr, len); + } + */ + + /* This CPU handles unaligned word access */ + /* Process 32-bit chunks */ + end = ptr + len/4*4; + for( ; ptr < end ; ptr+=4) { + k1 = U8TO32_LE(ptr); + MURMUR_DOBLOCK(h1, k1); + } +#else + /* This CPU does not handle unaligned word access */ + + /* Consume enough so that the next data byte is word aligned */ + STRLEN i = -PTR2IV(ptr) & 3; + if(i && i <= len) { + MURMUR_DOBYTES(i, h1, carry, bytes_in_carry, ptr, len); + } + + /* We're now aligned. Process in aligned blocks. Specialise for each possible carry count */ + end = ptr + len/4*4; + switch(bytes_in_carry) { /* how many bytes in carry */ + case 0: /* c=[----] w=[3210] b=[3210]=w c'=[----] */ + for( ; ptr < end ; ptr+=4) { + k1 = U8TO32_LE(ptr); + MURMUR_DOBLOCK(h1, k1); + } + break; + case 1: /* c=[0---] w=[4321] b=[3210]=c>>24|w<<8 c'=[4---] */ + for( ; ptr < end ; ptr+=4) { + k1 = carry>>24; + carry = U8TO32_LE(ptr); + k1 |= carry<<8; + MURMUR_DOBLOCK(h1, k1); + } + break; + case 2: /* c=[10--] w=[5432] b=[3210]=c>>16|w<<16 c'=[54--] */ + for( ; ptr < end ; ptr+=4) { + k1 = carry>>16; + carry = U8TO32_LE(ptr); + k1 |= carry<<16; + MURMUR_DOBLOCK(h1, k1); + } + break; + case 3: /* c=[210-] w=[6543] b=[3210]=c>>8|w<<24 c'=[654-] */ + for( ; ptr < end ; ptr+=4) { + k1 = carry>>8; + carry = U8TO32_LE(ptr); + k1 |= carry<<24; + MURMUR_DOBLOCK(h1, k1); + } + } +#endif + /* Advance over whole 32-bit chunks, possibly leaving 1..3 bytes */ + len -= len/4*4; + + /* Append any remaining bytes into carry */ + MURMUR_DOBYTES(len, h1, carry, bytes_in_carry, ptr, len); + + if (bytes_in_carry) { + k1 = carry >> ( 4 - bytes_in_carry ) * 8; + k1 *= MURMUR_C1; + k1 = ROTL32(k1,15); + k1 *= MURMUR_C2; + h1 ^= k1; + } + h1 ^= total_length; + + /* fmix */ + h1 ^= h1 >> 16; + h1 *= MURMUR_C4; + h1 ^= h1 >> 13; + h1 *= MURMUR_C5; + h1 ^= h1 >> 16; + return h1; +} + + +PERL_STATIC_INLINE U32 +S_perl_hash_djb2(const unsigned char * const seed, const unsigned char *str, const STRLEN len) { + const unsigned char * const end = (const unsigned char *)str + len; + U32 hash = *((U32*)seed + len); + while (str < end) { + hash = ((hash << 5) + hash) + *str++; + } + return hash; +} + +PERL_STATIC_INLINE U32 +S_perl_hash_sdbm(const unsigned char * const seed, const unsigned char *str, const STRLEN len) { + const unsigned char * const end = (const unsigned char *)str + len; + U32 hash = *((U32*)seed + len); + while (str < end) { + hash = (hash << 6) + (hash << 16) - hash + *str++; + } + return hash; +} + + +/* This is the "One-at-a-Time" algorithm by Bob Jenkins + * from requirements by Colin Plumb. + * (http://burtleburtle.net/bob/hash/doobs.html) + * With seed/len tweak. + * */ +PERL_STATIC_INLINE U32 +S_perl_hash_one_at_a_time(const unsigned char * const seed, const unsigned char *str, const STRLEN len) { + const unsigned char * const end = (const unsigned char *)str + len; + U32 hash = *((U32*)seed) + len; + while (str < end) { + hash += *str++; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + return (hash + (hash << 15)); +} + +/* Derived from "One-at-a-Time" algorithm by Bob Jenkins */ +PERL_STATIC_INLINE U32 +S_perl_hash_one_at_a_time_hard(const unsigned char * const seed, const unsigned char *str, const STRLEN len) { + const unsigned char * const end = (const unsigned char *)str + len; + U32 hash = *((U32*)seed) + len; + + while (str < end) { + hash += (hash << 10); + hash ^= (hash >> 6); + hash += *str++; + } + + hash += (hash << 10); + hash ^= (hash >> 6); + hash += seed[4]; + + hash += (hash << 10); + hash ^= (hash >> 6); + hash += seed[5]; + + hash += (hash << 10); + hash ^= (hash >> 6); + hash += seed[6]; + + hash += (hash << 10); + hash ^= (hash >> 6); + hash += seed[7]; + + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += (hash << 3); + hash ^= (hash >> 11); + return (hash + (hash << 15)); +} + +PERL_STATIC_INLINE U32 +S_perl_hash_old_one_at_a_time(const unsigned char * const seed, const unsigned char *str, const STRLEN len) { + const unsigned char * const end = (const unsigned char *)str + len; + U32 hash = *((U32*)seed); + while (str < end) { + hash += *str++; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + return (hash + (hash << 15)); +} + +/* legacy - only mod_perl should be doing this. */ +#ifdef PERL_HASH_INTERNAL_ACCESS +#define PERL_HASH_INTERNAL(hash,str,len) PERL_HASH(hash,str,len) +#endif + +#endif /*compile once*/ + +/* + * Local variables: + * c-indentation-style: bsd + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + * + * ex: set ts=8 sts=4 sw=4 et: + */ diff --git a/Master/tlpkg/tlperl/lib/CORE/inline.h b/Master/tlpkg/tlperl/lib/CORE/inline.h new file mode 100755 index 00000000000..953bb33cffb --- /dev/null +++ b/Master/tlpkg/tlperl/lib/CORE/inline.h @@ -0,0 +1,156 @@ +/* inline.h + * + * Copyright (C) 2012 by Larry Wall and others + * + * You may distribute under the terms of either the GNU General Public + * License or the Artistic License, as specified in the README file. + * + * This file is a home for static inline functions that cannot go in other + * headers files, because they depend on proto.h (included after most other + * headers) or struct definitions. + * + * Each section names the header file that the functions "belong" to. + */ + +/* ------------------------------- av.h ------------------------------- */ + +PERL_STATIC_INLINE I32 +S_av_top_index(pTHX_ AV *av) +{ + PERL_ARGS_ASSERT_AV_TOP_INDEX; + assert(SvTYPE(av) == SVt_PVAV); + + return AvFILL(av); +} + +/* ------------------------------- cv.h ------------------------------- */ + +PERL_STATIC_INLINE I32 * +S_CvDEPTHp(const CV * const sv) +{ + assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM); + return &((XPVCV*)SvANY(sv))->xcv_depth; +} + +/* ----------------------------- regexp.h ----------------------------- */ + +PERL_STATIC_INLINE struct regexp * +S_ReANY(const REGEXP * const re) +{ + assert(isREGEXP(re)); + return re->sv_u.svu_rx; +} + +/* ------------------------------- sv.h ------------------------------- */ + +PERL_STATIC_INLINE SV * +S_SvREFCNT_inc(SV *sv) +{ + if (LIKELY(sv != NULL)) + SvREFCNT(sv)++; + return sv; +} +PERL_STATIC_INLINE SV * +S_SvREFCNT_inc_NN(SV *sv) +{ + SvREFCNT(sv)++; + return sv; +} +PERL_STATIC_INLINE void +S_SvREFCNT_inc_void(SV *sv) +{ + if (LIKELY(sv != NULL)) + SvREFCNT(sv)++; +} +PERL_STATIC_INLINE void +S_SvREFCNT_dec(pTHX_ SV *sv) +{ + if (LIKELY(sv != NULL)) { + U32 rc = SvREFCNT(sv); + if (rc > 1) + SvREFCNT(sv) = rc - 1; + else + Perl_sv_free2(aTHX_ sv, rc); + } +} + +PERL_STATIC_INLINE void +S_SvREFCNT_dec_NN(pTHX_ SV *sv) +{ + U32 rc = SvREFCNT(sv); + if (rc > 1) + SvREFCNT(sv) = rc - 1; + else + Perl_sv_free2(aTHX_ sv, rc); +} + +PERL_STATIC_INLINE void +SvAMAGIC_on(SV *sv) +{ + assert(SvROK(sv)); + if (SvOBJECT(SvRV(sv))) HvAMAGIC_on(SvSTASH(SvRV(sv))); +} +PERL_STATIC_INLINE void +SvAMAGIC_off(SV *sv) +{ + if (SvROK(sv) && SvOBJECT(SvRV(sv))) + HvAMAGIC_off(SvSTASH(SvRV(sv))); +} + +PERL_STATIC_INLINE U32 +S_SvPADTMP_on(SV *sv) +{ + assert(!(SvFLAGS(sv) & SVs_PADMY)); + return SvFLAGS(sv) |= SVs_PADTMP; +} +PERL_STATIC_INLINE U32 +S_SvPADTMP_off(SV *sv) +{ + assert(!(SvFLAGS(sv) & SVs_PADMY)); + return SvFLAGS(sv) &= ~SVs_PADTMP; +} +PERL_STATIC_INLINE U32 +S_SvPADSTALE_on(SV *sv) +{ + assert(SvFLAGS(sv) & SVs_PADMY); + return SvFLAGS(sv) |= SVs_PADSTALE; +} +PERL_STATIC_INLINE U32 +S_SvPADSTALE_off(SV *sv) +{ + assert(SvFLAGS(sv) & SVs_PADMY); + return SvFLAGS(sv) &= ~SVs_PADSTALE; +} +#ifdef PERL_CORE +PERL_STATIC_INLINE STRLEN +S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) +{ + if (SvGAMAGIC(sv)) { + U8 *hopped = utf8_hop((U8 *)pv, pos); + if (lenp) *lenp = (STRLEN)(utf8_hop(hopped, *lenp) - hopped); + return (STRLEN)(hopped - (U8 *)pv); + } + return sv_pos_u2b_flags(sv,pos,lenp,SV_CONST_RETURN); +} +#endif + +/* ------------------------------- utf8.h ------------------------------- */ + +/* These exist only to replace the macros they formerly were so that their use + * can be deprecated */ + +PERL_STATIC_INLINE bool +S_isIDFIRST_lazy(pTHX_ const char* p) +{ + PERL_ARGS_ASSERT_ISIDFIRST_LAZY; + + return isIDFIRST_lazy_if(p,1); +} + +PERL_STATIC_INLINE bool +S_isALNUM_lazy(pTHX_ const char* p) +{ + PERL_ARGS_ASSERT_ISALNUM_LAZY; + + return isALNUM_lazy_if(p,1); +} diff --git a/Master/tlpkg/tlperl/lib/CORE/intrpvar.h b/Master/tlpkg/tlperl/lib/CORE/intrpvar.h index cc9e46ededd..d31b15e0aeb 100644 --- a/Master/tlpkg/tlperl/lib/CORE/intrpvar.h +++ b/Master/tlpkg/tlperl/lib/CORE/intrpvar.h @@ -8,6 +8,8 @@ * */ +#include "handy.h" + /* =head1 Per-Interpreter Variables */ @@ -41,32 +43,116 @@ PERLVAR(I, curpad, SV **) /* active pad (lexicals+tmps) */ PERLVAR(I, stack_base, SV **) PERLVAR(I, stack_max, SV **) -PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */ -/* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be - present always, as -DDEUBGGING must be binary compatible with non. */ -PERLVARI(I, scopestack_name, const char * *, NULL) -PERLVAR(I, scopestack_ix, I32) -PERLVAR(I, scopestack_max, I32) - PERLVAR(I, savestack, ANY *) /* items that need to be restored when LEAVEing scopes we've ENTERed */ PERLVAR(I, savestack_ix, I32) PERLVAR(I, savestack_max, I32) +PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */ +PERLVAR(I, scopestack_ix, I32) +PERLVAR(I, scopestack_max, I32) + PERLVAR(I, tmps_stack, SV **) /* mortals we've made */ PERLVARI(I, tmps_ix, I32, -1) PERLVARI(I, tmps_floor, I32, -1) PERLVAR(I, tmps_max, I32) -PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in - assignment? */ + +PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */ PERLVAR(I, markstack, I32 *) /* stack_sp locations we're remembering */ PERLVAR(I, markstack_ptr, I32 *) PERLVAR(I, markstack_max, I32 *) +#ifdef PERL_HASH_RANDOMIZE_KEYS +#ifdef USE_PERL_PERTURB_KEYS +PERLVARI(I, hash_rand_bits_enabled, U8, 1) /* used to randomize hash stuff 0 == no-random, 1 == random, 2 == determinsitic */ +#endif +PERLVARI(I, hash_rand_bits, UV, 0) /* used to randomize hash stuff */ +#endif +PERLVAR(I, strtab, HV *) /* shared string table */ + +/* Fields used by magic variables such as $@, $/ and so on */ +PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */ + +PERLVAR(I, tainting, bool) /* doing taint checks */ +PERLVAR(I, tainted, bool) /* using variables controlled by $< */ +PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */ +PERLVAR(I, localizing, U8) /* are we processing a local() list? */ +PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */ +/* + +=for apidoc mn|bool|PL_dowarn + +The C variable which corresponds to Perl's $^W warning variable. + +=cut +*/ + +PERLVAR(I, dowarn, U8) + +#if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING) +# define PERL___I -1 +#else +# define PERL___I 1 +#endif +PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */ +#undef PERL___I + + +/* Stashes */ +PERLVAR(I, defstash, HV *) /* main symbol table */ +PERLVAR(I, curstash, HV *) /* symbol table for current package */ + +PERLVAR(I, curcop, COP *) +PERLVAR(I, curstack, AV *) /* THE STACK */ +PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */ +PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is + happening */ + +/* memory management */ +PERLVAR(I, sv_count, IV) /* how many SV* are currently allocated */ +PERLVAR(I, sv_objcount, IV) /* DEPRECATED AND UNMAINTAINED. + * Will be removed in Perl 5.20. + * Used to be: how many objects are currently allocated. */ + +PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */ +PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */ + +PERLVAR(I, reg_state, struct re_save_state) + +/* the currently active slab in a chain of slabs of regmatch states, + * and the currently active state within that slab */ + +PERLVARI(I, regmatch_slab, regmatch_slab *, NULL) +PERLVAR(I, regmatch_state, regmatch_state *) + +PERLVAR(I, comppad, PAD *) /* storage for lexically scoped temporaries */ + +/* +=for apidoc Amn|SV|PL_sv_undef +This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>. + +=for apidoc Amn|SV|PL_sv_no +This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as +C<&PL_sv_no>. + +=for apidoc Amn|SV|PL_sv_yes +This is the C<true> SV. See C<PL_sv_no>. Always refer to this as +C<&PL_sv_yes>. + +=cut +*/ + +PERLVAR(I, sv_undef, SV) +PERLVAR(I, sv_no, SV) +PERLVAR(I, sv_yes, SV) PERLVAR(I, Sv, SV *) /* used to hold temporary values */ -PERLVAR(I, Xpv, XPV *) /* used to hold temporary values */ + +PERLVAR(I, parser, yy_parser *) /* current parser state */ + +PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */ + /* =for apidoc Amn|STRLEN|PL_na @@ -92,9 +178,6 @@ PERLVARI(I, statname, SV *, NULL) PERLVAR(I, timesbuf, struct tms) #endif -/* Fields used by magic variables such as $@, $/ and so on */ -PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */ - /* =for apidoc mn|SV*|PL_rs @@ -120,17 +203,9 @@ PERLVAR(I, formtarget, SV *) PERLVAR(I, bodytarget, SV *) PERLVAR(I, toptarget, SV *) -/* Stashes */ -PERLVAR(I, defstash, HV *) /* main symbol table */ -PERLVAR(I, curstash, HV *) /* symbol table for current package */ PERLVAR(I, restartop, OP *) /* propagating an error from croak? */ PERLVAR(I, restartjmpenv, JMPENV *) /* target frame for longjmp in die */ -PERLVAR(I, curcop, COP *) -PERLVAR(I, curstack, AV *) /* THE STACK */ -PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */ -PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is - happening */ PERLVAR(I, top_env, JMPENV *) /* ptr to current sigjmp environment */ PERLVAR(I, start_env, JMPENV) /* empty startup sigjmp environment */ @@ -151,18 +226,14 @@ PERLVAR(I, secondgv, GV *) /* $b */ PERLVAR(I, efloatbuf, char *) PERLVAR(I, efloatsize, STRLEN) -/* regex stuff */ - -PERLVAR(I, reg_state, struct re_save_state) - PERLVAR(I, regdummy, regnode) /* from regcomp.c */ PERLVARI(I, dumpindent, U16, 4) /* number of blanks per dump indentation level */ +PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */ PERLVAR(I, utf8locale, bool) /* utf8 locale detected */ -PERLVARI(I, rehash_seed_set, bool, FALSE) /* 582 hash initialized? */ PERLVARA(I, colors,6, char *) /* from regcomp.c */ @@ -230,33 +301,12 @@ PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */ PERLVARI(I, watchaddr, char **, 0) PERLVAR(I, watchok, char *) -/* the currently active slab in a chain of slabs of regmatch states, - * and the currently active state within that slab */ - -PERLVARI(I, regmatch_slab, regmatch_slab *, NULL) -PERLVAR(I, regmatch_state, regmatch_state *) - -/* Put anything new that is pointer aligned here. */ - -PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */ -PERLVAR(I, localizing, U8) /* are we processing a local() list? */ -PERLVAR(I, colorset, bool) /* from regcomp.c */ -PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */ -PERLVAR(I, tainted, bool) /* using variables controlled by $< */ -PERLVAR(I, tainting, bool) /* doing taint checks */ - -/* This value may be set when embedding for full cleanup */ -/* 0=none, 1=full, 2=full with checks */ -/* mod_perl is special, and also assigns a meaning -1 */ -PERLVARI(I, perl_destruct_level, signed char, 0) - -/* current phase the interpreter is in */ -PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT) - PERLVAR(I, perldb, U32) PERLVAR(I, signals, U32) /* Using which pre-5.8 signals */ +PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */ + /* pseudo environmental stuff */ PERLVAR(I, origargc, int) PERLVAR(I, origargv, char **) @@ -282,29 +332,10 @@ PERLVAR(I, minus_F, bool) PERLVAR(I, doswitches, bool) PERLVAR(I, minus_E, bool) -/* - -=for apidoc mn|bool|PL_dowarn - -The C variable which corresponds to Perl's $^W warning variable. - -=cut -*/ - -PERLVAR(I, dowarn, U8) -PERLVAR(I, sawampersand, bool) /* must save all match strings */ -PERLVAR(I, unsafe, bool) -PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */ - -PERLVARI(I, reginterp_cnt, I32, 0) /* Whether "Regexp" was interpolated. */ - PERLVAR(I, inplace, char *) PERLVAR(I, e_script, SV *) -/* magical thingies */ PERLVAR(I, basetime, Time_t) /* $^T */ -PERLVAR(I, formfeed, SV *) /* $^L */ - PERLVARI(I, maxsysfd, I32, MAXSYSFD) /* top fd to pass to subprocesses */ @@ -373,17 +404,6 @@ PERLVAR(I, endav, AV *) /* names of END subroutines */ PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */ PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */ PERLVAR(I, initav, AV *) /* names of INIT subroutines */ -PERLVAR(I, strtab, HV *) /* shared string table */ -PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */ - -/* funky return mechanisms */ -PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */ - -/* memory management */ -PERLVAR(I, sv_count, I32) /* how many SV* are currently allocated */ -PERLVAR(I, sv_objcount, I32) /* how many objects are currently allocated */ -PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */ -PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */ /* subprocess state */ PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */ @@ -413,13 +433,21 @@ PERLVAR(I, Cmd, char *) /* stuff to free from do_aexec, vfork safe */ PERLVAR(I, preambleav, AV *) PERLVAR(I, mess_sv, SV *) PERLVAR(I, ors_sv, SV *) /* output record separator $\ */ + +/* funky return mechanisms */ +PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */ + /* statics moved here for shared library purposes */ PERLVARI(I, gensym, I32, 0) /* next symbol for getsym() to define */ PERLVARI(I, cv_has_eval, bool, FALSE) /* PL_compcv includes an entereval or similar */ PERLVAR(I, taint_warn, bool) /* taint warns instead of dying */ PERLVARI(I, laststype, U16, OP_STAT) + PERLVARI(I, laststatval, int, -1) +PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in + assignment? */ + /* interpreter atexit processing */ PERLVARI(I, exitlistlen, I32, 0) /* length of same */ PERLVARI(I, exitlist, PerlExitListEntry *, NULL) @@ -445,8 +473,7 @@ PERLVARI(I, profiledata, U32 *, NULL) /* table of ops, counts */ PERLVAR(I, compiling, COP) /* compiling/done executing marker */ PERLVAR(I, compcv, CV *) /* currently compiling subroutine */ -PERLVAR(I, comppad, AV *) /* storage for lexically scoped temporaries */ -PERLVAR(I, comppad_name, AV *) /* variable names for "my" variables */ +PERLVAR(I, comppad_name, PADNAMELIST *) /* variable names for "my" variables */ PERLVAR(I, comppad_name_fill, I32) /* last "introduced" variable offset */ PERLVAR(I, comppad_name_floor, I32) /* start of vars in innermost block */ @@ -459,17 +486,23 @@ PERLVAR(I, sys_intern, struct interp_intern) PERLVAR(I, DBcv, CV *) /* from perl.c */ PERLVARI(I, generation, int, 100) /* from op.c */ +PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ + PERLVARI(I, in_clean_objs,bool, FALSE) /* from sv.c */ PERLVARI(I, in_clean_all, bool, FALSE) /* ptrs to freed SVs now legal */ PERLVAR(I, nomemok, bool) /* let malloc context handle nomem */ PERLVARI(I, savebegin, bool, FALSE) /* save BEGINs for compiler */ + PERLVAR(I, delaymagic_uid, Uid_t) /* current real user id, only for delaymagic */ PERLVAR(I, delaymagic_euid, Uid_t) /* current effective user id, only for delaymagic */ PERLVAR(I, delaymagic_gid, Gid_t) /* current real group id, only for delaymagic */ PERLVAR(I, delaymagic_egid, Gid_t) /* current effective group id, only for delaymagic */ PERLVARI(I, an, U32, 0) /* malloc sequence number */ +/* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */ +PERLVARI(I, breakable_sub_gen, U32, 0) + #ifdef DEBUGGING /* exercise wrap-around */ #define PERL_COP_SEQMAX (U32_MAX-50) @@ -491,31 +524,12 @@ PERLVAR(I, sighandlerp, Sighandler_t) PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */ -PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ +PERLVAR(I, debug, VOL U32) /* flags given to -D switch */ PERLVARI(I, maxo, int, MAXO) /* maximum number of ops */ PERLVARI(I, runops, runops_proc_t, RUNOPS_DEFAULT) -/* -=for apidoc Amn|SV|PL_sv_undef -This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>. - -=for apidoc Amn|SV|PL_sv_no -This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as -C<&PL_sv_no>. - -=for apidoc Amn|SV|PL_sv_yes -This is the C<true> SV. See C<PL_sv_no>. Always refer to this as -C<&PL_sv_yes>. - -=cut -*/ - -PERLVAR(I, sv_undef, SV) -PERLVAR(I, sv_no, SV) -PERLVAR(I, sv_yes, SV) - PERLVAR(I, subname, SV *) /* name of current subroutine */ PERLVAR(I, subline, I32) /* line this subroutine began on */ @@ -528,13 +542,6 @@ PERLVAR(I, padix_floor, I32) /* how low may inner block reset padix */ PERLVAR(I, hints, U32) /* pragma-tic compile-time flags */ -PERLVAR(I, debug, VOL U32) /* flags given to -D switch */ - -/* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */ -PERLVARI(I, breakable_sub_gen, U32, 0) - -PERLVARI(I, amagic_generation, long, 0) - #ifdef USE_LOCALE_COLLATE PERLVAR(I, collation_name, char *) /* Name of current collation */ PERLVAR(I, collxfrm_base, Size_t) /* Basic overhead in *xfrm() */ @@ -544,15 +551,24 @@ PERLVARI(I, collation_standard, bool, TRUE) /* Assume simple collation */ #endif /* USE_LOCALE_COLLATE */ - -#if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING) -# define PERL___I -1 -#else -# define PERL___I 1 +#ifdef PERL_SAWAMPERSAND +PERLVAR(I, sawampersand, U8) /* must save all match strings */ #endif -PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */ -#undef PERL___I +PERLVAR(I, unsafe, bool) +PERLVAR(I, colorset, bool) /* from regcomp.c */ + +/* current phase the interpreter is in + for ordering this structure to remove holes, we're assuming that this is 4 + bytes. */ +PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT) + +PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */ + +/* This value may be set when embedding for full cleanup */ +/* 0=none, 1=full, 2=full with checks */ +/* mod_perl is special, and also assigns a meaning -1 */ +PERLVARI(I, perl_destruct_level, signed char, 0) #ifdef USE_LOCALE_NUMERIC @@ -570,93 +586,39 @@ PERLVAR(I, ASCII, SV *) PERLVAR(I, Latin1, SV *) PERLVAR(I, AboveLatin1, SV *) -PERLVAR(I, PerlSpace, SV *) -PERLVAR(I, XPerlSpace, SV *) - -PERLVAR(I, L1PosixAlnum,SV *) -PERLVAR(I, PosixAlnum, SV *) - -PERLVAR(I, L1PosixAlpha,SV *) -PERLVAR(I, PosixAlpha, SV *) - -PERLVAR(I, PosixBlank, SV *) -PERLVAR(I, XPosixBlank, SV *) - -PERLVAR(I, L1Cased, SV *) - -PERLVAR(I, PosixCntrl, SV *) -PERLVAR(I, XPosixCntrl, SV *) - -PERLVAR(I, PosixDigit, SV *) - -PERLVAR(I, L1PosixGraph,SV *) -PERLVAR(I, PosixGraph, SV *) - -PERLVAR(I, L1PosixLower,SV *) -PERLVAR(I, PosixLower, SV *) - -PERLVAR(I, L1PosixPrint,SV *) -PERLVAR(I, PosixPrint, SV *) - -PERLVAR(I, L1PosixPunct,SV *) -PERLVAR(I, PosixPunct, SV *) - -PERLVAR(I, PosixSpace, SV *) -PERLVAR(I, XPosixSpace, SV *) - -PERLVAR(I, L1PosixUpper,SV *) -PERLVAR(I, PosixUpper, SV *) - -PERLVAR(I, L1PosixWord, SV *) -PERLVAR(I, PosixWord, SV *) - -PERLVAR(I, PosixXDigit, SV *) -PERLVAR(I, XPosixXDigit, SV *) - -PERLVAR(I, VertSpace, SV *) +PERLVAR(I, NonL1NonFinalFold, SV *) +PERLVAR(I, HasMultiCharFold, SV *) /* utf8 character class swashes */ -PERLVAR(I, utf8_alnum, SV *) -PERLVAR(I, utf8_alpha, SV *) -PERLVAR(I, utf8_space, SV *) -PERLVAR(I, utf8_graph, SV *) -PERLVAR(I, utf8_digit, SV *) -PERLVAR(I, utf8_upper, SV *) -PERLVAR(I, utf8_lower, SV *) -PERLVAR(I, utf8_print, SV *) -PERLVAR(I, utf8_punct, SV *) -PERLVAR(I, utf8_xdigit, SV *) PERLVAR(I, utf8_mark, SV *) -PERLVAR(I, utf8_X_begin, SV *) +PERLVAR(I, utf8_X_regular_begin, SV *) PERLVAR(I, utf8_X_extend, SV *) -PERLVAR(I, utf8_X_prepend, SV *) -PERLVAR(I, utf8_X_non_hangul, SV *) -PERLVAR(I, utf8_X_L, SV *) -PERLVAR(I, utf8_X_LV, SV *) -PERLVAR(I, utf8_X_LVT, SV *) -PERLVAR(I, utf8_X_T, SV *) -PERLVAR(I, utf8_X_V, SV *) -PERLVAR(I, utf8_X_LV_LVT_V, SV *) PERLVAR(I, utf8_toupper, SV *) PERLVAR(I, utf8_totitle, SV *) PERLVAR(I, utf8_tolower, SV *) PERLVAR(I, utf8_tofold, SV *) -PERLVAR(I, utf8_quotemeta, SV *) +PERLVAR(I, utf8_charname_begin, SV *) +PERLVAR(I, utf8_charname_continue, SV *) + +PERLVARA(I, utf8_swash_ptrs, POSIX_SWASH_COUNT, SV *) +PERLVARA(I, Posix_ptrs, POSIX_CC_COUNT, SV *) +PERLVARA(I, L1Posix_ptrs, POSIX_CC_COUNT, SV *) +PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV *) + PERLVAR(I, last_swash_hv, HV *) PERLVAR(I, last_swash_tmps, U8 *) PERLVAR(I, last_swash_slen, STRLEN) -PERLVARA(I, last_swash_key,12, U8) +PERLVARA(I, last_swash_key,UTF8_MAXBYTES-1, U8) PERLVAR(I, last_swash_klen, U8) /* Only needs to store 0-12 */ #ifdef FCRYPT PERLVARI(I, cryptseen, bool, FALSE) /* has fast crypt() been initialized? */ +#else +/* One byte hole in the interpreter structure. */ #endif PERLVAR(I, pad_reset_pending, bool) /* reset pad on next attempted alloc */ PERLVAR(I, srand_called, bool) -PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */ - -PERLVAR(I, parser, yy_parser *) /* current parser state */ /* Array of signal handlers, indexed by signal number, through which the C signal handler dispatches. */ @@ -692,6 +654,9 @@ PERLVAR(I, regex_padav, AV *) /* All regex objects, indexed via the Entry 0 is an SV whose PV is a "packed" list of IVs listing the now-free slots in the array */ +PERLVAR(I, stashpad, HV **) /* for CopSTASH */ +PERLVARI(I, stashpadmax, PADOFFSET, 64) +PERLVARI(I, stashpadix, PADOFFSET, 0) #endif #ifdef USE_REENTRANT_API @@ -709,12 +674,11 @@ PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL) PERLVARI(I, encoding, SV *, NULL) /* character encoding */ -PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */ - PERLVAR(I, utf8_idstart, SV *) PERLVAR(I, utf8_idcont, SV *) PERLVAR(I, utf8_xidstart, SV *) PERLVAR(I, utf8_perl_idstart, SV *) +PERLVAR(I, utf8_perl_idcont, SV *) PERLVAR(I, utf8_xidcont, SV *) PERLVAR(I, sort_RealCmp, SVCOMPARE_t) @@ -725,8 +689,6 @@ PERLVARI(I, unitcheckav_save, AV *, NULL) PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */ -PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */ - /* Hooks to shared SVs and locks. */ PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing) PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing) @@ -747,10 +709,6 @@ PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable) PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals) #endif -PERLVARI(I, hash_seed, UV, 0) /* Hash initializer */ - -PERLVARI(I, rehash_seed, UV, 0) /* 582 hash initializer */ - PERLVARI(I, isarev, HV *, NULL) /* Reverse map of @ISA dependencies */ /* Register of known Method Resolution Orders. @@ -772,17 +730,22 @@ PERLVARI(I, utf8_foldable, SV *, NULL) PERLVAR(I, custom_ops, HV *) /* custom op registrations */ +PERLVAR(I, Xpv, XPV *) /* (unused) held temporary value */ + +/* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be + present always, as -DDEBUGGING must be binary compatible with non. */ +PERLVARI(I, scopestack_name, const char * *, NULL) + +PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */ + /* Hook for File::Glob */ PERLVARI(I, globhook, globhook_t, NULL) -PERLVARI(I, glob_index, int, 0) -PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */ - -/* The last unconditional member of the interpreter structure when 5.10.0 was +/* The last unconditional member of the interpreter structure when 5.18.2 was released. The offset of the end of this is baked into a global variable in any shared perl library which will allow a sanity test in future perl releases. */ -#define PERL_LAST_5_16_0_INTERP_MEMBER Ireentrant_retint +#define PERL_LAST_5_18_0_INTERP_MEMBER Iglobhook #ifdef PERL_IMPLICIT_CONTEXT PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */ @@ -808,17 +771,6 @@ PERLVARI(I, madskills, bool, FALSE) /* preserve all syntactic info */ PERLVARI(I, xmlfp, PerlIO *, NULL) #endif -#ifdef PL_OP_SLAB_ALLOC -PERLVAR(I, OpPtr, I32 **) -PERLVARI(I, OpSpace, I32, 0) -PERLVAR(I, OpSlab, I32 *) -#endif - -#ifdef PERL_DEBUG_READONLY_OPS -PERLVARI(I, slabs, I32**, NULL) /* Array of slabs that have been allocated */ -PERLVARI(I, slab_count, U32, 0) /* Size of the array */ -#endif - #ifdef DEBUG_LEAKING_SCALARS PERLVARI(I, sv_serial, U32, 0) /* SV serial number, used in sv.c */ #endif diff --git a/Master/tlpkg/tlperl/lib/CORE/iperlsys.h b/Master/tlpkg/tlperl/lib/CORE/iperlsys.h index 0bfad3ce09f..b23f4d3eb29 100644 --- a/Master/tlpkg/tlperl/lib/CORE/iperlsys.h +++ b/Master/tlpkg/tlperl/lib/CORE/iperlsys.h @@ -1416,8 +1416,8 @@ struct IPerlSockInfo * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/l1_char_class_tab.h b/Master/tlpkg/tlperl/lib/CORE/l1_char_class_tab.h index d649c89d8a7..b5bf444a6af 100644 --- a/Master/tlpkg/tlperl/lib/CORE/l1_char_class_tab.h +++ b/Master/tlpkg/tlperl/lib/CORE/l1_char_class_tab.h @@ -1,265 +1,264 @@ /* -*- buffer-read-only: t -*- * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! - * This file is built by regen/mk_PL_charclass.pl from property definitions - * and lib/unicore/CaseFolding.txt. + * This file is built by regen/mk_PL_charclass.pl from property definitions. * Any changes made here will be lost! */ -/* U+00 NUL */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+01 SOH */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+02 STX */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+03 ETX */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+04 EOT */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+05 ENQ */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+06 ACK */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+07 BEL */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+08 BS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+09 HT */ _CC_BLANK_A|_CC_BLANK_L1|_CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+0A LF */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+0B VT */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_QUOTEMETA, -/* U+0C FF */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+0D CR */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+0E SO */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+0F SI */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+10 DLE */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+11 DC1 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+12 DC2 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+13 DC3 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+14 DC4 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+15 NAK */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+16 SYN */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+17 ETB */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+18 CAN */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+19 EOM */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+1A SUB */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+1B ESC */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+1C FS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+1D GS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+1E RS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+1F US */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+20 SPACE */ _CC_BLANK_A|_CC_BLANK_L1|_CC_CHARNAME_CONT|_CC_PRINT_A|_CC_PRINT_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+21 '!' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+22 '"' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+23 '#' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+24 '$' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+25 '%' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+26 '&' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+27 ''' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+28 '(' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+29 ')' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+2A '*' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+2B '+' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+2C ',' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+2D '-' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+2E '.' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+2F '/' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+30 '0' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+31 '1' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+32 '2' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+33 '3' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+34 '4' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+35 '5' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+36 '6' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+37 '7' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+38 '8' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+39 '9' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+3A ':' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+3B ';' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+3C '<' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+3D '=' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+3E '>' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+3F '?' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+40 '@' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+41 'A' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+42 'B' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+43 'C' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+44 'D' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+45 'E' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+46 'F' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+47 'G' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+48 'H' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+49 'I' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+4A 'J' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+4B 'K' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+4C 'L' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+4D 'M' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+4E 'N' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+4F 'O' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+50 'P' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+51 'Q' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+52 'R' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+53 'S' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+54 'T' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+55 'U' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+56 'V' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+57 'W' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+58 'X' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+59 'Y' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+5A 'Z' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+5B '[' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+5C '\' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+5D ']' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+5E '^' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+5F '_' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+60 '`' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+61 'a' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+62 'b' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+63 'c' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+64 'd' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+65 'e' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+66 'f' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, -/* U+67 'g' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+68 'h' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+69 'i' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+6A 'j' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+6B 'k' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+6C 'l' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+6D 'm' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+6E 'n' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+6F 'o' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+70 'p' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+71 'q' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+72 'r' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+73 's' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+74 't' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+75 'u' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+76 'v' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+77 'w' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+78 'x' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+79 'y' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+7A 'z' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, -/* U+7B '{' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+7C '|' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+7D '}' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+7E '~' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+7F DEL */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+80 PAD */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+81 HOP */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+82 BPH */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+83 NBH */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+84 IND */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+85 NEL */ _CC_CNTRL_L1|_CC_PSXSPC_L1|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+86 SSA */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+87 ESA */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+88 HTS */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+89 HTJ */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+8A VTS */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+8B PLD */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+8C PLU */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+8D RI */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+8E SS2 */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+8F SS3 */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+90 DCS */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+91 PU1 */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+92 PU2 */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+93 STS */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+94 CCH */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+95 MW */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+96 SPA */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+97 EPA */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+98 SOS */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+99 SGC */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+9A SCI */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+9B CSI */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+9C ST */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+9D OSC */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+9E PM */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+9F APC */ _CC_CNTRL_L1|_CC_QUOTEMETA, -/* U+A0 NO-BREAK SPACE */ _CC_BLANK_L1|_CC_CHARNAME_CONT|_CC_PRINT_L1|_CC_PSXSPC_L1|_CC_SPACE_L1|_CC_QUOTEMETA, -/* U+A1 INVERTED EXCLAMATION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+A2 CENT SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+A3 POUND SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+A4 CURRENCY SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+A5 YEN SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+A6 BROKEN BAR */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+A7 SECTION SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+A8 DIAERESIS */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+A9 COPYRIGHT SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+AA FEMININE ORDINAL INDICATOR */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+AC NOT SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+AD SOFT HYPHEN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+AE REGISTERED SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+AF MACRON */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+B0 DEGREE SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+B1 PLUS-MINUS SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+B2 SUPERSCRIPT TWO */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+B3 SUPERSCRIPT THREE */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+B4 ACUTE ACCENT */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+B5 MICRO SIGN */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+B6 PILCROW SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+B7 MIDDLE DOT */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1, -/* U+B8 CEDILLA */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+B9 SUPERSCRIPT ONE */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+BA MASCULINE ORDINAL INDICATOR */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+BC VULGAR FRACTION ONE QUARTER */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+BD VULGAR FRACTION ONE HALF */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+BE VULGAR FRACTION THREE QUARTERS */ _CC_GRAPH_L1|_CC_PRINT_L1, -/* U+BF INVERTED QUESTION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, -/* U+C0 A WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C1 A WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C2 A WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C3 A WITH TILDE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C4 A WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C5 A WITH RING ABOVE */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C6 AE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C7 C WITH CEDILLA */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C8 E WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+C9 E WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+CA E WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+CB E WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+CC I WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+CD I WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+CE I WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+CF I WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D0 ETH */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D1 N WITH TILDE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D2 O WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D3 O WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D4 O WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D5 O WITH TILDE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D6 O WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D7 MULTIPLICATION SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+D8 O WITH STROKE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+D9 U WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+DA U WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+DB U WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+DC U WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+DD Y WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+DE THORN */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, -/* U+DF sharp s */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E0 a with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E1 a with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E2 a with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E3 a with tilde */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E4 a with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E5 a with ring above */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E6 ae */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E7 c with cedilla */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E8 e with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+E9 e with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+EA e with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+EB e with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+EC i with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+ED i with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+EE i with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+EF i with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F0 eth */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F1 n with tilde */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F2 o with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F3 o with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F4 o with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F5 o with tilde */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F6 o with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F7 DIVISION SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, -/* U+F8 o with stroke */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+F9 u with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+FA u with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+FB u with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+FC u with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+FD y with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+FE thorn */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, -/* U+FF y with diaeresis */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, +/* U+00 NUL */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+01 SOH */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+02 STX */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+03 ETX */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+04 EOT */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+05 ENQ */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+06 ACK */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+07 BEL */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+08 BS */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+09 HT */ (1U<<_CC_ASCII)|(1U<<_CC_BLANK)|(1U<<_CC_CNTRL)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE), +/* U+0A LF */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE)|(1U<<_CC_VERTSPACE), +/* U+0B VT */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE)|(1U<<_CC_VERTSPACE), +/* U+0C FF */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE)|(1U<<_CC_VERTSPACE), +/* U+0D CR */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE)|(1U<<_CC_VERTSPACE), +/* U+0E SO */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+0F SI */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+10 DLE */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+11 DC1 */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+12 DC2 */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+13 DC3 */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+14 DC4 */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+15 NAK */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+16 SYN */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+17 ETB */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+18 CAN */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+19 EOM */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+1A SUB */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+1B ESC */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+1C FS */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+1D GS */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+1E RS */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+1F US */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+20 SPACE */ (1U<<_CC_ASCII)|(1U<<_CC_BLANK)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_PRINT)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE), +/* U+21 '!' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+22 '"' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+23 '#' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+24 '$' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+25 '%' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+26 '&' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+27 ''' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+28 '(' */ (1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+29 ')' */ (1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+2A '*' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+2B '+' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+2C ',' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+2D '-' */ (1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+2E '.' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+2F '/' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+30 '0' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+31 '1' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+32 '2' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+33 '3' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+34 '4' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+35 '5' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+36 '6' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+37 '7' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+38 '8' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+39 '9' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_DIGIT)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT), +/* U+3A ':' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+3B ';' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+3C '<' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+3D '=' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+3E '>' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+3F '?' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+40 '@' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+41 'A' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+42 'B' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+43 'C' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+44 'D' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+45 'E' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+46 'F' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+47 'G' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+48 'H' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+49 'I' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+4A 'J' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+4B 'K' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+4C 'L' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+4D 'M' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+4E 'N' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+4F 'O' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+50 'P' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+51 'Q' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+52 'R' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+53 'S' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+54 'T' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+55 'U' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+56 'V' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+57 'W' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+58 'X' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+59 'Y' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+5A 'Z' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+5B '[' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+5C '\' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+5D ']' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+5E '^' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+5F '_' */ (1U<<_CC_ASCII)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_WORDCHAR), +/* U+60 '`' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+61 'a' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+62 'b' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+63 'c' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+64 'd' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+65 'e' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+66 'f' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_XDIGIT)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+67 'g' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+68 'h' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+69 'i' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+6A 'j' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+6B 'k' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+6C 'l' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+6D 'm' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+6E 'n' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+6F 'o' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+70 'p' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+71 'q' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+72 'r' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+73 's' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+74 't' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+75 'u' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+76 'v' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+77 'w' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+78 'x' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD)|(1U<<_CC_BACKSLASH_FOO_LBRACE_IS_META), +/* U+79 'y' */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_NON_FINAL_FOLD)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+7A 'z' */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_ASCII)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+7B '{' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+7C '|' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+7D '}' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+7E '~' */ (1U<<_CC_ASCII)|(1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+7F DEL */ (1U<<_CC_ASCII)|(1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+80 PAD */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+81 HOP */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+82 BPH */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+83 NBH */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+84 IND */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+85 NEL */ (1U<<_CC_CNTRL)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE)|(1U<<_CC_VERTSPACE), +/* U+86 SSA */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+87 ESA */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+88 HTS */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+89 HTJ */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+8A VTS */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+8B PLD */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+8C PLU */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+8D RI */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+8E SS2 */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+8F SS3 */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+90 DCS */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+91 PU1 */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+92 PU2 */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+93 STS */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+94 CCH */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+95 MW */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+96 SPA */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+97 EPA */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+98 SOS */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+99 SGC */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+9A SCI */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+9B CSI */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+9C ST */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+9D OSC */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+9E PM */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+9F APC */ (1U<<_CC_CNTRL)|(1U<<_CC_QUOTEMETA), +/* U+A0 NO-BREAK SPACE */ (1U<<_CC_BLANK)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_PRINT)|(1U<<_CC_PSXSPC)|(1U<<_CC_QUOTEMETA)|(1U<<_CC_SPACE), +/* U+A1 INVERTED EXCLAMATION MARK */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+A2 CENT SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+A3 POUND SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+A4 CURRENCY SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+A5 YEN SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+A6 BROKEN BAR */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+A7 SECTION SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+A8 DIAERESIS */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+A9 COPYRIGHT SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+AA FEMININE ORDINAL INDICATOR */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR), +/* U+AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+AC NOT SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+AD SOFT HYPHEN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+AE REGISTERED SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+AF MACRON */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+B0 DEGREE SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+B1 PLUS-MINUS SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+B2 SUPERSCRIPT TWO */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+B3 SUPERSCRIPT THREE */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+B4 ACUTE ACCENT */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+B5 MICRO SIGN */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+B6 PILCROW SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+B7 MIDDLE DOT */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT), +/* U+B8 CEDILLA */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+B9 SUPERSCRIPT ONE */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+BA MASCULINE ORDINAL INDICATOR */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR), +/* U+BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+BC VULGAR FRACTION ONE QUARTER */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+BD VULGAR FRACTION ONE HALF */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+BE VULGAR FRACTION THREE QUARTERS */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT), +/* U+BF INVERTED QUESTION MARK */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_PUNCT)|(1U<<_CC_QUOTEMETA), +/* U+C0 A WITH GRAVE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C1 A WITH ACUTE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C2 A WITH CIRCUMFLEX */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C3 A WITH TILDE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C4 A WITH DIAERESIS */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C5 A WITH RING ABOVE */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C6 AE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C7 C WITH CEDILLA */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C8 E WITH GRAVE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+C9 E WITH ACUTE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+CA E WITH CIRCUMFLEX */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+CB E WITH DIAERESIS */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+CC I WITH GRAVE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+CD I WITH ACUTE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+CE I WITH CIRCUMFLEX */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+CF I WITH DIAERESIS */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D0 ETH */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D1 N WITH TILDE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D2 O WITH GRAVE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D3 O WITH ACUTE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D4 O WITH CIRCUMFLEX */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D5 O WITH TILDE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D6 O WITH DIAERESIS */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D7 MULTIPLICATION SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+D8 O WITH STROKE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+D9 U WITH GRAVE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+DA U WITH ACUTE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+DB U WITH CIRCUMFLEX */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+DC U WITH DIAERESIS */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+DD Y WITH ACUTE */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+DE THORN */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_PRINT)|(1U<<_CC_UPPER)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+DF sharp s */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E0 a with grave */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E1 a with acute */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E2 a with circumflex */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E3 a with tilde */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E4 a with diaeresis */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E5 a with ring above */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E6 ae */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E7 c with cedilla */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E8 e with grave */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+E9 e with acute */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+EA e with circumflex */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+EB e with diaeresis */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+EC i with grave */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+ED i with acute */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+EE i with circumflex */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+EF i with diaeresis */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F0 eth */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F1 n with tilde */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F2 o with grave */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F3 o with acute */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F4 o with circumflex */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F5 o with tilde */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F6 o with diaeresis */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F7 DIVISION SIGN */ (1U<<_CC_GRAPH)|(1U<<_CC_PRINT)|(1U<<_CC_QUOTEMETA), +/* U+F8 o with stroke */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+F9 u with grave */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+FA u with acute */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+FB u with circumflex */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+FC u with diaeresis */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+FD y with acute */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+FE thorn */ (1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), +/* U+FF y with diaeresis */ (1U<<_CC_NONLATIN1_FOLD)|(1U<<_CC_ALPHANUMERIC)|(1U<<_CC_ALPHA)|(1U<<_CC_CASED)|(1U<<_CC_CHARNAME_CONT)|(1U<<_CC_GRAPH)|(1U<<_CC_IDFIRST)|(1U<<_CC_LOWER)|(1U<<_CC_PRINT)|(1U<<_CC_WORDCHAR)|(1U<<_CC_IS_IN_SOME_FOLD), /* ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/libperl518.a b/Master/tlpkg/tlperl/lib/CORE/libperl518.a Binary files differnew file mode 100755 index 00000000000..ad9154cfd61 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/CORE/libperl518.a diff --git a/Master/tlpkg/tlperl/lib/CORE/metaconfig.h b/Master/tlpkg/tlperl/lib/CORE/metaconfig.h index 7fb867edeb4..0a90c86ed03 100644 --- a/Master/tlpkg/tlperl/lib/CORE/metaconfig.h +++ b/Master/tlpkg/tlperl/lib/CORE/metaconfig.h @@ -10,6 +10,7 @@ * they won't be available unless used. When new symbols are probed * in Configure, this is the way to force them into availability. * + * BOOTSTRAP_CHARSET * CHARBITS * HAS_ASCTIME64 * HAS_CTIME64 @@ -17,7 +18,10 @@ * HAS_GMTIME64 * HAS_ISBLANK * HAS_LOCALTIME64 + * HAS_IP_MREQ + * HAS_IP_MREQ_SOURCE * HAS_IPV6_MREQ + * HAS_IPV6_MREQ_SOURCE * HAS_MKTIME64 * HAS_PRCTL * HAS_PSEUDOFORK diff --git a/Master/tlpkg/tlperl/lib/CORE/mg.h b/Master/tlpkg/tlperl/lib/CORE/mg.h index 53ef6287513..995bc5eb1ab 100644 --- a/Master/tlpkg/tlperl/lib/CORE/mg.h +++ b/Master/tlpkg/tlperl/lib/CORE/mg.h @@ -67,8 +67,8 @@ struct magic { * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/mg_data.h b/Master/tlpkg/tlperl/lib/CORE/mg_data.h index 10b10682488..23645abef46 100644 --- a/Master/tlpkg/tlperl/lib/CORE/mg_data.h +++ b/Master/tlpkg/tlperl/lib/CORE/mg_data.h @@ -40,7 +40,8 @@ 0, /* rhash '%' extra data for restricted hashes */ magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, - 0, + /* proto '&' my sub prototype CV */ + magic_vtable_max, 0, 0, 0, @@ -71,8 +72,7 @@ 0, /* arylen_p '@' to move arylen out of XPVAV */ magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, - /* overload 'A' %OVERLOAD hash */ - want_vtbl_amagic, + 0, /* bm 'B' Boyer-Moore (fast string search) */ want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, 0, @@ -81,8 +81,7 @@ /* env 'E' %ENV hash */ want_vtbl_env, 0, - /* study 'G' study()ed string */ - want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, + 0, /* hints 'H' %^H hash */ want_vtbl_hints, /* isa 'I' @ISA array */ @@ -104,7 +103,7 @@ /* uvar 'U' Available for use by extensions */ want_vtbl_uvar, /* vstring 'V' SV was vstring literal */ - want_vtbl_vstring | PERL_MAGIC_VALUE_MAGIC, + magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, 0, 0, 0, @@ -112,12 +111,11 @@ 0, 0, /* checkcall ']' inlining/mutation of call to this CV */ - magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, + want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC, + 0, 0, 0, 0, - /* overload_elem 'a' %OVERLOAD hash element */ - want_vtbl_amagicelem, 0, /* overload_table 'c' Holds overload table (AMT) on stash */ want_vtbl_ovrld, @@ -126,7 +124,7 @@ /* envelem 'e' %ENV hash element */ want_vtbl_envelem, /* fm 'f' Formline ('compiled' format) */ - want_vtbl_regdata | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, + want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, /* regex_global 'g' m//g target */ want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, /* hintselem 'h' %^H hash element */ diff --git a/Master/tlpkg/tlperl/lib/CORE/mg_raw.h b/Master/tlpkg/tlperl/lib/CORE/mg_raw.h index f4e174247bd..487e209da1f 100644 --- a/Master/tlpkg/tlperl/lib/CORE/mg_raw.h +++ b/Master/tlpkg/tlperl/lib/CORE/mg_raw.h @@ -12,6 +12,8 @@ "/* arylen '#' Array length ($#ary) */" }, { '%', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", "/* rhash '%' extra data for restricted hashes */" }, + { '&', "magic_vtable_max", + "/* proto '&' my sub prototype CV */" }, { '.', "want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC", "/* pos '.' pos() lvalue */" }, { ':', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", @@ -20,10 +22,6 @@ "/* backref '<' for weak ref data */" }, { '@', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", "/* arylen_p '@' to move arylen out of XPVAV */" }, - { 'A', "want_vtbl_amagic", - "/* overload 'A' %OVERLOAD hash */" }, - { 'a', "want_vtbl_amagicelem", - "/* overload_elem 'a' %OVERLOAD hash element */" }, { 'B', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* bm 'B' Boyer-Moore (fast string search) */" }, { 'c', "want_vtbl_ovrld", @@ -36,10 +34,8 @@ "/* env 'E' %ENV hash */" }, { 'e', "want_vtbl_envelem", "/* envelem 'e' %ENV hash element */" }, - { 'f', "want_vtbl_regdata | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", + { 'f', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* fm 'f' Formline ('compiled' format) */" }, - { 'G', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", - "/* study 'G' study()ed string */" }, { 'g', "want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* regex_global 'g' m//g target */" }, { 'H', "want_vtbl_hints", @@ -74,7 +70,7 @@ "/* taint 't' Taintedness */" }, { 'U', "want_vtbl_uvar", "/* uvar 'U' Available for use by extensions */" }, - { 'V', "want_vtbl_vstring | PERL_MAGIC_VALUE_MAGIC", + { 'V', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", "/* vstring 'V' SV was vstring literal */" }, { 'v', "want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC", "/* vec 'v' vec() lvalue */" }, @@ -84,7 +80,7 @@ "/* substr 'x' substr() lvalue */" }, { 'y', "want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC", "/* defelem 'y' Shadow \"foreach\" iterator variable / smart parameter vivification */" }, - { ']', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", + { ']', "want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC", "/* checkcall ']' inlining/mutation of call to this CV */" }, { '~', "magic_vtable_max", "/* ext '~' Available for use by extensions */" }, diff --git a/Master/tlpkg/tlperl/lib/CORE/mg_vtable.h b/Master/tlpkg/tlperl/lib/CORE/mg_vtable.h index 12f2fa35f32..f3917137619 100644 --- a/Master/tlpkg/tlperl/lib/CORE/mg_vtable.h +++ b/Master/tlpkg/tlperl/lib/CORE/mg_vtable.h @@ -15,12 +15,11 @@ #define PERL_MAGIC_sv '\0' /* Special scalar variable */ #define PERL_MAGIC_arylen '#' /* Array length ($#ary) */ #define PERL_MAGIC_rhash '%' /* extra data for restricted hashes */ +#define PERL_MAGIC_proto '&' /* my sub prototype CV */ #define PERL_MAGIC_pos '.' /* pos() lvalue */ #define PERL_MAGIC_symtab ':' /* extra data for symbol tables */ #define PERL_MAGIC_backref '<' /* for weak ref data */ #define PERL_MAGIC_arylen_p '@' /* to move arylen out of XPVAV */ -#define PERL_MAGIC_overload 'A' /* %OVERLOAD hash */ -#define PERL_MAGIC_overload_elem 'a' /* %OVERLOAD hash element */ #define PERL_MAGIC_bm 'B' /* Boyer-Moore (fast string search) */ #define PERL_MAGIC_overload_table 'c' /* Holds overload table (AMT) on stash */ #define PERL_MAGIC_regdata 'D' /* Regex match position data @@ -29,7 +28,6 @@ #define PERL_MAGIC_env 'E' /* %ENV hash */ #define PERL_MAGIC_envelem 'e' /* %ENV hash element */ #define PERL_MAGIC_fm 'f' /* Formline ('compiled' format) */ -#define PERL_MAGIC_study 'G' /* study()ed string */ #define PERL_MAGIC_regex_global 'g' /* m//g target */ #define PERL_MAGIC_hints 'H' /* %^H hash */ #define PERL_MAGIC_hintselem 'h' /* %^H hash element */ @@ -60,11 +58,10 @@ #define PERL_MAGIC_ext '~' /* Available for use by extensions */ enum { /* pass one of these to get_vtbl */ - want_vtbl_amagic, - want_vtbl_amagicelem, want_vtbl_arylen, want_vtbl_arylen_p, want_vtbl_backref, + want_vtbl_checkcall, want_vtbl_collxfrm, want_vtbl_dbline, want_vtbl_defelem, @@ -90,17 +87,15 @@ enum { /* pass one of these to get_vtbl */ want_vtbl_utf8, want_vtbl_uvar, want_vtbl_vec, - want_vtbl_vstring, magic_vtable_max }; #ifdef DOINIT -EXTCONST char *PL_magic_vtable_names[magic_vtable_max] = { - "amagic", - "amagicelem", +EXTCONST char * const PL_magic_vtable_names[magic_vtable_max] = { "arylen", "arylen_p", "backref", + "checkcall", "collxfrm", "dbline", "defelem", @@ -125,11 +120,10 @@ EXTCONST char *PL_magic_vtable_names[magic_vtable_max] = { "taint", "utf8", "uvar", - "vec", - "vstring" + "vec" }; #else -EXTCONST char *PL_magic_vtable_names[magic_vtable_max]; +EXTCONST char * const PL_magic_vtable_names[magic_vtable_max]; #endif /* These all need to be 0, not NULL, as NULL can be (void*)0, which is a @@ -151,11 +145,10 @@ EXTCONST char *PL_magic_vtable_names[magic_vtable_max]; #ifdef DOINIT EXT_MGVTBL PL_magic_vtables[magic_vtable_max] = { - { 0, Perl_magic_setamagic, 0, 0, Perl_magic_setamagic, 0, 0, 0 }, - { 0, Perl_magic_setamagic, 0, 0, Perl_magic_setamagic, 0, 0, 0 }, { (int (*)(pTHX_ SV *, MAGIC *))Perl_magic_getarylen, Perl_magic_setarylen, 0, 0, 0, 0, 0, 0 }, - { 0, 0, 0, 0, Perl_magic_freearylen_p, 0, 0, 0 }, + { 0, 0, 0, Perl_magic_cleararylen_p, Perl_magic_freearylen_p, 0, 0, 0 }, { 0, 0, 0, 0, Perl_magic_killbackrefs, 0, 0, 0 }, + { 0, 0, 0, 0, 0, Perl_magic_copycallchecker, 0, 0 }, #ifdef USE_LOCALE_COLLATE { 0, Perl_magic_setcollxfrm, 0, 0, 0, 0, 0, 0 }, #else @@ -184,12 +177,11 @@ EXT_MGVTBL PL_magic_vtables[magic_vtable_max] = { { 0, 0, 0, 0, 0, 0, 0, 0 }, #endif { Perl_magic_getsubstr, Perl_magic_setsubstr, 0, 0, 0, 0, 0, 0 }, - { Perl_magic_get, Perl_magic_set, Perl_magic_len, 0, 0, 0, 0, 0 }, + { Perl_magic_get, Perl_magic_set, 0, 0, 0, 0, 0, 0 }, { Perl_magic_gettaint, Perl_magic_settaint, 0, 0, 0, 0, 0, 0 }, { 0, Perl_magic_setutf8, 0, 0, 0, 0, 0, 0 }, { Perl_magic_getuvar, Perl_magic_setuvar, 0, 0, 0, 0, 0, 0 }, - { Perl_magic_getvec, Perl_magic_setvec, 0, 0, 0, 0, 0, 0 }, - { 0, Perl_magic_setvstring, 0, 0, 0, 0, 0, 0 } + { Perl_magic_getvec, Perl_magic_setvec, 0, 0, 0, 0, 0, 0 } }; #else EXT_MGVTBL PL_magic_vtables[magic_vtable_max]; @@ -198,12 +190,11 @@ EXT_MGVTBL PL_magic_vtables[magic_vtable_max]; #define want_vtbl_bm want_vtbl_regexp #define want_vtbl_fm want_vtbl_regexp -#define PL_vtbl_amagic PL_magic_vtables[want_vtbl_amagic] -#define PL_vtbl_amagicelem PL_magic_vtables[want_vtbl_amagicelem] #define PL_vtbl_arylen PL_magic_vtables[want_vtbl_arylen] #define PL_vtbl_arylen_p PL_magic_vtables[want_vtbl_arylen_p] #define PL_vtbl_backref PL_magic_vtables[want_vtbl_backref] #define PL_vtbl_bm PL_magic_vtables[want_vtbl_bm] +#define PL_vtbl_checkcall PL_magic_vtables[want_vtbl_checkcall] #define PL_vtbl_collxfrm PL_magic_vtables[want_vtbl_collxfrm] #define PL_vtbl_dbline PL_magic_vtables[want_vtbl_dbline] #define PL_vtbl_defelem PL_magic_vtables[want_vtbl_defelem] @@ -230,6 +221,5 @@ EXT_MGVTBL PL_magic_vtables[magic_vtable_max]; #define PL_vtbl_utf8 PL_magic_vtables[want_vtbl_utf8] #define PL_vtbl_uvar PL_magic_vtables[want_vtbl_uvar] #define PL_vtbl_vec PL_magic_vtables[want_vtbl_vec] -#define PL_vtbl_vstring PL_magic_vtables[want_vtbl_vstring] /* ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/mydtrace.h b/Master/tlpkg/tlperl/lib/CORE/mydtrace.h index 5a2e35fe7fc..5093f466ab2 100644 --- a/Master/tlpkg/tlperl/lib/CORE/mydtrace.h +++ b/Master/tlpkg/tlperl/lib/CORE/mydtrace.h @@ -32,6 +32,18 @@ PERL_SUB_RETURN(tmp_func, file, line, stash); \ } +# define LOADING_FILE_PROBE(name) \ + if (PERL_LOADING_FILE_ENABLED()) { \ + const char *tmp_name = name; \ + PERL_LOADING_FILE(tmp_name); \ + } + +# define LOADED_FILE_PROBE(name) \ + if (PERL_LOADED_FILE_ENABLED()) { \ + const char *tmp_name = name; \ + PERL_LOADED_FILE(tmp_name); \ + } + # else # define ENTRY_PROBE(func, file, line, stash) \ @@ -44,8 +56,23 @@ PERL_SUB_RETURN(func, file, line, stash); \ } +# define LOADING_FILE_PROBE(name) \ + if (PERL_LOADING_FILE_ENABLED()) { \ + PERL_LOADING_FILE(name); \ + } + +# define LOADED_FILE_PROBE(name) \ + if (PERL_LOADED_FILE_ENABLED()) { \ + PERL_LOADED_FILE(name); \ + } + # endif +# define OP_ENTRY_PROBE(name) \ + if (PERL_OP_ENTRY_ENABLED()) { \ + PERL_OP_ENTRY(name); \ + } + # define PHASE_CHANGE_PROBE(new_phase, old_phase) \ if (PERL_PHASE_CHANGE_ENABLED()) { \ PERL_PHASE_CHANGE(new_phase, old_phase); \ @@ -57,6 +84,9 @@ # define ENTRY_PROBE(func, file, line, stash) # define RETURN_PROBE(func, file, line, stash) # define PHASE_CHANGE_PROBE(new_phase, old_phase) +# define OP_ENTRY_PROBE(name) +# define LOADING_FILE_PROBE(name) +# define LOADED_FILE_PROBE(name) #endif @@ -64,8 +94,8 @@ * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/nostdio.h b/Master/tlpkg/tlperl/lib/CORE/nostdio.h index f6a13b4998c..ef8d6526b45 100644 --- a/Master/tlpkg/tlperl/lib/CORE/nostdio.h +++ b/Master/tlpkg/tlperl/lib/CORE/nostdio.h @@ -129,8 +129,8 @@ struct _FILE; * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/op.h b/Master/tlpkg/tlperl/lib/CORE/op.h index 05cd323d694..7c5030dde70 100644 --- a/Master/tlpkg/tlperl/lib/CORE/op.h +++ b/Master/tlpkg/tlperl/lib/CORE/op.h @@ -19,17 +19,11 @@ * op_type The type of the operation. * op_opt Whether or not the op has been optimised by the * peephole optimiser. - * - * See the comments in S_clear_yystack() for more - * details on the following three flags: - * - * op_latefree tell op_free() to clear this op (and free any kids) - * but not yet deallocate the struct. This means that - * the op may be safely op_free()d multiple times - * op_latefreed an op_latefree op has been op_free()d - * op_attached this op (sub)tree has been attached to a CV - * - * op_spare three spare bits! + * op_slabbed allocated via opslab + * op_static tell op_free() to skip PerlMemShared_free(), when + * !op_slabbed. + * op_savefree on savestack via SAVEFREEOP + * op_spare Three spare bits * op_flags Flags common to all operations. See OPf_* below. * op_private Flags peculiar to a particular operation (BUT, * by default, set to the number of children until @@ -59,9 +53,9 @@ typedef PERL_BITFIELD16 Optype; PADOFFSET op_targ; \ PERL_BITFIELD16 op_type:9; \ PERL_BITFIELD16 op_opt:1; \ - PERL_BITFIELD16 op_latefree:1; \ - PERL_BITFIELD16 op_latefreed:1; \ - PERL_BITFIELD16 op_attached:1; \ + PERL_BITFIELD16 op_slabbed:1; \ + PERL_BITFIELD16 op_savefree:1; \ + PERL_BITFIELD16 op_static:1; \ PERL_BITFIELD16 op_spare:3; \ U8 op_flags; \ U8 op_private; @@ -72,11 +66,9 @@ typedef PERL_BITFIELD16 Optype; then all the other bit-fields before/after it should change their types too to let VC pack them into the same 4 byte integer.*/ +/* for efficiency, requires OPf_WANT_VOID == G_VOID etc */ #define OP_GIMME(op,dfl) \ - (((op)->op_flags & OPf_WANT) == OPf_WANT_VOID ? G_VOID : \ - ((op)->op_flags & OPf_WANT) == OPf_WANT_SCALAR ? G_SCALAR : \ - ((op)->op_flags & OPf_WANT) == OPf_WANT_LIST ? G_ARRAY : \ - dfl) + (((op)->op_flags & OPf_WANT) ? ((op)->op_flags & OPf_WANT) : dfl) #define OP_GIMME_REVERSE(flags) ((flags) & G_WANT) @@ -123,7 +115,7 @@ Deprecated. Use C<GIMME_V> instead. /* On OP_ENTERSUB || OP_NULL, saw a "do". */ /* On OP_EXISTS, treat av as av, not avhv. */ /* On OP_(ENTER|LEAVE)EVAL, don't clear $@ */ - /* On pushre, rx is used as part of split, e.g. split " " */ + /* On pushre, rx is used as part of split, e.g. split " " */ /* On regcomp, "use re 'eval'" was in scope */ /* On OP_READLINE, was <$filehandle> */ /* On RV2[ACGHS]V, don't create GV--in @@ -148,6 +140,7 @@ Deprecated. Use C<GIMME_V> instead. - Before ck_glob, called as CORE::glob - After ck_glob, use Perl glob function */ + /* On OP_PADRANGE, push @_ */ /* old names; don't use in new code, but don't break them, either */ #define OPf_LIST OPf_WANT_LIST @@ -183,7 +176,7 @@ Deprecated. Use C<GIMME_V> instead. #define OPpASSIGN_BACKWARDS 64 /* Left & right switched. */ #define OPpASSIGN_CV_TO_GV 128 /* Possible optimisation for constants. */ -/* Private for OP_MATCH and OP_SUBST{,CONST} */ +/* Private for OP_MATCH and OP_SUBST{,CONT} */ #define OPpRUNTIME 64 /* Pattern coming in on the stack */ /* Private for OP_TRANS */ @@ -230,6 +223,11 @@ Deprecated. Use C<GIMME_V> instead. /* OP_RV2[AGH]V, OP_PAD[AH]V, OP_[AH]ELEM, OP_[AH]SLICE OP_AV2ARYLEN, OP_R?KEYS, OP_SUBSTR, OP_POS, OP_VEC */ #define OPpMAYBE_LVSUB 8 /* We might be an lvalue to return */ + /* OP_RV2HV and OP_PADHV */ +#define OPpTRUEBOOL 32 /* %hash in (%hash || $foo) in + void context */ +#define OPpMAYBE_TRUEBOOL 64 /* %hash in (%hash || $foo) where + cx is not known till run time */ /* OP_SUBSTR only */ #define OPpSUBSTR_REPL_FIRST 16 /* 1st arg is replacement string */ @@ -238,6 +236,11 @@ Deprecated. Use C<GIMME_V> instead. #define OPpPAD_STATE 16 /* is a "state" pad */ /* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */ + /* OP_PADRANGE only */ + /* bit 7 is OPpLVAL_INTRO */ +#define OPpPADRANGE_COUNTMASK 127 /* bits 6..0 hold target range, */ +#define OPpPADRANGE_COUNTSHIFT 7 /* 7 bits in total */ + /* OP_RV2GV only */ #define OPpDONT_INIT_GV 4 /* Call gv_fetchpv with GV_NOINIT */ /* (Therefore will return whatever is currently in the symbol table, not @@ -254,7 +257,7 @@ Deprecated. Use C<GIMME_V> instead. #define OPpCONST_STRICT 8 /* bareword subject to strict 'subs' */ #define OPpCONST_ENTERED 16 /* Has been entered as symbol. */ #define OPpCONST_BARE 64 /* Was a bare word (filehandle?). */ -#define OPpCONST_WARNING 128 /* Was a $^W translated to constant. */ +#define OPpCONST_FOLDED 128 /* Result of constant folding */ /* Private for OP_FLIP/FLOP */ #define OPpFLIP_LINENUM 64 /* Range arg potentially a line num. */ @@ -305,6 +308,7 @@ Deprecated. Use C<GIMME_V> instead. #define OPpEVAL_UNICODE 4 #define OPpEVAL_BYTES 8 #define OPpEVAL_COPHH 16 /* Construct %^H from cop hints */ +#define OPpEVAL_RE_REPARSING 32 /* eval_sv(..., G_RE_REPARSING) */ /* Private for OP_CALLER, OP_WANTARRAY and OP_RUNCV */ #define OPpOFFBYONE 128 /* Treat caller(1) as caller(2) */ @@ -368,14 +372,12 @@ struct pmop { union { OP * op_pmreplstart; /* Only used in OP_SUBST */ #ifdef USE_ITHREADS - struct { - char * op_pmstashpv; /* Only used in OP_MATCH, with PMf_ONCE set */ - U32 op_pmstashflags; /* currently only SVf_UTF8 or 0 */ - } op_pmstashthr; + PADOFFSET op_pmstashoff; /* Only used in OP_MATCH, with PMf_ONCE set */ #else HV * op_pmstash; #endif } op_pmstashstartu; + OP * op_code_list; /* list of (?{}) code blocks */ }; #ifdef USE_ITHREADS @@ -411,10 +413,7 @@ struct pmop { * OP_MATCH and OP_QR */ #define PMf_ONCE (1<<(PMf_BASE_SHIFT+1)) -/* replacement contains variables */ -#define PMf_MAYBE_CONST (1<<(PMf_BASE_SHIFT+2)) - -/* PMf_ONCE has matched successfully. Not used under threading. */ +/* PMf_ONCE, i.e. ?pat?, has matched successfully. Not used under threading. */ #define PMf_USED (1<<(PMf_BASE_SHIFT+3)) /* subst replacement is constant */ @@ -434,36 +433,32 @@ struct pmop { /* Return substituted string instead of modifying it. */ #define PMf_NONDESTRUCT (1<<(PMf_BASE_SHIFT+9)) -#if PMf_BASE_SHIFT+9 > 31 +/* the pattern has a CV attached (currently only under qr/...(?{}).../) */ +#define PMf_HAS_CV (1<<(PMf_BASE_SHIFT+10)) + +/* op_code_list is private; don't free it etc. It may well point to + * code within another sub, with different pad etc */ +#define PMf_CODELIST_PRIVATE (1<<(PMf_BASE_SHIFT+11)) + +/* the PMOP is a QR (we should be able to detect that from the op type, + * but the regex compilation API passes just the pm flags, not the op + * itself */ +#define PMf_IS_QR (1<<(PMf_BASE_SHIFT+12)) +#define PMf_USE_RE_EVAL (1<<(PMf_BASE_SHIFT+13)) /* use re'eval' in scope */ + +#if PMf_BASE_SHIFT+13 > 31 # error Too many PMf_ bits used. See above and regnodes.h for any spare in middle #endif #ifdef USE_ITHREADS -# define PmopSTASHPV(o) \ - (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv : NULL) -# if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define PmopSTASHPV_set(o,pv) ({ \ - assert((o)->op_pmflags & PMf_ONCE); \ - ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv = savesharedpv(pv)); \ - }) -# else -# define PmopSTASHPV_set(o,pv) \ - ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv = savesharedpv(pv)) -# endif -# define PmopSTASH_flags(o) ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashflags) -# define PmopSTASH_flags_set(o,flags) ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashflags = flags) -# define PmopSTASH(o) (PmopSTASHPV(o) \ - ? gv_stashpv((o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv, \ - GV_ADD | PmopSTASH_flags(o)) : NULL) -# define PmopSTASH_set(o,hv) (PmopSTASHPV_set(o, (hv) ? HvNAME_get(hv) : NULL), \ - PmopSTASH_flags_set(o, \ - ((hv) && HvNAME_HEK(hv) && \ - HvNAMEUTF8(hv)) \ - ? SVf_UTF8 \ - : 0)) -# define PmopSTASH_free(o) PerlMemShared_free(PmopSTASHPV(o)) - +# define PmopSTASH(o) ((o)->op_pmflags & PMf_ONCE \ + ? PL_stashpad[(o)->op_pmstashstartu.op_pmstashoff] \ + : NULL) +# define PmopSTASH_set(o,hv) \ + (assert_((o)->op_pmflags & PMf_ONCE) \ + (o)->op_pmstashstartu.op_pmstashoff = \ + (hv) ? alloccopstash(hv) : 0) #else # define PmopSTASH(o) \ (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL) @@ -475,13 +470,10 @@ struct pmop { # else # define PmopSTASH_set(o,hv) ((o)->op_pmstashstartu.op_pmstash = (hv)) # endif -# define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL) - /* op_pmstashstartu.op_pmstash is not refcounted */ -# define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD)) -/* Note that if this becomes non-empty, then S_forget_pmop in op.c will need - changing */ -# define PmopSTASH_free(o) #endif +#define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL) + /* op_pmstashstartu.op_pmstash is not refcounted */ +#define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD)) struct svop { BASEOP @@ -556,7 +548,8 @@ struct loop { # define cGVOPx_gv(o) ((GV*)PAD_SVl(cPADOPx(o)->op_padix)) # define IS_PADGV(v) (v && SvTYPE(v) == SVt_PVGV && isGV_with_GP(v) \ && GvIN_PAD(v)) -# define IS_PADCONST(v) (v && SvREADONLY(v)) +# define IS_PADCONST(v) \ + (v && (SvREADONLY(v) || (SvIsCOW(v) && !SvLEN(v)))) # define cSVOPx_sv(v) (cSVOPx(v)->op_sv \ ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ)) # define cSVOPx_svp(v) (cSVOPx(v)->op_sv \ @@ -695,19 +688,66 @@ least an C<UNOP>. #include "reentr.h" #endif -#if defined(PL_OP_SLAB_ALLOC) #define NewOp(m,var,c,type) \ (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type))) #define NewOpSz(m,var,size) \ (var = (OP *) Perl_Slab_Alloc(aTHX_ size)) #define FreeOp(p) Perl_Slab_Free(aTHX_ p) -#else -#define NewOp(m, var, c, type) \ - (var = (MEM_WRAP_CHECK_(c,type) \ - (type*)PerlMemShared_calloc(c, sizeof(type)))) -#define NewOpSz(m, var, size) \ - (var = (OP*)PerlMemShared_calloc(1, size)) -#define FreeOp(p) PerlMemShared_free(p) + +/* + * The per-CV op slabs consist of a header (the opslab struct) and a bunch + * of space for allocating op slots, each of which consists of two pointers + * followed by an op. The first pointer points to the next op slot. The + * second points to the slab. At the end of the slab is a null pointer, + * so that slot->opslot_next - slot can be used to determine the size + * of the op. + * + * Each CV can have multiple slabs; opslab_next points to the next slab, to + * form a chain. All bookkeeping is done on the first slab, which is where + * all the op slots point. + * + * Freed ops are marked as freed and attached to the freed chain + * via op_next pointers. + * + * When there is more than one slab, the second slab in the slab chain is + * assumed to be the one with free space available. It is used when allo- + * cating an op if there are no freed ops available or big enough. + */ + +#ifdef PERL_CORE +struct opslot { + /* keep opslot_next first */ + OPSLOT * opslot_next; /* next slot */ + OPSLAB * opslot_slab; /* owner */ + OP opslot_op; /* the op itself */ +}; + +struct opslab { + OPSLOT * opslab_first; /* first op in this slab */ + OPSLAB * opslab_next; /* next slab */ + OP * opslab_freed; /* chain of freed ops */ + size_t opslab_refcnt; /* number of ops */ +# ifdef PERL_DEBUG_READONLY_OPS + U16 opslab_size; /* size of slab in pointers */ + bool opslab_readonly; +# endif + OPSLOT opslab_slots; /* slots begin here */ +}; + +# define OPSLOT_HEADER STRUCT_OFFSET(OPSLOT, opslot_op) +# define OPSLOT_HEADER_P (OPSLOT_HEADER/sizeof(I32 *)) +# define OpSLOT(o) (assert_(o->op_slabbed) \ + (OPSLOT *)(((char *)o)-OPSLOT_HEADER)) +# define OpSLAB(o) OpSLOT(o)->opslot_slab +# define OpslabREFCNT_dec(slab) \ + (((slab)->opslab_refcnt == 1) \ + ? opslab_free_nopad(slab) \ + : (void)--(slab)->opslab_refcnt) + /* Variant that does not null out the pads */ +# define OpslabREFCNT_dec_padok(slab) \ + (((slab)->opslab_refcnt == 1) \ + ? opslab_free(slab) \ + : (void)--(slab)->opslab_refcnt) #endif struct block_hooks { @@ -1022,8 +1062,8 @@ struct token { * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/op_reg_common.h b/Master/tlpkg/tlperl/lib/CORE/op_reg_common.h index 4e173504c5d..9dcdaaec63b 100644 --- a/Master/tlpkg/tlperl/lib/CORE/op_reg_common.h +++ b/Master/tlpkg/tlperl/lib/CORE/op_reg_common.h @@ -27,6 +27,7 @@ * RXf_PMf_STD_PMMOD_SHIFT, followed by the p. See STD_PAT_MODS and * INT_PAT_MODS in regexp.h for the reason contiguity is needed */ /* Make sure to update lib/re.pm when changing these! */ +/* Make sure you keep the pure PMf_ versions below in sync */ #define RXf_PMf_MULTILINE (1 << (RXf_PMf_STD_PMMOD_SHIFT+0)) /* /m */ #define RXf_PMf_SINGLELINE (1 << (RXf_PMf_STD_PMMOD_SHIFT+1)) /* /s */ #define RXf_PMf_FOLD (1 << (RXf_PMf_STD_PMMOD_SHIFT+2)) /* /i */ @@ -36,7 +37,9 @@ /* The character set for the regex is stored in a field of more than one bit * using an enum, for reasons of compactness and to ensure that the options are * mutually exclusive */ -/* Make sure to update ext/re/re.pm when changing this! */ +/* Make sure to update ext/re/re.pm and regcomp.sym (as these are used as + * offsets for various node types, like POSIXD vs POSIXL, etc) when changing + * this! */ typedef enum { REGEX_DEPENDS_CHARSET = 0, REGEX_LOCALE_CHARSET, @@ -77,13 +80,27 @@ get_regex_charset(const U32 flags) return (regex_charset) ((flags & RXf_PMf_CHARSET) >> _RXf_PMf_CHARSET_SHIFT); } +#define _RXf_PMf_SHIFT_COMPILETIME (RXf_PMf_STD_PMMOD_SHIFT+8) + +/* + Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will + be used by regex engines to check whether they should set + RXf_SKIPWHITE +*/ +#define RXf_PMf_SPLIT (1<<(RXf_PMf_STD_PMMOD_SHIFT+8)) + /* Next available bit after the above. Name begins with '_' so won't be * exported by B */ -#define _RXf_PMf_SHIFT_NEXT (RXf_PMf_STD_PMMOD_SHIFT+8) +#define _RXf_PMf_SHIFT_NEXT (RXf_PMf_STD_PMMOD_SHIFT+9) /* Mask of the above bits. These need to be transferred from op_pmflags to * re->extflags during compilation */ -#define RXf_PMf_COMPILETIME (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_CHARSET|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_KEEPCOPY) +#define RXf_PMf_COMPILETIME (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_KEEPCOPY|RXf_PMf_CHARSET) +#define RXf_PMf_FLAGCOPYMASK (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_KEEPCOPY|RXf_PMf_CHARSET|RXf_PMf_SPLIT) + +#if RXf_PMf_COMPILETIME > 255 +# error RXf_PMf_COMPILETIME wont fit in U8 flags field of eval node +#endif /* These copies need to be numerical or defsubs_h.PL won't know about them. */ #define PMf_MULTILINE 1<<0 @@ -91,18 +108,18 @@ get_regex_charset(const U32 flags) #define PMf_FOLD 1<<2 #define PMf_EXTENDED 1<<3 #define PMf_KEEPCOPY 1<<4 +#define PMf_CHARSET 7<<5 +#define PMf_SPLIT 1<<8 -#if PMf_MULTILINE != RXf_PMf_MULTILINE || PMf_SINGLELINE != RXf_PMf_SINGLELINE || PMf_FOLD != RXf_PMf_FOLD || PMf_EXTENDED != RXf_PMf_EXTENDED || PMf_KEEPCOPY != RXf_PMf_KEEPCOPY +#if PMf_MULTILINE != RXf_PMf_MULTILINE || PMf_SINGLELINE != RXf_PMf_SINGLELINE || PMf_FOLD != RXf_PMf_FOLD || PMf_EXTENDED != RXf_PMf_EXTENDED || PMf_KEEPCOPY != RXf_PMf_KEEPCOPY || PMf_SPLIT != RXf_PMf_SPLIT || PMf_CHARSET != RXf_PMf_CHARSET # error RXf_PMf defines are wrong #endif -#define PMf_COMPILETIME RXf_PMf_COMPILETIME - /* Error check that haven't left something out of this. This isn't done * directly in the #define because doing so confuses regcomp.pl. * (2**n - 1) is n 1 bits, so the below gets the contiguous bits between the * beginning and ending shifts */ -#if RXf_PMf_COMPILETIME != (((1 << (_RXf_PMf_SHIFT_NEXT))-1) \ +#if RXf_PMf_COMPILETIME != (((1 << (_RXf_PMf_SHIFT_COMPILETIME))-1) \ & (~((1 << RXf_PMf_STD_PMMOD_SHIFT)-1))) # error RXf_PMf_COMPILETIME is invalid #endif diff --git a/Master/tlpkg/tlperl/lib/CORE/opcode.h b/Master/tlpkg/tlperl/lib/CORE/opcode.h index 0a9628da928..540dc0ba974 100644 --- a/Master/tlpkg/tlperl/lib/CORE/opcode.h +++ b/Master/tlpkg/tlperl/lib/CORE/opcode.h @@ -291,7 +291,6 @@ EXTCONST char* const PL_op_name[] = { "rv2hv", "helem", "hslice", - "boolkeys", "unpack", "pack", "split", @@ -522,6 +521,11 @@ EXTCONST char* const PL_op_name[] = { "coreargs", "runcv", "fc", + "padcv", + "introcv", + "clonecv", + "padrange", + "freed", }; #endif @@ -672,7 +676,6 @@ EXTCONST char* const PL_op_desc[] = { "hash dereference", "hash element", "hash slice", - "boolkeys", "unpack", "pack", "split", @@ -903,6 +906,11 @@ EXTCONST char* const PL_op_desc[] = { "CORE:: subroutine", "__SUB__", "fc", + "private subroutine", + "private subroutine", + "private subroutine", + "list of private variables", + "freed op", }; #endif @@ -1067,7 +1075,6 @@ EXT Perl_ppaddr_t PL_ppaddr[] /* or perlvars.h */ Perl_pp_rv2hv, /* implemented by Perl_pp_rv2av */ Perl_pp_helem, Perl_pp_hslice, - Perl_pp_boolkeys, Perl_pp_unpack, Perl_pp_pack, Perl_pp_split, @@ -1298,6 +1305,10 @@ EXT Perl_ppaddr_t PL_ppaddr[] /* or perlvars.h */ Perl_pp_coreargs, Perl_pp_runcv, Perl_pp_fc, + Perl_pp_padcv, + Perl_pp_introcv, + Perl_pp_clonecv, + Perl_pp_padrange, } #endif #ifdef PERL_PPADDR_INITED @@ -1360,9 +1371,9 @@ EXT Perl_check_t PL_check[] /* or perlvars.h */ Perl_ck_spair, /* chomp */ Perl_ck_null, /* schomp */ Perl_ck_defined, /* defined */ - Perl_ck_lfun, /* undef */ + Perl_ck_fun, /* undef */ Perl_ck_fun, /* study */ - Perl_ck_lfun, /* pos */ + Perl_ck_fun, /* pos */ Perl_ck_lfun, /* preinc */ Perl_ck_lfun, /* i_preinc */ Perl_ck_lfun, /* predec */ @@ -1459,7 +1470,6 @@ EXT Perl_check_t PL_check[] /* or perlvars.h */ Perl_ck_rvconst, /* rv2hv */ Perl_ck_null, /* helem */ Perl_ck_null, /* hslice */ - Perl_ck_fun, /* boolkeys */ Perl_ck_fun, /* unpack */ Perl_ck_fun, /* pack */ Perl_ck_split, /* split */ @@ -1596,7 +1606,7 @@ EXT Perl_check_t PL_check[] /* or perlvars.h */ Perl_ck_ftst, /* fttty */ Perl_ck_ftst, /* fttext */ Perl_ck_ftst, /* ftbinary */ - Perl_ck_chdir, /* chdir */ + Perl_ck_trunc, /* chdir */ Perl_ck_fun, /* chown */ Perl_ck_fun, /* chroot */ Perl_ck_fun, /* unlink */ @@ -1690,6 +1700,10 @@ EXT Perl_check_t PL_check[] /* or perlvars.h */ Perl_ck_null, /* coreargs */ Perl_ck_null, /* runcv */ Perl_ck_fun, /* fc */ + Perl_ck_null, /* padcv */ + Perl_ck_null, /* introcv */ + Perl_ck_null, /* clonecv */ + Perl_ck_null, /* padrange */ } #endif #ifdef PERL_CHECK_INITED @@ -1746,9 +1760,9 @@ EXTCONST U32 PL_opargs[] = { 0x00002b1d, /* chomp */ 0x00009b9c, /* schomp */ 0x00009b84, /* defined */ - 0x00009b04, /* undef */ + 0x0000fb04, /* undef */ 0x00009b84, /* study */ - 0x00009b8c, /* pos */ + 0x0000fb8c, /* pos */ 0x00001164, /* preinc */ 0x00001144, /* i_preinc */ 0x00001164, /* predec */ @@ -1764,7 +1778,7 @@ EXTCONST U32 PL_opargs[] = { 0x0001121e, /* i_divide */ 0x0001123e, /* modulo */ 0x0001121e, /* i_modulo */ - 0x00012209, /* repeat */ + 0x0001220b, /* repeat */ 0x0001123e, /* add */ 0x0001121e, /* i_add */ 0x0001123e, /* subtract */ @@ -1845,9 +1859,8 @@ EXTCONST U32 PL_opargs[] = { 0x00000148, /* rv2hv */ 0x00014204, /* helem */ 0x00024401, /* hslice */ - 0x00004b00, /* boolkeys */ 0x00091480, /* unpack */ - 0x0002140d, /* pack */ + 0x0002140f, /* pack */ 0x00111408, /* split */ 0x0002140d, /* join */ 0x00002401, /* list */ @@ -2076,6 +2089,10 @@ EXTCONST U32 PL_opargs[] = { 0x00000600, /* coreargs */ 0x00000004, /* runcv */ 0x00009b8e, /* fc */ + 0x00000040, /* padcv */ + 0x00000040, /* introcv */ + 0x00000040, /* clonecv */ + 0x00000040, /* padrange */ }; #endif diff --git a/Master/tlpkg/tlperl/lib/CORE/opnames.h b/Master/tlpkg/tlperl/lib/CORE/opnames.h index 8b6a39a1619..5502ba4d15d 100644 --- a/Master/tlpkg/tlperl/lib/CORE/opnames.h +++ b/Master/tlpkg/tlperl/lib/CORE/opnames.h @@ -157,241 +157,245 @@ typedef enum opcode { OP_RV2HV = 140, OP_HELEM = 141, OP_HSLICE = 142, - OP_BOOLKEYS = 143, - OP_UNPACK = 144, - OP_PACK = 145, - OP_SPLIT = 146, - OP_JOIN = 147, - OP_LIST = 148, - OP_LSLICE = 149, - OP_ANONLIST = 150, - OP_ANONHASH = 151, - OP_SPLICE = 152, - OP_PUSH = 153, - OP_POP = 154, - OP_SHIFT = 155, - OP_UNSHIFT = 156, - OP_SORT = 157, - OP_REVERSE = 158, - OP_GREPSTART = 159, - OP_GREPWHILE = 160, - OP_MAPSTART = 161, - OP_MAPWHILE = 162, - OP_RANGE = 163, - OP_FLIP = 164, - OP_FLOP = 165, - OP_AND = 166, - OP_OR = 167, - OP_XOR = 168, - OP_DOR = 169, - OP_COND_EXPR = 170, - OP_ANDASSIGN = 171, - OP_ORASSIGN = 172, - OP_DORASSIGN = 173, - OP_METHOD = 174, - OP_ENTERSUB = 175, - OP_LEAVESUB = 176, - OP_LEAVESUBLV = 177, - OP_CALLER = 178, - OP_WARN = 179, - OP_DIE = 180, - OP_RESET = 181, - OP_LINESEQ = 182, - OP_NEXTSTATE = 183, - OP_DBSTATE = 184, - OP_UNSTACK = 185, - OP_ENTER = 186, - OP_LEAVE = 187, - OP_SCOPE = 188, - OP_ENTERITER = 189, - OP_ITER = 190, - OP_ENTERLOOP = 191, - OP_LEAVELOOP = 192, - OP_RETURN = 193, - OP_LAST = 194, - OP_NEXT = 195, - OP_REDO = 196, - OP_DUMP = 197, - OP_GOTO = 198, - OP_EXIT = 199, - OP_METHOD_NAMED = 200, - OP_ENTERGIVEN = 201, - OP_LEAVEGIVEN = 202, - OP_ENTERWHEN = 203, - OP_LEAVEWHEN = 204, - OP_BREAK = 205, - OP_CONTINUE = 206, - OP_OPEN = 207, - OP_CLOSE = 208, - OP_PIPE_OP = 209, - OP_FILENO = 210, - OP_UMASK = 211, - OP_BINMODE = 212, - OP_TIE = 213, - OP_UNTIE = 214, - OP_TIED = 215, - OP_DBMOPEN = 216, - OP_DBMCLOSE = 217, - OP_SSELECT = 218, - OP_SELECT = 219, - OP_GETC = 220, - OP_READ = 221, - OP_ENTERWRITE = 222, - OP_LEAVEWRITE = 223, - OP_PRTF = 224, - OP_PRINT = 225, - OP_SAY = 226, - OP_SYSOPEN = 227, - OP_SYSSEEK = 228, - OP_SYSREAD = 229, - OP_SYSWRITE = 230, - OP_EOF = 231, - OP_TELL = 232, - OP_SEEK = 233, - OP_TRUNCATE = 234, - OP_FCNTL = 235, - OP_IOCTL = 236, - OP_FLOCK = 237, - OP_SEND = 238, - OP_RECV = 239, - OP_SOCKET = 240, - OP_SOCKPAIR = 241, - OP_BIND = 242, - OP_CONNECT = 243, - OP_LISTEN = 244, - OP_ACCEPT = 245, - OP_SHUTDOWN = 246, - OP_GSOCKOPT = 247, - OP_SSOCKOPT = 248, - OP_GETSOCKNAME = 249, - OP_GETPEERNAME = 250, - OP_LSTAT = 251, - OP_STAT = 252, - OP_FTRREAD = 253, - OP_FTRWRITE = 254, - OP_FTREXEC = 255, - OP_FTEREAD = 256, - OP_FTEWRITE = 257, - OP_FTEEXEC = 258, - OP_FTIS = 259, - OP_FTSIZE = 260, - OP_FTMTIME = 261, - OP_FTATIME = 262, - OP_FTCTIME = 263, - OP_FTROWNED = 264, - OP_FTEOWNED = 265, - OP_FTZERO = 266, - OP_FTSOCK = 267, - OP_FTCHR = 268, - OP_FTBLK = 269, - OP_FTFILE = 270, - OP_FTDIR = 271, - OP_FTPIPE = 272, - OP_FTSUID = 273, - OP_FTSGID = 274, - OP_FTSVTX = 275, - OP_FTLINK = 276, - OP_FTTTY = 277, - OP_FTTEXT = 278, - OP_FTBINARY = 279, - OP_CHDIR = 280, - OP_CHOWN = 281, - OP_CHROOT = 282, - OP_UNLINK = 283, - OP_CHMOD = 284, - OP_UTIME = 285, - OP_RENAME = 286, - OP_LINK = 287, - OP_SYMLINK = 288, - OP_READLINK = 289, - OP_MKDIR = 290, - OP_RMDIR = 291, - OP_OPEN_DIR = 292, - OP_READDIR = 293, - OP_TELLDIR = 294, - OP_SEEKDIR = 295, - OP_REWINDDIR = 296, - OP_CLOSEDIR = 297, - OP_FORK = 298, - OP_WAIT = 299, - OP_WAITPID = 300, - OP_SYSTEM = 301, - OP_EXEC = 302, - OP_KILL = 303, - OP_GETPPID = 304, - OP_GETPGRP = 305, - OP_SETPGRP = 306, - OP_GETPRIORITY = 307, - OP_SETPRIORITY = 308, - OP_TIME = 309, - OP_TMS = 310, - OP_LOCALTIME = 311, - OP_GMTIME = 312, - OP_ALARM = 313, - OP_SLEEP = 314, - OP_SHMGET = 315, - OP_SHMCTL = 316, - OP_SHMREAD = 317, - OP_SHMWRITE = 318, - OP_MSGGET = 319, - OP_MSGCTL = 320, - OP_MSGSND = 321, - OP_MSGRCV = 322, - OP_SEMOP = 323, - OP_SEMGET = 324, - OP_SEMCTL = 325, - OP_REQUIRE = 326, - OP_DOFILE = 327, - OP_HINTSEVAL = 328, - OP_ENTEREVAL = 329, - OP_LEAVEEVAL = 330, - OP_ENTERTRY = 331, - OP_LEAVETRY = 332, - OP_GHBYNAME = 333, - OP_GHBYADDR = 334, - OP_GHOSTENT = 335, - OP_GNBYNAME = 336, - OP_GNBYADDR = 337, - OP_GNETENT = 338, - OP_GPBYNAME = 339, - OP_GPBYNUMBER = 340, - OP_GPROTOENT = 341, - OP_GSBYNAME = 342, - OP_GSBYPORT = 343, - OP_GSERVENT = 344, - OP_SHOSTENT = 345, - OP_SNETENT = 346, - OP_SPROTOENT = 347, - OP_SSERVENT = 348, - OP_EHOSTENT = 349, - OP_ENETENT = 350, - OP_EPROTOENT = 351, - OP_ESERVENT = 352, - OP_GPWNAM = 353, - OP_GPWUID = 354, - OP_GPWENT = 355, - OP_SPWENT = 356, - OP_EPWENT = 357, - OP_GGRNAM = 358, - OP_GGRGID = 359, - OP_GGRENT = 360, - OP_SGRENT = 361, - OP_EGRENT = 362, - OP_GETLOGIN = 363, - OP_SYSCALL = 364, - OP_LOCK = 365, - OP_ONCE = 366, - OP_CUSTOM = 367, - OP_REACH = 368, - OP_RKEYS = 369, - OP_RVALUES = 370, - OP_COREARGS = 371, - OP_RUNCV = 372, - OP_FC = 373, + OP_UNPACK = 143, + OP_PACK = 144, + OP_SPLIT = 145, + OP_JOIN = 146, + OP_LIST = 147, + OP_LSLICE = 148, + OP_ANONLIST = 149, + OP_ANONHASH = 150, + OP_SPLICE = 151, + OP_PUSH = 152, + OP_POP = 153, + OP_SHIFT = 154, + OP_UNSHIFT = 155, + OP_SORT = 156, + OP_REVERSE = 157, + OP_GREPSTART = 158, + OP_GREPWHILE = 159, + OP_MAPSTART = 160, + OP_MAPWHILE = 161, + OP_RANGE = 162, + OP_FLIP = 163, + OP_FLOP = 164, + OP_AND = 165, + OP_OR = 166, + OP_XOR = 167, + OP_DOR = 168, + OP_COND_EXPR = 169, + OP_ANDASSIGN = 170, + OP_ORASSIGN = 171, + OP_DORASSIGN = 172, + OP_METHOD = 173, + OP_ENTERSUB = 174, + OP_LEAVESUB = 175, + OP_LEAVESUBLV = 176, + OP_CALLER = 177, + OP_WARN = 178, + OP_DIE = 179, + OP_RESET = 180, + OP_LINESEQ = 181, + OP_NEXTSTATE = 182, + OP_DBSTATE = 183, + OP_UNSTACK = 184, + OP_ENTER = 185, + OP_LEAVE = 186, + OP_SCOPE = 187, + OP_ENTERITER = 188, + OP_ITER = 189, + OP_ENTERLOOP = 190, + OP_LEAVELOOP = 191, + OP_RETURN = 192, + OP_LAST = 193, + OP_NEXT = 194, + OP_REDO = 195, + OP_DUMP = 196, + OP_GOTO = 197, + OP_EXIT = 198, + OP_METHOD_NAMED = 199, + OP_ENTERGIVEN = 200, + OP_LEAVEGIVEN = 201, + OP_ENTERWHEN = 202, + OP_LEAVEWHEN = 203, + OP_BREAK = 204, + OP_CONTINUE = 205, + OP_OPEN = 206, + OP_CLOSE = 207, + OP_PIPE_OP = 208, + OP_FILENO = 209, + OP_UMASK = 210, + OP_BINMODE = 211, + OP_TIE = 212, + OP_UNTIE = 213, + OP_TIED = 214, + OP_DBMOPEN = 215, + OP_DBMCLOSE = 216, + OP_SSELECT = 217, + OP_SELECT = 218, + OP_GETC = 219, + OP_READ = 220, + OP_ENTERWRITE = 221, + OP_LEAVEWRITE = 222, + OP_PRTF = 223, + OP_PRINT = 224, + OP_SAY = 225, + OP_SYSOPEN = 226, + OP_SYSSEEK = 227, + OP_SYSREAD = 228, + OP_SYSWRITE = 229, + OP_EOF = 230, + OP_TELL = 231, + OP_SEEK = 232, + OP_TRUNCATE = 233, + OP_FCNTL = 234, + OP_IOCTL = 235, + OP_FLOCK = 236, + OP_SEND = 237, + OP_RECV = 238, + OP_SOCKET = 239, + OP_SOCKPAIR = 240, + OP_BIND = 241, + OP_CONNECT = 242, + OP_LISTEN = 243, + OP_ACCEPT = 244, + OP_SHUTDOWN = 245, + OP_GSOCKOPT = 246, + OP_SSOCKOPT = 247, + OP_GETSOCKNAME = 248, + OP_GETPEERNAME = 249, + OP_LSTAT = 250, + OP_STAT = 251, + OP_FTRREAD = 252, + OP_FTRWRITE = 253, + OP_FTREXEC = 254, + OP_FTEREAD = 255, + OP_FTEWRITE = 256, + OP_FTEEXEC = 257, + OP_FTIS = 258, + OP_FTSIZE = 259, + OP_FTMTIME = 260, + OP_FTATIME = 261, + OP_FTCTIME = 262, + OP_FTROWNED = 263, + OP_FTEOWNED = 264, + OP_FTZERO = 265, + OP_FTSOCK = 266, + OP_FTCHR = 267, + OP_FTBLK = 268, + OP_FTFILE = 269, + OP_FTDIR = 270, + OP_FTPIPE = 271, + OP_FTSUID = 272, + OP_FTSGID = 273, + OP_FTSVTX = 274, + OP_FTLINK = 275, + OP_FTTTY = 276, + OP_FTTEXT = 277, + OP_FTBINARY = 278, + OP_CHDIR = 279, + OP_CHOWN = 280, + OP_CHROOT = 281, + OP_UNLINK = 282, + OP_CHMOD = 283, + OP_UTIME = 284, + OP_RENAME = 285, + OP_LINK = 286, + OP_SYMLINK = 287, + OP_READLINK = 288, + OP_MKDIR = 289, + OP_RMDIR = 290, + OP_OPEN_DIR = 291, + OP_READDIR = 292, + OP_TELLDIR = 293, + OP_SEEKDIR = 294, + OP_REWINDDIR = 295, + OP_CLOSEDIR = 296, + OP_FORK = 297, + OP_WAIT = 298, + OP_WAITPID = 299, + OP_SYSTEM = 300, + OP_EXEC = 301, + OP_KILL = 302, + OP_GETPPID = 303, + OP_GETPGRP = 304, + OP_SETPGRP = 305, + OP_GETPRIORITY = 306, + OP_SETPRIORITY = 307, + OP_TIME = 308, + OP_TMS = 309, + OP_LOCALTIME = 310, + OP_GMTIME = 311, + OP_ALARM = 312, + OP_SLEEP = 313, + OP_SHMGET = 314, + OP_SHMCTL = 315, + OP_SHMREAD = 316, + OP_SHMWRITE = 317, + OP_MSGGET = 318, + OP_MSGCTL = 319, + OP_MSGSND = 320, + OP_MSGRCV = 321, + OP_SEMOP = 322, + OP_SEMGET = 323, + OP_SEMCTL = 324, + OP_REQUIRE = 325, + OP_DOFILE = 326, + OP_HINTSEVAL = 327, + OP_ENTEREVAL = 328, + OP_LEAVEEVAL = 329, + OP_ENTERTRY = 330, + OP_LEAVETRY = 331, + OP_GHBYNAME = 332, + OP_GHBYADDR = 333, + OP_GHOSTENT = 334, + OP_GNBYNAME = 335, + OP_GNBYADDR = 336, + OP_GNETENT = 337, + OP_GPBYNAME = 338, + OP_GPBYNUMBER = 339, + OP_GPROTOENT = 340, + OP_GSBYNAME = 341, + OP_GSBYPORT = 342, + OP_GSERVENT = 343, + OP_SHOSTENT = 344, + OP_SNETENT = 345, + OP_SPROTOENT = 346, + OP_SSERVENT = 347, + OP_EHOSTENT = 348, + OP_ENETENT = 349, + OP_EPROTOENT = 350, + OP_ESERVENT = 351, + OP_GPWNAM = 352, + OP_GPWUID = 353, + OP_GPWENT = 354, + OP_SPWENT = 355, + OP_EPWENT = 356, + OP_GGRNAM = 357, + OP_GGRGID = 358, + OP_GGRENT = 359, + OP_SGRENT = 360, + OP_EGRENT = 361, + OP_GETLOGIN = 362, + OP_SYSCALL = 363, + OP_LOCK = 364, + OP_ONCE = 365, + OP_CUSTOM = 366, + OP_REACH = 367, + OP_RKEYS = 368, + OP_RVALUES = 369, + OP_COREARGS = 370, + OP_RUNCV = 371, + OP_FC = 372, + OP_PADCV = 373, + OP_INTROCV = 374, + OP_CLONECV = 375, + OP_PADRANGE = 376, OP_max } opcode; -#define MAXO 374 +#define MAXO 377 +#define OP_FREED MAXO /* the OP_IS_* macros are optimized to a simple range check because all the member OPs are contiguous in regen/opcodes table. diff --git a/Master/tlpkg/tlperl/lib/CORE/overload.h b/Master/tlpkg/tlperl/lib/CORE/overload.h index 24cde2ad131..1628ac00252 100644 --- a/Master/tlpkg/tlperl/lib/CORE/overload.h +++ b/Master/tlpkg/tlperl/lib/CORE/overload.h @@ -82,7 +82,6 @@ enum { smart_amg, /* 0x41 ~~ */ ftest_amg, /* 0x42 -X */ regexp_amg, /* 0x43 qr */ - DESTROY_amg, /* 0x44 DESTROY */ max_amg_code /* Do not leave a trailing comma here. C9X allows it, C89 doesn't. */ }; diff --git a/Master/tlpkg/tlperl/lib/CORE/pad.h b/Master/tlpkg/tlperl/lib/CORE/pad.h index aa6521ff9b2..26e183ccd83 100644 --- a/Master/tlpkg/tlperl/lib/CORE/pad.h +++ b/Master/tlpkg/tlperl/lib/CORE/pad.h @@ -16,13 +16,6 @@ */ -/* a padlist is currently just an AV; but that might change, - * so hide the type. Ditto a pad. */ - -typedef AV PADLIST; -typedef AV PAD; - - /* offsets within a pad */ #if PTRSIZE == 4 @@ -34,6 +27,14 @@ typedef U64TYPE PADOFFSET; #endif #define NOT_IN_PAD ((PADOFFSET) -1) + +struct padlist { + SSize_t xpadl_max; /* max index for which array has space */ + PAD ** xpadl_alloc; /* pointer to beginning of array of AVs */ + PADNAMELIST*xpadl_outid; /* Padnamelist of outer pad; used as ID */ +}; + + /* a value that PL_cop_seqmax is guaranteed never to be, * flagging that a lexical is being introduced, or has not yet left scope */ @@ -126,6 +127,8 @@ typedef enum { #define padadd_OUR 0x01 /* our declaration. */ #define padadd_STATE 0x02 /* state declaration. */ #define padadd_NO_DUP_CHECK 0x04 /* skip warning on dups. */ +#define padadd_STALEOK 0x08 /* allow stale lexical in active + * sub, but only one level up */ #define padadd_UTF8_NAME SVf_UTF8 /* name is UTF-8 encoded. */ /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine @@ -171,7 +174,66 @@ Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my') save PL_comppad and PL_curpad +=for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist +The C array of a padlist, containing the pads. Only subscript it with +numbers >= 1, as the 0th entry is not guaranteed to remain usable. + +=for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist +The index of the last pad in the padlist. + +=for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist +The names associated with pad entries. + +=for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist +The C array of pad names. + +=for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist +The index of the last pad name. + +=for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist +The reference count of the padlist. Currently this is always 1. + +=for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl +The C array of pad names. + +=for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl +The index of the last pad name. + +=for apidoc Amx|SV **|PadARRAY|PAD pad +The C array of pad entries. +=for apidoc Amx|SSize_t|PadMAX|PAD pad +The index of the last pad entry. + +=for apidoc Amx|char *|PadnamePV|PADNAME pn +The name stored in the pad name struct. This returns NULL for a target or +GV slot. + +=for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn +The length of the name. + +=for apidoc Amx|bool|PadnameUTF8|PADNAME pn +Whether PadnamePV is in UTF8. + +=for apidoc Amx|SV *|PadnameSV|PADNAME pn +Returns the pad name as an SV. This is currently just C<pn>. It will +begin returning a new mortal SV if pad names ever stop being SVs. + +=for apidoc m|bool|PadnameIsOUR|PADNAME pn +Whether this is an "our" variable. + +=for apidoc m|HV *|PadnameOURSTASH +The stash in which this "our" variable was declared. + +=for apidoc m|bool|PadnameOUTER|PADNAME pn +Whether this entry belongs to an outer pad. + +=for apidoc m|bool|PadnameIsSTATE|PADNAME pn +Whether this is a "state" variable. + +=for apidoc m|HV *|PadnameTYPE|PADNAME pn +The stash associated with a typed lexical. This returns the %Foo:: hash +for C<my Foo $bar>. =for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv @@ -214,6 +276,30 @@ Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL() =cut */ +#define PadlistARRAY(pl) (pl)->xpadl_alloc +#define PadlistMAX(pl) (pl)->xpadl_max +#define PadlistNAMES(pl) (*PadlistARRAY(pl)) +#define PadlistNAMESARRAY(pl) PadnamelistARRAY(PadlistNAMES(pl)) +#define PadlistNAMESMAX(pl) PadnamelistMAX(PadlistNAMES(pl)) +#define PadlistREFCNT(pl) 1 /* reserved for future use */ + +#define PadnamelistARRAY(pnl) AvARRAY(pnl) +#define PadnamelistMAX(pnl) AvFILLp(pnl) + +#define PadARRAY(pad) AvARRAY(pad) +#define PadMAX(pad) AvFILLp(pad) + +#define PadnamePV(pn) (SvPOKp(pn) ? SvPVX(pn) : NULL) +#define PadnameLEN(pn) SvCUR(pn) +#define PadnameUTF8(pn) !!SvUTF8(pn) +#define PadnameSV(pn) pn +#define PadnameIsOUR(pn) !!SvPAD_OUR(pn) +#define PadnameOURSTASH(pn) SvOURSTASH(pn) +#define PadnameOUTER(pn) !!SvFAKE(pn) +#define PadnameIsSTATE(pn) !!SvPAD_STATE(pn) +#define PadnameTYPE(pn) (SvPAD_TYPED(pn) ? SvSTASH(pn) : NULL) + + #ifdef DEBUGGING # define PAD_SV(po) pad_sv(po) # define PAD_SETSV(po,sv) pad_setsv(po,sv) @@ -225,12 +311,13 @@ Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL() #define PAD_SVl(po) (PL_curpad[po]) #define PAD_BASE_SV(padlist, po) \ - (AvARRAY(padlist)[1]) \ - ? AvARRAY(MUTABLE_AV((AvARRAY(padlist)[1])))[po] : NULL; + (PadlistARRAY(padlist)[1]) \ + ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \ + : NULL; #define PAD_SET_CUR_NOSAVE(padlist,nth) \ - PL_comppad = (PAD*) (AvARRAY(padlist)[nth]); \ + PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]); \ PL_curpad = AvARRAY(PL_comppad); \ DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ "Pad 0x%"UVxf"[0x%"UVxf"] set_cur depth=%d\n", \ @@ -307,6 +394,7 @@ ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose */ +#define PAD_COMPNAME(po) PAD_COMPNAME_SV(po) #define PAD_COMPNAME_SV(po) (*av_fetch(PL_comppad_name, (po), FALSE)) #define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po)) #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po)) @@ -378,8 +466,8 @@ of a string/length pair. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/parser.h b/Master/tlpkg/tlperl/lib/CORE/parser.h index 1e9c71d3ce8..e7b887ec3b4 100644 --- a/Master/tlpkg/tlperl/lib/CORE/parser.h +++ b/Master/tlpkg/tlperl/lib/CORE/parser.h @@ -21,6 +21,17 @@ typedef struct { #endif } yy_stack_frame; +/* Fields that need to be shared with (i.e., visible to) inner lex- + ing scopes. */ +typedef struct yy_lexshared { + struct yy_lexshared *ls_prev; + SV *ls_linestr; /* mirrors PL_parser->linestr */ + char *ls_bufptr; /* mirrors PL_parser->bufptr */ + char *re_eval_start; /* start of "(?{..." text */ + SV *re_eval_str; /* "(?{...})" text */ + line_t herelines; /* number of lines in here-doc */ +} LEXSHARED; + typedef struct yy_parser { /* parser state */ @@ -52,32 +63,40 @@ typedef struct yy_parser { OP *lex_op; /* extra info to pass back on op */ SV *lex_repl; /* runtime replacement from s/// */ U16 lex_inwhat; /* what kind of quoting are we in */ - OPCODE last_lop_op; /* last list operator */ + OPCODE last_lop_op; /* last named list or unary operator */ I32 lex_starts; /* how many interps done on level */ SV *lex_stuff; /* runtime pattern from m// or s/// */ I32 multi_start; /* 1st line of multi-line string */ I32 multi_end; /* last line of multi-line string */ char multi_open; /* delimiter of said string */ char multi_close; /* delimiter of said string */ - char pending_ident; /* pending identifier lookup */ bool preambled; + bool lex_re_reparsing; /* we're doing G_RE_REPARSING */ I32 lex_allbrackets;/* (), [], {}, ?: bracket count */ SUBLEXINFO sublex_info; + LEXSHARED *lex_shared; SV *linestr; /* current chunk of src text */ - char *bufptr; - char *oldbufptr; - char *oldoldbufptr; + char *bufptr; /* carries the cursor (current parsing + position) from one invocation of yylex + to the next */ + char *oldbufptr; /* in yylex, beginning of current token */ + char *oldoldbufptr; /* in yylex, beginning of previous token */ char *bufend; char *linestart; /* beginning of most recently read line */ char *last_uni; /* position of last named-unary op */ char *last_lop; /* position of last list operator */ - line_t copline; /* current line number */ + /* copline is used to pass a specific line number to newSTATEOP. It + is a one-time line number, as newSTATEOP invalidates it (sets it to + NOLINE) after using it. The purpose of this is to report line num- + bers in multiline constructs using the number of the first line. */ + line_t copline; U16 in_my; /* we're compiling a "my"/"our" declaration */ U8 lex_state; /* next token is determined */ U8 error_count; /* how many compile errors so far, max 10 */ HV *in_my_stash; /* declared class of this "my" declaration */ PerlIO *rsfp; /* current source file pointer */ AV *rsfp_filters; /* holds chain of active source filters */ + U8 form_lex_state; /* remember lex_state when parsing fmt */ #ifdef PERL_MAD SV *endwhite; @@ -149,8 +168,8 @@ enum { * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/patchlevel.h b/Master/tlpkg/tlperl/lib/CORE/patchlevel.h index 9937f98155a..9f85e9452ad 100644 --- a/Master/tlpkg/tlperl/lib/CORE/patchlevel.h +++ b/Master/tlpkg/tlperl/lib/CORE/patchlevel.h @@ -14,7 +14,7 @@ * exactly on the third column */ #define PERL_REVISION 5 /* age */ -#define PERL_VERSION 16 /* epoch */ +#define PERL_VERSION 18 /* epoch */ #define PERL_SUBVERSION 2 /* generation */ /* The following numbers describe the earliest compatible version of @@ -35,7 +35,7 @@ changing them should not be necessary. */ #define PERL_API_REVISION 5 -#define PERL_API_VERSION 16 +#define PERL_API_VERSION 18 #define PERL_API_SUBVERSION 0 /* XXX Note: The selection of non-default Configure options, such diff --git a/Master/tlpkg/tlperl/lib/CORE/perl.h b/Master/tlpkg/tlperl/lib/CORE/perl.h index e532af2637c..89f4c98904f 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perl.h +++ b/Master/tlpkg/tlperl/lib/CORE/perl.h @@ -48,15 +48,6 @@ * repeated in makedef.pl, so be certain to update * both places when editing. */ -#ifdef PERL_IMPLICIT_SYS -/* PERL_IMPLICIT_SYS implies PerlMemShared != PerlMem - so use slab allocator to avoid lots of MUTEX overhead - */ -# ifndef PL_OP_SLAB_ALLOC -# define PL_OP_SLAB_ALLOC -# endif -#endif - #ifdef USE_ITHREADS # if !defined(MULTIPLICITY) # define MULTIPLICITY @@ -100,8 +91,8 @@ /* Any stack-challenged places. The limit varies (and often * is configurable), but using more than a kilobyte of stack * is usually dubious in these systems. */ -#if defined(EPOC) || defined(__SYMBIAN32__) -/* EPOC/Symbian: need to work around the SDK features. * +#if defined(__SYMBIAN32__) +/* Symbian: need to work around the SDK features. * * On WINS: MS VC5 generates calls to _chkstk, * * if a "large" stack frame is allocated. * * gcc on MARM does not generate calls like these. */ @@ -166,7 +157,7 @@ # endif #endif -#define pVAR register struct perl_vars* my_vars PERL_UNUSED_DECL +#define pVAR struct perl_vars* my_vars PERL_UNUSED_DECL #ifdef PERL_GLOBAL_STRUCT # define dVAR pVAR = (struct perl_vars*)PERL_GET_VARS() @@ -179,8 +170,9 @@ # define MULTIPLICITY # endif # define tTHX PerlInterpreter* -# define pTHX register tTHX my_perl PERL_UNUSED_DECL +# define pTHX tTHX my_perl PERL_UNUSED_DECL # define aTHX my_perl +# define aTHXa(a) aTHX = (tTHX)a # ifdef PERL_GLOBAL_STRUCT # define dTHXa(a) dVAR; pTHX = (tTHX)a # else @@ -359,7 +351,11 @@ /* Rats: if dTHR is just blank then the subsequent ";" throws an error */ /* Declaring a *function*, instead of a variable, ensures that we don't rely on being able to suppress "unused" warnings. */ +#ifdef __cplusplus +#define dNOOP (void)0 +#else #define dNOOP extern int Perl___notused(void) +#endif #ifndef pTHX /* Don't bother defining tTHX and sTHX; using them outside @@ -369,6 +365,7 @@ # define pTHX_ # define aTHX # define aTHX_ +# define aTHXa(a) NOOP # define dTHXa(a) dNOOP # define dTHX dNOOP # define pTHX_1 1 @@ -397,7 +394,7 @@ #endif #ifndef pTHXx -# define pTHXx register PerlInterpreter *my_perl +# define pTHXx PerlInterpreter *my_perl # define pTHXx_ pTHXx, # define aTHXx my_perl # define aTHXx_ aTHXx, @@ -445,7 +442,7 @@ # ifdef __GNUC__ # define stringify_immed(s) #s # define stringify(s) stringify_immed(s) -register struct op *Perl_op asm(stringify(OP_IN_REGISTER)); +struct op *Perl_op asm(stringify(OP_IN_REGISTER)); # endif #endif @@ -515,15 +512,15 @@ register struct op *Perl_op asm(stringify(OP_IN_REGISTER)); */ /* define this once if either system, instead of cluttering up the src */ -#if defined(MSDOS) || defined(atarist) || defined(WIN32) || defined(NETWARE) +#if defined(MSDOS) || defined(WIN32) || defined(NETWARE) #define DOSISH 1 #endif -#if defined(__STDC__) || defined(_AIX) || defined(__stdc__) || defined(__cplusplus) || defined(EPOC) || defined(NETWARE) || defined(__SYMBIAN32__) +#if defined(__STDC__) || defined(_AIX) || defined(__stdc__) || defined(__cplusplus) || defined(NETWARE) || defined(__SYMBIAN32__) # define STANDARD_C 1 #endif -#if defined(__cplusplus) || defined(WIN32) || defined(__sgi) || defined(__EMX__) || defined(__DGUX) || defined(EPOC) || defined(__QNX__) || defined(NETWARE) || defined(PERL_MICRO) +#if defined(__cplusplus) || defined(WIN32) || defined(__sgi) || defined(__EMX__) || defined(__DGUX) || defined(__QNX__) || defined(NETWARE) || defined(PERL_MICRO) # define DONT_DECLARE_STD 1 #endif @@ -533,11 +530,54 @@ register struct op *Perl_op asm(stringify(OP_IN_REGISTER)); # define VOL #endif -#define TAINT (PL_tainted = TRUE) -#define TAINT_NOT (PL_tainted = FALSE) -#define TAINT_IF(c) if (c) { PL_tainted = TRUE; } -#define TAINT_ENV() if (PL_tainting) { taint_env(); } -#define TAINT_PROPER(s) if (PL_tainting) { taint_proper(NULL, s); } +/* By compiling a perl with -DNO_TAINT_SUPPORT or -DSILENT_NO_TAINT_SUPPORT, + * you get a perl without taint support, but doubtlessly with a lesser + * degree of support. Do not do so unless you know exactly what it means + * technically, have a good reason to do so, and know exactly how the + * perl will be used. perls with -DSILENT_NO_TAINT_SUPPORT are considered + * a potential security risk due to flat out ignoring the security-relevant + * taint flags. This being said, a perl without taint support compiled in + * has marginal run-time performance benefits. + * SILENT_NO_TAINT_SUPPORT implies NO_TAINT_SUPPORT. + * SILENT_NO_TAINT_SUPPORT is the same as NO_TAINT_SUPPORT except it + * silently ignores -t/-T instead of throwing an exception. + * + * DANGER! Using NO_TAINT_SUPPORT or SILENT_NO_TAINT_SUPPORT + * voids your nonexistent warranty! + */ +#if SILENT_NO_TAINT_SUPPORT && !defined(NO_TAINT_SUPPORT) +# define NO_TAINT_SUPPORT 1 +#endif + +/* NO_TAINT_SUPPORT can be set to transform virtually all taint-related + * operations into no-ops for a very modest speed-up. Enable only if you + * know what you're doing: tests and CPAN modules' tests are bound to fail. + */ +#if NO_TAINT_SUPPORT +# define TAINT NOOP +# define TAINT_NOT NOOP +# define TAINT_IF(c) NOOP +# define TAINT_ENV() NOOP +# define TAINT_PROPER(s) NOOP +# define TAINT_set(s) NOOP +# define TAINT_get 0 +# define TAINTING_get 0 +# define TAINTING_set(s) NOOP +# define TAINT_WARN_get 0 +# define TAINT_WARN_set(s) NOOP +#else +# define TAINT (PL_tainted = TRUE) +# define TAINT_NOT (PL_tainted = FALSE) +# define TAINT_IF(c) if (UNLIKELY(c)) { PL_tainted = TRUE; } +# define TAINT_ENV() if (UNLIKELY(PL_tainting)) { taint_env(); } +# define TAINT_PROPER(s) if (UNLIKELY(PL_tainting)) { taint_proper(NULL, s); } +# define TAINT_set(s) (PL_tainted = (s)) +# define TAINT_get (PL_tainted) +# define TAINTING_get (PL_tainting) +# define TAINTING_set(s) (PL_tainting = (s)) +# define TAINT_WARN_get (PL_taint_warn) +# define TAINT_WARN_set(s) (PL_taint_warn = (s)) +#endif /* flags used internally only within pp_subst and pp_substcont */ #ifdef PERL_CORE @@ -734,6 +774,8 @@ EXTERN_C int usleep(unsigned int); # define U64_CONST(x) ((U64)x##UL) # elif QUADKIND == QUAD_IS_LONG_LONG # define U64_CONST(x) ((U64)x##ULL) +# elif QUADKIND == QUAD_IS___INT64 +# define U64_CONST(x) ((U64)x##UI64) # else /* best guess we can make */ # define U64_CONST(x) ((U64)x##UL) # endif @@ -970,7 +1012,7 @@ EXTERN_C int usleep(unsigned int); #define PERL_USES_PL_PIDSTATUS #endif -#if !defined(OS2) && !defined(WIN32) && !defined(DJGPP) && !defined(EPOC) && !defined(__SYMBIAN32__) +#if !defined(OS2) && !defined(WIN32) && !defined(DJGPP) && !defined(__SYMBIAN32__) #define PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION #endif @@ -1175,7 +1217,7 @@ EXTERN_C int usleep(unsigned int); # define S_IFIFO _S_IFIFO #endif -/* The stat macros for Amdahl UTS, Unisoft System V/88 (and derivatives +/* The stat macros for Unisoft System V/88 (and derivatives like UTekV) are broken, sometimes giving false positives. Undefine them here and let the code below set them to proper values. @@ -1184,7 +1226,7 @@ EXTERN_C int usleep(unsigned int); This header file bug is corrected in gcc-2.5.8 and later versions. --Kaveh Ghazi (ghazi@noc.rutgers.edu) 10/3/94. */ -#if defined(uts) || (defined(m88k) && defined(ghs)) +#if defined(m88k) && defined(ghs) # undef S_ISDIR # undef S_ISCHR # undef S_ISBLK @@ -1381,13 +1423,13 @@ EXTERN_C char *crypt(const char *, const char *); #endif #ifdef HAS_STRERROR +#ifndef DONT_DECLARE_STD # ifdef VMS char *strerror (int,...); # else -#ifndef DONT_DECLARE_STD char *strerror (int); -#endif # endif +#endif # ifndef Strerror # define Strerror strerror # endif @@ -1599,15 +1641,15 @@ EXTERN_C char *crypt(const char *, const char *); # define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH) #endif -/* BeOS 5.0 and Haiku R1 seem to define S_IREAD and S_IWRITE in <posix/fcntl.h> +/* Haiku R1 seems to define S_IREAD and S_IWRITE in <posix/fcntl.h> * which would get included through <sys/file.h >, but that is 3000 * lines in the future. --jhi */ -#if !defined(S_IREAD) && !(defined(__BEOS__) || defined(__HAIKU__)) +#if !defined(S_IREAD) && !defined(__HAIKU__) # define S_IREAD S_IRUSR #endif -#if !defined(S_IWRITE) && !(defined(__BEOS__) || defined(__HAIKU__)) +#if !defined(S_IWRITE) && !defined(__HAIKU__) # define S_IWRITE S_IWUSR #endif @@ -1627,10 +1669,6 @@ EXTERN_C char *crypt(const char *, const char *); #undef UV #endif -#ifdef SPRINTF_E_BUG -# define sprintf UTS_sprintf_wrap -#endif - /* For the times when you want the return value of sprintf, and you want it to be the length. Can't have a thread variable passed in, because C89 has no varargs macros. @@ -1671,7 +1709,7 @@ EXTERN_C char *crypt(const char *, const char *); #if defined(HAS_VSNPRINTF) && defined(HAS_C99_VARIADIC_MACROS) && !(defined(DEBUGGING) && !defined(PERL_USE_GCC_BRACE_GROUPS)) && !defined(PERL_GCC_PEDANTIC) # ifdef PERL_USE_GCC_BRACE_GROUPS -# define my_vsnprintf(buffer, len, ...) ({ int __len__ = vsnprintf(buffer, len, __VA_ARGS__); if ((len) > 0 && (Size_t)__len__ >= (len)) Perl_croak_nocontext("panic: vsnprintf buffer overflow"); __len__; }) +# define my_vsnprintf(buffer, len, ...) ({ int __len__ = vsnprintf(buffer, len, __VA_ARGS__); if ((len) > 0 && (Size_t)__len__ >= (Size_t)(len)) Perl_croak_nocontext("panic: vsnprintf buffer overflow"); __len__; }) # define PERL_MY_VSNPRINTF_GUARDED # else # define my_vsnprintf(buffer, len, ...) vsnprintf(buffer, len, __VA_ARGS__) @@ -1693,13 +1731,6 @@ EXTERN_C char *crypt(const char *, const char *); # define my_strlcpy Perl_my_strlcpy #endif -/* Configure gets this right but the UTS compiler gets it wrong. - -- Hal Morris <hom00@utsglobal.com> */ -#ifdef UTS -# undef UVTYPE -# define UVTYPE unsigned -#endif - /* The IV type is supposed to be long enough to hold any integral value or a pointer. @@ -1765,11 +1796,6 @@ typedef UVTYPE UV; # undef PERL_NEED_MY_BETOH64 #endif -#if defined(uts) || defined(UTS) -# undef UV_MAX -# define UV_MAX (4294967295u) -#endif - #define IV_DIG (BIT_DIGITS(IVSIZE * 8)) #define UV_DIG (BIT_DIGITS(UVSIZE * 8)) @@ -2414,14 +2440,18 @@ typedef struct padop PADOP; typedef struct pvop PVOP; typedef struct loop LOOP; +#ifdef PERL_CORE +typedef struct opslab OPSLAB; +typedef struct opslot OPSLOT; +#endif + typedef struct block_hooks BHK; typedef struct custom_op XOP; typedef struct interpreter PerlInterpreter; -/* Amdahl's <ksync.h> has struct sv */ /* SGI's <sys/sema.h> has struct sv */ -#if defined(UTS) || defined(__sgi) +#if defined(__sgi) # define STRUCT_SV perl_sv #else # define STRUCT_SV sv @@ -2457,6 +2487,29 @@ typedef struct ptr_tbl_ent PTR_TBL_ENT_t; typedef struct ptr_tbl PTR_TBL_t; typedef struct clone_params CLONE_PARAMS; +/* a pad or name pad is currently just an AV; but that might change, + * so hide the type. */ +typedef struct padlist PADLIST; +typedef AV PAD; +typedef AV PADNAMELIST; +typedef SV PADNAME; + +/* XXX for 5.18, disable the COW by default + * #if !defined(PERL_OLD_COPY_ON_WRITE) && !defined(PERL_NEW_COPY_ON_WRITE) && !defined(PERL_NO_COW) + * # define PERL_NEW_COPY_ON_WRITE + * #endif + */ + +#if defined(PERL_OLD_COPY_ON_WRITE) || defined(PERL_NEW_COPY_ON_WRITE) +# if defined(PERL_OLD_COPY_ON_WRITE) && defined(PERL_NEW_COPY_ON_WRITE) +# error PERL_OLD_COPY_ON_WRITE and PERL_NEW_COPY_ON_WRITE are exclusive +# else +# define PERL_ANY_COW +# endif +#else +# define PERL_SAWAMPERSAND +#endif + #include "handy.h" #if defined(USE_LARGE_FILES) && !defined(NO_64_BIT_RAWIO) @@ -2563,11 +2616,6 @@ typedef struct clone_params CLONE_PARAMS; # include "iperlsys.h" #endif -#if defined(__OPEN_VM) -# include "vmesa/vmesaish.h" -# define ISHISH "vmesa" -#endif - #ifdef DOSISH # if defined(OS2) # include "os2ish.h" @@ -2587,11 +2635,6 @@ typedef struct clone_params CLONE_PARAMS; # define ISHISH "plan9" #endif -#if defined(MPE) -# include "mpeix/mpeixish.h" -# define ISHISH "mpeix" -#endif - #if defined(__VOS__) # ifdef __GNUC__ # include "./vos/vosish.h" @@ -2601,11 +2644,6 @@ typedef struct clone_params CLONE_PARAMS; # define ISHISH "vos" #endif -#if defined(EPOC) -# include "epocish.h" -# define ISHISH "epoc" -#endif - #ifdef __SYMBIAN32__ # include "symbian/symbianish.h" # define ISHISH "symbian" @@ -2615,9 +2653,6 @@ typedef struct clone_params CLONE_PARAMS; #if defined(__HAIKU__) # include "haiku/haikuish.h" # define ISHISH "haiku" -#elif defined(__BEOS__) -# include "beos/beosish.h" -# define ISHISH "beos" #endif #ifndef ISHISH @@ -2721,12 +2756,12 @@ typedef struct clone_params CLONE_PARAMS; #endif /* -=for apidoc Am|void|PERL_SYS_INIT|int argc|char** argv +=for apidoc Am|void|PERL_SYS_INIT|int *argc|char*** argv Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. -=for apidoc Am|void|PERL_SYS_INIT3|int argc|char** argv|char** env +=for apidoc Am|void|PERL_SYS_INIT3|int *argc|char*** argv|char*** env Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. @@ -3277,9 +3312,9 @@ typedef pthread_key_t perl_key; appropriate to call return. In either case, include the lint directive. */ #ifdef HASATTRIBUTE_NORETURN -# define NORETURN_FUNCTION_END /* NOTREACHED */ +# define NORETURN_FUNCTION_END assert(0); /* NOTREACHED */ #else -# define NORETURN_FUNCTION_END /* NOTREACHED */ return 0 +# define NORETURN_FUNCTION_END assert(0); /* NOTREACHED */ return 0 #endif /* Some OS warn on NULL format to printf */ @@ -3464,8 +3499,7 @@ struct _sublex_info { U8 super_state; /* lexer state to save */ U16 sub_inwhat; /* "lex_inwhat" to use */ OP *sub_op; /* "lex_op" to use */ - char *super_bufptr; /* PL_parser->bufptr that was */ - char *super_bufend; /* PL_parser->bufend that was */ + SV *repl; /* replacement of s/// or y/// */ }; #include "parser.h" @@ -3490,10 +3524,6 @@ struct ptr_tbl { struct ptr_tbl_ent *tbl_arena_end; }; -#if defined(iAPX286) || defined(M_I286) || defined(I80286) -# define I286 -#endif - #if defined(htonl) && !defined(HAS_HTONL) #define HAS_HTONL #endif @@ -3619,7 +3649,7 @@ long vtohl(long n); #endif #ifndef __cplusplus -#if !(defined(UNDER_CE) || defined(SYMBIAN)) +#if !(defined(WIN32) || defined(UNDER_CE) || defined(SYMBIAN)) Uid_t getuid (void); Uid_t geteuid (void); Gid_t getgid (void); @@ -3658,7 +3688,7 @@ Gid_t getegid (void); #define DEBUG_H_FLAG 0x00002000 /* 8192 */ #define DEBUG_X_FLAG 0x00004000 /* 16384 */ #define DEBUG_D_FLAG 0x00008000 /* 32768 */ -/* 0x00010000 is unused, used to be S */ +#define DEBUG_S_FLAG 0x00010000 /* 65536 */ #define DEBUG_T_FLAG 0x00020000 /* 131072 */ #define DEBUG_R_FLAG 0x00040000 /* 262144 */ #define DEBUG_J_FLAG 0x00080000 /* 524288 */ @@ -3668,7 +3698,7 @@ Gid_t getegid (void); #define DEBUG_q_FLAG 0x00800000 /*8388608 */ #define DEBUG_M_FLAG 0x01000000 /*16777216*/ #define DEBUG_B_FLAG 0x02000000 /*33554432*/ -#define DEBUG_MASK 0x03FEEFFF /* mask of all the standard flags */ +#define DEBUG_MASK 0x03FFEFFF /* mask of all the standard flags */ #define DEBUG_DB_RECURSE_FLAG 0x40000000 #define DEBUG_TOP_FLAG 0x80000000 /* XXX what's this for ??? Signal @@ -3690,6 +3720,7 @@ Gid_t getegid (void); # define DEBUG_H_TEST_ (PL_debug & DEBUG_H_FLAG) # define DEBUG_X_TEST_ (PL_debug & DEBUG_X_FLAG) # define DEBUG_D_TEST_ (PL_debug & DEBUG_D_FLAG) +# define DEBUG_S_TEST_ (PL_debug & DEBUG_S_FLAG) # define DEBUG_T_TEST_ (PL_debug & DEBUG_T_FLAG) # define DEBUG_R_TEST_ (PL_debug & DEBUG_R_FLAG) # define DEBUG_J_TEST_ (PL_debug & DEBUG_J_FLAG) @@ -3721,6 +3752,7 @@ Gid_t getegid (void); # define DEBUG_H_TEST DEBUG_H_TEST_ # define DEBUG_X_TEST DEBUG_X_TEST_ # define DEBUG_D_TEST DEBUG_D_TEST_ +# define DEBUG_S_TEST DEBUG_S_TEST_ # define DEBUG_T_TEST DEBUG_T_TEST_ # define DEBUG_R_TEST DEBUG_R_TEST_ # define DEBUG_J_TEST DEBUG_J_TEST_ @@ -3772,6 +3804,7 @@ Gid_t getegid (void); # define DEBUG_Uv(a) DEBUG__(DEBUG_Uv_TEST, a) # define DEBUG_Pv(a) DEBUG__(DEBUG_Pv_TEST, a) +# define DEBUG_S(a) DEBUG__(DEBUG_S_TEST, a) # define DEBUG_T(a) DEBUG__(DEBUG_T_TEST, a) # define DEBUG_R(a) DEBUG__(DEBUG_R_TEST, a) # define DEBUG_v(a) DEBUG__(DEBUG_v_TEST, a) @@ -3799,6 +3832,7 @@ Gid_t getegid (void); # define DEBUG_H_TEST (0) # define DEBUG_X_TEST (0) # define DEBUG_D_TEST (0) +# define DEBUG_S_TEST (0) # define DEBUG_T_TEST (0) # define DEBUG_R_TEST (0) # define DEBUG_J_TEST (0) @@ -3830,6 +3864,7 @@ Gid_t getegid (void); # define DEBUG_H(a) # define DEBUG_X(a) # define DEBUG_D(a) +# define DEBUG_S(a) # define DEBUG_T(a) # define DEBUG_R(a) # define DEBUG_v(a) @@ -3866,6 +3901,11 @@ Gid_t getegid (void); #ifndef assert # define assert(what) Perl_assert(what) #endif +#ifdef DEBUGGING +# define assert_(what) assert(what), +#else +# define assert_(what) +#endif struct ufuncs { I32 (*uf_val)(pTHX_ IV, SV*); @@ -3907,7 +3947,7 @@ double atof (const char*); /* All of these are in stdlib.h or time.h for ANSI C */ Time_t time(); struct tm *gmtime(), *localtime(); -#if defined(OEMVS) || defined(__OPEN_VM) +#if defined(OEMVS) char *(strchr)(), *(strrchr)(); char *(strcpy)(), *(strcat)(); #else @@ -3998,7 +4038,7 @@ char *crypt (const char*, const char*); # ifndef getenv char *getenv (const char*); # endif /* !getenv */ -# if !defined(HAS_LSEEK_PROTO) && !defined(EPOC) && !defined(__hpux) +# if !defined(HAS_LSEEK_PROTO) && !defined(__hpux) # ifdef _FILE_OFFSET_BITS # if _FILE_OFFSET_BITS == 64 Off_t lseek (int,Off_t,int); @@ -4006,9 +4046,11 @@ Off_t lseek (int,Off_t,int); # endif # endif # endif /* !DONT_DECLARE_STD */ -#ifndef getlogin +# ifndef WIN32 +# ifndef getlogin char *getlogin (void); -#endif +# endif +# endif /* !WIN32 */ #endif /* !__cplusplus */ /* Fixme on VMS. This needs to be a run-time, not build time options */ @@ -4235,7 +4277,7 @@ EXTCONST char PL_no_helem_sv[] INIT("Modification of non-creatable hash value attempted, subscript \"%"SVf"\""); EXTCONST char PL_no_modify[] INIT("Modification of a read-only value attempted"); -EXTCONST char PL_no_mem[] +EXTCONST char PL_no_mem[sizeof("Out of memory!\n")] INIT("Out of memory!\n"); EXTCONST char PL_no_security[] INIT("Insecure dependency in %s%s"); @@ -4472,8 +4514,10 @@ EXTCONST unsigned char PL_mod_latin1_uc[] = { 248-32, 249-32, 250-32, 251-32, 252-32, 253-32, 254-32, 255 }; #else /* ! DOINIT */ +#ifndef EBCDIC EXTCONST unsigned char PL_fold[]; EXTCONST unsigned char PL_fold_latin1[]; +#endif EXTCONST unsigned char PL_mod_latin1_uc[]; EXTCONST unsigned char PL_latin1_lc[]; #endif @@ -4595,7 +4639,9 @@ EXTCONST unsigned char PL_freq[] = { /* letter frequencies for mixed English/C * EXTCONST unsigned char PL_freq[]; #endif -#ifdef DEBUGGING +/* Although only used for debugging, these constants must be available in + * non-debugging builds too, since they're used in ext/re/re_exec.c, + * which has DEBUGGING enabled always */ #ifdef DOINIT EXTCONST char* const PL_block_type[] = { "NULL", @@ -4614,7 +4660,6 @@ EXTCONST char* const PL_block_type[] = { #else EXTCONST char* PL_block_type[]; #endif -#endif /* These are all the compile time options that affect binary compatibility. Other compile time options that are binary compatible are in perl.c @@ -4677,18 +4722,21 @@ EXTCONST char PL_bincompat_options[] = # ifdef PERL_OLD_COPY_ON_WRITE " PERL_OLD_COPY_ON_WRITE" # endif +# ifdef PERL_NEW_COPY_ON_WRITE + " PERL_NEW_COPY_ON_WRITE" +# endif # ifdef PERL_POISON " PERL_POISON" # endif +# ifdef PERL_SAWAMPERSAND + " PERL_SAWAMPERSAND" +# endif # ifdef PERL_TRACK_MEMPOOL " PERL_TRACK_MEMPOOL" # endif # ifdef PERL_USES_PL_PIDSTATUS " PERL_USES_PL_PIDSTATUS" # endif -# ifdef PL_OP_SLAB_ALLOC - " PL_OP_SLAB_ALLOC" -# endif # ifdef USE_64_BIT_ALL " USE_64_BIT_ALL" # endif @@ -4776,6 +4824,8 @@ EXTCONST char *const PL_phase_names[]; * instead of using the newer PL_phase, which provides everything PL_dirty * provided, and more. */ # define PL_dirty (PL_phase == PERL_PHASE_DESTRUCT) + +# define PL_amagic_generation PL_na #endif /* !PERL_CORE */ END_EXTERN_C @@ -4862,6 +4912,17 @@ typedef enum { #define HINT_SORT_MERGESORT 0x00000002 #define HINT_SORT_STABLE 0x00000100 /* sort styles (currently one) */ +/* flags for PL_sawampersand */ + +#define SAWAMPERSAND_LEFT 1 /* saw $` */ +#define SAWAMPERSAND_MIDDLE 2 /* saw $& */ +#define SAWAMPERSAND_RIGHT 4 /* saw $' */ + +#ifndef PERL_SAWAMPERSAND +# define PL_sawampersand \ + (SAWAMPERSAND_LEFT|SAWAMPERSAND_MIDDLE|SAWAMPERSAND_RIGHT) +#endif + /* Various states of the input record separator SV (rs) */ #define RsSNARF(sv) (! SvOK(sv)) #define RsSIMPLE(sv) (SvOK(sv) && (! SvPOK(sv) || SvCUR(sv))) @@ -4948,8 +5009,14 @@ struct interpreter { /* Set up PERLVAR macros for populating structs */ # define PERLVAR(prefix,var,type) type prefix##var; + +/* 'var' is an array of length 'n' */ # define PERLVARA(prefix,var,n,type) type prefix##var[n]; + +/* initialize 'var' to init' */ # define PERLVARI(prefix,var,type,init) type prefix##var; + +/* like PERLVARI, but make 'var' a const */ # define PERLVARIC(prefix,var,type,init) type prefix##var; struct interpreter { @@ -4966,8 +5033,8 @@ EXTCONST U16 PL_interp_size /* This will be useful for subsequent releases, because this has to be the same in your libperl as in main(), else you have a mismatch and must abort. */ -EXTCONST U16 PL_interp_size_5_16_0 - INIT(PERL_INTERPRETER_SIZE_UPTO_MEMBER(PERL_LAST_5_16_0_INTERP_MEMBER)); +EXTCONST U16 PL_interp_size_5_18_0 + INIT(PERL_INTERPRETER_SIZE_UPTO_MEMBER(PERL_LAST_5_18_0_INTERP_MEMBER)); # ifdef PERL_GLOBAL_STRUCT @@ -5018,6 +5085,24 @@ struct tempsym; /* defined in pp_pack.c */ # define PERL_CALLCONV # endif #endif +#ifndef PERL_CALLCONV_NO_RET +# define PERL_CALLCONV_NO_RET PERL_CALLCONV +#endif + +/* PERL_STATIC_NO_RET is supposed to be equivalent to STATIC on builds that + dont have a noreturn as a declaration specifier +*/ +#ifndef PERL_STATIC_NO_RET +# define PERL_STATIC_NO_RET STATIC +#endif +/* PERL_STATIC_NO_RET is supposed to be equivalent to PERL_STATIC_INLINE on + builds that dont have a noreturn as a declaration specifier +*/ +#ifndef PERL_STATIC_INLINE_NO_RET +# define PERL_STATIC_INLINE_NO_RET PERL_STATIC_INLINE +#endif + + #undef PERL_CKDEF #undef PERL_PPDEF #define PERL_CKDEF(s) PERL_CALLCONV OP *s (pTHX_ OP *o); @@ -5135,7 +5220,7 @@ PL_valid_types_IVX[] = { 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0 }; EXTCONST bool PL_valid_types_NVX[] = { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0 }; EXTCONST bool -PL_valid_types_PVX[] = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 }; +PL_valid_types_PVX[] = { 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1 }; EXTCONST bool PL_valid_types_RV[] = { 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1 }; EXTCONST bool @@ -5154,6 +5239,21 @@ EXTCONST bool PL_valid_types_NV_set[]; #endif +#ifndef PERL_NO_INLINE_FUNCTIONS +/* Static inline funcs that depend on includes and declarations above. + Some of these reference functions in the perl object files, and some + compilers aren't smart enough to eliminate unused static inline + functions, so including this file in source code can cause link errors + even if the source code uses none of the functions. Hence including these + can be be suppressed by setting PERL_NO_INLINE_FUNCTIONS. Doing this will + (obviously) result in unworkable XS code, but allows simple probing code + to continue to work, because it permits tests to include the perl headers + for definitions without creating a link dependency on the perl library + (which may not exist yet). +*/ + +# include "inline.h" +#endif #include "overload.h" @@ -5164,7 +5264,6 @@ struct am_table { U8 fallback; U16 spare; U32 was_ok_sub; - long was_ok_am; CV* table[NofAMmeth]; }; struct am_table_short { @@ -5172,7 +5271,6 @@ struct am_table_short { U8 fallback; U16 spare; U32 was_ok_sub; - long was_ok_am; }; typedef struct am_table AMT; typedef struct am_table_short AMTS; @@ -5182,13 +5280,9 @@ typedef struct am_table_short AMTS; #define AMGfallYES 3 #define AMTf_AMAGIC 1 -#define AMTf_OVERLOADED 2 #define AMT_AMAGIC(amt) ((amt)->flags & AMTf_AMAGIC) #define AMT_AMAGIC_on(amt) ((amt)->flags |= AMTf_AMAGIC) #define AMT_AMAGIC_off(amt) ((amt)->flags &= ~AMTf_AMAGIC) -#define AMT_OVERLOADED(amt) ((amt)->flags & AMTf_OVERLOADED) -#define AMT_OVERLOADED_on(amt) ((amt)->flags |= AMTf_OVERLOADED) -#define AMT_OVERLOADED_off(amt) ((amt)->flags &= ~AMTf_OVERLOADED) #define StashHANDLER(stash,meth) gv_handler((stash),CAT2(meth,_amg)) @@ -5311,10 +5405,12 @@ typedef struct am_table_short AMTS; #define RESTORE_NUMERIC_STANDARD() /**/ #define Atof my_atof #define IN_LOCALE_RUNTIME 0 +#define IN_LOCALE_COMPILETIME 0 #endif /* !USE_LOCALE_NUMERIC */ -#if !defined(Strtol) && defined(USE_64_BIT_INT) && defined(IV_IS_QUAD) && QUADKIND == QUAD_IS_LONG_LONG +#if !defined(Strtol) && defined(USE_64_BIT_INT) && defined(IV_IS_QUAD) && \ + (QUADKIND == QUAD_IS_LONG_LONG || QUADKIND == QUAD_IS___INT64) # ifdef __hpux # define strtoll __strtoll /* secret handshake */ # endif @@ -5336,7 +5432,8 @@ typedef struct am_table_short AMTS; /* It would be more fashionable to use Strtol() to define atol() * (as is done for Atoul(), see below) but for backward compatibility * we just assume atol(). */ -# if defined(USE_64_BIT_INT) && defined(IV_IS_QUAD) && QUADKIND == QUAD_IS_LONG_LONG && defined(HAS_ATOLL) +# if defined(USE_64_BIT_INT) && defined(IV_IS_QUAD) && defined(HAS_ATOLL) && \ + (QUADKIND == QUAD_IS_LONG_LONG || QUADKIND == QUAD_IS___INT64) # ifdef WIN64 # define atoll _atoi64 /* secret handshake */ # endif @@ -5346,7 +5443,8 @@ typedef struct am_table_short AMTS; # endif #endif -#if !defined(Strtoul) && defined(USE_64_BIT_INT) && defined(UV_IS_QUAD) && QUADKIND == QUAD_IS_LONG_LONG +#if !defined(Strtoul) && defined(USE_64_BIT_INT) && defined(UV_IS_QUAD) && \ + (QUADKIND == QUAD_IS_LONG_LONG || QUADKIND == QUAD_IS___INT64) # ifdef __hpux # define strtoull __strtoull /* secret handshake */ # endif @@ -5590,10 +5688,9 @@ int flock(int fd, int op); #if O_TEXT != O_BINARY /* If you have different O_TEXT and O_BINARY and you are a CLRF shop, * that is, you are somehow DOSish. */ -# if defined(__BEOS__) || defined(__HAIKU__) || defined(__VOS__) || \ - defined(__CYGWIN__) - /* BeOS/Haiku has O_TEXT != O_BINARY but O_TEXT and O_BINARY have no effect; - * BeOS/Haiku is always UNIXoid (LF), not DOSish (CRLF). */ +# if defined(__HAIKU__) || defined(__VOS__) || defined(__CYGWIN__) + /* Haiku has O_TEXT != O_BINARY but O_TEXT and O_BINARY have no effect; + * Haiku is always UNIXoid (LF), not DOSish (CRLF). */ /* VOS has O_TEXT != O_BINARY, and they have effect, * but VOS always uses LF, never CRLF. */ /* If you have O_TEXT different from your O_BINARY but you still are @@ -5647,15 +5744,7 @@ extern void moncontrol(int); /* ISO 6429 NEL - C1 control NExt Line */ /* See http://www.unicode.org/unicode/reports/tr13/ */ -#ifdef EBCDIC /* In EBCDIC NEL is just an alias for LF */ -# if '^' == 95 /* CP 1047: MVS OpenEdition - OS/390 - z/OS */ -# define NEXT_LINE_CHAR 0x15 -# else /* CDRA */ -# define NEXT_LINE_CHAR 0x25 -# endif -#else -# define NEXT_LINE_CHAR 0x85 -#endif +#define NEXT_LINE_CHAR NEXT_LINE_NATIVE /* The UTF-8 bytes of the Unicode LS and PS, U+2028 and U+2029 */ #define UNICODE_LINE_SEPA_0 0xE2 @@ -5828,8 +5917,8 @@ extern void moncontrol(int); * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/perlapi.h b/Master/tlpkg/tlperl/lib/CORE/perlapi.h index 80425c368cf..910f7895406 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perlapi.h +++ b/Master/tlpkg/tlperl/lib/CORE/perlapi.h @@ -115,6 +115,10 @@ END_EXTERN_C #define PL_dollarzero_mutex (*Perl_Gdollarzero_mutex_ptr(NULL)) #undef PL_fold_locale #define PL_fold_locale (*Perl_Gfold_locale_ptr(NULL)) +#undef PL_hash_seed +#define PL_hash_seed (*Perl_Ghash_seed_ptr(NULL)) +#undef PL_hash_seed_set +#define PL_hash_seed_set (*Perl_Ghash_seed_set_ptr(NULL)) #undef PL_hints_mutex #define PL_hints_mutex (*Perl_Ghints_mutex_ptr(NULL)) #undef PL_keyword_plugin diff --git a/Master/tlpkg/tlperl/lib/CORE/perlhost.h b/Master/tlpkg/tlperl/lib/CORE/perlhost.h index e8f5fb4928e..265328b69b7 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perlhost.h +++ b/Master/tlpkg/tlperl/lib/CORE/perlhost.h @@ -26,11 +26,10 @@ #endif START_EXTERN_C -extern char * g_win32_get_privlib(const char *pl, STRLEN *const len); -extern char * g_win32_get_sitelib(const char *pl, STRLEN *const len); -extern char * g_win32_get_vendorlib(const char *pl, - STRLEN *const len); -extern char * g_getlogin(void); +extern char * g_win32_get_privlib(const char *pl, STRLEN *const len); +extern char * g_win32_get_sitelib(const char *pl, STRLEN *const len); +extern char * g_win32_get_vendorlib(const char *pl, STRLEN *const len); +extern char * g_getlogin(void); END_EXTERN_C class CPerlHost @@ -1279,8 +1278,7 @@ PerlSockGethostbyname(struct IPerlSock* piPerl, const char* name) struct hostent* PerlSockGethostent(struct IPerlSock* piPerl) { - dTHX; - Perl_croak(aTHX_ "gethostent not implemented!\n"); + win32_croak_not_implemented("gethostent"); return NULL; } @@ -1535,13 +1533,13 @@ PerlProcCrypt(struct IPerlProc* piPerl, const char* clear, const char* salt) return win32_crypt(clear, salt); } -void +PERL_CALLCONV_NO_RET void PerlProcExit(struct IPerlProc* piPerl, int status) { exit(status); } -void +PERL_CALLCONV_NO_RET void PerlProc_Exit(struct IPerlProc* piPerl, int status) { _exit(status); @@ -1809,8 +1807,8 @@ restart: int PerlProcFork(struct IPerlProc* piPerl) { - dTHX; #ifdef USE_ITHREADS + dTHX; DWORD id; HANDLE handle; CPerlHost *h; @@ -1862,7 +1860,7 @@ PerlProcFork(struct IPerlProc* piPerl) # endif return -(int)id; #else - Perl_croak(aTHX_ "fork() not implemented!\n"); + win32_croak_not_implemented("fork()"); return -1; #endif /* USE_ITHREADS */ } @@ -1894,6 +1892,8 @@ PerlProcSpawnvp(struct IPerlProc* piPerl, int mode, const char *cmdname, const c int PerlProcLastHost(struct IPerlProc* piPerl) { + /* this dTHX is unused in an optimized build since CPerlHost::num_hosts + is a static */ dTHX; CPerlHost *h = (CPerlHost*)w32_internal_host; return h->LastHost(); @@ -2178,7 +2178,6 @@ compare(const void *arg1, const void *arg2) void CPerlHost::Add(LPCSTR lpStr) { - dTHX; char szBuffer[1024]; LPSTR *lpPtr; int index, length = strlen(lpStr)+1; @@ -2225,14 +2224,12 @@ CPerlHost::CalculateEnvironmentSpace(void) void CPerlHost::FreeLocalEnvironmentStrings(LPSTR lpStr) { - dTHX; Safefree(lpStr); } char* CPerlHost::GetChildDir(void) { - dTHX; char* ptr; size_t length; @@ -2249,20 +2246,18 @@ CPerlHost::GetChildDir(void) void CPerlHost::FreeChildDir(char* pStr) { - dTHX; Safefree(pStr); } LPSTR CPerlHost::CreateLocalEnvironmentStrings(VDir &vDir) { - dTHX; LPSTR lpStr, lpPtr, lpEnvPtr, lpTmp, lpLocalEnv, lpAllocPtr; DWORD dwSize, dwEnvIndex; int nLength, compVal; // get the process environment strings - lpAllocPtr = lpTmp = (LPSTR)GetEnvironmentStrings(); + lpAllocPtr = lpTmp = (LPSTR)win32_getenvironmentstrings(); // step over current directory stuff while(*lpTmp == '=') @@ -2338,7 +2333,7 @@ CPerlHost::CreateLocalEnvironmentStrings(VDir &vDir) } // release the process environment strings - FreeEnvironmentStrings(lpAllocPtr); + win32_freeenvironmentstrings(lpAllocPtr); return lpPtr; } @@ -2346,7 +2341,6 @@ CPerlHost::CreateLocalEnvironmentStrings(VDir &vDir) void CPerlHost::Reset(void) { - dTHX; if(m_lppEnvList != NULL) { for(DWORD index = 0; index < m_dwEnvCount; ++index) { Free(m_lppEnvList[index]); @@ -2361,7 +2355,6 @@ CPerlHost::Reset(void) void CPerlHost::Clearenv(void) { - dTHX; char ch; LPSTR lpPtr, lpStr, lpEnvPtr; if (m_lppEnvList != NULL) { @@ -2375,7 +2368,7 @@ CPerlHost::Clearenv(void) } /* get the process environment strings */ - lpStr = lpEnvPtr = (LPSTR)GetEnvironmentStrings(); + lpStr = lpEnvPtr = (LPSTR)win32_getenvironmentstrings(); /* step over current directory stuff */ while(*lpStr == '=') @@ -2394,14 +2387,13 @@ CPerlHost::Clearenv(void) lpStr += strlen(lpStr) + 1; } - FreeEnvironmentStrings(lpEnvPtr); + win32_freeenvironmentstrings(lpEnvPtr); } char* CPerlHost::Getenv(const char *varname) { - dTHX; if (!m_bTopLevel) { char *pEnv = Find(varname); if (pEnv && *pEnv) @@ -2413,7 +2405,6 @@ CPerlHost::Getenv(const char *varname) int CPerlHost::Putenv(const char *envstring) { - dTHX; Add(envstring); if (m_bTopLevel) return win32_putenv(envstring); @@ -2424,7 +2415,6 @@ CPerlHost::Putenv(const char *envstring) int CPerlHost::Chdir(const char *dirname) { - dTHX; int ret; if (!dirname) { errno = ENOENT; diff --git a/Master/tlpkg/tlperl/lib/CORE/perlio.h b/Master/tlpkg/tlperl/lib/CORE/perlio.h index 0575cb17bdf..7b5adbd3458 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perlio.h +++ b/Master/tlpkg/tlperl/lib/CORE/perlio.h @@ -64,11 +64,6 @@ */ #include <stdio.h> -#ifdef __BEOS__ -int fseeko(FILE *stream, off_t offset, int whence); -off_t ftello(FILE *stream); -#endif - #if defined(USE_64_BIT_STDIO) && defined(HAS_FTELLO) && !defined(USE_FTELL64) #define ftell ftello #endif @@ -392,8 +387,8 @@ END_EXTERN_C * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/perliol.h b/Master/tlpkg/tlperl/lib/CORE/perliol.h index 3bce866f490..c667f1f5ebc 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perliol.h +++ b/Master/tlpkg/tlperl/lib/CORE/perliol.h @@ -279,8 +279,8 @@ PERL_EXPORT_C IV PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/perlsdio.h b/Master/tlpkg/tlperl/lib/CORE/perlsdio.h index 691ee325711..29e817617af 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perlsdio.h +++ b/Master/tlpkg/tlperl/lib/CORE/perlsdio.h @@ -157,8 +157,8 @@ * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/perlsfio.h b/Master/tlpkg/tlperl/lib/CORE/perlsfio.h index 2471753ad19..66ec10fdbd7 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perlsfio.h +++ b/Master/tlpkg/tlperl/lib/CORE/perlsfio.h @@ -77,8 +77,8 @@ extern int _stdprintf _ARG_((const char*, ...)); * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/perlvars.h b/Master/tlpkg/tlperl/lib/CORE/perlvars.h index 20c3882fc8d..96dfe04c26a 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perlvars.h +++ b/Master/tlpkg/tlperl/lib/CORE/perlvars.h @@ -231,3 +231,6 @@ PERLVAR(G, sv_placeholder, SV) #if defined(MYMALLOC) && defined(USE_ITHREADS) PERLVAR(G, malloc_mutex, perl_mutex) /* Mutex for malloc */ #endif + +PERLVARI(G, hash_seed_set, bool, FALSE) /* perl.c */ +PERLVARA(G, hash_seed, PERL_HASH_SEED_BYTES, unsigned char) /* perl.c and hv.h */ diff --git a/Master/tlpkg/tlperl/lib/CORE/perly.h b/Master/tlpkg/tlperl/lib/CORE/perly.h index 7cbdd2f0670..6f1d6b95db5 100644 --- a/Master/tlpkg/tlperl/lib/CORE/perly.h +++ b/Master/tlpkg/tlperl/lib/CORE/perly.h @@ -5,27 +5,24 @@ */ #ifdef PERL_CORE -/* A Bison parser, made by GNU Bison 2.3. */ +/* A Bison parser, made by GNU Bison 2.6.1. */ -/* Skeleton interface for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work @@ -36,10 +33,18 @@ special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. - + This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif + /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE @@ -100,33 +105,35 @@ NOAMP = 309, LOCAL = 310, MY = 311, - MYSUB = 312, - REQUIRE = 313, - COLONATTR = 314, - PREC_LOW = 315, - DOROP = 316, - OROP = 317, - ANDOP = 318, - NOTOP = 319, - ASSIGNOP = 320, - DORDOR = 321, - OROR = 322, - ANDAND = 323, - BITOROP = 324, - BITANDOP = 325, - SHIFTOP = 326, - MATCHOP = 327, - REFGEN = 328, - UMINUS = 329, - POWOP = 330, - POSTDEC = 331, - POSTINC = 332, - PREDEC = 333, - PREINC = 334, - ARROW = 335, - PEG = 336 + REQUIRE = 312, + COLONATTR = 313, + FORMLBRACK = 314, + FORMRBRACK = 315, + PREC_LOW = 316, + DOROP = 317, + OROP = 318, + ANDOP = 319, + NOTOP = 320, + ASSIGNOP = 321, + DORDOR = 322, + OROR = 323, + ANDAND = 324, + BITOROP = 325, + BITANDOP = 326, + SHIFTOP = 327, + MATCHOP = 328, + REFGEN = 329, + UMINUS = 330, + POWOP = 331, + POSTDEC = 332, + POSTINC = 333, + PREDEC = 334, + PREINC = 335, + ARROW = 336, + PEG = 337 }; #endif + /* Tokens. */ #define GRAMPROG 258 #define GRAMEXPR 259 @@ -182,39 +189,62 @@ #define NOAMP 309 #define LOCAL 310 #define MY 311 -#define MYSUB 312 -#define REQUIRE 313 -#define COLONATTR 314 -#define PREC_LOW 315 -#define DOROP 316 -#define OROP 317 -#define ANDOP 318 -#define NOTOP 319 -#define ASSIGNOP 320 -#define DORDOR 321 -#define OROR 322 -#define ANDAND 323 -#define BITOROP 324 -#define BITANDOP 325 -#define SHIFTOP 326 -#define MATCHOP 327 -#define REFGEN 328 -#define UMINUS 329 -#define POWOP 330 -#define POSTDEC 331 -#define POSTINC 332 -#define PREDEC 333 -#define PREINC 334 -#define ARROW 335 -#define PEG 336 - - +#define REQUIRE 312 +#define COLONATTR 313 +#define FORMLBRACK 314 +#define FORMRBRACK 315 +#define PREC_LOW 316 +#define DOROP 317 +#define OROP 318 +#define ANDOP 319 +#define NOTOP 320 +#define ASSIGNOP 321 +#define DORDOR 322 +#define OROR 323 +#define ANDAND 324 +#define BITOROP 325 +#define BITANDOP 326 +#define SHIFTOP 327 +#define MATCHOP 328 +#define REFGEN 329 +#define UMINUS 330 +#define POWOP 331 +#define POSTDEC 332 +#define POSTINC 333 +#define PREDEC 334 +#define PREINC 335 +#define ARROW 336 +#define PEG 337 +#ifdef PERL_IN_TOKE_C +static bool +S_is_opval_token(int type) { + switch (type) { + case FUNC0OP: + case FUNC0SUB: + case FUNCMETH: + case LSTOPSUB: + case METHOD: + case PLUGEXPR: + case PLUGSTMT: + case PMFUNC: + case PRIVATEREF: + case QWLIST: + case THING: + case UNIOPSUB: + case WORD: + return 1; + } + return 0; +} +#endif /* PERL_IN_TOKE_C */ #endif /* PERL_CORE */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE { +/* Line 2049 of yacc.c */ + I32 ival; /* __DEFAULT__ (marker for regen_perly.pl; must always be 1st union member) */ char *pval; @@ -230,18 +260,32 @@ typedef union YYSTYPE #ifdef PERL_MAD TOKEN* tkval; #endif -} -/* Line 1529 of yacc.c. */ - YYSTYPE; + + +/* Line 2049 of yacc.c */ +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 #endif +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ /* Generated from: - * 047d7d5048e78a17bc586b7bb9a0f0e9dedd5cd43b30e486482b1ff8f955ddcb perly.y - * 53f57d7143a42b3c008841a14d158bcf9cab64b2904b07ef5e95051fe9a8a875 regen_perly.pl + * 28c2c7738eefc00762e227af0363c729186c992e9127e0c935684cccbf3a3b4f perly.y + * 5c9d2a0262457fe9b70073fc8ad6c188f812f38ad57712b7e2f53daa01b297cc regen_perly.pl * ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/pp.h b/Master/tlpkg/tlperl/lib/CORE/pp.h index 63b22340f9e..cb6a0668f94 100644 --- a/Master/tlpkg/tlperl/lib/CORE/pp.h +++ b/Master/tlpkg/tlperl/lib/CORE/pp.h @@ -67,7 +67,7 @@ Refetch the stack pointer. Used after a callback. See L<perlcall>. #define dSP SV **sp = PL_stack_sp #define djSP dSP -#define dMARK register SV **mark = PL_stack_base + POPMARK +#define dMARK SV **mark = PL_stack_base + POPMARK #define dORIGMARK const I32 origmark = (I32)(mark - PL_stack_base) #define ORIGMARK (PL_stack_base + origmark) @@ -97,10 +97,11 @@ See C<PUSHMARK> and L<perlcall> for other uses. Pops an SV off the stack. =for apidoc Amn|char*|POPp -Pops a string off the stack. Deprecated. New code should use POPpx. +Pops a string off the stack. =for apidoc Amn|char*|POPpx -Pops a string off the stack. +Pops a string off the stack. Identical to POPp. There are two names for +historical reasons. =for apidoc Amn|char*|POPpbytex Pops a string off the stack which must consist of bytes i.e. characters < 256. @@ -123,7 +124,7 @@ Pops a long off the stack. #define RETURNX(x) return (x, PUTBACK, NORMAL) #define POPs (*sp--) -#define POPp (SvPVx(POPs, PL_na)) /* deprecated */ +#define POPp POPpx #define POPpx (SvPVx_nolen(POPs)) #define POPpconstx (SvPVx_nolen_const(POPs)) #define POPpbytex (SvPVbytex_nolen(POPs)) @@ -140,7 +141,7 @@ Pops a long off the stack. #define TOPs (*sp) #define TOPm1s (*(sp-1)) #define TOPp1s (*(sp+1)) -#define TOPp (SvPV(TOPs, PL_na)) /* deprecated */ +#define TOPp TOPpx #define TOPpx (SvPV_nolen(TOPs)) #define TOPn (SvNV(TOPs)) #define TOPi ((IV)SvIV(TOPs)) @@ -277,16 +278,15 @@ Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu> and C<PUSHu>. =cut */ -#define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (int)(n)) { \ - sp = stack_grow(sp,p, (int) (n)); \ - } } STMT_END +#define EXTEND(p,n) (void)(UNLIKELY(PL_stack_max - p < (int)(n)) && \ + (sp = stack_grow(sp,p, (int) (n)))) /* Same thing, but update mark register too. */ -#define MEXTEND(p,n) STMT_START {if (PL_stack_max - p < (int)(n)) { \ - const int markoff = mark - PL_stack_base; \ - sp = stack_grow(sp,p,(int) (n)); \ - mark = PL_stack_base + markoff; \ - } } STMT_END +#define MEXTEND(p,n) STMT_START {if (UNLIKELY(PL_stack_max - p < (int)(n))) {\ + const int markoff = mark - PL_stack_base; \ + sp = stack_grow(sp,p,(int) (n)); \ + mark = PL_stack_base + markoff; \ + } } STMT_END #define PUSHs(s) (*++sp = (s)) #define PUSHTARG STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END @@ -295,7 +295,7 @@ Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu> and C<PUSHu>. #define PUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END #define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END -#define XPUSHs(s) STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END +#define XPUSHs(s) (EXTEND(sp,1), *++sp = (s)) #define XPUSHTARG STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END #define XPUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END #define XPUSHn(n) STMT_START { sv_setnv(TARG, (NV)(n)); XPUSHTARG; } STMT_END @@ -388,7 +388,7 @@ Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu> and C<PUSHu>. #define EXTEND_MORTAL(n) \ STMT_START { \ - if (PL_tmps_ix + (n) >= PL_tmps_max) \ + if (UNLIKELY(PL_tmps_ix + (n) >= PL_tmps_max)) \ tmps_grow(n); \ } STMT_END @@ -398,6 +398,7 @@ Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu> and C<PUSHu>. #define AMGf_unary 8 #define AMGf_numeric 0x10 /* for Perl_try_amagic_bin */ #define AMGf_set 0x20 /* for Perl_try_amagic_bin */ +#define AMGf_want_list 0x40 /* do SvGETMAGIC on the stack args before checking for overload */ @@ -419,21 +420,37 @@ Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu> and C<PUSHu>. /* No longer used in core. Use AMG_CALLunary instead */ #define AMG_CALLun(sv,meth) AMG_CALLunary(sv, CAT2(meth,_amg)) -#define tryAMAGICunTARGET(meth, shift, jump) \ +#define tryAMAGICunTARGETlist(meth, jump) \ STMT_START { \ - dATARGET; \ dSP; \ SV *tmpsv; \ - SV *arg= sp[shift]; \ + SV *arg= *sp; \ + int gimme = GIMME_V; \ if (SvAMAGIC(arg) && \ (tmpsv = amagic_call(arg, &PL_sv_undef, meth, \ - AMGf_noright | AMGf_unary))) { \ + AMGf_want_list | AMGf_noright \ + |AMGf_unary))) { \ SPAGAIN; \ - sp += shift; \ - sv_setsv(TARG, tmpsv); \ - if (opASSIGN) \ - sp--; \ - SETTARG; \ + if (gimme == G_VOID) { \ + (void)POPs; /* XXX ??? */ \ + } \ + else if (gimme == G_ARRAY) { \ + int i; \ + I32 len; \ + assert(SvTYPE(tmpsv) == SVt_PVAV); \ + len = av_len((AV *)tmpsv) + 1; \ + (void)POPs; /* get rid of the arg */ \ + EXTEND(sp, len); \ + for (i = 0; i < len; ++i) \ + PUSHs(av_shift((AV *)tmpsv)); \ + } \ + else { /* AMGf_want_scalar */ \ + dATARGET; /* just use the arg's location */ \ + sv_setsv(TARG, tmpsv); \ + if (opASSIGN) \ + sp--; \ + SETTARG; \ + } \ PUTBACK; \ if (jump) { \ OP *jump_o = NORMAL->op_next; \ @@ -476,8 +493,8 @@ True if this op will be the return value of an lvalue subroutine #define SvCANEXISTDELETE(sv) \ (!SvRMAGICAL(sv) \ - || ((mg = mg_find((const SV *) sv, PERL_MAGIC_tied)) \ - && (stash = SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(sv), mg)))) \ + || !(mg = mg_find((const SV *) sv, PERL_MAGIC_tied)) \ + || ( (stash = SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(sv), mg)))) \ && gv_fetchmethod_autoload(stash, "EXISTS", TRUE) \ && gv_fetchmethod_autoload(stash, "DELETE", TRUE) \ ) \ @@ -497,7 +514,7 @@ True if this op will be the return value of an lvalue subroutine ( \ (void)(phlags & SV_GMAGIC && (SvGETMAGIC(sv),0)), \ isGV_with_GP(sv) \ - ? (GV *)sv \ + ? (GV *)(sv) \ : SvROK(sv) && SvTYPE(SvRV(sv)) <= SVt_PVLV && \ (SvGETMAGIC(SvRV(sv)), isGV_with_GP(SvRV(sv))) \ ? (GV *)SvRV(sv) \ @@ -506,14 +523,17 @@ True if this op will be the return value of an lvalue subroutine # define MAYBE_DEREF_GV(sv) MAYBE_DEREF_GV_flags(sv,SV_GMAGIC) # define MAYBE_DEREF_GV_nomg(sv) MAYBE_DEREF_GV_flags(sv,0) +# define FIND_RUNCV_padid_eq 1 +# define FIND_RUNCV_level_eq 2 + #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/pp_proto.h b/Master/tlpkg/tlperl/lib/CORE/pp_proto.h index 52011dadd3d..a4dd46d5cc0 100644 --- a/Master/tlpkg/tlperl/lib/CORE/pp_proto.h +++ b/Master/tlpkg/tlperl/lib/CORE/pp_proto.h @@ -27,7 +27,6 @@ PERL_CALLCONV OP *Perl_pp_binmode(pTHX); PERL_CALLCONV OP *Perl_pp_bit_and(pTHX); PERL_CALLCONV OP *Perl_pp_bit_or(pTHX); PERL_CALLCONV OP *Perl_pp_bless(pTHX); -PERL_CALLCONV OP *Perl_pp_boolkeys(pTHX); PERL_CALLCONV OP *Perl_pp_break(pTHX); PERL_CALLCONV OP *Perl_pp_caller(pTHX); PERL_CALLCONV OP *Perl_pp_chdir(pTHX); @@ -35,6 +34,7 @@ PERL_CALLCONV OP *Perl_pp_chop(pTHX); PERL_CALLCONV OP *Perl_pp_chown(pTHX); PERL_CALLCONV OP *Perl_pp_chr(pTHX); PERL_CALLCONV OP *Perl_pp_chroot(pTHX); +PERL_CALLCONV OP *Perl_pp_clonecv(pTHX); PERL_CALLCONV OP *Perl_pp_close(pTHX); PERL_CALLCONV OP *Perl_pp_closedir(pTHX); PERL_CALLCONV OP *Perl_pp_complement(pTHX); @@ -119,6 +119,7 @@ PERL_CALLCONV OP *Perl_pp_i_negate(pTHX); PERL_CALLCONV OP *Perl_pp_i_subtract(pTHX); PERL_CALLCONV OP *Perl_pp_index(pTHX); PERL_CALLCONV OP *Perl_pp_int(pTHX); +PERL_CALLCONV OP *Perl_pp_introcv(pTHX); PERL_CALLCONV OP *Perl_pp_ioctl(pTHX); PERL_CALLCONV OP *Perl_pp_iter(pTHX); PERL_CALLCONV OP *Perl_pp_join(pTHX); @@ -164,7 +165,9 @@ PERL_CALLCONV OP *Perl_pp_or(pTHX); PERL_CALLCONV OP *Perl_pp_ord(pTHX); PERL_CALLCONV OP *Perl_pp_pack(pTHX); PERL_CALLCONV OP *Perl_pp_padav(pTHX); +PERL_CALLCONV OP *Perl_pp_padcv(pTHX); PERL_CALLCONV OP *Perl_pp_padhv(pTHX); +PERL_CALLCONV OP *Perl_pp_padrange(pTHX); PERL_CALLCONV OP *Perl_pp_padsv(pTHX); PERL_CALLCONV OP *Perl_pp_pipe_op(pTHX); PERL_CALLCONV OP *Perl_pp_pos(pTHX); diff --git a/Master/tlpkg/tlperl/lib/CORE/proto.h b/Master/tlpkg/tlperl/lib/CORE/proto.h index 143eee0e3e3..607eef8cbac 100644 --- a/Master/tlpkg/tlperl/lib/CORE/proto.h +++ b/Master/tlpkg/tlperl/lib/CORE/proto.h @@ -23,13 +23,52 @@ PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing) assert(stash) PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); -PERL_CALLCONV bool Perl__is_utf8__perl_idstart(pTHX_ const U8 *p) +PERL_CALLCONV_NO_RET void Perl_croak_memory_wrap(void) + __attribute__noreturn__; + +PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) + __attribute__malloc__ + __attribute__warn_unused_result__; + +PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_SLAB_FREE \ + assert(op) + +PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) + __attribute__warn_unused_result__; + +PERL_CALLCONV bool Perl__is_uni_perl_idcont(pTHX_ UV c) + __attribute__warn_unused_result__; + +PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c) + __attribute__warn_unused_result__; + +PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT__IS_UTF8_FOO \ + assert(p) + +PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__IS_UTF8_MARK \ + assert(p) + +PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ + assert(p) + +PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT__IS_UTF8__PERL_IDSTART \ +#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p) -PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, const bool flags) +PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, const U8 flags) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ @@ -129,6 +168,13 @@ PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, I32 key) #define PERL_ARGS_ASSERT_AV_EXTEND \ assert(av) +PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, I32 key, SSize_t *maxp, SV ***allocp, SV ***arrayp) + __attribute__nonnull__(pTHX_3) + __attribute__nonnull__(pTHX_4) + __attribute__nonnull__(pTHX_5); +#define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ + assert(maxp); assert(allocp); assert(arrayp) + PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -184,6 +230,16 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, I32 key, SV *val) #define PERL_ARGS_ASSERT_AV_STORE \ assert(av) +/* PERL_CALLCONV I32 Perl_av_tindex(pTHX_ AV *av) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); */ + +PERL_STATIC_INLINE I32 S_av_top_index(pTHX_ AV *av) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_AV_TOP_INDEX \ + assert(av) + PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNDEF \ @@ -303,12 +359,6 @@ PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) #define PERL_ARGS_ASSERT_CK_BITOP \ assert(o) -PERL_CALLCONV OP * Perl_ck_chdir(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_CK_CHDIR \ - assert(o) - PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -620,32 +670,39 @@ PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ assert(name) -PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *coreargssv, const int code, const int opnum) +PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CORESUB_OP \ assert(coreargssv) PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags); -PERL_CALLCONV void Perl_croak(pTHX_ const char* pat, ...) +PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); -PERL_CALLCONV void Perl_croak_no_modify(pTHX) +PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void) + __attribute__noreturn__; + +PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void) __attribute__noreturn__; -PERL_CALLCONV void Perl_croak_sv(pTHX_ SV *baseex) +PERL_CALLCONV_NO_RET void Perl_croak_popstack(void) + __attribute__noreturn__; + +PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) __attribute__noreturn__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CROAK_SV \ assert(baseex) -PERL_CALLCONV void Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) +PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *const params) __attribute__noreturn__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ assert(cv); assert(params) +PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -680,9 +737,20 @@ PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto) #define PERL_ARGS_ASSERT_CV_CLONE \ assert(proto) +PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_CV_CLONE_INTO \ + assert(proto); assert(target) + PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv) __attribute__warn_unused_result__; +PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_CV_FORGET_SLAB \ + assert(cv) + PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -754,7 +822,7 @@ PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex) #define PERL_ARGS_ASSERT_DIE_SV \ assert(baseex) -PERL_CALLCONV void Perl_die_unwind(pTHX_ SV* msv) +PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv) __attribute__noreturn__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DIE_UNWIND \ @@ -893,7 +961,7 @@ PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv) #define PERL_ARGS_ASSERT_DO_TRANS \ assert(sv) -PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, I32 offset, I32 size) +PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, SSize_t offset, int size) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_VECGET \ assert(sv) @@ -1019,9 +1087,13 @@ PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o) #define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ assert(o) +PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off); PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp) __attribute__warn_unused_result__; +PERL_CALLCONV CV* Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp) + __attribute__warn_unused_result__; + PERL_CALLCONV SV* Perl_find_rundefsv(pTHX); PERL_CALLCONV SV* Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq) __attribute__nonnull__(pTHX_1); @@ -1098,8 +1170,10 @@ PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv) #define PERL_ARGS_ASSERT_GET_DB_SUB \ assert(cv) -PERL_CALLCONV UV Perl_get_hash_seed(pTHX) - __attribute__warn_unused_result__; +PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_GET_HASH_SEED \ + assert(seed_buffer) PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags) __attribute__nonnull__(pTHX_1); @@ -1480,7 +1554,7 @@ PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV const *const hv) #define PERL_ARGS_ASSERT_HV_FILL \ assert(hv) -PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entryK) +PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entry) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_FREE_ENT \ assert(hv) @@ -1562,6 +1636,11 @@ PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph) #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ assert(hv) +PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_HV_RAND_SET \ + assert(hv) + PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -1601,6 +1680,7 @@ PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ assert(argv) +PERL_CALLCONV void Perl_init_constants(pTHX); PERL_CALLCONV void Perl_init_dbargs(pTHX); PERL_CALLCONV void Perl_init_debugger(pTHX); PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); @@ -1628,6 +1708,22 @@ PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit) #define PERL_ARGS_ASSERT_IO_CLOSE \ assert(io) +PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__pure__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_ISALNUM_LAZY \ + assert(p) + +PERL_STATIC_INLINE bool S_isIDFIRST_lazy(pTHX_ const char* p) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__pure__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_ISIDFIRST_LAZY \ + assert(p) + PERL_CALLCONV bool Perl_is_ascii_string(const U8 *s, STRLEN len) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_ASCII_STRING \ @@ -1637,187 +1733,190 @@ PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__pure__; + +PERL_CALLCONV bool Perl_is_uni_alnumc(pTHX_ UV c) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__pure__; + +PERL_CALLCONV bool Perl_is_uni_alnumc_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__pure__; + +PERL_CALLCONV bool Perl_is_uni_blank(pTHX_ UV c) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__pure__; + +PERL_CALLCONV bool Perl_is_uni_blank_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; -PERL_CALLCONV bool Perl_is_utf8_X_L(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_L \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_LV(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_LV \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_LVT(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_LV_LVT_V(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_LV_LVT_V \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_T(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_T \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_V(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_V \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_begin(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_BEGIN \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_extend(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_non_hangul(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_NON_HANGUL \ - assert(p) - -PERL_CALLCONV bool Perl_is_utf8_X_prepend(pTHX_ const U8 *p) +PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_X_PREPEND \ +#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \ assert(p) -PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p) +PERL_CALLCONV bool Perl_is_utf8_alnumc(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \ +#define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC \ assert(p) PERL_CALLCONV bool Perl_is_utf8_alpha(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \ assert(p) PERL_CALLCONV bool Perl_is_utf8_ascii(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \ assert(p) +PERL_CALLCONV bool Perl_is_utf8_blank(pTHX_ const U8 *p) + __attribute__deprecated__ + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_IS_UTF8_BLANK \ + assert(p) + PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s) __attribute__deprecated__ __attribute__nonnull__(1); @@ -1831,78 +1930,91 @@ PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end) assert(buf); assert(buf_end) PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \ assert(p) PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \ assert(p) PERL_CALLCONV bool Perl_is_utf8_idcont(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \ assert(p) PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_LOWER \ assert(p) PERL_CALLCONV bool Perl_is_utf8_mark(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_MARK \ assert(p) PERL_CALLCONV bool Perl_is_utf8_perl_space(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE \ assert(p) PERL_CALLCONV bool Perl_is_utf8_perl_word(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD \ assert(p) PERL_CALLCONV bool Perl_is_utf8_posix_digit(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_print(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PRINT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_punct(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \ @@ -1913,7 +2025,7 @@ PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) #define PERL_ARGS_ASSERT_IS_UTF8_STRING \ assert(s) -/* PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p) +/* PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep) __attribute__nonnull__(1); */ #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ assert(s) @@ -1924,24 +2036,28 @@ PERL_CALLCONV bool Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 assert(s) PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_UPPER \ assert(p) PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_xidcont(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \ @@ -2025,6 +2141,12 @@ PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg) #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ assert(sv); assert(mg) +PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV* sv, MAGIC* mg) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \ + assert(sv); assert(mg) + PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -2060,6 +2182,13 @@ PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV* sv, MAGIC* mg) #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ assert(sv); assert(mg) +PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV* sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ + assert(sv); assert(mg); assert(nsv) + PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg) __attribute__nonnull__(pTHX_1) @@ -2151,12 +2280,6 @@ PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ assert(sv); assert(mg) -PERL_CALLCONV U32 Perl_magic_len(pTHX_ SV* sv, MAGIC* mg) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_MAGIC_LEN \ - assert(sv); assert(mg) - PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -2183,13 +2306,6 @@ PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg) #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ assert(sv); assert(mg) -PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) - __attribute__noreturn__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ - assert(sv); assert(mg) - PERL_CALLCONV SV* Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -2208,12 +2324,6 @@ PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV* sv, MAGIC* mg) #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ assert(sv); assert(mg) -PERL_CALLCONV int Perl_magic_setamagic(pTHX_ SV* sv, MAGIC* mg) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_MAGIC_SETAMAGIC \ - assert(sv); assert(mg) - PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -2315,12 +2425,6 @@ PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg) #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ assert(sv); assert(mg) -PERL_CALLCONV int Perl_magic_setvstring(pTHX_ SV* sv, MAGIC* mg) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_MAGIC_SETVSTRING \ - assert(sv); assert(mg) - PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -2383,6 +2487,7 @@ PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv) assert(sv) PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv) + __attribute__deprecated__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_LENGTH \ assert(sv) @@ -2474,11 +2579,6 @@ PERL_CALLCONV SV* Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta, #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ assert(smeta); assert(which); assert(data) -PERL_CALLCONV void Perl_munge_qwlist_to_paren_list(pTHX_ OP* qwlist) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_MUNGE_QWLIST_TO_PAREN_LIST \ - assert(qwlist) - PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_ATOF \ @@ -2497,10 +2597,10 @@ PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) PERL_CALLCONV void Perl_my_clearenv(pTHX); PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir); -PERL_CALLCONV void Perl_my_exit(pTHX_ U32 status) +PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status) __attribute__noreturn__; -PERL_CALLCONV void Perl_my_failure_exit(pTHX) +PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX) __attribute__noreturn__; PERL_CALLCONV I32 Perl_my_fflush_all(pTHX); @@ -2666,6 +2766,11 @@ PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* __attribute__malloc__ __attribute__warn_unused_result__; +PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_NEWMYSUB \ + assert(o) + PERL_CALLCONV OP* Perl_newNULLLIST(pTHX) __attribute__malloc__ __attribute__warn_unused_result__; @@ -2717,6 +2822,11 @@ PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o) __attribute__malloc__ __attribute__warn_unused_result__; +PERL_CALLCONV CV* Perl_newSTUB(pTHX_ GV *gv, bool fake) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_NEWSTUB \ + assert(gv) + /* PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */ PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len) __attribute__malloc__ @@ -2913,6 +3023,7 @@ PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last); PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o); +PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o); PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -2985,7 +3096,7 @@ PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv assert(padlist); assert(old_cv); assert(new_cv) PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po); -PERL_CALLCONV void Perl_pad_leavemy(pTHX); +PERL_CALLCONV OP * Perl_pad_leavemy(pTHX); PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags) __attribute__malloc__ __attribute__warn_unused_result__; @@ -2997,6 +3108,11 @@ PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth) PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust); PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type); +PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_PADLIST_STORE \ + assert(padlist) + PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags); @@ -3044,7 +3160,7 @@ PERL_CALLCONV int perl_run(PerlInterpreter *my_perl) assert(my_perl) PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm); -PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg) +PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PMRUNTIME \ @@ -3136,7 +3252,7 @@ PERL_CALLCONV void Perl_qerror(pTHX_ SV* err) #define PERL_ARGS_ASSERT_QERROR \ assert(err) -PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 flags) +PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_RE_COMPILE \ assert(pattern) @@ -3153,10 +3269,23 @@ PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r) #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ assert(r) +PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *old_re, bool *is_bare_re, U32 rx_flags, U32 pm_flags) + __attribute__nonnull__(pTHX_4); +#define PERL_ARGS_ASSERT_RE_OP_COMPILE \ + assert(eng) + PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; +PERL_CALLCONV void Perl_reentrant_free(pTHX); +PERL_CALLCONV void Perl_reentrant_init(pTHX); +PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...) + __attribute__nonnull__(1); +#define PERL_ARGS_ASSERT_REENTRANT_RETRY \ + assert(f) + +PERL_CALLCONV void Perl_reentrant_size(pTHX); /* PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); */ PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags) @@ -3269,11 +3398,6 @@ PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) #define PERL_ARGS_ASSERT_REGDUMP \ assert(r) -PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_REGDUMP \ - assert(r) - PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, I32 minend, SV *sv, void *data, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -3634,7 +3758,11 @@ PERL_CALLCONV void Perl_set_context(void *t) PERL_CALLCONV void Perl_set_numeric_local(pTHX); PERL_CALLCONV void Perl_set_numeric_radix(pTHX); PERL_CALLCONV void Perl_set_numeric_standard(pTHX); -PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv); +PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_SETDEFOUT \ + assert(gv) + PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, I32 len, U32 hash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SHARE_HEK \ @@ -3663,13 +3791,6 @@ PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io) assert(tmpglob); assert(io) PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); -PERL_CALLCONV bool Perl_stashpv_hvname_match(pTHX_ const COP *c, const HV *hv) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_STASHPV_HVNAME_MATCH \ - assert(c); assert(hv) - PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -3840,29 +3961,22 @@ PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2); PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2); PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); -PERL_CALLCONV OP* Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp) - __attribute__deprecated__ +/* PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv) __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3) - __attribute__nonnull__(pTHX_4); -#define PERL_ARGS_ASSERT_SV_COMPILE_2OP \ - assert(sv); assert(startop); assert(code); assert(padp) - -PERL_CALLCONV OP* Perl_sv_compile_2op_is_broken(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3) - __attribute__nonnull__(pTHX_4); -#define PERL_ARGS_ASSERT_SV_COMPILE_2OP_IS_BROKEN \ - assert(sv); assert(startop); assert(code); assert(padp) + __attribute__nonnull__(pTHX_2); */ +#define PERL_ARGS_ASSERT_SV_COPYPV \ + assert(dsv); assert(ssv) -PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv) +PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_SV_COPYPV \ +#define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ assert(dsv); assert(ssv) +/* PERL_CALLCONV void Perl_sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); */ + PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv) @@ -3946,7 +4060,7 @@ PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flag assert(sv) PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv); -PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv) +PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_FREE2 \ assert(sv) @@ -3990,6 +4104,11 @@ PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); +PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ + assert(sv) + PERL_CALLCONV void Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGIC \ @@ -4000,7 +4119,11 @@ PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const #define PERL_ARGS_ASSERT_SV_MAGICEXT \ assert(sv) -PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) +/* PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) + __attribute__malloc__ + __attribute__warn_unused_result__; */ + +PERL_CALLCONV SV* Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags) __attribute__malloc__ __attribute__warn_unused_result__; @@ -4121,6 +4244,7 @@ PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash) #define PERL_ARGS_ASSERT_SV_RESET \ assert(s) +PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash); PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ @@ -4365,6 +4489,12 @@ PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, c #define PERL_ARGS_ASSERT_SV_VCATPVFN \ assert(sv); assert(pat) +PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted, const U32 flags) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ + assert(sv); assert(pat) + PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -4437,6 +4567,7 @@ PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; @@ -4447,6 +4578,7 @@ PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; @@ -4457,6 +4589,7 @@ PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) + __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; @@ -4604,11 +4737,6 @@ PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ assert(d) -PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ - assert(s) - PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \ @@ -4620,7 +4748,7 @@ PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv) #define PERL_ARGS_ASSERT_VCMP \ assert(lhv); assert(rhv) -PERL_CALLCONV void Perl_vcroak(pTHX_ const char* pat, va_list* args) +PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args) __attribute__noreturn__; PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args) @@ -4801,6 +4929,11 @@ STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv) #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ assert(d) +/* PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) + __attribute__nonnull__(pTHX_1); */ +#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ + assert(s) + #endif #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) PERL_CALLCONV Signal_t Perl_csighandler(int sig); @@ -4827,9 +4960,6 @@ PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size) #endif #if !(defined(PERL_MAD)) PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); -PERL_CALLCONV void Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) - __attribute__noreturn__; - PERL_CALLCONV void Perl_package(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PACKAGE \ @@ -4841,14 +4971,14 @@ PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop assert(idop) #endif -#if !(defined(USE_ITHREADS)) -# if defined(PERL_IN_OP_C) -STATIC void S_forget_pmop(pTHX_ PMOP *const o) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_FORGET_PMOP \ - assert(o) +#if !(defined(_MSC_VER)) +PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) + __attribute__noreturn__ + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ + assert(sv); assert(mg) -# endif #endif #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len) @@ -5135,6 +5265,11 @@ PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ assert(d) +PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ + assert(s) + #endif #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp) @@ -5213,17 +5348,14 @@ PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) #endif #if defined(MYSWAP) PERL_CALLCONV long Perl_my_htonl(pTHX_ long l) - __attribute__malloc__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV long Perl_my_ntohl(pTHX_ long l) - __attribute__malloc__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV short Perl_my_swap(pTHX_ short s) - __attribute__malloc__ __attribute__warn_unused_result__ __attribute__pure__; @@ -5231,6 +5363,48 @@ PERL_CALLCONV short Perl_my_swap(pTHX_ short s) #if defined(NO_MATHOMS) /* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */ #endif +#if defined(PERL_ANY_COW) +PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_SV_SETSV_COW \ + assert(sstr) + +#endif +#if defined(PERL_CORE) +PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ + assert(slab) + +PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_OPSLAB_FREE \ + assert(slab) + +PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ + assert(slab) + +PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ + assert(parser); assert(slab) + +# if defined(PERL_DEBUG_READONLY_OPS) +PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_SLAB_TO_RO \ + assert(slab) + +PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_SLAB_TO_RW \ + assert(slab) + +# endif +#endif #if defined(PERL_CR_FILTER) # if defined(PERL_IN_TOKE_C) STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); @@ -5242,24 +5416,12 @@ STATIC void S_strip_return(pTHX_ SV *sv) # endif #endif #if defined(PERL_DEBUG_READONLY_OPS) -# if defined(PERL_IN_OP_C) -# if defined(PL_OP_SLAB_ALLOC) -STATIC void S_Slab_to_rw(pTHX_ void *op) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_SLAB_TO_RW \ - assert(op) - -# endif -# endif -# if defined(PL_OP_SLAB_ALLOC) PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ assert(o) PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); -PERL_CALLCONV void Perl_pending_Slabs_to_ro(pTHX); -# endif #endif #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) /* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) @@ -5293,7 +5455,7 @@ PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size) # endif #endif #if defined(PERL_IMPLICIT_CONTEXT) -PERL_CALLCONV void Perl_croak_nocontext(const char* pat, ...) +PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,1,2); @@ -5476,27 +5638,6 @@ STATIC I32 S_do_trans_simple_utf8(pTHX_ SV * const sv) assert(sv) #endif -#if defined(PERL_IN_DQUOTE_STATIC_C) -STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning) - __attribute__warn_unused_result__; - -STATIC bool S_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3) - __attribute__nonnull__(pTHX_4); -#define PERL_ARGS_ASSERT_GROK_BSLASH_O \ - assert(s); assert(uv); assert(len); assert(error_msg) - -PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s) - __attribute__warn_unused_result__ - __attribute__pure__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_REGCURLY \ - assert(s) - -#endif #if defined(PERL_IN_DUMP_C) STATIC CV* S_deb_curcv(pTHX_ const I32 ix); STATIC void S_debprof(pTHX_ const OP *o) @@ -5528,11 +5669,6 @@ PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) #endif #if defined(PERL_IN_GV_C) -STATIC HV* S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen, U32 flags) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_GV_GET_SUPER_PKG \ - assert(name) - STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ @@ -5543,11 +5679,6 @@ STATIC void S_gv_magicalize_isa(pTHX_ GV *gv) #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ assert(gv) -STATIC void S_gv_magicalize_overload(pTHX_ GV *gv) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_GV_MAGICALIZE_OVERLOAD \ - assert(gv) - STATIC HV* S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -5576,21 +5707,22 @@ STATIC void S_hfreeentries(pTHX_ HV *hv) #define PERL_ARGS_ASSERT_HFREEENTRIES \ assert(hv) -STATIC void S_hsplit(pTHX_ HV *hv) +STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HSPLIT \ assert(hv) -STATIC struct xpvhv_aux* S_hv_auxinit(HV *hv) - __attribute__nonnull__(1); +STATIC struct xpvhv_aux* S_hv_auxinit(pTHX_ HV *hv) + __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_AUXINIT \ assert(hv) STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); -STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entryK) - __attribute__nonnull__(pTHX_1); +STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ - assert(hv) + assert(hv); assert(entry) STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) __attribute__nonnull__(1) @@ -5599,7 +5731,7 @@ STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ assert(hv); assert(needs_copy); assert(needs_store) -STATIC void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) +PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) __attribute__noreturn__ __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); @@ -5610,6 +5742,7 @@ STATIC HE* S_new_he(pTHX) __attribute__malloc__ __attribute__warn_unused_result__; +STATIC U32 S_ptr_hash(PTRV u); STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ @@ -5710,7 +5843,7 @@ STATIC NV S_mulexp10(NV value, I32 exponent); #endif #if defined(PERL_IN_OP_C) PERL_STATIC_INLINE bool S_aassign_common_vars(pTHX_ OP* o); -STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my) +STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_APPLY_ATTRS \ @@ -5763,6 +5896,11 @@ STATIC OP* S_fold_constants(pTHX_ OP *o) assert(o) STATIC OP* S_force_list(pTHX_ OP* arg); +STATIC void S_forget_pmop(pTHX_ PMOP *const o) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_FORGET_PMOP \ + assert(o) + STATIC OP* S_gen_constant_list(pTHX_ OP* o); STATIC SV* S_gv_ename(pTHX_ GV *gv) __attribute__nonnull__(pTHX_1); @@ -5831,11 +5969,6 @@ PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o) #define PERL_ARGS_ASSERT_OP_STD_INIT \ assert(o) -STATIC OP* S_opt_scalarhv(pTHX_ OP* rep_op) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_OPT_SCALARHV \ - assert(rep_op) - STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -5843,10 +5976,10 @@ STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) #define PERL_ARGS_ASSERT_PMTRANS \ assert(o); assert(expr); assert(repl) -STATIC void S_process_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv) - __attribute__nonnull__(pTHX_1) +STATIC void S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv) __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__nonnull__(pTHX_3) + __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ assert(fullname); assert(gv); assert(cv) @@ -5900,13 +6033,6 @@ STATIC OP* S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \ assert(o); assert(namesv) -# if defined(USE_ITHREADS) -STATIC void S_forget_pmop(pTHX_ PMOP *const o, U32 flags) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_FORGET_PMOP \ - assert(o) - -# endif #endif #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) @@ -5970,10 +6096,10 @@ STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags) #define PERL_ARGS_ASSERT_MAYBERELOCATE \ assert(dir) -STATIC void S_minus_v(pTHX) +PERL_STATIC_NO_RET void S_minus_v(pTHX) __attribute__noreturn__; -STATIC void S_my_exit_jump(pTHX) +PERL_STATIC_NO_RET void S_my_exit_jump(pTHX) __attribute__noreturn__; STATIC void S_nuke_stacks(pTHX); @@ -5984,10 +6110,10 @@ STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool assert(scriptname); assert(suidscript) STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); -STATIC void S_run_body(pTHX_ I32 oldscope) +PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope) __attribute__noreturn__; -STATIC void S_usage(pTHX) +PERL_STATIC_NO_RET void S_usage(pTHX) __attribute__noreturn__; #endif @@ -6039,7 +6165,7 @@ STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copie STATIC OP* S_docatch(pTHX_ OP *o) __attribute__warn_unused_result__; -STATIC bool S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq, HV* hh); +STATIC bool S_doeval(pTHX_ int gimme, CV* outside, U32 seq, HV* hh); STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) @@ -6124,12 +6250,11 @@ STATIC void S_save_lines(pTHX_ AV *array, SV *sv) #endif #if defined(PERL_IN_PP_HOT_C) -STATIC void S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem) +STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey) __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_ODDBALL \ - assert(hash); assert(relem); assert(firstrelem) + assert(oddkey); assert(firstkey) STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp) __attribute__warn_unused_result__ @@ -6314,12 +6439,6 @@ STATIC SV* S__new_invlist_C_array(pTHX_ UV* list) #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ assert(list) -STATIC void S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_ADD_ALTERNATE \ - assert(alternate_ptr); assert(string) - PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) __attribute__warn_unused_result__; @@ -6330,10 +6449,12 @@ STATIC U32 S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s) #define PERL_ARGS_ASSERT_ADD_DATA \ assert(pRExC_state); assert(s) -STATIC void S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_CHECKPOSIXCC \ - assert(pRExC_state) +PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ struct RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \ + assert(pRExC_state); assert(node); assert(flagp) STATIC void S_cl_and(struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with) __attribute__nonnull__(1) @@ -6366,16 +6487,26 @@ STATIC void S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charc #define PERL_ARGS_ASSERT_CL_OR \ assert(pRExC_state); assert(cl); assert(or_with) +PERL_STATIC_INLINE U8 S_compute_EXACTish(pTHX_ struct RExC_state_t *pRExC_state) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ + assert(pRExC_state) + +STATIC bool S_could_it_be_a_POSIX_class(pTHX_ struct RExC_state_t *pRExC_state) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS \ + assert(pRExC_state) + PERL_STATIC_INLINE UV* S_get_invlist_iter_addr(pTHX_ SV* invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ assert(invlist) -PERL_STATIC_INLINE UV* S_get_invlist_len_addr(pTHX_ SV* invlist) +PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_GET_INVLIST_LEN_ADDR \ +#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ assert(invlist) PERL_STATIC_INLINE UV* S_get_invlist_version_id_addr(pTHX_ SV* invlist) @@ -6390,6 +6521,19 @@ PERL_STATIC_INLINE UV* S_get_invlist_zero_addr(pTHX_ SV* invlist) #define PERL_ARGS_ASSERT_GET_INVLIST_ZERO_ADDR \ assert(invlist) +STATIC bool S_grok_bslash_N(pTHX_ struct RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, bool in_char_class, const bool strict) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_4); +#define PERL_ARGS_ASSERT_GROK_BSLASH_N \ + assert(pRExC_state); assert(flagp) + +STATIC regnode* S_handle_regex_sets(pTHX_ struct RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_3) + __attribute__nonnull__(pTHX_5); +#define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ + assert(pRExC_state); assert(flagp); assert(oregcomp_parse) + PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -6407,6 +6551,23 @@ STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len) #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ assert(invlist) +PERL_STATIC_INLINE UV S_invlist_highest(pTHX_ SV* const invlist) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ + assert(invlist) + +PERL_STATIC_INLINE bool S_invlist_is_iterating(pTHX_ SV* const invlist) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ + assert(invlist) + +PERL_STATIC_INLINE void S_invlist_iterfinish(pTHX_ SV* invlist) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ + assert(invlist) + PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ @@ -6420,22 +6581,16 @@ STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end) #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ assert(invlist); assert(start); assert(end) -PERL_STATIC_INLINE UV S_invlist_len(pTHX_ SV* const invlist) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_INVLIST_LEN \ - assert(invlist) - PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_MAX \ assert(invlist) -STATIC IV S_invlist_search(pTHX_ SV* const invlist, const UV cp) +PERL_STATIC_INLINE IV S_invlist_previous_index(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_INVLIST_SEARCH \ +#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ assert(invlist) PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len) @@ -6443,6 +6598,11 @@ PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len) #define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ assert(invlist) +PERL_STATIC_INLINE void S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ + assert(invlist) + PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_TRIM \ @@ -6477,7 +6637,12 @@ STATIC char * S_nextchar(pTHX_ struct RExC_state_t *pRExC_state) #define PERL_ARGS_ASSERT_NEXTCHAR \ assert(pRExC_state) -STATIC void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...) +STATIC void S_parse_lparen_question_flags(pTHX_ struct RExC_state_t *pRExC_state) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ + assert(pRExC_state) + +PERL_STATIC_NO_RET void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...) __attribute__noreturn__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -6490,11 +6655,6 @@ STATIC regnode* S_reg(pTHX_ struct RExC_state_t *pRExC_state, I32 paren, I32 *fl #define PERL_ARGS_ASSERT_REG \ assert(pRExC_state); assert(flagp) -STATIC regnode* S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep, I32 *flagp, U32 depth) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_REG_NAMEDSEQ \ - assert(pRExC_state) - STATIC regnode* S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NODE \ @@ -6532,10 +6692,11 @@ STATIC regnode* S_regbranch(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, #define PERL_ARGS_ASSERT_REGBRANCH \ assert(pRExC_state); assert(flagp) -STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, U32 depth) - __attribute__nonnull__(pTHX_1); +STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, SV** ret_invlist) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGCLASS \ - assert(pRExC_state) + assert(pRExC_state); assert(flagp) STATIC void S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth) __attribute__nonnull__(pTHX_1) @@ -6543,13 +6704,20 @@ STATIC void S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode * #define PERL_ARGS_ASSERT_REGINSERT \ assert(pRExC_state); assert(opnd) +STATIC char * S_regpatws(struct RExC_state_t *pRExC_state, char *p, const bool recognize_comment) + __attribute__warn_unused_result__ + __attribute__nonnull__(1) + __attribute__nonnull__(2); +#define PERL_ARGS_ASSERT_REGPATWS \ + assert(pRExC_state); assert(p) + STATIC regnode* S_regpiece(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGPIECE \ assert(pRExC_state); assert(flagp) -STATIC I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value) +PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, const bool strict) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGPPOSIXCC \ assert(pRExC_state) @@ -6581,22 +6749,6 @@ STATIC void S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct s #define PERL_ARGS_ASSERT_SCAN_COMMIT \ assert(pRExC_state); assert(data); assert(minlenp) -PERL_STATIC_INLINE U8 S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_4) - __attribute__nonnull__(pTHX_5); -#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT \ - assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr) - -STATIC U8 S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_4) - __attribute__nonnull__(pTHX_5); -#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD \ - assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr) - STATIC I32 S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -6608,18 +6760,91 @@ STATIC I32 S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) -PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, bool return_if_undef, SV* invlist, bool passed_in_invlist_has_user_defined_property) +PERL_STATIC_INLINE UV* S__get_invlist_len_addr(pTHX_ SV* invlist) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__GET_INVLIST_LEN_ADDR \ + assert(invlist) + +PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \ + assert(swash) + +PERL_STATIC_INLINE bool S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ + assert(invlist) + +PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__INVLIST_CONTENTS \ + assert(invlist) + +PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__INVLIST_LEN \ + assert(invlist) + +PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__INVLIST_SEARCH \ + assert(invlist) + +PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ + assert(swash) + +#endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C) +PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT__CORE_SWASH_INIT \ assert(pkg); assert(name); assert(listsv) -PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist) +#endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) +STATIC char* S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len) __attribute__warn_unused_result__ + __attribute__pure__ __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT__INVLIST_CONTENTS \ - assert(invlist) +#define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \ + assert(s) + +STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning) + __attribute__warn_unused_result__; + +STATIC bool S_grok_bslash_o(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_GROK_BSLASH_O \ + assert(s); assert(uv); assert(error_msg) + +PERL_STATIC_INLINE bool S_grok_bslash_x(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_GROK_BSLASH_X \ + assert(s); assert(uv); assert(error_msg) + +PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped) + __attribute__warn_unused_result__ + __attribute__pure__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_REGCURLY \ + assert(s) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) @@ -6671,12 +6896,6 @@ PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, S PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) __attribute__warn_unused_result__; -PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ - assert(swash) - PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -6685,13 +6904,13 @@ PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash) #endif #if defined(PERL_IN_REGEXEC_C) -STATIC SV* S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp) +STATIC SV* S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH \ assert(node) -STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) +STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo, bool is_utf_pat) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -6700,6 +6919,15 @@ STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, cons #define PERL_ARGS_ASSERT_FIND_BYCLASS \ assert(prog); assert(c); assert(s); assert(strend) +STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) + __attribute__warn_unused_result__; + +STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ + assert(character) + STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) @@ -6707,12 +6935,17 @@ STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ assert(rex); assert(scan) -STATIC char* S_regcppop(pTHX_ const regexp *rex) - __attribute__nonnull__(pTHX_1); +STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGCPPOP \ + assert(rex); assert(maxopenparen_p) + +STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_REGCPPUSH \ assert(rex) -STATIC CHECKPOINT S_regcppush(pTHX_ I32 parenfloor); STATIC U8* S_reghop3(U8 *s, I32 off, const U8 *lim) __attribute__warn_unused_result__ __attribute__nonnull__(1) @@ -6727,35 +6960,37 @@ STATIC U8* S_reghopmaybe3(U8 *s, I32 off, const U8 *lim) #define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ assert(s); assert(lim) -STATIC bool S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, STRLEN *lenp, bool const do_utf8sv_is_utf8) +STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, bool const utf8_target) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGINCLASS \ assert(n); assert(p) -STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog) +STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGMATCH \ - assert(reginfo); assert(prog) + assert(reginfo); assert(startpos); assert(prog) -STATIC I32 S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth) +STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, I32 max, int depth, bool is_utf8_pat) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGREPEAT \ - assert(prog); assert(p) + assert(prog); assert(startposp); assert(p) -STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startpos) +STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGTRY \ - assert(reginfo); assert(startpos) + assert(reginfo); assert(startposp) -STATIC void S_to_byte_substr(pTHX_ regexp * prog) +STATIC bool S_to_byte_substr(pTHX_ regexp * prog) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ assert(prog) @@ -6986,6 +7221,7 @@ STATIC void S_force_ident(pTHX_ const char *s, int kind) #define PERL_ARGS_ASSERT_FORCE_IDENT \ assert(s) +STATIC void S_force_ident_maybe_lex(pTHX_ char pit); STATIC void S_force_next(pTHX_ I32 type); STATIC char* S_force_strict_version(pTHX_ char *s) __attribute__nonnull__(pTHX_1); @@ -7002,6 +7238,13 @@ STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int a #define PERL_ARGS_ASSERT_FORCE_WORD \ assert(start) +PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ + assert(s); assert(e) + STATIC void S_incline(pTHX_ const char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INCLINE \ @@ -7022,7 +7265,7 @@ STATIC I32 S_lop(pTHX_ I32 f, int x, char *s) #define PERL_ARGS_ASSERT_LOP \ assert(s) -STATIC void S_missingterm(pTHX_ char *s) +PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s) __attribute__noreturn__; STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen) @@ -7036,6 +7279,14 @@ STATIC void S_no_op(pTHX_ const char *const what, char *s) #define PERL_ARGS_ASSERT_NO_OP \ assert(what) +STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_PARSE_IDENT \ + assert(s); assert(d); assert(e) + +STATIC int S_pending_ident(pTHX); STATIC void S_readpipe_override(pTHX); STATIC char* S_scan_const(pTHX_ char *start) __attribute__warn_unused_result__ @@ -7074,7 +7325,7 @@ STATIC char* S_scan_pat(pTHX_ char *start, I32 type) #define PERL_ARGS_ASSERT_SCAN_PAT \ assert(start) -STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) +STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_STR \ @@ -7174,13 +7425,13 @@ STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV res #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ assert(p); assert(ustrp); assert(lenp) -STATIC STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) +PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \ assert(s) -STATIC bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname) +PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -7199,12 +7450,6 @@ STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp) #endif #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) -PERL_CALLCONV bool Perl__is_utf8_quotemeta(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT__IS_UTF8_QUOTEMETA \ - assert(p) - PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); @@ -7234,9 +7479,6 @@ STATIC SV * S_with_queued_errors(pTHX_ SV *ex) #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ assert(ex) -STATIC char * S_write_no_mem(pTHX) - __attribute__noreturn__; - # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) __attribute__nonnull__(4) @@ -7270,9 +7512,6 @@ PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv) #define PERL_ARGS_ASSERT_NEWMADSV \ assert(sv) -PERL_CALLCONV OP * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) - __attribute__noreturn__; - PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop); PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot); PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot); @@ -7445,27 +7684,9 @@ PERL_CALLCONV long Perl_my_letohl(long n); #if defined(PERL_NEED_MY_LETOHS) PERL_CALLCONV short Perl_my_letohs(short n); #endif -#if defined(PERL_OLD_COPY_ON_WRITE) -PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_SV_SETSV_COW \ - assert(sstr) - -#endif #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) STATIC void S_pidgone(pTHX_ Pid_t pid, int status); #endif -#if defined(PL_OP_SLAB_ALLOC) -PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) - __attribute__malloc__ - __attribute__warn_unused_result__; - -PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_SLAB_FREE \ - assert(op) - -#endif #if defined(UNLINK_ALL_VERSIONS) PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) __attribute__nonnull__(pTHX_1); @@ -7474,6 +7695,11 @@ PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) #endif #if defined(USE_ITHREADS) +PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ + assert(hv) + PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); @@ -7547,7 +7773,7 @@ PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv) #define PERL_ARGS_ASSERT_NEWPADOP \ assert(sv) -PERL_CALLCONV AV* Perl_padlist_dup(pTHX_ AV *srcpad, CLONE_PARAMS *param) +PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PADLIST_DUP \ @@ -7680,15 +7906,13 @@ PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_ assert(vbuf) #endif -#if defined(USE_REENTRANT_API) -PERL_CALLCONV void Perl_reentrant_free(pTHX); -PERL_CALLCONV void Perl_reentrant_init(pTHX); -PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...) +#if defined(WIN32) +PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname) + __attribute__noreturn__ __attribute__nonnull__(1); -#define PERL_ARGS_ASSERT_REENTRANT_RETRY \ - assert(f) +#define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ + assert(fname) -PERL_CALLCONV void Perl_reentrant_size(pTHX); #endif #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp) @@ -7708,6 +7932,14 @@ PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd) assert(cmd) #endif +#if defined(_MSC_VER) +PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ + assert(sv); assert(mg) + +#endif #ifdef PERL_CORE # include "pp_proto.h" #endif diff --git a/Master/tlpkg/tlperl/lib/CORE/regcharclass.h b/Master/tlpkg/tlperl/lib/CORE/regcharclass.h index 5e233ea730e..e51fe64af40 100644 --- a/Master/tlpkg/tlperl/lib/CORE/regcharclass.h +++ b/Master/tlpkg/tlperl/lib/CORE/regcharclass.h @@ -12,17 +12,15 @@ * Any changes made here will be lost! */ + +#ifndef H_REGCHARCLASS /* Guard against nested #includes */ +#define H_REGCHARCLASS 1 + /* LNBREAK: Line Break: \R "\x0D\x0A" # CRLF - Network (Windows) line ending - 0x0A # LF | LINE FEED - 0x0B # VT | VERTICAL TAB - 0x0C # FF | FORM FEED - 0x0D # CR | CARRIAGE RETURN - 0x85 # NEL | NEXT LINE - 0x2028 # LINE SEPARATOR - 0x2029 # PARAGRAPH SEPARATOR + \p{VertSpace} */ /*** GENERATED CODE ***/ #define is_LNBREAK(s,is_utf8) \ @@ -32,9 +30,7 @@ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ : ( 0x85 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ @@ -46,9 +42,7 @@ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ @@ -71,9 +65,7 @@ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ -: ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ -: 0 ) +: ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 ) /*** GENERATED CODE ***/ #define is_LNBREAK_utf8_safe(s,e) \ @@ -83,34 +75,30 @@ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ - : ( 0xC2 == ((U8*)s)[0] ) ? \ - ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : 0 ) \ + : ( ( 0xC2 == ((U8*)s)[0] ) && ( 0x85 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ : ((e)-(s) > 0) ? \ ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) \ : 0 ) /*** GENERATED CODE ***/ #define is_LNBREAK_latin1(s) \ -( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ +( ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) || 0x85 == ((U8*)s)[0] ) ? 1\ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ -: ( 0x85 == ((U8*)s)[0] ) ) +: 0 ) /*** GENERATED CODE ***/ #define is_LNBREAK_latin1_safe(s,e) \ ( ((e)-(s) > 1) ? \ - ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ + ( ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) || 0x85 == ((U8*)s)[0] ) ? 1\ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ - : ( 0x85 == ((U8*)s)[0] ) ) \ + : 0 ) \ : ((e)-(s) > 0) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x85 == ((U8*)s)[0] )\ : 0 ) @@ -118,25 +106,7 @@ /* HORIZWS: Horizontal Whitespace: \h \H - 0x09 # HT - 0x20 # SPACE - 0xa0 # NBSP - 0x1680 # OGHAM SPACE MARK - 0x180e # MONGOLIAN VOWEL SEPARATOR - 0x2000 # EN QUAD - 0x2001 # EM QUAD - 0x2002 # EN SPACE - 0x2003 # EM SPACE - 0x2004 # THREE-PER-EM SPACE - 0x2005 # FOUR-PER-EM SPACE - 0x2006 # SIX-PER-EM SPACE - 0x2007 # FIGURE SPACE - 0x2008 # PUNCTUATION SPACE - 0x2009 # THIN SPACE - 0x200A # HAIR SPACE - 0x202f # NARROW NO-BREAK SPACE - 0x205f # MEDIUM MATHEMATICAL SPACE - 0x3000 # IDEOGRAPHIC SPACE + \p{HorizSpace} */ /*** GENERATED CODE ***/ #define is_HORIZWS(s,is_utf8) \ @@ -147,18 +117,12 @@ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ - : ( 0xA0 == ((U8*)s)[1] ) ? \ - ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ - : ( 0x81 == ((U8*)s)[1] ) ? \ - ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ - : ( 0xE3 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ - : 0 ) \ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : ( 0xA0 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ @@ -171,18 +135,12 @@ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ - : ( 0xA0 == ((U8*)s)[1] ) ? \ - ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 )\ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ - : ( 0x81 == ((U8*)s)[1] ) ? \ - ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ - : ( 0xE3 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 )\ + : ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : ( 0xA0 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ @@ -204,18 +162,12 @@ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ - : ( 0xA0 == ((U8*)s)[1] ) ? \ - ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ - ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ - : ( 0x81 == ((U8*)s)[1] ) ? \ - ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ -: ( 0xE3 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ -: 0 ) + ( ( ( ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) /*** GENERATED CODE ***/ #define is_HORIZWS_utf8_safe(s,e) \ @@ -226,35 +178,53 @@ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ - : ( 0xA0 == ((U8*)s)[1] ) ? \ - ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ - : ( 0x81 == ((U8*)s)[1] ) ? \ - ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ - : ( 0xE3 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ - : 0 ) \ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : ((e)-(s) > 1) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ - : ( 0xC2 == ((U8*)s)[0] ) ? \ - ( ( 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : 0 ) \ + : ( ( 0xC2 == ((U8*)s)[0] ) && ( 0xA0 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ : ((e)-(s) > 0) ? \ ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) \ : 0 ) /*** GENERATED CODE ***/ #define is_HORIZWS_latin1(s) \ -( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] || 0xA0 == ((U8*)s)[0] ) +( ((U8*)s)[0] == 0x09 || ( ( ((U8*)s)[0] & 0x7F ) == 0x20 ) ) /*** GENERATED CODE ***/ #define is_HORIZWS_latin1_safe(s,e) \ ( ((e)-(s) > 0) ? \ - ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] || 0xA0 == ((U8*)s)[0] ) \ + ( ((U8*)s)[0] == 0x09 || ( ( ((U8*)s)[0] & 0x7F ) == 0x20 ) ) \ +: 0 ) + +/*** GENERATED CODE ***/ +#define is_HORIZWS_high(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x9A == ((U8*)s)[1] ) ? \ + ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( 0xE2 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) + +/*** GENERATED CODE ***/ +#define is_HORIZWS_high_safe(s,e) \ +( ((e)-(s) > 2) ? \ + ( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x9A == ((U8*)s)[1] ) ? \ + ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xE2 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) /*** GENERATED CODE ***/ @@ -266,19 +236,20 @@ ( 0x180E == cp || ( 0x180E < cp && \ ( ( 0x2000 <= cp && cp <= 0x200A ) || ( 0x200A < cp && \ ( 0x202F == cp || ( 0x202F < cp && \ -( 0x205F == cp || ( 0x205F < cp && \ -0x3000 == cp ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) +( 0x205F == cp || 0x3000 == cp ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) + +/*** GENERATED CODE ***/ +#define is_HORIZWS_cp_high(cp) \ +( 0x1680 == cp || ( 0x1680 < cp && \ +( 0x180E == cp || ( 0x180E < cp && \ +( ( 0x2000 <= cp && cp <= 0x200A ) || ( 0x200A < cp && \ +( 0x202F == cp || ( 0x202F < cp && \ +( 0x205F == cp || 0x3000 == cp ) ) ) ) ) ) ) ) ) /* VERTWS: Vertical Whitespace: \v \V - 0x0A # LF - 0x0B # VT - 0x0C # FF - 0x0D # CR - 0x85 # NEL - 0x2028 # LINE SEPARATOR - 0x2029 # PARAGRAPH SEPARATOR + \p{VertSpace} */ /*** GENERATED CODE ***/ #define is_VERTWS(s,is_utf8) \ @@ -286,9 +257,7 @@ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ : ( 0x85 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ @@ -298,9 +267,7 @@ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ @@ -319,9 +286,7 @@ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ -: ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ -: 0 ) +: ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 ) /*** GENERATED CODE ***/ #define is_VERTWS_utf8_safe(s,e) \ @@ -329,19 +294,23 @@ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE2 == ((U8*)s)[0] ) ? \ - ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ - : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ - : ( 0xC2 == ((U8*)s)[0] ) ? \ - ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : 0 ) \ + : ( ( 0xC2 == ((U8*)s)[0] ) && ( 0x85 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ : ((e)-(s) > 0) ? \ ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) \ : 0 ) /*** GENERATED CODE ***/ +#define is_VERTWS_high(s) \ +( ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 ) + +/*** GENERATED CODE ***/ +#define is_VERTWS_high_safe(s,e) \ +( ( ( ( ((e)-(s) > 2) && ( 0xE2 == ((U8*)s)[0] ) ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 ) + +/*** GENERATED CODE ***/ #define is_VERTWS_latin1(s) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x85 == ((U8*)s)[0] ) @@ -355,171 +324,599 @@ #define is_VERTWS_cp(cp) \ ( ( 0x0A <= cp && cp <= 0x0D ) || ( 0x0D < cp && \ ( 0x85 == cp || ( 0x85 < cp && \ -( 0x2028 == cp || ( 0x2028 < cp && \ -0x2029 == cp ) ) ) ) ) ) +( 0x2028 == cp || 0x2029 == cp ) ) ) ) ) + +/*** GENERATED CODE ***/ +#define is_VERTWS_cp_high(cp) \ +( 0x2028 == cp || 0x2029 == cp ) /* - TRICKYFOLD: Problematic fold case letters. When adding to this list, also should add them to regcomp.c and fold_grind.t - - 0x00DF # LATIN SMALL LETTER SHARP S - 0x0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS - 0x03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS - 0x1E9E # LATIN CAPITAL LETTER SHARP S, because maps to same as 00DF - 0x1FD3 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA; maps same as 0390 - 0x1FE3 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA; maps same as 03B0 + XDIGIT: Hexadecimal digits + + \p{XDigit} */ /*** GENERATED CODE ***/ -#define is_TRICKYFOLD(s,is_utf8) \ -( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] || 0xB0 == ((U8*)s)[1] ) ? 2 : 0 ) \ +#define is_XDIGIT_utf8(s) \ +( ( ( 0x30 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x39 ) || ( 0x41 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x46 ) || ( 0x61 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x66 ) ) ? 1\ +: ( 0xEF == ((U8*)s)[0] ) ? \ + ( ( 0xBC == ((U8*)s)[1] ) ? \ + ( ( ( 0x90 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x99 ) || ( 0xA1 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xA6 ) ) ? 3 : 0 )\ + : ( ( 0xBD == ((U8*)s)[1] ) && ( 0x81 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x86 ) ) ? 3 : 0 )\ +: 0 ) + +/*** GENERATED CODE ***/ +#define is_XDIGIT_high(s) \ +( ( 0xEF == ((U8*)s)[0] ) ? \ + ( ( 0xBC == ((U8*)s)[1] ) ? \ + ( ( ( 0x90 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x99 ) || ( 0xA1 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xA6 ) ) ? 3 : 0 )\ + : ( ( 0xBD == ((U8*)s)[1] ) && ( 0x81 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x86 ) ) ? 3 : 0 )\ +: 0 ) + +/*** GENERATED CODE ***/ +#define is_XDIGIT_cp_high(cp) \ +( ( 0xFF10 <= cp && cp <= 0xFF19 ) || ( 0xFF19 < cp && \ +( ( 0xFF21 <= cp && cp <= 0xFF26 ) || ( 0xFF41 <= cp && cp <= 0xFF46 ) ) ) ) + +/* + XPERLSPACE: \p{XPerlSpace} + + \p{XPerlSpace} +*/ +/*** GENERATED CODE ***/ +#define is_XPERLSPACE(s,is_utf8) \ +( ( ( 0x09 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x20 == ((U8*)s)[0] ) ? 1\ +: ( is_utf8 ) ? \ + ( ( 0xC2 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] || 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ - ( ( 0xBA == ((U8*)s)[1] ) ? \ - ( ( 0x9E == ((U8*)s)[2] ) ? 3 : 0 ) \ - : ( 0xBF == ((U8*)s)[1] ) ? \ - ( ( 0x93 == ((U8*)s)[2] || 0xA3 == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ + ( ( 0x9A == ((U8*)s)[1] ) ? \ + ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xE2 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || ( ((U8*)s)[2] & 0xFE ) == 0xA8 || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ +: ( 0x85 == ((U8*)s)[0] || 0xA0 == ((U8*)s)[0] ) ) + +/*** GENERATED CODE ***/ +#define is_XPERLSPACE_utf8(s) \ +( ( ( 0x09 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x20 == ((U8*)s)[0] ) ? 1\ +: ( 0xC2 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] || 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ +: ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x9A == ((U8*)s)[1] ) ? \ + ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( 0xE2 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] <= 0x8A ) || ( ((U8*)s)[2] & 0xFE ) == 0xA8 || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) + +/*** GENERATED CODE ***/ +#define is_XPERLSPACE_high(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x9A == ((U8*)s)[1] ) ? \ + ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( 0xE2 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] <= 0x8A ) || ( ((U8*)s)[2] & 0xFE ) == 0xA8 || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ + : ( ( 0x81 == ((U8*)s)[1] ) && ( 0x9F == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( ( ( 0xE3 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) + +/*** GENERATED CODE ***/ +#define is_XPERLSPACE_cp_high(cp) \ +( 0x1680 == cp || ( 0x1680 < cp && \ +( 0x180E == cp || ( 0x180E < cp && \ +( ( 0x2000 <= cp && cp <= 0x200A ) || ( 0x200A < cp && \ +( 0x2028 == cp || ( 0x2028 < cp && \ +( 0x2029 == cp || ( 0x2029 < cp && \ +( 0x202F == cp || ( 0x202F < cp && \ +( 0x205F == cp || 0x3000 == cp ) ) ) ) ) ) ) ) ) ) ) ) ) + +/* + REPLACEMENT: Unicode REPLACEMENT CHARACTER + + 0xFFFD +*/ +/*** GENERATED CODE ***/ +#define is_REPLACEMENT_utf8_safe(s,e) \ +( ( ( ( ((e)-(s) > 2) && ( 0xEF == ((U8*)s)[0] ) ) && ( 0xBF == ((U8*)s)[1] ) ) && ( 0xBD == ((U8*)s)[2] ) ) ? 3 : 0 ) + +/* + NONCHAR: Non character code points + + \p{Nchar} +*/ +/*** GENERATED CODE ***/ +#define is_NONCHAR_utf8(s) \ +( ( 0xEF == ((U8*)s)[0] ) ? \ + ( ( 0xB7 == ((U8*)s)[1] ) ? \ + ( ( 0x90 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xAF ) ? 3 : 0 ) \ + : ( ( 0xBF == ((U8*)s)[1] ) && ( ((U8*)s)[2] >= 0xBE ) ) ? 3 : 0 ) \ +: ( 0xF0 == ((U8*)s)[0] ) ? \ + ( ( ( ( ((U8*)s)[1] == 0x9F || ( ( ((U8*)s)[1] & 0xEF ) == 0xAF ) ) && ( 0xBF == ((U8*)s)[2] ) ) && ( ((U8*)s)[3] >= 0xBE ) ) ? 4 : 0 )\ +: ( 0xF1 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xF3 ) ? \ + ( ( ( ( ( ((U8*)s)[1] & 0xCF ) == 0x8F ) && ( 0xBF == ((U8*)s)[2] ) ) && ( ((U8*)s)[3] >= 0xBE ) ) ? 4 : 0 )\ +: ( ( ( ( 0xF4 == ((U8*)s)[0] ) && ( 0x8F == ((U8*)s)[1] ) ) && ( 0xBF == ((U8*)s)[2] ) ) && ( ((U8*)s)[3] >= 0xBE ) ) ? 4 : 0 ) + +/* + SURROGATE: Surrogate characters + + \p{Gc=Cs} +*/ +/*** GENERATED CODE ***/ +#define is_SURROGATE_utf8(s) \ +( ( ( 0xED == ((U8*)s)[0] ) && ( ((U8*)s)[1] >= 0xA0 ) ) ? 3 : 0 ) + +/* + GCB_L: Grapheme_Cluster_Break=L + + \p{_X_GCB_L} +*/ +/*** GENERATED CODE ***/ +#define is_GCB_L_utf8(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x84 == ((U8*)s)[1] ) ? \ + 3 \ + : ( ( 0x85 == ((U8*)s)[1] ) && ( ((U8*)s)[2] <= 0x9F ) ) ? 3 : 0 ) \ +: ( ( ( 0xEA == ((U8*)s)[0] ) && ( 0xA5 == ((U8*)s)[1] ) ) && ( 0xA0 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xBC ) ) ? 3 : 0 ) + +/* + GCB_LV_LVT_V: Grapheme_Cluster_Break=(LV or LVT or V) + + \p{_X_LV_LVT_V} +*/ +/*** GENERATED CODE ***/ +#define is_GCB_LV_LVT_V_utf8(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] >= 0xA0 ) ? 3 : 0 ) \ + : ( ( 0x86 == ((U8*)s)[1] ) && ( ((U8*)s)[2] <= 0xA7 ) ) ? 3 : 0 ) \ +: ( 0xEA == ((U8*)s)[0] ) ? \ + ( ( ((U8*)s)[1] >= 0xB0 ) ? \ + 3 \ : 0 ) \ -: ( 0xDF == ((U8*)s)[0] ) ) +: ( 0xEB == ((U8*)s)[0] || 0xEC == ((U8*)s)[0] ) ? \ + 3 \ +: ( 0xED == ((U8*)s)[0] ) ? \ + ( ( ((U8*)s)[1] <= 0x9D ) ? \ + 3 \ + : ( 0x9E == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] <= 0xA3 ) || ( ((U8*)s)[2] >= 0xB0 ) ) ? 3 : 0 ) \ + : ( ( 0x9F == ((U8*)s)[1] ) && ( ((U8*)s)[2] <= 0x86 ) ) ? 3 : 0 ) \ +: 0 ) + +/* + GCB_Prepend: Grapheme_Cluster_Break=Prepend + \p{_X_GCB_Prepend} +*/ /*** GENERATED CODE ***/ -#define is_TRICKYFOLD_safe(s,e,is_utf8) \ -( ((e)-(s) > 2) ? \ - ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] || 0xB0 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xE1 == ((U8*)s)[0] ) ? \ - ( ( 0xBA == ((U8*)s)[1] ) ? \ - ( ( 0x9E == ((U8*)s)[2] ) ? 3 : 0 ) \ - : ( 0xBF == ((U8*)s)[1] ) ? \ - ( ( 0x93 == ((U8*)s)[2] || 0xA3 == ((U8*)s)[2] ) ? 3 : 0 ) \ - : 0 ) \ - : 0 ) \ - : ( 0xDF == ((U8*)s)[0] ) ) \ -: ((e)-(s) > 1) ? \ - ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? 2 : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] || 0xB0 == ((U8*)s)[1] ) ? 2 : 0 ) \ - : 0 ) \ - : ( 0xDF == ((U8*)s)[0] ) ) \ -: ((e)-(s) > 0) ? \ - ( ( !( is_utf8 ) ) ? \ - ( 0xDF == ((U8*)s)[0] ) \ +#define is_GCB_Prepend_utf8(s) \ +( 0 ) + +/* + GCB_RI: Grapheme_Cluster_Break=RI + + \p{_X_RI} +*/ +/*** GENERATED CODE ***/ +#define is_GCB_RI_utf8(s) \ +( ( ( ( ( 0xF0 == ((U8*)s)[0] ) && ( 0x9F == ((U8*)s)[1] ) ) && ( 0x87 == ((U8*)s)[2] ) ) && ( ((U8*)s)[3] >= 0xA6 ) ) ? 4 : 0 ) + +/* + GCB_SPECIAL_BEGIN_START: Grapheme_Cluster_Break=special_begin_starts + + \p{_X_Special_Begin_Start} +*/ +/*** GENERATED CODE ***/ +#define is_GCB_SPECIAL_BEGIN_START_utf8(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( ( ((U8*)s)[1] & 0xFC ) == 0x84 ) ? \ + 3 \ + : 0 ) \ +: ( 0xEA == ((U8*)s)[0] ) ? \ + ( ( 0xA5 == ((U8*)s)[1] ) ? \ + ( ( 0xA0 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xBC ) ? 3 : 0 ) \ + : ( ((U8*)s)[1] >= 0xB0 ) ? \ + 3 \ + : 0 ) \ +: ( 0xEB == ((U8*)s)[0] || 0xEC == ((U8*)s)[0] ) ? \ + 3 \ +: ( 0xED == ((U8*)s)[0] ) ? \ + ( ( ((U8*)s)[1] <= 0x9D ) ? \ + 3 \ + : ( 0x9E == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] <= 0xA3 ) || ( ((U8*)s)[2] >= 0xB0 ) ) ? 3 : 0 ) \ + : ( ( 0x9F == ((U8*)s)[1] ) && ( ( ((U8*)s)[2] <= 0x86 ) || ( 0x8B <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xBB ) ) ) ? 3 : 0 )\ +: ( ( ( ( 0xF0 == ((U8*)s)[0] ) && ( 0x9F == ((U8*)s)[1] ) ) && ( 0x87 == ((U8*)s)[2] ) ) && ( ((U8*)s)[3] >= 0xA6 ) ) ? 4 : 0 ) + +/* + GCB_T: Grapheme_Cluster_Break=T + + \p{_X_GCB_T} +*/ +/*** GENERATED CODE ***/ +#define is_GCB_T_utf8(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x86 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] >= 0xA8 ) ? 3 : 0 ) \ + : ( 0x87 == ((U8*)s)[1] ) ? \ + 3 \ : 0 ) \ +: ( ( ( 0xED == ((U8*)s)[0] ) && ( 0x9F == ((U8*)s)[1] ) ) && ( 0x8B <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xBB ) ) ? 3 : 0 ) + +/* + GCB_V: Grapheme_Cluster_Break=V + + \p{_X_GCB_V} +*/ +/*** GENERATED CODE ***/ +#define is_GCB_V_utf8(s) \ +( ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] >= 0xA0 ) ? 3 : 0 ) \ + : ( ( 0x86 == ((U8*)s)[1] ) && ( ((U8*)s)[2] <= 0xA7 ) ) ? 3 : 0 ) \ +: ( 0xED == ((U8*)s)[0] ) ? \ + ( ( 0x9E == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] >= 0xB0 ) ? 3 : 0 ) \ + : ( ( 0x9F == ((U8*)s)[1] ) && ( ((U8*)s)[2] <= 0x86 ) ) ? 3 : 0 ) \ : 0 ) +/* + QUOTEMETA: Meta-characters that \Q should quote + + \p{_Perl_Quotemeta} +*/ /*** GENERATED CODE ***/ -#define is_TRICKYFOLD_cp(cp) \ -( 0xDF == cp || ( 0xDF < cp && \ -( 0x390 == cp || ( 0x390 < cp && \ -( 0x3B0 == cp || ( 0x3B0 < cp && \ -( 0x1E9E == cp || ( 0x1E9E < cp && \ -( 0x1FD3 == cp || ( 0x1FD3 < cp && \ -0x1FE3 == cp ) ) ) ) ) ) ) ) ) ) +#define is_QUOTEMETA_high(s) \ +( ( 0xCD == ((U8*)s)[0] ) ? \ + ( ( 0x8F == ((U8*)s)[1] ) ? 2 : 0 ) \ +: ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? \ + ( ( 0x9F == ((U8*)s)[2] || 0xA0 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( 0x9A == ((U8*)s)[1] ) ? \ + ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( 0x9E == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] & 0xFE ) == 0xB4 ) ? 3 : 0 ) \ + : ( ( 0xA0 == ((U8*)s)[1] ) && ( 0x8B <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8E ) ) ? 3 : 0 )\ +: ( 0xE2 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] <= 0xBE ) ? 3 : 0 ) \ + : ( 0x81 == ((U8*)s)[1] ) ? \ + ( ( ( 0x81 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x93 ) || ( 0x95 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xAF ) ) ? 3 : 0 )\ + : ( 0x86 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] >= 0x90 ) ? 3 : 0 ) \ + : ( ( 0x87 <= ((U8*)s)[1] && ((U8*)s)[1] <= 0x90 ) || ( 0x94 <= ((U8*)s)[1] && ((U8*)s)[1] <= 0x9C ) || ( 0x9F <= ((U8*)s)[1] && ((U8*)s)[1] <= 0xAF ) || ( ((U8*)s)[1] & 0xFE ) == 0xB8 ) ?\ + 3 \ + : ( 0x91 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] <= 0x9F ) ? 3 : 0 ) \ + : ( 0x9D == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] <= 0xB5 ) ? 3 : 0 ) \ + : ( ( 0x9E == ((U8*)s)[1] ) && ( ((U8*)s)[2] >= 0x94 ) ) ? 3 : 0 ) \ +: ( 0xE3 == ((U8*)s)[0] ) ? \ + ( ( 0x80 == ((U8*)s)[1] ) ? \ + ( ( ( ((U8*)s)[2] <= 0x83 ) || ( 0x88 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xA0 ) || 0xB0 == ((U8*)s)[2] ) ? 3 : 0 )\ + : ( ( 0x85 == ((U8*)s)[1] ) && ( 0xA4 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ +: ( 0xEF == ((U8*)s)[0] ) ? \ + ( ( 0xB4 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] >= 0xBE ) ? 3 : 0 ) \ + : ( 0xB8 == ((U8*)s)[1] ) ? \ + ( ( ((U8*)s)[2] <= 0x8F ) ? 3 : 0 ) \ + : ( 0xB9 == ((U8*)s)[1] ) ? \ + ( ( 0x85 == ((U8*)s)[2] || 0x86 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( 0xBB == ((U8*)s)[1] ) ? \ + ( ( 0xBF == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( 0xBE == ((U8*)s)[1] ) ? \ + ( ( 0xA0 == ((U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0xBF == ((U8*)s)[1] ) && ( 0xB0 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0xB8 ) ) ? 3 : 0 )\ +: ( 0xF0 == ((U8*)s)[0] ) ? \ + ( ( ( ( 0x9D == ((U8*)s)[1] ) && ( 0x85 == ((U8*)s)[2] ) ) && ( 0xB3 <= ((U8*)s)[3] && ((U8*)s)[3] <= 0xBA ) ) ? 4 : 0 )\ +: ( ( 0xF3 == ((U8*)s)[0] ) && ( 0xA0 == ((U8*)s)[1] ) ) ? 4 : 0 ) + +/* + MULTI_CHAR_FOLD: multi-char strings that are folded to by a single character + do regen/regcharclass_multi_char_folds.pl + ®charclass_multi_char_folds::multi_char_folds(1) +*/ /*** GENERATED CODE ***/ -#define what_TRICKYFOLD(s,is_utf8) \ -( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? 0xDF : 0 ) \ +#define is_MULTI_CHAR_FOLD_utf8_safe_part0(s,e) \ +( ( 0x61 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCA == ((U8*)s)[1] ) && ( 0xBE == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x66 == ((U8*)s)[0] ) ? \ + ( ( 0x66 == ((U8*)s)[1] ) ? \ + ( ( 0x69 == ((U8*)s)[2] || 0x6C == ((U8*)s)[2] ) ? 3 : 2 ) \ + : ( 0x69 == ((U8*)s)[1] || 0x6C == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x68 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0xB1 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x69 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x87 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x6A == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8C == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x73 == ((U8*)s)[0] ) ? \ + ( ( 0x73 == ((U8*)s)[1] || 0x74 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x74 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x88 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x77 == ((U8*)s)[0] || 0x79 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8A == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xCA == ((U8*)s)[0] ) ? \ + ( ( ( 0xBC == ((U8*)s)[1] ) && ( 0x6E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] ) ? 0x390 \ - : ( 0xB0 == ((U8*)s)[1] ) ? 0x3B0 : 0 ) \ + ( ( ( ((U8*)s)[1] & 0xFD ) == 0xAC ) ? \ + ( ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB1 == ((U8*)s)[1] || 0xB7 == ((U8*)s)[1] ) ? \ + ( ( 0xCD == ((U8*)s)[2] ) ? \ + ( ( 0x82 == ((U8*)s)[3] ) ? 4 : 0 ) \ + : ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( ( ( 0xB9 == ((U8*)s)[1] ) && ( 0xCD == ((U8*)s)[2] ) ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xCF == ((U8*)s)[0] ) ? \ + ( ( 0x81 == ((U8*)s)[1] ) ? \ + ( ( ( 0xCC == ((U8*)s)[2] ) && ( 0x93 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0x85 == ((U8*)s)[1] ) ? \ + ( ( 0xCC == ((U8*)s)[2] ) ? \ + ( ( 0x93 == ((U8*)s)[3] ) ? 4 : 0 ) \ + : ( ( 0xCD == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0x89 == ((U8*)s)[1] ) ? \ + ( ( 0xCD == ((U8*)s)[2] ) ? \ + ( ( 0x82 == ((U8*)s)[3] ) ? 4 : 0 ) \ + : ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( ( ( 0x8E == ((U8*)s)[1] ) && ( 0xCE == ((U8*)s)[2] ) ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xD5 == ((U8*)s)[0] ) ? \ + ( ( 0xA5 == ((U8*)s)[1] ) ? \ + ( ( ( 0xD6 == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB4 == ((U8*)s)[1] ) ? \ + ( ( ( 0xD5 == ((U8*)s)[2] ) && ( ( ( ((U8*)s)[3] & 0xF7 ) == 0xA5 ) || ((U8*)s)[3] == 0xAB || ((U8*)s)[3] == 0xB6 ) ) ? 4 : 0 )\ + : ( ( ( 0xBE == ((U8*)s)[1] ) && ( 0xD5 == ((U8*)s)[2] ) ) && ( 0xB6 == ((U8*)s)[3] ) ) ? 4 : 0 )\ : ( 0xE1 == ((U8*)s)[0] ) ? \ - ( ( 0xBA == ((U8*)s)[1] ) ? \ - ( ( 0x9E == ((U8*)s)[2] ) ? 0x1E9E : 0 ) \ - : ( 0xBF == ((U8*)s)[1] ) ? \ - ( ( 0x93 == ((U8*)s)[2] ) ? 0x1FD3 \ - : ( 0xA3 == ((U8*)s)[2] ) ? 0x1FE3 : 0 ) \ + ( ( 0xBC == ((U8*)s)[1] ) ? \ + ( ( ( ( ( ((U8*)s)[2] & 0xD8 ) == 0x80 ) && ( 0xCE == ((U8*)s)[3] ) ) && ( 0xB9 == ((U8*)s)[4] ) ) ? 5 : 0 )\ + : ( ( ( ( 0xBD == ((U8*)s)[1] ) && ( ( ( ((U8*)s)[2] & 0xF8 ) == 0xA0 ) || ( ( ((U8*)s)[2] & 0xFB ) == 0xB0 ) || ((U8*)s)[2] == 0xBC ) ) && ( 0xCE == ((U8*)s)[3] ) ) && ( 0xB9 == ((U8*)s)[4] ) ) ? 5 : 0 )\ + : 0 ) + + +/*** GENERATED CODE ***/ +#define is_MULTI_CHAR_FOLD_utf8_safe_part1(s,e) \ +( ((e)-(s) > 3) ? \ + ( ( 0x61 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCA == ((U8*)s)[1] ) && ( 0xBE == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x66 == ((U8*)s)[0] ) ? \ + ( ( 0x66 == ((U8*)s)[1] ) ? \ + ( ( 0x69 == ((U8*)s)[2] || 0x6C == ((U8*)s)[2] ) ? 3 : 2 ) \ + : ( 0x69 == ((U8*)s)[1] || 0x6C == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x68 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0xB1 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x69 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x87 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x6A == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8C == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x73 == ((U8*)s)[0] ) ? \ + ( ( 0x73 == ((U8*)s)[1] || 0x74 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x74 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x88 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x77 == ((U8*)s)[0] || 0x79 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8A == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xCA == ((U8*)s)[0] ) ? \ + ( ( ( 0xBC == ((U8*)s)[1] ) && ( 0x6E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xCE == ((U8*)s)[0] ) ? \ + ( ( ( ((U8*)s)[1] & 0xFD ) == 0xAC ) ? \ + ( ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB1 == ((U8*)s)[1] || 0xB7 == ((U8*)s)[1] ) ? \ + ( ( 0xCD == ((U8*)s)[2] ) ? \ + ( ( 0x82 == ((U8*)s)[3] ) ? 4 : 0 ) \ + : ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( ( ( 0xB9 == ((U8*)s)[1] ) && ( 0xCD == ((U8*)s)[2] ) ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xCF == ((U8*)s)[0] ) ? \ + ( ( 0x81 == ((U8*)s)[1] ) ? \ + ( ( ( 0xCC == ((U8*)s)[2] ) && ( 0x93 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0x85 == ((U8*)s)[1] ) ? \ + ( ( 0xCC == ((U8*)s)[2] ) ? \ + ( ( 0x93 == ((U8*)s)[3] ) ? 4 : 0 ) \ + : ( ( 0xCD == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0x89 == ((U8*)s)[1] ) ? \ + ( ( 0xCD == ((U8*)s)[2] ) ? \ + ( ( 0x82 == ((U8*)s)[3] ) ? 4 : 0 ) \ + : ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( ( ( 0x8E == ((U8*)s)[1] ) && ( 0xCE == ((U8*)s)[2] ) ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xD5 == ((U8*)s)[0] ) ? \ + ( ( 0xA5 == ((U8*)s)[1] ) ? \ + ( ( ( 0xD6 == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB4 == ((U8*)s)[1] ) ? \ + ( ( ( 0xD5 == ((U8*)s)[2] ) && ( ( ( ((U8*)s)[3] & 0xF7 ) == 0xA5 ) || ((U8*)s)[3] == 0xAB || ((U8*)s)[3] == 0xB6 ) ) ? 4 : 0 )\ + : ( ( ( 0xBE == ((U8*)s)[1] ) && ( 0xD5 == ((U8*)s)[2] ) ) && ( 0xB6 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : 0 ) \ +: ((e)-(s) > 2) ? \ + ( ( 0x61 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCA == ((U8*)s)[1] ) && ( 0xBE == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x66 == ((U8*)s)[0] ) ? \ + ( ( 0x66 == ((U8*)s)[1] ) ? \ + ( ( 0x69 == ((U8*)s)[2] || 0x6C == ((U8*)s)[2] ) ? 3 : 2 ) \ + : ( 0x69 == ((U8*)s)[1] || 0x6C == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x68 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0xB1 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x69 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x87 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x6A == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8C == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x73 == ((U8*)s)[0] ) ? \ + ( ( 0x73 == ((U8*)s)[1] || 0x74 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x74 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x88 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x77 == ((U8*)s)[0] || 0x79 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8A == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( ( ( 0xCA == ((U8*)s)[0] ) && ( 0xBC == ((U8*)s)[1] ) ) && ( 0x6E == ((U8*)s)[2] ) ) ? 3 : 0 )\ +: ((e)-(s) > 1) ? \ + ( ( 0x66 == ((U8*)s)[0] ) ? \ + ( ( 0x66 == ((U8*)s)[1] || 0x69 == ((U8*)s)[1] || 0x6C == ((U8*)s)[1] ) ? 2 : 0 )\ + : ( ( 0x73 == ((U8*)s)[0] ) && ( 0x73 == ((U8*)s)[1] || 0x74 == ((U8*)s)[1] ) ) ? 2 : 0 )\ +: 0 ) + + +/*** GENERATED CODE ***/ +#define is_MULTI_CHAR_FOLD_utf8_safe(s,e) \ +( ((e)-(s) > 5) ? \ + ( ( 0x61 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCA == ((U8*)s)[1] ) && ( 0xBE == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x66 == ((U8*)s)[0] ) ? \ + ( ( 0x66 == ((U8*)s)[1] ) ? \ + ( ( 0x69 == ((U8*)s)[2] || 0x6C == ((U8*)s)[2] ) ? 3 : 2 ) \ + : ( 0x69 == ((U8*)s)[1] || 0x6C == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x68 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0xB1 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x69 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x87 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x6A == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8C == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x73 == ((U8*)s)[0] ) ? \ + ( ( 0x73 == ((U8*)s)[1] || 0x74 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0x74 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x88 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0x77 == ((U8*)s)[0] || 0x79 == ((U8*)s)[0] ) ? \ + ( ( ( 0xCC == ((U8*)s)[1] ) && ( 0x8A == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xCA == ((U8*)s)[0] ) ? \ + ( ( ( 0xBC == ((U8*)s)[1] ) && ( 0x6E == ((U8*)s)[2] ) ) ? 3 : 0 ) \ + : ( 0xCE == ((U8*)s)[0] ) ? \ + ( ( ( ((U8*)s)[1] & 0xFD ) == 0xAC ) ? \ + ( ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB1 == ((U8*)s)[1] || 0xB7 == ((U8*)s)[1] ) ? \ + ( ( 0xCD == ((U8*)s)[2] ) ? \ + ( ( 0x82 == ((U8*)s)[3] ) ? \ + ( ( ( 0xCE == ((U8*)s)[4] ) && ( 0xB9 == ((U8*)s)[5] ) ) ? 6 : 4 )\ + : 0 ) \ + : ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB9 == ((U8*)s)[1] ) ? \ + ( ( 0xCC == ((U8*)s)[2] ) ? \ + ( ( 0x88 == ((U8*)s)[3] ) ? \ + ( ( 0xCC == ((U8*)s)[4] ) ? \ + ( ( ( ((U8*)s)[5] & 0xFE ) == 0x80 ) ? 6 : 0 ) \ + : ( ( 0xCD == ((U8*)s)[4] ) && ( 0x82 == ((U8*)s)[5] ) ) ? 6 : 0 )\ + : 0 ) \ + : ( ( 0xCD == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ : 0 ) \ + : ( 0xCF == ((U8*)s)[0] ) ? \ + ( ( 0x81 == ((U8*)s)[1] ) ? \ + ( ( ( 0xCC == ((U8*)s)[2] ) && ( 0x93 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0x85 == ((U8*)s)[1] ) ? \ + ( ( 0xCC == ((U8*)s)[2] ) ? \ + ( ( 0x88 == ((U8*)s)[3] ) ? \ + ( ( 0xCC == ((U8*)s)[4] ) ? \ + ( ( ( ((U8*)s)[5] & 0xFE ) == 0x80 ) ? 6 : 0 ) \ + : ( ( 0xCD == ((U8*)s)[4] ) && ( 0x82 == ((U8*)s)[5] ) ) ? 6 : 0 )\ + : ( 0x93 == ((U8*)s)[3] ) ? \ + ( ( 0xCC == ((U8*)s)[4] ) ? \ + ( ( ( ((U8*)s)[5] & 0xFE ) == 0x80 ) ? 6 : 4 ) \ + : ( ( 0xCD == ((U8*)s)[4] ) && ( 0x82 == ((U8*)s)[5] ) ) ? 6 : 4 )\ + : 0 ) \ + : ( ( 0xCD == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0x89 == ((U8*)s)[1] ) ? \ + ( ( 0xCD == ((U8*)s)[2] ) ? \ + ( ( 0x82 == ((U8*)s)[3] ) ? \ + ( ( ( 0xCE == ((U8*)s)[4] ) && ( 0xB9 == ((U8*)s)[5] ) ) ? 6 : 4 )\ + : 0 ) \ + : ( ( 0xCE == ((U8*)s)[2] ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( ( ( 0x8E == ((U8*)s)[1] ) && ( 0xCE == ((U8*)s)[2] ) ) && ( 0xB9 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xD5 == ((U8*)s)[0] ) ? \ + ( ( 0xA5 == ((U8*)s)[1] ) ? \ + ( ( ( 0xD6 == ((U8*)s)[2] ) && ( 0x82 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xB4 == ((U8*)s)[1] ) ? \ + ( ( ( 0xD5 == ((U8*)s)[2] ) && ( ( ( ((U8*)s)[3] & 0xF7 ) == 0xA5 ) || ((U8*)s)[3] == 0xAB || ((U8*)s)[3] == 0xB6 ) ) ? 4 : 0 )\ + : ( ( ( 0xBE == ((U8*)s)[1] ) && ( 0xD5 == ((U8*)s)[2] ) ) && ( 0xB6 == ((U8*)s)[3] ) ) ? 4 : 0 )\ + : ( 0xE1 == ((U8*)s)[0] ) ? \ + ( ( 0xBC == ((U8*)s)[1] ) ? \ + ( ( ( ( ( ((U8*)s)[2] & 0xD8 ) == 0x80 ) && ( 0xCE == ((U8*)s)[3] ) ) && ( 0xB9 == ((U8*)s)[4] ) ) ? 5 : 0 )\ + : ( ( ( ( 0xBD == ((U8*)s)[1] ) && ( ( ( ((U8*)s)[2] & 0xF8 ) == 0xA0 ) || ( ( ((U8*)s)[2] & 0xFB ) == 0xB0 ) || ((U8*)s)[2] == 0xBC ) ) && ( 0xCE == ((U8*)s)[3] ) ) && ( 0xB9 == ((U8*)s)[4] ) ) ? 5 : 0 )\ : 0 ) \ -: ( 0xDF == ((U8*)s)[0] ) ? 0xDF : 0 ) +: ((e)-(s) > 4) ? is_MULTI_CHAR_FOLD_utf8_safe_part0(s,e) : is_MULTI_CHAR_FOLD_utf8_safe_part1(s,e) ) + +/* + MULTI_CHAR_FOLD: multi-char strings that are folded to by a single character + ®charclass_multi_char_folds::multi_char_folds(0) +*/ /*** GENERATED CODE ***/ -#define what_TRICKYFOLD_safe(s,e,is_utf8) \ +#define is_MULTI_CHAR_FOLD_latin1_safe(s,e) \ ( ((e)-(s) > 2) ? \ - ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? 0xDF : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] ) ? 0x390 \ - : ( 0xB0 == ((U8*)s)[1] ) ? 0x3B0 : 0 ) \ - : ( 0xE1 == ((U8*)s)[0] ) ? \ - ( ( 0xBA == ((U8*)s)[1] ) ? \ - ( ( 0x9E == ((U8*)s)[2] ) ? 0x1E9E : 0 ) \ - : ( 0xBF == ((U8*)s)[1] ) ? \ - ( ( 0x93 == ((U8*)s)[2] ) ? 0x1FD3 \ - : ( 0xA3 == ((U8*)s)[2] ) ? 0x1FE3 : 0 ) \ - : 0 ) \ - : 0 ) \ - : ( 0xDF == ((U8*)s)[0] ) ? 0xDF : 0 ) \ + ( ( ( ((U8*)s)[0] & 0xDF ) == 0x46 ) ? \ + ( ( ( ((U8*)s)[1] & 0xDF ) == 0x46 ) ? \ + ( ( ( ( ((U8*)s)[2] & 0xDF ) == 0x49 ) || ( ( ((U8*)s)[2] & 0xDF ) == 0x4C ) ) ? 3 : 2 )\ + : ( ( ( ((U8*)s)[1] & 0xDF ) == 0x49 ) || ( ( ((U8*)s)[1] & 0xDF ) == 0x4C ) ) ? 2 : 0 )\ + : ( ( ( ((U8*)s)[0] & 0xDF ) == 0x53 ) && ( ( ( ((U8*)s)[1] & 0xDF ) == 0x53 ) || ( ( ((U8*)s)[1] & 0xDF ) == 0x54 ) ) ) ? 2 : 0 )\ : ((e)-(s) > 1) ? \ - ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? 0xDF : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] ) ? 0x390 \ - : ( 0xB0 == ((U8*)s)[1] ) ? 0x3B0 : 0 ) \ - : 0 ) \ - : ( 0xDF == ((U8*)s)[0] ) ? 0xDF : 0 ) \ + ( ( ( ((U8*)s)[0] & 0xDF ) == 0x46 ) ? \ + ( ( ( ( ((U8*)s)[1] & 0xDF ) == 0x46 ) || ( ( ((U8*)s)[1] & 0xDF ) == 0x49 ) || ( ( ((U8*)s)[1] & 0xDF ) == 0x4C ) ) ? 2 : 0 )\ + : ( ( ( ((U8*)s)[0] & 0xDF ) == 0x53 ) && ( ( ( ((U8*)s)[1] & 0xDF ) == 0x53 ) || ( ( ((U8*)s)[1] & 0xDF ) == 0x54 ) ) ) ? 2 : 0 )\ +: 0 ) + +/* + PATWS: pattern white space + + \p{PatWS} +*/ +/*** GENERATED CODE ***/ +#define is_PATWS(s,is_utf8) \ +( ( ( 0x09 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x20 == ((U8*)s)[0] ) ? 1\ +: ( is_utf8 ) ? \ + ( ( 0xC2 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0x8E || ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ +: ( 0x85 == ((U8*)s)[0] ) ) + +/*** GENERATED CODE ***/ +#define is_PATWS_safe(s,e,is_utf8) \ +( ((e)-(s) > 2) ? \ + ( ( ( 0x09 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x20 == ((U8*)s)[0] ) ? 1\ + : ( is_utf8 ) ? \ + ( ( 0xC2 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0x8E || ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ + : ( 0x85 == ((U8*)s)[0] ) ) \ +: ((e)-(s) > 1) ? \ + ( ( ( 0x09 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x20 == ((U8*)s)[0] ) ? 1\ + : ( is_utf8 ) ? \ + ( ( ( 0xC2 == ((U8*)s)[0] ) && ( 0x85 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ + : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 0) ? \ - ( ( ( !( is_utf8 ) ) && ( 0xDF == ((U8*)s)[0] ) ) ? 0xDF : 0 ) \ + ( ( ( 0x09 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x20 == ((U8*)s)[0] ) ? 1\ + : ( !( is_utf8 ) ) ? \ + ( 0x85 == ((U8*)s)[0] ) \ + : 0 ) \ : 0 ) /*** GENERATED CODE ***/ -#define what_len_TRICKYFOLD(s,is_utf8,len) \ +#define is_PATWS_non_low(s,is_utf8) \ ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? len=2, 0xDF : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] ) ? len=2, 0x390 \ - : ( 0xB0 == ((U8*)s)[1] ) ? len=2, 0x3B0 : 0 ) \ - : ( 0xE1 == ((U8*)s)[0] ) ? \ - ( ( 0xBA == ((U8*)s)[1] ) ? \ - ( ( 0x9E == ((U8*)s)[2] ) ? len=3, 0x1E9E : 0 ) \ - : ( 0xBF == ((U8*)s)[1] ) ? \ - ( ( 0x93 == ((U8*)s)[2] ) ? len=3, 0x1FD3 \ - : ( 0xA3 == ((U8*)s)[2] ) ? len=3, 0x1FE3 : 0 ) \ - : 0 ) \ - : 0 ) \ -: ( 0xDF == ((U8*)s)[0] ) ? len=1, 0xDF : 0 ) + ( ( 0xC2 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0x8E || ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ +: ( 0x85 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ -#define what_len_TRICKYFOLD_safe(s,e,is_utf8,len) \ +#define is_PATWS_non_low_safe(s,e,is_utf8) \ ( ((e)-(s) > 2) ? \ ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? len=2, 0xDF : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] ) ? len=2, 0x390 \ - : ( 0xB0 == ((U8*)s)[1] ) ? len=2, 0x3B0 : 0 ) \ - : ( 0xE1 == ((U8*)s)[0] ) ? \ - ( ( 0xBA == ((U8*)s)[1] ) ? \ - ( ( 0x9E == ((U8*)s)[2] ) ? len=3, 0x1E9E : 0 ) \ - : ( 0xBF == ((U8*)s)[1] ) ? \ - ( ( 0x93 == ((U8*)s)[2] ) ? len=3, 0x1FD3 \ - : ( 0xA3 == ((U8*)s)[2] ) ? len=3, 0x1FE3 : 0 ) \ - : 0 ) \ - : 0 ) \ - : ( 0xDF == ((U8*)s)[0] ) ? len=1, 0xDF : 0 ) \ + ( ( 0xC2 == ((U8*)s)[0] ) ? \ + ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ + : ( ( ( 0xE2 == ((U8*)s)[0] ) && ( 0x80 == ((U8*)s)[1] ) ) && ( ( ((U8*)s)[2] & 0xFE ) == 0x8E || ( ((U8*)s)[2] & 0xFE ) == 0xA8 ) ) ? 3 : 0 )\ + : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( is_utf8 ) ? \ - ( ( 0xC3 == ((U8*)s)[0] ) ? \ - ( ( 0x9F == ((U8*)s)[1] ) ? len=2, 0xDF : 0 ) \ - : ( 0xCE == ((U8*)s)[0] ) ? \ - ( ( 0x90 == ((U8*)s)[1] ) ? len=2, 0x390 \ - : ( 0xB0 == ((U8*)s)[1] ) ? len=2, 0x3B0 : 0 ) \ - : 0 ) \ - : ( 0xDF == ((U8*)s)[0] ) ? len=1, 0xDF : 0 ) \ -: ((e)-(s) > 0) ? \ - ( ( ( !( is_utf8 ) ) && ( 0xDF == ((U8*)s)[0] ) ) ? len=1, 0xDF : 0 ) \ -: 0 ) + ( ( ( 0xC2 == ((U8*)s)[0] ) && ( 0x85 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ + : ( 0x85 == ((U8*)s)[0] ) ) \ +: ( ((e)-(s) > 0) && ( !( is_utf8 ) ) ) ? ( 0x85 == ((U8*)s)[0] ) : 0 ) + +/*** GENERATED CODE ***/ +#define is_PATWS_cp(cp) \ +( ( 0x09 <= cp && cp <= 0x0D ) || ( 0x0D < cp && \ +( 0x20 == cp || ( 0x20 < cp && \ +( 0x85 == cp || ( 0x85 < cp && \ +( 0x200E == cp || ( 0x200E < cp && \ +( 0x200F == cp || ( 0x200F < cp && \ +( 0x2028 == cp || 0x2029 == cp ) ) ) ) ) ) ) ) ) ) ) + +#endif /* H_REGCHARCLASS */ /* ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/regcomp.h b/Master/tlpkg/tlperl/lib/CORE/regcomp.h index e1e9fdb22bf..21d2e1e3519 100644 --- a/Master/tlpkg/tlperl/lib/CORE/regcomp.h +++ b/Master/tlpkg/tlperl/lib/CORE/regcomp.h @@ -9,9 +9,6 @@ */ #include "regcharclass.h" -typedef OP OP_4tree; /* Will be redefined later. */ - - /* Convert branch sequences to more efficient trie ops? */ #define PERL_ENABLE_TRIE_OPTIMISATION 1 @@ -121,6 +118,8 @@ typedef OP OP_4tree; /* Will be redefined later. */ Used to make it easier to clone and free arbitrary data that the regops need. Often the ARG field of a regop is an index into this structure */ + struct reg_code_block *code_blocks;/* positions of literal (?{}) */ + int num_code_blocks; /* size of code_blocks[] */ regnode program[1]; /* Unwarranted chumminess with compiler. */ } regexp_internal; @@ -138,6 +137,7 @@ typedef OP OP_4tree; /* Will be redefined later. */ #define PREGf_NAUGHTY 0x00000004 /* how exponential is this pattern? */ #define PREGf_VERBARG_SEEN 0x00000008 #define PREGf_CUTGROUP_SEEN 0x00000010 +#define PREGf_USE_RE_EVAL 0x00000020 /* compiled with "use re 'eval'" */ /* this is where the old regcomp.h started */ @@ -178,7 +178,6 @@ struct regnode_2 { #define ANYOF_BITMAP_SIZE 32 /* 256 b/(8 b/B) */ -#define ANYOF_CLASSBITMAP_SIZE 4 /* up to 32 (8*4) named classes */ /* also used by trie */ struct regnode_charclass { @@ -196,7 +195,7 @@ struct regnode_charclass_class { U16 next_off; U32 arg1; /* used as ptr in S_regclass */ char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time */ - char classflags[ANYOF_CLASSBITMAP_SIZE]; /* and run-time */ + U32 classflags; /* and run-time */ }; /* XXX fix this description. @@ -307,50 +306,36 @@ struct regnode_charclass_class { * ANYOF_NONBITMAP_NON_UTF8 bit is also set. */ #define ANYOF_NONBITMAP(node) (ARG(node) != ANYOF_NONBITMAP_EMPTY) -/* Flags for node->flags of ANYOF. These are in short supply, so some games - * are done to share them, as described below. If necessary, the ANYOF_LOCALE - * and ANYOF_CLASS bits could be shared with a space penalty for locale nodes, - * but this isn't quite so easy, as the optimizer also uses ANYOF_CLASS. - * Another option would be to push them into new nodes. E.g. there could be an - * ANYOF_LOCALE node that would be in place of the flag of the same name. - * Once the planned change to compile all the above-latin1 code points is done, - * then the UNICODE_ALL bit can be freed up, with a small performance penalty. - * If flags need to be added that are applicable to the synthetic start class - * only, with some work, they could be put in the next-node field, or in an - * unused bit of the classflags field. */ +/* Flags for node->flags of ANYOF. These are in short supply, but there is one + * currently available. If more than this are needed, the ANYOF_LOCALE and + * ANYOF_CLASS bits could be shared, making a space penalty for all locale nodes. + * Also, the UNICODE_ALL bit could be freed up by resorting to creating a swash + * containing everything above 255. This introduces a performance penalty. + * Better would be to split it off into a separate node, which actually would + * improve performance a bit by allowing regexec.c to test for a UTF-8 + * character being above 255 without having to call a function nor calculate + * its code point value. However, this solution might need to have a second + * node type, ANYOF_SYNTHETIC_ABOVE_LATIN1_ALL */ #define ANYOF_LOCALE 0x01 /* /l modifier */ /* The fold is calculated and stored in the bitmap where possible at compile - * time. However there are two cases where it isn't possible. These share - * this bit: 1) under locale, where the actual folding varies depending on - * what the locale is at the time of execution; and 2) where the folding is - * specified in a swash, not the bitmap, such as characters which aren't - * specified in the bitmap, or properties that aren't looked at at compile time - */ -#define ANYOF_LOC_NONBITMAP_FOLD 0x02 + * time. However under locale, the actual folding varies depending on + * what the locale is at the time of execution, so it has to be deferred until + * then */ +#define ANYOF_LOC_FOLD 0x02 #define ANYOF_INVERT 0x04 /* Set if this is a struct regnode_charclass_class vs a regnode_charclass. This * is used for runtime \d, \w, [:posix:], ..., which are used only in locale * and the optimizer's synthetic start class. Non-locale \d, etc are resolved - * at compile-time */ -#define ANYOF_CLASS 0x08 -#define ANYOF_LARGE ANYOF_CLASS /* Same; name retained for back compat */ - -/* EOS, meaning that it can match an empty string too, is used for the - * synthetic start class only. */ -#define ANYOF_EOS 0x10 - -/* ? Is this node the synthetic start class (ssc). This bit is shared with - * ANYOF_EOS, as the latter is used only for the ssc, and then not used by - * regexec.c. And, the code is structured so that if it is set, the ssc is - * not used, so it is guaranteed to be 0 for the ssc by the time regexec.c - * gets executed, and 0 for a non-ssc ANYOF node, as it only ever gets set for - * a potential ssc candidate. Thus setting it to 1 after it has been - * determined that the ssc will be used is not ambiguous */ -#define ANYOF_IS_SYNTHETIC ANYOF_EOS + * at compile-time. Could be shared with ANYOF_LOCALE, forcing all locale + * nodes to be large */ +#define ANYOF_CLASS 0x08 +#define ANYOF_LARGE ANYOF_CLASS /* Same; name retained for back compat */ + +/* Unused: 0x10. When using, be sure to change ANYOF_FLAGS_ALL below */ /* Can match something outside the bitmap that isn't in utf8 */ #define ANYOF_NONBITMAP_NON_UTF8 0x20 @@ -362,62 +347,80 @@ struct regnode_charclass_class { * in utf8. */ #define ANYOF_NON_UTF8_LATIN1_ALL 0x80 -#define ANYOF_FLAGS_ALL 0xff +#define ANYOF_FLAGS_ALL (0xff & ~0x10) /* These are the flags that ANYOF_INVERT being set or not doesn't affect * whether they are operative or not. e.g., the node still has LOCALE * regardless of being inverted; whereas ANYOF_UNICODE_ALL means something * different if inverted */ #define INVERSION_UNAFFECTED_FLAGS (ANYOF_LOCALE \ - |ANYOF_LOC_NONBITMAP_FOLD \ + |ANYOF_LOC_FOLD \ |ANYOF_CLASS \ - |ANYOF_EOS \ |ANYOF_NONBITMAP_NON_UTF8) /* Character classes for node->classflags of ANYOF */ /* Should be synchronized with a table in regprop() */ -/* 2n should pair with 2n+1 */ - -#define ANYOF_ALNUM 0 /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */ -#define ANYOF_NALNUM 1 -#define ANYOF_SPACE 2 /* \s */ -#define ANYOF_NSPACE 3 -#define ANYOF_DIGIT 4 /* \d */ -#define ANYOF_NDIGIT 5 -#define ANYOF_ALNUMC 6 /* [[:alnum:]] isalnum(3), utf8::IsAlnum, ALNUMC */ -#define ANYOF_NALNUMC 7 -#define ANYOF_ALPHA 8 -#define ANYOF_NALPHA 9 -#define ANYOF_ASCII 10 -#define ANYOF_NASCII 11 -#define ANYOF_CNTRL 12 -#define ANYOF_NCNTRL 13 -#define ANYOF_GRAPH 14 -#define ANYOF_NGRAPH 15 -#define ANYOF_LOWER 16 -#define ANYOF_NLOWER 17 -#define ANYOF_PRINT 18 -#define ANYOF_NPRINT 19 -#define ANYOF_PUNCT 20 -#define ANYOF_NPUNCT 21 -#define ANYOF_UPPER 22 -#define ANYOF_NUPPER 23 -#define ANYOF_XDIGIT 24 -#define ANYOF_NXDIGIT 25 -#define ANYOF_PSXSPC 26 /* POSIX space: \s plus the vertical tab */ -#define ANYOF_NPSXSPC 27 -#define ANYOF_BLANK 28 /* GNU extension: space and tab: non-vertical space */ -#define ANYOF_NBLANK 29 - -#define ANYOF_MAX 32 - -/* pseudo classes, not stored in the class bitmap, but used as flags +/* 2n should be the normal one, paired with its complement at 2n+1 */ + +#define ANYOF_ALPHA ((_CC_ALPHA) * 2) +#define ANYOF_NALPHA ((ANYOF_ALPHA) + 1) +#define ANYOF_ALPHANUMERIC ((_CC_ALPHANUMERIC) * 2) /* [[:alnum:]] isalnum(3), utf8::IsAlnum */ +#define ANYOF_NALPHANUMERIC ((ANYOF_ALPHANUMERIC) + 1) +#define ANYOF_ASCII ((_CC_ASCII) * 2) +#define ANYOF_NASCII ((ANYOF_ASCII) + 1) +#define ANYOF_BLANK ((_CC_BLANK) * 2) /* GNU extension: space and tab: non-vertical space */ +#define ANYOF_NBLANK ((ANYOF_BLANK) + 1) +#define ANYOF_CASED ((_CC_CASED) * 2) /* Pseudo class for [:lower:] or + [:upper:] under /i */ +#define ANYOF_NCASED ((ANYOF_CASED) + 1) +#define ANYOF_CNTRL ((_CC_CNTRL) * 2) +#define ANYOF_NCNTRL ((ANYOF_CNTRL) + 1) +#define ANYOF_DIGIT ((_CC_DIGIT) * 2) /* \d */ +#define ANYOF_NDIGIT ((ANYOF_DIGIT) + 1) +#define ANYOF_GRAPH ((_CC_GRAPH) * 2) +#define ANYOF_NGRAPH ((ANYOF_GRAPH) + 1) +#define ANYOF_LOWER ((_CC_LOWER) * 2) +#define ANYOF_NLOWER ((ANYOF_LOWER) + 1) +#define ANYOF_PRINT ((_CC_PRINT) * 2) +#define ANYOF_NPRINT ((ANYOF_PRINT) + 1) +#define ANYOF_PSXSPC ((_CC_PSXSPC) * 2) /* POSIX space: \s plus the vertical tab */ +#define ANYOF_NPSXSPC ((ANYOF_PSXSPC) + 1) +#define ANYOF_PUNCT ((_CC_PUNCT) * 2) +#define ANYOF_NPUNCT ((ANYOF_PUNCT) + 1) +#define ANYOF_SPACE ((_CC_SPACE) * 2) /* \s */ +#define ANYOF_NSPACE ((ANYOF_SPACE) + 1) +#define ANYOF_UPPER ((_CC_UPPER) * 2) +#define ANYOF_NUPPER ((ANYOF_UPPER) + 1) +#define ANYOF_WORDCHAR ((_CC_WORDCHAR) * 2) /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */ +#define ANYOF_NWORDCHAR ((ANYOF_WORDCHAR) + 1) +#define ANYOF_XDIGIT ((_CC_XDIGIT) * 2) +#define ANYOF_NXDIGIT ((ANYOF_XDIGIT) + 1) + +/* pseudo classes below this, not stored in the class bitmap, but used as flags during compilation of char classes */ -#define ANYOF_VERTWS (ANYOF_MAX+1) -#define ANYOF_NVERTWS (ANYOF_MAX+2) -#define ANYOF_HORIZWS (ANYOF_MAX+3) -#define ANYOF_NHORIZWS (ANYOF_MAX+4) +#define ANYOF_VERTWS ((_CC_VERTSPACE) * 2) +#define ANYOF_NVERTWS ((ANYOF_VERTWS)+1) + +/* It is best if this is the last one, as all above it are stored as bits in a + * bitmap, and it isn't part of that bitmap */ +#if _CC_VERTSPACE != _HIGHEST_REGCOMP_DOT_H_SYNC +# error Problem with handy.h _HIGHEST_REGCOMP_DOT_H_SYNC #define +#endif + +#define ANYOF_MAX (ANYOF_VERTWS) /* So upper loop limit is written: + * '< ANYOF_MAX' + * Hence doesn't include VERTWS, as that + * is a pseudo class */ +#if (ANYOF_MAX > 32) /* Must fit in 32-bit word */ +# error Problem with handy.h _CC_foo #defines +#endif + +#define ANYOF_HORIZWS ((ANYOF_MAX)+2) /* = (ANYOF_NVERTWS + 1) */ +#define ANYOF_NHORIZWS ((ANYOF_MAX)+3) + +#define ANYOF_UNIPROP ((ANYOF_MAX)+4) /* Used to indicate a Unicode + property: \p{} or \P{} */ /* Backward source code compatibility. */ @@ -425,6 +428,8 @@ struct regnode_charclass_class { #define ANYOF_NALNUML ANYOF_NALNUM #define ANYOF_SPACEL ANYOF_SPACE #define ANYOF_NSPACEL ANYOF_NSPACE +#define ANYOF_ALNUM ANYOF_WORDCHAR +#define ANYOF_NALNUM ANYOF_NWORDCHAR /* Utility macros for the bitmap and classes of ANYOF */ @@ -435,16 +440,18 @@ struct regnode_charclass_class { #define ANYOF_BIT(c) (1 << ((c) & 7)) -#define ANYOF_CLASS_BYTE(p, c) (((struct regnode_charclass_class*)(p))->classflags[((c) >> 3) & 3]) -#define ANYOF_CLASS_SET(p, c) (ANYOF_CLASS_BYTE(p, c) |= ANYOF_BIT(c)) -#define ANYOF_CLASS_CLEAR(p, c) (ANYOF_CLASS_BYTE(p, c) &= ~ANYOF_BIT(c)) -#define ANYOF_CLASS_TEST(p, c) (ANYOF_CLASS_BYTE(p, c) & ANYOF_BIT(c)) +#define ANYOF_CLASS_SET(p, c) (((struct regnode_charclass_class*) (p))->classflags |= (1U << (c))) +#define ANYOF_CLASS_CLEAR(p, c) (((struct regnode_charclass_class*) (p))->classflags &= ~ (1U <<(c))) +#define ANYOF_CLASS_TEST(p, c) (((struct regnode_charclass_class*) (p))->classflags & (1U << (c))) -#define ANYOF_CLASS_ZERO(ret) Zero(((struct regnode_charclass_class*)(ret))->classflags, ANYOF_CLASSBITMAP_SIZE, char) -#define ANYOF_CLASS_SETALL(ret) \ - memset (((struct regnode_charclass_class*)(ret))->classflags, 255, ANYOF_CLASSBITMAP_SIZE) -#define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char) +#define ANYOF_CLASS_ZERO(ret) STMT_START { ((struct regnode_charclass_class*) (ret))->classflags = 0; } STMT_END + +/* Shifts a bit to get, eg. 0x4000_0000, then subtracts 1 to get 0x3FFF_FFFF */ +#define ANYOF_CLASS_SETALL(ret) STMT_START { ((struct regnode_charclass_class*) (ret))->classflags = ((1U << ((ANYOF_MAX) - 1))) - 1; } STMT_END +#define ANYOF_CLASS_OR(source, dest) STMT_START { (dest)->classflags |= source->classflags ; } STMT_END + +#define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char) #define ANYOF_BITMAP(p) (((struct regnode_charclass*)(p))->bitmap) #define ANYOF_BITMAP_BYTE(p, c) (ANYOF_BITMAP(p)[(((U8)(c)) >> 3) & 31]) #define ANYOF_BITMAP_SET(p, c) (ANYOF_BITMAP_BYTE(p, c) |= ANYOF_BIT(c)) @@ -462,12 +469,9 @@ struct regnode_charclass_class { #define ANYOF_SKIP ((ANYOF_SIZE - 1)/sizeof(regnode)) #define ANYOF_CLASS_SKIP ((ANYOF_CLASS_SIZE - 1)/sizeof(regnode)) -#if ANYOF_CLASSBITMAP_SIZE != 4 -# error ANYOF_CLASSBITMAP_SIZE is expected to be 4 -#endif -#define ANYOF_CLASS_TEST_ANY_SET(p) ((ANYOF_FLAGS(p) & ANYOF_CLASS) \ - && memNE (((struct regnode_charclass_class*)(p))->classflags, \ - "\0\0\0\0", ANYOF_CLASSBITMAP_SIZE)) +#define ANYOF_CLASS_TEST_ANY_SET(p) \ + ((ANYOF_FLAGS(p) & ANYOF_CLASS) \ + && (((struct regnode_charclass_class*)(p))->classflags)) /*#define ANYOF_CLASS_ADD_SKIP (ANYOF_CLASS_SKIP - ANYOF_SKIP) * */ @@ -486,7 +490,7 @@ struct regnode_charclass_class { #define REG_SEEN_ZERO_LEN 0x00000001 #define REG_SEEN_LOOKBEHIND 0x00000002 #define REG_SEEN_GPOS 0x00000004 -#define REG_SEEN_EVAL 0x00000008 +/* spare */ #define REG_SEEN_CANY 0x00000010 #define REG_SEEN_SANY REG_SEEN_CANY /* src bckwrd cmpt */ #define REG_SEEN_RECURSE 0x00000020 @@ -521,8 +525,9 @@ EXTCONST regexp_engine PL_core_reg_engine = { Perl_reg_named_buff_iter, Perl_reg_qr_package, #if defined(USE_ITHREADS) - Perl_regdupe_internal + Perl_regdupe_internal, #endif + Perl_re_op_compile }; #endif /* DOINIT */ #endif /* PLUGGABLE_RE_EXTENSION */ @@ -535,9 +540,9 @@ END_EXTERN_C * The character describes the function of the corresponding .data item: * a - AV for paren_name_list under DEBUGGING * f - start-class data for regstclass optimization - * n - Root of op tree for (?{EVAL}) item - * o - Start op for (?{EVAL}) item - * p - Pad for (?{EVAL}) item + * l - start op for literal (?{EVAL}) item + * L - start op for literal (?{EVAL}) item, with separate CV (qr//) + * r - pointer to an embedded code-containing qr, e.g. /ab$qr/ * s - swash for Unicode-style character class, and the multicharacter * strings resulting from casefolding the single-character entries * in the character class @@ -574,10 +579,10 @@ struct reg_data { #define check_offset_max substrs->data[2].max_offset #define check_end_shift substrs->data[2].end_shift -#define RX_ANCHORED_SUBSTR(rx) (((struct regexp *)SvANY(rx))->anchored_substr) -#define RX_ANCHORED_UTF8(rx) (((struct regexp *)SvANY(rx))->anchored_utf8) -#define RX_FLOAT_SUBSTR(rx) (((struct regexp *)SvANY(rx))->float_substr) -#define RX_FLOAT_UTF8(rx) (((struct regexp *)SvANY(rx))->float_utf8) +#define RX_ANCHORED_SUBSTR(rx) (ReANY(rx)->anchored_substr) +#define RX_ANCHORED_UTF8(rx) (ReANY(rx)->anchored_utf8) +#define RX_FLOAT_SUBSTR(rx) (ReANY(rx)->float_substr) +#define RX_FLOAT_UTF8(rx) (ReANY(rx)->float_utf8) /* trie related stuff */ @@ -824,11 +829,9 @@ re.pm, especially to the documentation. if (re_debug_flags & RE_DEBUG_EXTRA_GPOS) x ) /* initialization */ -/* get_sv() can return NULL during global destruction. re_debug_flags can get - * clobbered by a longjmp, so must be initialized */ +/* get_sv() can return NULL during global destruction. */ #define GET_RE_DEBUG_FLAGS DEBUG_r({ \ SV * re_debug_flags_sv = NULL; \ - re_debug_flags = 0; \ re_debug_flags_sv = get_sv(RE_DEBUG_FLAGS, 1); \ if (re_debug_flags_sv) { \ if (!SvIOK(re_debug_flags_sv)) \ @@ -839,8 +842,8 @@ re.pm, especially to the documentation. #ifdef DEBUGGING -#define GET_RE_DEBUG_FLAGS_DECL VOL IV re_debug_flags \ - PERL_UNUSED_DECL = 0; GET_RE_DEBUG_FLAGS; +#define GET_RE_DEBUG_FLAGS_DECL VOL IV re_debug_flags = 0; \ + PERL_UNUSED_VAR(re_debug_flags); GET_RE_DEBUG_FLAGS; #define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2) \ const char * const rpv = \ @@ -881,8 +884,8 @@ re.pm, especially to the documentation. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/regexp.h b/Master/tlpkg/tlperl/lib/CORE/regexp.h index 78fec5781a0..31fb879c66a 100644 --- a/Master/tlpkg/tlperl/lib/CORE/regexp.h +++ b/Master/tlpkg/tlperl/lib/CORE/regexp.h @@ -18,6 +18,8 @@ /* we don't want to include this stuff if we are inside of an external regex engine based on the core one - like re 'debug'*/ +#include "utf8.h" + struct regnode { U8 flags; U8 type; @@ -44,15 +46,24 @@ struct reg_substr_data { struct reg_substr_datum data[3]; /* Actual array */ }; -#ifdef PERL_OLD_COPY_ON_WRITE +#ifdef PERL_ANY_COW #define SV_SAVED_COPY SV *saved_copy; /* If non-NULL, SV which is COW from original */ #else #define SV_SAVED_COPY #endif +/* offsets within a string of a particular /(.)/ capture */ + typedef struct regexp_paren_pair { I32 start; I32 end; + /* 'start_tmp' records a new opening position before the matching end + * has been found, so that the old start and end values are still + * valid, e.g. + * "abc" =~ /(.(?{print "[$1]"}))+/ + *outputs [][a][b] + * This field is not part of the API. */ + I32 start_tmp; } regexp_paren_pair; #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) @@ -64,6 +75,16 @@ typedef struct regexp_paren_pair { #define _invlist_subtract(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output) #endif +/* record the position of a (?{...}) within a pattern */ + +struct reg_code_block { + STRLEN start; + STRLEN end; + OP *block; + REGEXP *src_regex; +}; + + /* The regexp/REGEXP struct, see L<perlreapi> for further documentation on the individual fields. The struct is ordered so that the most @@ -83,8 +104,8 @@ typedef struct regexp_paren_pair { /* Information about the match that the perl core uses to */ \ /* manage things */ \ U32 extflags; /* Flags used both externally and internally */ \ - I32 minlen; /* mininum possible length of string to match */\ - I32 minlenret; /* mininum possible length of $& */ \ + I32 minlen; /* mininum possible number of chars in string to match */\ + I32 minlenret; /* mininum possible number of chars in $& */ \ U32 gofs; /* chars left of pos that we search from */ \ /* substring data about strings that must appear in the */ \ /* final match, used for optimisations */ \ @@ -98,18 +119,21 @@ typedef struct regexp_paren_pair { /* during matching */ \ U32 lastparen; /* last open paren matched */ \ U32 lastcloseparen; /* last close paren matched */ \ - regexp_paren_pair *swap; /* Unused: 5.10.1 and later */ \ /* Array of offsets for (@-) and (@+) */ \ regexp_paren_pair *offs; \ /* saved or original string so \digit works forever. */ \ char *subbeg; \ SV_SAVED_COPY /* If non-NULL, SV which is COW from original */\ I32 sublen; /* Length of string pointed by subbeg */ \ + I32 suboffset; /* byte offset of subbeg from logical start of str */ \ + I32 subcoffset; /* suboffset equiv, but in chars (for @-/@+) */ \ /* Information about the match that isn't often used */ \ /* offset from wrapped to the start of precomp */ \ PERL_BITFIELD32 pre_prefix:4; \ - /* number of eval groups in the pattern - for security checks */\ - PERL_BITFIELD32 seen_evals:28 + /* original flags used to compile the pattern, may differ */ \ + /* from extflags in various ways */ \ + PERL_BITFIELD32 compflags:9; \ + CV *qr_anoncv /* the anon sub wrapped round qr/(?{..})/ */ typedef struct regexp { _XPV_HEAD; @@ -152,6 +176,10 @@ typedef struct regexp_engine { #ifdef USE_ITHREADS void* (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param); #endif + REGEXP* (*op_comp) (pTHX_ SV ** const patternp, int pat_count, + OP *expr, const struct regexp_engine* eng, + REGEXP *VOL old_re, + bool *is_bare_re, U32 orig_rx_flags, U32 pm_flags); } regexp_engine; /* @@ -159,9 +187,12 @@ typedef struct regexp_engine { paren name. >= 1 is reserved for actual numbered captures, i.e. $1, $2 etc. */ -#define RX_BUFF_IDX_PREMATCH -2 /* $` / ${^PREMATCH} */ -#define RX_BUFF_IDX_POSTMATCH -1 /* $' / ${^POSTMATCH} */ -#define RX_BUFF_IDX_FULLMATCH 0 /* $& / ${^MATCH} */ +#define RX_BUFF_IDX_CARET_PREMATCH -5 /* ${^PREMATCH} */ +#define RX_BUFF_IDX_CARET_POSTMATCH -4 /* ${^POSTMATCH} */ +#define RX_BUFF_IDX_CARET_FULLMATCH -3 /* ${^MATCH} */ +#define RX_BUFF_IDX_PREMATCH -2 /* $` */ +#define RX_BUFF_IDX_POSTMATCH -1 /* $' */ +#define RX_BUFF_IDX_FULLMATCH 0 /* $& */ /* Flags that are passed to the named_buff and named_buff_iter @@ -305,7 +336,17 @@ and check for NULL. /* Leave some space, so future bit allocations can go either in the shared or * unshared area without affecting binary compatibility */ -#define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+1) +#define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT) + +/* + Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will + be used by regex engines to check whether they should set + RXf_SKIPWHITE +*/ +#define RXf_SPLIT (1<<(RXf_BASE_SHIFT-1)) +#if RXf_SPLIT != RXf_PMf_SPLIT +# error "RXf_SPLIT does not match RXf_PMf_SPLIT" +#endif /* Manually decorate this function with gcc-style attributes just to * avoid having to restructure the header files and their called order, @@ -351,7 +392,7 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) #define RXf_ANCH_SINGLE (RXf_ANCH_SBOL|RXf_ANCH_GPOS) /* What we have seen */ -#define RXf_LOOKBEHIND_SEEN (1<<(RXf_BASE_SHIFT+6)) +#define RXf_NO_INPLACE_SUBST (1<<(RXf_BASE_SHIFT+6)) #define RXf_EVAL_SEEN (1<<(RXf_BASE_SHIFT+7)) #define RXf_CANY_SEEN (1<<(RXf_BASE_SHIFT+8)) @@ -366,14 +407,6 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) #define RXf_USE_INTUIT_NOML (1<<(RXf_BASE_SHIFT+12)) #define RXf_USE_INTUIT_ML (1<<(RXf_BASE_SHIFT+13)) #define RXf_INTUIT_TAIL (1<<(RXf_BASE_SHIFT+14)) - -/* - Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will - be used by regex engines to check whether they should set - RXf_SKIPWHITE -*/ -#define RXf_SPLIT (1<<(RXf_BASE_SHIFT+15)) - #define RXf_USE_INTUIT (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML) /* Copy and tainted info */ @@ -387,7 +420,7 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) /* Flags indicating special patterns */ #define RXf_START_ONLY (1<<(RXf_BASE_SHIFT+19)) /* Pattern is /^/ */ -#define RXf_SKIPWHITE (1<<(RXf_BASE_SHIFT+20)) /* Pattern is for a split / / */ +#define RXf_SKIPWHITE (1<<(RXf_BASE_SHIFT+20)) /* Pattern is for a split " " */ #define RXf_WHITE (1<<(RXf_BASE_SHIFT+21)) /* Pattern is /\s+/ */ #define RXf_NULL (1U<<(RXf_BASE_SHIFT+22)) /* Pattern is // */ #if RXf_BASE_SHIFT+22 > 31 @@ -400,11 +433,25 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) * */ +#if NO_TAINT_SUPPORT +# define RX_ISTAINTED(prog) 0 +# define RX_TAINT_on(prog) NOOP +# define RXp_MATCH_TAINTED(prog) 0 +# define RX_MATCH_TAINTED(prog) 0 +# define RXp_MATCH_TAINTED_on(prog) NOOP +# define RX_MATCH_TAINTED_on(prog) NOOP +# define RX_MATCH_TAINTED_off(prog) NOOP +#else +# define RX_ISTAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED) +# define RX_TAINT_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED) +# define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN) +# define RX_MATCH_TAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED_SEEN) +# define RXp_MATCH_TAINTED_on(prog) (RXp_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) +# define RX_MATCH_TAINTED_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) +# define RX_MATCH_TAINTED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN) +#endif + #define RX_HAS_CUTGROUP(prog) ((prog)->intflags & PREGf_CUTGROUP_SEEN) -#define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN) -#define RX_MATCH_TAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED_SEEN) -#define RX_MATCH_TAINTED_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) -#define RX_MATCH_TAINTED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN) #define RX_MATCH_TAINTED_set(prog, t) ((t) \ ? RX_MATCH_TAINTED_on(prog) \ : RX_MATCH_TAINTED_off(prog)) @@ -420,71 +467,41 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) : RX_MATCH_COPIED_off(prog)) #define RXp_EXTFLAGS(rx) ((rx)->extflags) +#define RXp_COMPFLAGS(rx) ((rx)->compflags) /* For source compatibility. We used to store these explicitly. */ -#define RX_PRECOMP(prog) (RX_WRAPPED(prog) + ((struct regexp *)SvANY(prog))->pre_prefix) -#define RX_PRECOMP_const(prog) (RX_WRAPPED_const(prog) + ((struct regexp *)SvANY(prog))->pre_prefix) +#define RX_PRECOMP(prog) (RX_WRAPPED(prog) + ReANY(prog)->pre_prefix) +#define RX_PRECOMP_const(prog) (RX_WRAPPED_const(prog) + ReANY(prog)->pre_prefix) /* FIXME? Are we hardcoding too much here and constraining plugin extension writers? Specifically, the value 1 assumes that the wrapped version always has exactly one character at the end, a ')'. Will that always be true? */ -#define RX_PRELEN(prog) (RX_WRAPLEN(prog) - ((struct regexp *)SvANY(prog))->pre_prefix - 1) -#define RX_WRAPPED(prog) SvPVX(prog) -#define RX_WRAPPED_const(prog) SvPVX_const(prog) +#define RX_PRELEN(prog) (RX_WRAPLEN(prog) - ReANY(prog)->pre_prefix - 1) +#define RX_WRAPPED(prog) ReANY(prog)->xpv_len_u.xpvlenu_pv +#define RX_WRAPPED_const(prog) ((const char *)RX_WRAPPED(prog)) #define RX_WRAPLEN(prog) SvCUR(prog) -#define RX_CHECK_SUBSTR(prog) (((struct regexp *)SvANY(prog))->check_substr) +#define RX_CHECK_SUBSTR(prog) (ReANY(prog)->check_substr) #define RX_REFCNT(prog) SvREFCNT(prog) -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define RX_EXTFLAGS(prog) \ - (*({ \ - const REGEXP *const _rx_extflags = (prog); \ - assert(SvTYPE(_rx_extflags) == SVt_REGEXP); \ - &RXp_EXTFLAGS(SvANY(_rx_extflags)); \ - })) -# define RX_ENGINE(prog) \ - (*({ \ - const REGEXP *const _rx_engine = (prog); \ - assert(SvTYPE(_rx_engine) == SVt_REGEXP); \ - &SvANY(_rx_engine)->engine; \ - })) -# define RX_SUBBEG(prog) \ - (*({ \ - const REGEXP *const _rx_subbeg = (prog); \ - assert(SvTYPE(_rx_subbeg) == SVt_REGEXP); \ - &SvANY(_rx_subbeg)->subbeg; \ - })) -# define RX_OFFS(prog) \ - (*({ \ - const REGEXP *const _rx_offs = (prog); \ - assert(SvTYPE(_rx_offs) == SVt_REGEXP); \ - &SvANY(_rx_offs)->offs; \ - })) -# define RX_NPARENS(prog) \ - (*({ \ - const REGEXP *const _rx_nparens = (prog); \ - assert(SvTYPE(_rx_nparens) == SVt_REGEXP); \ - &SvANY(_rx_nparens)->nparens; \ - })) -#else -# define RX_EXTFLAGS(prog) RXp_EXTFLAGS((struct regexp *)SvANY(prog)) -# define RX_ENGINE(prog) (((struct regexp *)SvANY(prog))->engine) -# define RX_SUBBEG(prog) (((struct regexp *)SvANY(prog))->subbeg) -# define RX_OFFS(prog) (((struct regexp *)SvANY(prog))->offs) -# define RX_NPARENS(prog) (((struct regexp *)SvANY(prog))->nparens) -#endif -#define RX_SUBLEN(prog) (((struct regexp *)SvANY(prog))->sublen) -#define RX_MINLEN(prog) (((struct regexp *)SvANY(prog))->minlen) -#define RX_MINLENRET(prog) (((struct regexp *)SvANY(prog))->minlenret) -#define RX_GOFS(prog) (((struct regexp *)SvANY(prog))->gofs) -#define RX_LASTPAREN(prog) (((struct regexp *)SvANY(prog))->lastparen) -#define RX_LASTCLOSEPAREN(prog) (((struct regexp *)SvANY(prog))->lastcloseparen) -#define RX_SEEN_EVALS(prog) (((struct regexp *)SvANY(prog))->seen_evals) -#define RX_SAVED_COPY(prog) (((struct regexp *)SvANY(prog))->saved_copy) +#define RX_EXTFLAGS(prog) RXp_EXTFLAGS(ReANY(prog)) +#define RX_COMPFLAGS(prog) RXp_COMPFLAGS(ReANY(prog)) +#define RX_ENGINE(prog) (ReANY(prog)->engine) +#define RX_SUBBEG(prog) (ReANY(prog)->subbeg) +#define RX_SUBOFFSET(prog) (ReANY(prog)->suboffset) +#define RX_SUBCOFFSET(prog) (ReANY(prog)->subcoffset) +#define RX_OFFS(prog) (ReANY(prog)->offs) +#define RX_NPARENS(prog) (ReANY(prog)->nparens) +#define RX_SUBLEN(prog) (ReANY(prog)->sublen) +#define RX_MINLEN(prog) (ReANY(prog)->minlen) +#define RX_MINLENRET(prog) (ReANY(prog)->minlenret) +#define RX_GOFS(prog) (ReANY(prog)->gofs) +#define RX_LASTPAREN(prog) (ReANY(prog)->lastparen) +#define RX_LASTCLOSEPAREN(prog) (ReANY(prog)->lastcloseparen) +#define RX_SAVED_COPY(prog) (ReANY(prog)->saved_copy) #endif /* PLUGGABLE_RE_EXTENSION */ /* Stuff that needs to be included in the pluggable extension goes below here */ -#ifdef PERL_OLD_COPY_ON_WRITE +#ifdef PERL_ANY_COW #define RX_MATCH_COPY_FREE(rx) \ STMT_START {if (RX_SAVED_COPY(rx)) { \ SV_CHECK_THINKFIRST_COW_DROP(RX_SAVED_COPY(rx)); \ @@ -517,6 +534,11 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) #define REXEC_SCREAM 0x04 /* use scream table. */ #define REXEC_IGNOREPOS 0x08 /* \G matches at start. */ #define REXEC_NOT_FIRST 0x10 /* This is another iteration of //g. */ + /* under REXEC_COPY_STR, it's ok for the + * engine (modulo PL_sawamperand etc) + * to skip copying ... */ +#define REXEC_COPY_SKIP_PRE 0x20 /* ...the $` part of the string, or */ +#define REXEC_COPY_SKIP_POST 0x40 /* ...the $' part of the string */ #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define ReREFCNT_inc(re) \ @@ -537,6 +559,7 @@ get_regex_charset_name(const U32 flags, STRLEN* const lenp) # define ReREFCNT_dec(re) SvREFCNT_dec(re) # define ReREFCNT_inc(re) ((REGEXP *) SvREFCNT_inc(re)) #endif +#define ReANY(re) S_ReANY((const REGEXP *)(re)) /* FIXME for plugins. */ @@ -558,6 +581,8 @@ typedef struct { SV *sv; char *ganch; char *cutpoint; + bool is_utf8_pat; + bool warned; /* we have issued a recursion warning; no need for more */ } regmatch_info; @@ -589,6 +614,7 @@ typedef struct regmatch_state { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; U32 lastparen; + U32 lastcloseparen; CHECKPOINT cp; } branchlike; @@ -597,6 +623,7 @@ typedef struct regmatch_state { /* the first elements must match u.branchlike */ struct regmatch_state *prev_yes_state; U32 lastparen; + U32 lastcloseparen; CHECKPOINT cp; regnode *next_branch; /* next branch node */ @@ -606,17 +633,17 @@ typedef struct regmatch_state { /* the first elements must match u.branchlike */ struct regmatch_state *prev_yes_state; U32 lastparen; + U32 lastcloseparen; CHECKPOINT cp; U32 accepted; /* how many accepting states left */ + bool longfold;/* saw a fold with a 1->n char mapping */ U16 *jump; /* positive offsets from me */ - regnode *B; /* node following the trie */ regnode *me; /* Which node am I - needed for jump tries*/ U8 *firstpos;/* pos in string of first trie match */ U32 firstchars;/* len in chars of firstpos from start */ U16 nextword;/* next word to try */ U16 topword; /* longest accepted word */ - bool longfold;/* saw a fold with a 1->n char mapping */ } trie; /* special types - these members are used to store state for special @@ -627,9 +654,7 @@ typedef struct regmatch_state { struct regmatch_state *prev_eval; struct regmatch_state *prev_curlyx; REGEXP *prev_rex; - U32 toggle_reg_flags; /* what bits in PL_reg_flags to - flip when transitioning between - inner and outer rexen */ + bool saved_utf8_pat; /* saved copy of is_utf8_pat */ CHECKPOINT cp; /* remember current savestack indexes */ CHECKPOINT lastcp; U32 close_paren; /* which close bracket is our end */ @@ -687,24 +712,32 @@ typedef struct regmatch_state { struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; - I32 c1, c2; /* case fold search */ + int c1, c2; /* case fold search */ CHECKPOINT cp; + U32 lastparen; + U32 lastcloseparen; I32 alen; /* length of first-matched A string */ I32 count; bool minmod; regnode *A, *B; /* the nodes corresponding to /A*B/ */ regnode *me; /* the curlym node */ + U8 c1_utf8[UTF8_MAXBYTES+1]; /* */ + U8 c2_utf8[UTF8_MAXBYTES+1]; } curlym; struct { U32 paren; CHECKPOINT cp; - I32 c1, c2; /* case fold search */ + U32 lastparen; + U32 lastcloseparen; + int c1, c2; /* case fold search */ char *maxpos; /* highest possible point in string to match */ char *oldloc; /* the previous locinput */ int count; int min, max; /* {m,n} */ regnode *A, *B; /* the nodes corresponding to /A*B/ */ + U8 c1_utf8[UTF8_MAXBYTES+1]; /* */ + U8 c2_utf8[UTF8_MAXBYTES+1]; } curly; /* and CURLYN/PLUS/STAR */ } u; @@ -722,16 +755,8 @@ typedef struct regmatch_slab { struct regmatch_slab *prev, *next; } regmatch_slab; -#define PL_reg_flags PL_reg_state.re_state_reg_flags #define PL_bostr PL_reg_state.re_state_bostr -#define PL_reginput PL_reg_state.re_state_reginput #define PL_regeol PL_reg_state.re_state_regeol -#define PL_regoffs PL_reg_state.re_state_regoffs -#define PL_reglastparen PL_reg_state.re_state_reglastparen -#define PL_reglastcloseparen PL_reg_state.re_state_reglastcloseparen -#define PL_reg_start_tmp PL_reg_state.re_state_reg_start_tmp -#define PL_reg_start_tmpl PL_reg_state.re_state_reg_start_tmpl -#define PL_reg_eval_set PL_reg_state.re_state_reg_eval_set #define PL_reg_match_utf8 PL_reg_state.re_state_reg_match_utf8 #define PL_reg_magic PL_reg_state.re_state_reg_magic #define PL_reg_oldpos PL_reg_state.re_state_reg_oldpos @@ -739,39 +764,35 @@ typedef struct regmatch_slab { #define PL_reg_curpm PL_reg_state.re_state_reg_curpm #define PL_reg_oldsaved PL_reg_state.re_state_reg_oldsaved #define PL_reg_oldsavedlen PL_reg_state.re_state_reg_oldsavedlen +#define PL_reg_oldsavedoffset PL_reg_state.re_state_reg_oldsavedoffset +#define PL_reg_oldsavedcoffset PL_reg_state.re_state_reg_oldsavedcoffset #define PL_reg_maxiter PL_reg_state.re_state_reg_maxiter #define PL_reg_leftiter PL_reg_state.re_state_reg_leftiter #define PL_reg_poscache PL_reg_state.re_state_reg_poscache #define PL_reg_poscache_size PL_reg_state.re_state_reg_poscache_size -#define PL_regsize PL_reg_state.re_state_regsize #define PL_reg_starttry PL_reg_state.re_state_reg_starttry #define PL_nrs PL_reg_state.re_state_nrs struct re_save_state { - U32 re_state_reg_flags; /* from regexec.c */ - U32 re_state_reg_start_tmpl; /* from regexec.c */ - I32 re_state_reg_eval_set; /* from regexec.c */ + bool re_state_eval_setup_done; /* from regexec.c */ bool re_state_reg_match_utf8; /* from regexec.c */ + /* Space for U8 */ + I32 re_state_reg_oldpos; /* from regexec.c */ + I32 re_state_reg_maxiter; /* max wait until caching pos */ + I32 re_state_reg_leftiter; /* wait until caching pos */ char *re_state_bostr; - char *re_state_reginput; /* String-input pointer. */ char *re_state_regeol; /* End of input, for $ check. */ - regexp_paren_pair *re_state_regoffs; /* Pointer to start/end pairs */ - U32 *re_state_reglastparen; /* Similarly for lastparen. */ - U32 *re_state_reglastcloseparen; /* Similarly for lastcloseparen. */ - char **re_state_reg_start_tmp; /* from regexec.c */ MAGIC *re_state_reg_magic; /* from regexec.c */ PMOP *re_state_reg_oldcurpm; /* from regexec.c */ PMOP *re_state_reg_curpm; /* from regexec.c */ char *re_state_reg_oldsaved; /* old saved substr during match */ STRLEN re_state_reg_oldsavedlen; /* old length of saved substr during match */ + STRLEN re_state_reg_oldsavedoffset; /* old offset of saved substr during match */ + STRLEN re_state_reg_oldsavedcoffset;/* old coffset of saved substr during match */ STRLEN re_state_reg_poscache_size; /* size of pos cache of WHILEM */ - I32 re_state_reg_oldpos; /* from regexec.c */ - I32 re_state_reg_maxiter; /* max wait until caching pos */ - I32 re_state_reg_leftiter; /* wait until caching pos */ - U32 re_state_regsize; /* from regexec.c */ char *re_state_reg_poscache; /* cache of pos of WHILEM */ char *re_state_reg_starttry; /* from regexec.c */ -#ifdef PERL_OLD_COPY_ON_WRITE +#ifdef PERL_ANY_COW SV *re_state_nrs; /* was placeholder: unused since 5.8.0 (5.7.2 patch #12027 for bug ID 20010815.012). Used to save rx->saved_copy */ #endif }; @@ -783,8 +804,8 @@ struct re_save_state { * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/regnodes.h b/Master/tlpkg/tlperl/lib/CORE/regnodes.h index 14bac24cb24..0caf86dd556 100644 --- a/Master/tlpkg/tlperl/lib/CORE/regnodes.h +++ b/Master/tlpkg/tlperl/lib/CORE/regnodes.h @@ -6,8 +6,8 @@ /* Regops and State definitions */ -#define REGNODE_MAX 112 -#define REGMATCH_STATE_MAX 152 +#define REGNODE_MAX 95 +#define REGMATCH_STATE_MAX 135 #define END 0 /* 0000 End of program. */ #define SUCCEED 1 /* 0x01 Return from a subroutine, basically. */ @@ -31,97 +31,80 @@ #define SANY 19 /* 0x13 Match any one character. */ #define CANY 20 /* 0x14 Match any one byte. */ #define ANYOF 21 /* 0x15 Match character in (or not in) this class, single char match only */ -#define ANYOFV 22 /* 0x16 Match character in (or not in) this class, can match-multiple chars */ -#define ALNUM 23 /* 0x17 Match any alphanumeric character using native charset semantics for non-utf8 */ -#define ALNUML 24 /* 0x18 Match any alphanumeric char in locale */ -#define ALNUMU 25 /* 0x19 Match any alphanumeric char using Unicode semantics */ -#define ALNUMA 26 /* 0x1a Match [A-Za-z_0-9] */ -#define NALNUM 27 /* 0x1b Match any non-alphanumeric character using native charset semantics for non-utf8 */ -#define NALNUML 28 /* 0x1c Match any non-alphanumeric char in locale */ -#define NALNUMU 29 /* 0x1d Match any non-alphanumeric char using Unicode semantics */ -#define NALNUMA 30 /* 0x1e Match [^A-Za-z_0-9] */ -#define SPACE 31 /* 0x1f Match any whitespace character using native charset semantics for non-utf8 */ -#define SPACEL 32 /* 0x20 Match any whitespace char in locale */ -#define SPACEU 33 /* 0x21 Match any whitespace char using Unicode semantics */ -#define SPACEA 34 /* 0x22 Match [ \t\n\f\r] */ -#define NSPACE 35 /* 0x23 Match any non-whitespace character using native charset semantics for non-utf8 */ -#define NSPACEL 36 /* 0x24 Match any non-whitespace char in locale */ -#define NSPACEU 37 /* 0x25 Match any non-whitespace char using Unicode semantics */ -#define NSPACEA 38 /* 0x26 Match [^ \t\n\f\r] */ -#define DIGIT 39 /* 0x27 Match any numeric character using native charset semantics for non-utf8 */ -#define DIGITL 40 /* 0x28 Match any numeric character in locale */ -#define DIGITA 41 /* 0x29 Match [0-9] */ -#define NDIGIT 42 /* 0x2a Match any non-numeric character using native charset semantics for non-utf8 */ -#define NDIGITL 43 /* 0x2b Match any non-numeric character in locale */ -#define NDIGITA 44 /* 0x2c Match [^0-9] */ -#define CLUMP 45 /* 0x2d Match any extended grapheme cluster sequence */ -#define BRANCH 46 /* 0x2e Match this alternative, or the next... */ -#define BACK 47 /* 0x2f Match "", "next" ptr points backward. */ -#define EXACT 48 /* 0x30 Match this string (preceded by length). */ -#define EXACTF 49 /* 0x31 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */ -#define EXACTFL 50 /* 0x32 Match this string (not guaranteed to be folded) using /il rules (w/len). */ -#define EXACTFU 51 /* 0x33 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */ -#define EXACTFU_SS 52 /* 0x34 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */ -#define EXACTFU_TRICKYFOLD 53 /* 0x35 Match this folded UTF-8 string using /iu rules */ -#define EXACTFA 54 /* 0x36 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */ -#define NOTHING 55 /* 0x37 Match empty string. */ -#define TAIL 56 /* 0x38 Match empty string. Can jump here from outside. */ -#define STAR 57 /* 0x39 Match this (simple) thing 0 or more times. */ -#define PLUS 58 /* 0x3a Match this (simple) thing 1 or more times. */ -#define CURLY 59 /* 0x3b Match this simple thing {n,m} times. */ -#define CURLYN 60 /* 0x3c Capture next-after-this simple thing */ -#define CURLYM 61 /* 0x3d Capture this medium-complex thing {n,m} times. */ -#define CURLYX 62 /* 0x3e Match this complex thing {n,m} times. */ -#define WHILEM 63 /* 0x3f Do curly processing and see if rest matches. */ -#define OPEN 64 /* 0x40 Mark this point in input as start of */ -#define CLOSE 65 /* 0x41 Analogous to OPEN. */ -#define REF 66 /* 0x42 Match some already matched string */ -#define REFF 67 /* 0x43 Match already matched string, folded using native charset semantics for non-utf8 */ -#define REFFL 68 /* 0x44 Match already matched string, folded in loc. */ -#define REFFU 69 /* 0x45 Match already matched string, folded using unicode semantics for non-utf8 */ -#define REFFA 70 /* 0x46 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ -#define NREF 71 /* 0x47 Match some already matched string */ -#define NREFF 72 /* 0x48 Match already matched string, folded using native charset semantics for non-utf8 */ -#define NREFFL 73 /* 0x49 Match already matched string, folded in loc. */ -#define NREFFU 74 /* 0x4a Match already matched string, folded using unicode semantics for non-utf8 */ -#define NREFFA 75 /* 0x4b Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ -#define IFMATCH 76 /* 0x4c Succeeds if the following matches. */ -#define UNLESSM 77 /* 0x4d Fails if the following matches. */ -#define SUSPEND 78 /* 0x4e "Independent" sub-RE. */ -#define IFTHEN 79 /* 0x4f Switch, should be preceded by switcher . */ -#define GROUPP 80 /* 0x50 Whether the group matched. */ -#define LONGJMP 81 /* 0x51 Jump far away. */ -#define BRANCHJ 82 /* 0x52 BRANCH with long offset. */ -#define EVAL 83 /* 0x53 Execute some Perl code. */ -#define MINMOD 84 /* 0x54 Next operator is not greedy. */ -#define LOGICAL 85 /* 0x55 Next opcode should set the flag only. */ -#define RENUM 86 /* 0x56 Group with independently numbered parens. */ -#define TRIE 87 /* 0x57 Match many EXACT(F[ALU]?)? at once. flags==type */ -#define TRIEC 88 /* 0x58 Same as TRIE, but with embedded charclass data */ -#define AHOCORASICK 89 /* 0x59 Aho Corasick stclass. flags==type */ -#define AHOCORASICKC 90 /* 0x5a Same as AHOCORASICK, but with embedded charclass data */ -#define GOSUB 91 /* 0x5b recurse to paren arg1 at (signed) ofs arg2 */ -#define GOSTART 92 /* 0x5c recurse to start of pattern */ -#define NGROUPP 93 /* 0x5d Whether the group matched. */ -#define INSUBP 94 /* 0x5e Whether we are in a specific recurse. */ -#define DEFINEP 95 /* 0x5f Never execute directly. */ -#define ENDLIKE 96 /* 0x60 Used only for the type field of verbs */ -#define OPFAIL 97 /* 0x61 Same as (?!) */ -#define ACCEPT 98 /* 0x62 Accepts the current matched string. */ -#define VERB 99 /* 0x63 Used only for the type field of verbs */ -#define PRUNE 100 /* 0x64 Pattern fails at this startpoint if no-backtracking through this */ -#define MARKPOINT 101 /* 0x65 Push the current location for rollback by cut. */ -#define SKIP 102 /* 0x66 On failure skip forward (to the mark) before retrying */ -#define COMMIT 103 /* 0x67 Pattern fails outright if backtracking through this */ -#define CUTGROUP 104 /* 0x68 On failure go to the next alternation in the group */ -#define KEEPS 105 /* 0x69 $& begins here. */ -#define LNBREAK 106 /* 0x6a generic newline pattern */ -#define VERTWS 107 /* 0x6b vertical whitespace (Perl 6) */ -#define NVERTWS 108 /* 0x6c not vertical whitespace (Perl 6) */ -#define HORIZWS 109 /* 0x6d horizontal whitespace (Perl 6) */ -#define NHORIZWS 110 /* 0x6e not horizontal whitespace (Perl 6) */ -#define OPTIMIZED 111 /* 0x6f Placeholder for dump. */ -#define PSEUDO 112 /* 0x70 Pseudo opcode for internal use. */ +#define ANYOF_WARN_SUPER 22 /* 0x16 Match character in (or not in) this class, warn (if enabled) upon matching a char above Unicode max; */ +#define ANYOF_SYNTHETIC 23 /* 0x17 Synthetic start class */ +#define POSIXD 24 /* 0x18 Some [[:class:]] under /d; the FLAGS field gives which one */ +#define POSIXL 25 /* 0x19 Some [[:class:]] under /l; the FLAGS field gives which one */ +#define POSIXU 26 /* 0x1a Some [[:class:]] under /u; the FLAGS field gives which one */ +#define POSIXA 27 /* 0x1b Some [[:class:]] under /a; the FLAGS field gives which one */ +#define NPOSIXD 28 /* 0x1c complement of POSIXD, [[:^class:]] */ +#define NPOSIXL 29 /* 0x1d complement of POSIXL, [[:^class:]] */ +#define NPOSIXU 30 /* 0x1e complement of POSIXU, [[:^class:]] */ +#define NPOSIXA 31 /* 0x1f complement of POSIXA, [[:^class:]] */ +#define CLUMP 32 /* 0x20 Match any extended grapheme cluster sequence */ +#define BRANCH 33 /* 0x21 Match this alternative, or the next... */ +#define BACK 34 /* 0x22 Match "", "next" ptr points backward. */ +#define EXACT 35 /* 0x23 Match this string (preceded by length). */ +#define EXACTF 36 /* 0x24 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */ +#define EXACTFL 37 /* 0x25 Match this string (not guaranteed to be folded) using /il rules (w/len). */ +#define EXACTFU 38 /* 0x26 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */ +#define EXACTFA 39 /* 0x27 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */ +#define EXACTFU_SS 40 /* 0x28 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */ +#define EXACTFU_TRICKYFOLD 41 /* 0x29 Match this folded UTF-8 string using /iu rules */ +#define NOTHING 42 /* 0x2a Match empty string. */ +#define TAIL 43 /* 0x2b Match empty string. Can jump here from outside. */ +#define STAR 44 /* 0x2c Match this (simple) thing 0 or more times. */ +#define PLUS 45 /* 0x2d Match this (simple) thing 1 or more times. */ +#define CURLY 46 /* 0x2e Match this simple thing {n,m} times. */ +#define CURLYN 47 /* 0x2f Capture next-after-this simple thing */ +#define CURLYM 48 /* 0x30 Capture this medium-complex thing {n,m} times. */ +#define CURLYX 49 /* 0x31 Match this complex thing {n,m} times. */ +#define WHILEM 50 /* 0x32 Do curly processing and see if rest matches. */ +#define OPEN 51 /* 0x33 Mark this point in input as start of #n. */ +#define CLOSE 52 /* 0x34 Analogous to OPEN. */ +#define REF 53 /* 0x35 Match some already matched string */ +#define REFF 54 /* 0x36 Match already matched string, folded using native charset semantics for non-utf8 */ +#define REFFL 55 /* 0x37 Match already matched string, folded in loc. */ +#define REFFU 56 /* 0x38 Match already matched string, folded using unicode semantics for non-utf8 */ +#define REFFA 57 /* 0x39 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ +#define NREF 58 /* 0x3a Match some already matched string */ +#define NREFF 59 /* 0x3b Match already matched string, folded using native charset semantics for non-utf8 */ +#define NREFFL 60 /* 0x3c Match already matched string, folded in loc. */ +#define NREFFU 61 /* 0x3d Match already matched string, folded using unicode semantics for non-utf8 */ +#define NREFFA 62 /* 0x3e Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ +#define IFMATCH 63 /* 0x3f Succeeds if the following matches. */ +#define UNLESSM 64 /* 0x40 Fails if the following matches. */ +#define SUSPEND 65 /* 0x41 "Independent" sub-RE. */ +#define IFTHEN 66 /* 0x42 Switch, should be preceded by switcher. */ +#define GROUPP 67 /* 0x43 Whether the group matched. */ +#define LONGJMP 68 /* 0x44 Jump far away. */ +#define BRANCHJ 69 /* 0x45 BRANCH with long offset. */ +#define EVAL 70 /* 0x46 Execute some Perl code. */ +#define MINMOD 71 /* 0x47 Next operator is not greedy. */ +#define LOGICAL 72 /* 0x48 Next opcode should set the flag only. */ +#define RENUM 73 /* 0x49 Group with independently numbered parens. */ +#define TRIE 74 /* 0x4a Match many EXACT(F[ALU]?)? at once. flags==type */ +#define TRIEC 75 /* 0x4b Same as TRIE, but with embedded charclass data */ +#define AHOCORASICK 76 /* 0x4c Aho Corasick stclass. flags==type */ +#define AHOCORASICKC 77 /* 0x4d Same as AHOCORASICK, but with embedded charclass data */ +#define GOSUB 78 /* 0x4e recurse to paren arg1 at (signed) ofs arg2 */ +#define GOSTART 79 /* 0x4f recurse to start of pattern */ +#define NGROUPP 80 /* 0x50 Whether the group matched. */ +#define INSUBP 81 /* 0x51 Whether we are in a specific recurse. */ +#define DEFINEP 82 /* 0x52 Never execute directly. */ +#define ENDLIKE 83 /* 0x53 Used only for the type field of verbs */ +#define OPFAIL 84 /* 0x54 Same as (?!) */ +#define ACCEPT 85 /* 0x55 Accepts the current matched string. */ +#define VERB 86 /* 0x56 Used only for the type field of verbs */ +#define PRUNE 87 /* 0x57 Pattern fails at this startpoint if no-backtracking through this */ +#define MARKPOINT 88 /* 0x58 Push the current location for rollback by cut. */ +#define SKIP 89 /* 0x59 On failure skip forward (to the mark) before retrying */ +#define COMMIT 90 /* 0x5a Pattern fails outright if backtracking through this */ +#define CUTGROUP 91 /* 0x5b On failure go to the next alternation in the group */ +#define KEEPS 92 /* 0x5c $& begins here. */ +#define LNBREAK 93 /* 0x5d generic newline pattern */ +#define OPTIMIZED 94 /* 0x5e Placeholder for dump. */ +#define PSEUDO 95 /* 0x5f Pseudo opcode for internal use. */ /* ------------ States ------------- */ #define TRIE_next (REGNODE_MAX + 1) /* state for TRIE */ #define TRIE_next_fail (REGNODE_MAX + 2) /* state for TRIE */ @@ -192,29 +175,16 @@ EXTCONST U8 PL_regkind[] = { REG_ANY, /* SANY */ REG_ANY, /* CANY */ ANYOF, /* ANYOF */ - ANYOF, /* ANYOFV */ - ALNUM, /* ALNUM */ - ALNUM, /* ALNUML */ - ALNUM, /* ALNUMU */ - ALNUM, /* ALNUMA */ - NALNUM, /* NALNUM */ - NALNUM, /* NALNUML */ - NALNUM, /* NALNUMU */ - NALNUM, /* NALNUMA */ - SPACE, /* SPACE */ - SPACE, /* SPACEL */ - SPACE, /* SPACEU */ - SPACE, /* SPACEA */ - NSPACE, /* NSPACE */ - NSPACE, /* NSPACEL */ - NSPACE, /* NSPACEU */ - NSPACE, /* NSPACEA */ - DIGIT, /* DIGIT */ - DIGIT, /* DIGITL */ - DIGIT, /* DIGITA */ - NDIGIT, /* NDIGIT */ - NDIGIT, /* NDIGITL */ - NDIGIT, /* NDIGITA */ + ANYOF, /* ANYOF_WARN_SUPER */ + ANYOF, /* ANYOF_SYNTHETIC */ + POSIXD, /* POSIXD */ + POSIXD, /* POSIXL */ + POSIXD, /* POSIXU */ + POSIXD, /* POSIXA */ + NPOSIXD, /* NPOSIXD */ + NPOSIXD, /* NPOSIXL */ + NPOSIXD, /* NPOSIXU */ + NPOSIXD, /* NPOSIXA */ CLUMP, /* CLUMP */ BRANCH, /* BRANCH */ BACK, /* BACK */ @@ -222,9 +192,9 @@ EXTCONST U8 PL_regkind[] = { EXACT, /* EXACTF */ EXACT, /* EXACTFL */ EXACT, /* EXACTFU */ + EXACT, /* EXACTFA */ EXACT, /* EXACTFU_SS */ EXACT, /* EXACTFU_TRICKYFOLD */ - EXACT, /* EXACTFA */ NOTHING, /* NOTHING */ NOTHING, /* TAIL */ STAR, /* STAR */ @@ -277,10 +247,6 @@ EXTCONST U8 PL_regkind[] = { VERB, /* CUTGROUP */ KEEPS, /* KEEPS */ LNBREAK, /* LNBREAK */ - VERTWS, /* VERTWS */ - NVERTWS, /* NVERTWS */ - HORIZWS, /* HORIZWS */ - NHORIZWS, /* NHORIZWS */ NOTHING, /* OPTIMIZED */ PSEUDO, /* PSEUDO */ /* ------------ States ------------- */ @@ -353,29 +319,16 @@ static const U8 regarglen[] = { 0, /* SANY */ 0, /* CANY */ 0, /* ANYOF */ - 0, /* ANYOFV */ - 0, /* ALNUM */ - 0, /* ALNUML */ - 0, /* ALNUMU */ - 0, /* ALNUMA */ - 0, /* NALNUM */ - 0, /* NALNUML */ - 0, /* NALNUMU */ - 0, /* NALNUMA */ - 0, /* SPACE */ - 0, /* SPACEL */ - 0, /* SPACEU */ - 0, /* SPACEA */ - 0, /* NSPACE */ - 0, /* NSPACEL */ - 0, /* NSPACEU */ - 0, /* NSPACEA */ - 0, /* DIGIT */ - 0, /* DIGITL */ - 0, /* DIGITA */ - 0, /* NDIGIT */ - 0, /* NDIGITL */ - 0, /* NDIGITA */ + 0, /* ANYOF_WARN_SUPER */ + 0, /* ANYOF_SYNTHETIC */ + 0, /* POSIXD */ + 0, /* POSIXL */ + 0, /* POSIXU */ + 0, /* POSIXA */ + 0, /* NPOSIXD */ + 0, /* NPOSIXL */ + 0, /* NPOSIXU */ + 0, /* NPOSIXA */ 0, /* CLUMP */ 0, /* BRANCH */ 0, /* BACK */ @@ -383,9 +336,9 @@ static const U8 regarglen[] = { 0, /* EXACTF */ 0, /* EXACTFL */ 0, /* EXACTFU */ + 0, /* EXACTFA */ 0, /* EXACTFU_SS */ 0, /* EXACTFU_TRICKYFOLD */ - 0, /* EXACTFA */ 0, /* NOTHING */ 0, /* TAIL */ 0, /* STAR */ @@ -438,10 +391,6 @@ static const U8 regarglen[] = { EXTRA_SIZE(struct regnode_1), /* CUTGROUP */ 0, /* KEEPS */ 0, /* LNBREAK */ - 0, /* VERTWS */ - 0, /* NVERTWS */ - 0, /* HORIZWS */ - 0, /* NHORIZWS */ 0, /* OPTIMIZED */ 0, /* PSEUDO */ }; @@ -471,29 +420,16 @@ static const char reg_off_by_arg[] = { 0, /* SANY */ 0, /* CANY */ 0, /* ANYOF */ - 0, /* ANYOFV */ - 0, /* ALNUM */ - 0, /* ALNUML */ - 0, /* ALNUMU */ - 0, /* ALNUMA */ - 0, /* NALNUM */ - 0, /* NALNUML */ - 0, /* NALNUMU */ - 0, /* NALNUMA */ - 0, /* SPACE */ - 0, /* SPACEL */ - 0, /* SPACEU */ - 0, /* SPACEA */ - 0, /* NSPACE */ - 0, /* NSPACEL */ - 0, /* NSPACEU */ - 0, /* NSPACEA */ - 0, /* DIGIT */ - 0, /* DIGITL */ - 0, /* DIGITA */ - 0, /* NDIGIT */ - 0, /* NDIGITL */ - 0, /* NDIGITA */ + 0, /* ANYOF_WARN_SUPER */ + 0, /* ANYOF_SYNTHETIC */ + 0, /* POSIXD */ + 0, /* POSIXL */ + 0, /* POSIXU */ + 0, /* POSIXA */ + 0, /* NPOSIXD */ + 0, /* NPOSIXL */ + 0, /* NPOSIXU */ + 0, /* NPOSIXA */ 0, /* CLUMP */ 0, /* BRANCH */ 0, /* BACK */ @@ -501,9 +437,9 @@ static const char reg_off_by_arg[] = { 0, /* EXACTF */ 0, /* EXACTFL */ 0, /* EXACTFU */ + 0, /* EXACTFA */ 0, /* EXACTFU_SS */ 0, /* EXACTFU_TRICKYFOLD */ - 0, /* EXACTFA */ 0, /* NOTHING */ 0, /* TAIL */ 0, /* STAR */ @@ -556,10 +492,6 @@ static const char reg_off_by_arg[] = { 0, /* CUTGROUP */ 0, /* KEEPS */ 0, /* LNBREAK */ - 0, /* VERTWS */ - 0, /* NVERTWS */ - 0, /* HORIZWS */ - 0, /* NHORIZWS */ 0, /* OPTIMIZED */ 0, /* PSEUDO */ }; @@ -594,97 +526,80 @@ EXTCONST char * const PL_reg_name[] = { "SANY", /* 0x13 */ "CANY", /* 0x14 */ "ANYOF", /* 0x15 */ - "ANYOFV", /* 0x16 */ - "ALNUM", /* 0x17 */ - "ALNUML", /* 0x18 */ - "ALNUMU", /* 0x19 */ - "ALNUMA", /* 0x1a */ - "NALNUM", /* 0x1b */ - "NALNUML", /* 0x1c */ - "NALNUMU", /* 0x1d */ - "NALNUMA", /* 0x1e */ - "SPACE", /* 0x1f */ - "SPACEL", /* 0x20 */ - "SPACEU", /* 0x21 */ - "SPACEA", /* 0x22 */ - "NSPACE", /* 0x23 */ - "NSPACEL", /* 0x24 */ - "NSPACEU", /* 0x25 */ - "NSPACEA", /* 0x26 */ - "DIGIT", /* 0x27 */ - "DIGITL", /* 0x28 */ - "DIGITA", /* 0x29 */ - "NDIGIT", /* 0x2a */ - "NDIGITL", /* 0x2b */ - "NDIGITA", /* 0x2c */ - "CLUMP", /* 0x2d */ - "BRANCH", /* 0x2e */ - "BACK", /* 0x2f */ - "EXACT", /* 0x30 */ - "EXACTF", /* 0x31 */ - "EXACTFL", /* 0x32 */ - "EXACTFU", /* 0x33 */ - "EXACTFU_SS", /* 0x34 */ - "EXACTFU_TRICKYFOLD", /* 0x35 */ - "EXACTFA", /* 0x36 */ - "NOTHING", /* 0x37 */ - "TAIL", /* 0x38 */ - "STAR", /* 0x39 */ - "PLUS", /* 0x3a */ - "CURLY", /* 0x3b */ - "CURLYN", /* 0x3c */ - "CURLYM", /* 0x3d */ - "CURLYX", /* 0x3e */ - "WHILEM", /* 0x3f */ - "OPEN", /* 0x40 */ - "CLOSE", /* 0x41 */ - "REF", /* 0x42 */ - "REFF", /* 0x43 */ - "REFFL", /* 0x44 */ - "REFFU", /* 0x45 */ - "REFFA", /* 0x46 */ - "NREF", /* 0x47 */ - "NREFF", /* 0x48 */ - "NREFFL", /* 0x49 */ - "NREFFU", /* 0x4a */ - "NREFFA", /* 0x4b */ - "IFMATCH", /* 0x4c */ - "UNLESSM", /* 0x4d */ - "SUSPEND", /* 0x4e */ - "IFTHEN", /* 0x4f */ - "GROUPP", /* 0x50 */ - "LONGJMP", /* 0x51 */ - "BRANCHJ", /* 0x52 */ - "EVAL", /* 0x53 */ - "MINMOD", /* 0x54 */ - "LOGICAL", /* 0x55 */ - "RENUM", /* 0x56 */ - "TRIE", /* 0x57 */ - "TRIEC", /* 0x58 */ - "AHOCORASICK", /* 0x59 */ - "AHOCORASICKC", /* 0x5a */ - "GOSUB", /* 0x5b */ - "GOSTART", /* 0x5c */ - "NGROUPP", /* 0x5d */ - "INSUBP", /* 0x5e */ - "DEFINEP", /* 0x5f */ - "ENDLIKE", /* 0x60 */ - "OPFAIL", /* 0x61 */ - "ACCEPT", /* 0x62 */ - "VERB", /* 0x63 */ - "PRUNE", /* 0x64 */ - "MARKPOINT", /* 0x65 */ - "SKIP", /* 0x66 */ - "COMMIT", /* 0x67 */ - "CUTGROUP", /* 0x68 */ - "KEEPS", /* 0x69 */ - "LNBREAK", /* 0x6a */ - "VERTWS", /* 0x6b */ - "NVERTWS", /* 0x6c */ - "HORIZWS", /* 0x6d */ - "NHORIZWS", /* 0x6e */ - "OPTIMIZED", /* 0x6f */ - "PSEUDO", /* 0x70 */ + "ANYOF_WARN_SUPER", /* 0x16 */ + "ANYOF_SYNTHETIC", /* 0x17 */ + "POSIXD", /* 0x18 */ + "POSIXL", /* 0x19 */ + "POSIXU", /* 0x1a */ + "POSIXA", /* 0x1b */ + "NPOSIXD", /* 0x1c */ + "NPOSIXL", /* 0x1d */ + "NPOSIXU", /* 0x1e */ + "NPOSIXA", /* 0x1f */ + "CLUMP", /* 0x20 */ + "BRANCH", /* 0x21 */ + "BACK", /* 0x22 */ + "EXACT", /* 0x23 */ + "EXACTF", /* 0x24 */ + "EXACTFL", /* 0x25 */ + "EXACTFU", /* 0x26 */ + "EXACTFA", /* 0x27 */ + "EXACTFU_SS", /* 0x28 */ + "EXACTFU_TRICKYFOLD", /* 0x29 */ + "NOTHING", /* 0x2a */ + "TAIL", /* 0x2b */ + "STAR", /* 0x2c */ + "PLUS", /* 0x2d */ + "CURLY", /* 0x2e */ + "CURLYN", /* 0x2f */ + "CURLYM", /* 0x30 */ + "CURLYX", /* 0x31 */ + "WHILEM", /* 0x32 */ + "OPEN", /* 0x33 */ + "CLOSE", /* 0x34 */ + "REF", /* 0x35 */ + "REFF", /* 0x36 */ + "REFFL", /* 0x37 */ + "REFFU", /* 0x38 */ + "REFFA", /* 0x39 */ + "NREF", /* 0x3a */ + "NREFF", /* 0x3b */ + "NREFFL", /* 0x3c */ + "NREFFU", /* 0x3d */ + "NREFFA", /* 0x3e */ + "IFMATCH", /* 0x3f */ + "UNLESSM", /* 0x40 */ + "SUSPEND", /* 0x41 */ + "IFTHEN", /* 0x42 */ + "GROUPP", /* 0x43 */ + "LONGJMP", /* 0x44 */ + "BRANCHJ", /* 0x45 */ + "EVAL", /* 0x46 */ + "MINMOD", /* 0x47 */ + "LOGICAL", /* 0x48 */ + "RENUM", /* 0x49 */ + "TRIE", /* 0x4a */ + "TRIEC", /* 0x4b */ + "AHOCORASICK", /* 0x4c */ + "AHOCORASICKC", /* 0x4d */ + "GOSUB", /* 0x4e */ + "GOSTART", /* 0x4f */ + "NGROUPP", /* 0x50 */ + "INSUBP", /* 0x51 */ + "DEFINEP", /* 0x52 */ + "ENDLIKE", /* 0x53 */ + "OPFAIL", /* 0x54 */ + "ACCEPT", /* 0x55 */ + "VERB", /* 0x56 */ + "PRUNE", /* 0x57 */ + "MARKPOINT", /* 0x58 */ + "SKIP", /* 0x59 */ + "COMMIT", /* 0x5a */ + "CUTGROUP", /* 0x5b */ + "KEEPS", /* 0x5c */ + "LNBREAK", /* 0x5d */ + "OPTIMIZED", /* 0x5e */ + "PSEUDO", /* 0x5f */ /* ------------ States ------------- */ "TRIE_next", /* REGNODE_MAX +0x01 */ "TRIE_next_fail", /* REGNODE_MAX +0x02 */ @@ -735,23 +650,23 @@ EXTCONST char * const PL_reg_name[] = { EXTCONST char * PL_reg_extflags_name[]; #else EXTCONST char * const PL_reg_extflags_name[] = { - /* Bits in extflags defined: 11111111111111111111111011111111 */ + /* Bits in extflags defined: 11111110111111111111111111111111 */ "MULTILINE", /* 0x00000001 */ "SINGLELINE", /* 0x00000002 */ "FOLD", /* 0x00000004 */ "EXTENDED", /* 0x00000008 */ "KEEPCOPY", /* 0x00000010 */ - "CHARSET", /* 0x000000e0 */ - "CHARSET", /* 0x000000e0 */ - "CHARSET", /* 0x000000e0 */ - "UNUSED_BIT_8", /* 0x00000100 */ + "CHARSET0", /* 0x00000020 : "CHARSET" - 0x000000e0 */ + "CHARSET1", /* 0x00000040 : "CHARSET" - 0x000000e0 */ + "CHARSET2", /* 0x00000080 : "CHARSET" - 0x000000e0 */ + "SPLIT", /* 0x00000100 */ "ANCH_BOL", /* 0x00000200 */ "ANCH_MBOL", /* 0x00000400 */ "ANCH_SBOL", /* 0x00000800 */ "ANCH_GPOS", /* 0x00001000 */ "GPOS_SEEN", /* 0x00002000 */ "GPOS_FLOAT", /* 0x00004000 */ - "LOOKBEHIND_SEEN", /* 0x00008000 */ + "NO_INPLACE_SUBST", /* 0x00008000 */ "EVAL_SEEN", /* 0x00010000 */ "CANY_SEEN", /* 0x00020000 */ "NOSCAN", /* 0x00040000 */ @@ -760,7 +675,7 @@ EXTCONST char * const PL_reg_extflags_name[] = { "USE_INTUIT_NOML", /* 0x00200000 */ "USE_INTUIT_ML", /* 0x00400000 */ "INTUIT_TAIL", /* 0x00800000 */ - "SPLIT", /* 0x01000000 */ + "UNUSED_BIT_24", /* 0x01000000 */ "COPY_DONE", /* 0x02000000 */ "TAINTED_SEEN", /* 0x04000000 */ "TAINTED", /* 0x08000000 */ @@ -778,9 +693,9 @@ EXTCONST char * const PL_reg_extflags_name[] = { EXTCONST U8 PL_varies[] __attribute__deprecated__; #else EXTCONST U8 PL_varies[] __attribute__deprecated__ = { - ANYOFV, CLUMP, BRANCH, BACK, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, - WHILEM, REF, REFF, REFFL, REFFU, REFFA, NREF, NREFF, NREFFL, NREFFU, - NREFFA, SUSPEND, IFTHEN, BRANCHJ, + CLUMP, BRANCH, BACK, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, WHILEM, + REF, REFF, REFFL, REFFU, REFFA, NREF, NREFF, NREFFL, NREFFU, NREFFA, + SUSPEND, IFTHEN, BRANCHJ, 0 }; #endif /* DOINIT */ @@ -789,7 +704,7 @@ EXTCONST U8 PL_varies[] __attribute__deprecated__ = { EXTCONST U8 PL_varies_bitmask[]; #else EXTCONST U8 PL_varies_bitmask[] = { - 0x00, 0x00, 0x40, 0x00, 0x00, 0xE0, 0x00, 0xFE, 0xFC, 0xCF, 0x04, 0x00, 0x00, 0x00, 0x00 + 0x00, 0x00, 0x00, 0x00, 0x07, 0xF0, 0xE7, 0x7F, 0x26, 0x00, 0x00, 0x00 }; #endif /* DOINIT */ @@ -801,10 +716,8 @@ EXTCONST U8 PL_varies_bitmask[] = { EXTCONST U8 PL_simple[] __attribute__deprecated__; #else EXTCONST U8 PL_simple[] __attribute__deprecated__ = { - REG_ANY, SANY, CANY, ANYOF, ALNUM, ALNUML, ALNUMU, ALNUMA, NALNUM, - NALNUML, NALNUMU, NALNUMA, SPACE, SPACEL, SPACEU, SPACEA, NSPACE, - NSPACEL, NSPACEU, NSPACEA, DIGIT, DIGITL, DIGITA, NDIGIT, NDIGITL, - NDIGITA, VERTWS, NVERTWS, HORIZWS, NHORIZWS, + REG_ANY, SANY, CANY, ANYOF, ANYOF_WARN_SUPER, ANYOF_SYNTHETIC, POSIXD, + POSIXL, POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA, 0 }; #endif /* DOINIT */ @@ -813,7 +726,7 @@ EXTCONST U8 PL_simple[] __attribute__deprecated__ = { EXTCONST U8 PL_simple_bitmask[]; #else EXTCONST U8 PL_simple_bitmask[] = { - 0x00, 0x00, 0xBC, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00 + 0x00, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; #endif /* DOINIT */ diff --git a/Master/tlpkg/tlperl/lib/CORE/scope.h b/Master/tlpkg/tlperl/lib/CORE/scope.h index 38da244169f..22c728d1be2 100644 --- a/Master/tlpkg/tlperl/lib/CORE/scope.h +++ b/Master/tlpkg/tlperl/lib/CORE/scope.h @@ -8,56 +8,77 @@ * */ -#define SAVEt_ITEM 0 -#define SAVEt_SV 1 -#define SAVEt_AV 2 -#define SAVEt_HV 3 -#define SAVEt_INT 4 -#define SAVEt_LONG 5 -#define SAVEt_I32 6 -#define SAVEt_IV 7 -#define SAVEt_SPTR 8 -#define SAVEt_APTR 9 -#define SAVEt_HPTR 10 -#define SAVEt_PPTR 11 -#define SAVEt_NSTAB 12 -#define SAVEt_SVREF 13 -#define SAVEt_GP 14 -#define SAVEt_FREESV 15 -#define SAVEt_FREEOP 16 -#define SAVEt_FREEPV 17 -#define SAVEt_CLEARSV 18 -#define SAVEt_DELETE 19 -#define SAVEt_DESTRUCTOR 20 -#define SAVEt_REGCONTEXT 21 -#define SAVEt_STACK_POS 22 -#define SAVEt_I16 23 -#define SAVEt_AELEM 24 -#define SAVEt_HELEM 25 -#define SAVEt_OP 26 -#define SAVEt_HINTS 27 -#define SAVEt_ALLOC 28 -#define SAVEt_GENERIC_SVREF 29 -#define SAVEt_DESTRUCTOR_X 30 -#define SAVEt_VPTR 31 -#define SAVEt_I8 32 -#define SAVEt_COMPPAD 33 -#define SAVEt_GENERIC_PVREF 34 -#define SAVEt_PADSV_AND_MORTALIZE 35 -#define SAVEt_MORTALIZESV 36 -#define SAVEt_SHARED_PVREF 37 -#define SAVEt_BOOL 38 -#define SAVEt_SET_SVFLAGS 39 -#define SAVEt_SAVESWITCHSTACK 40 -#define SAVEt_RE_STATE 42 -#define SAVEt_COMPILE_WARNINGS 43 -#define SAVEt_STACK_CXPOS 44 -#define SAVEt_PARSER 45 -#define SAVEt_ADELETE 46 -#define SAVEt_I32_SMALL 47 -#define SAVEt_INT_SMALL 48 -#define SAVEt_GVSV 49 -#define SAVEt_FREECOPHH 50 +/* *** these are ordered by number of of auto-popped args */ + +/* zero args */ + +#define SAVEt_ALLOC 0 +#define SAVEt_CLEARPADRANGE 1 +#define SAVEt_CLEARSV 2 +#define SAVEt_REGCONTEXT 3 +#define SAVEt_RE_STATE 4 + +#define SAVEt_ARG0_MAX 4 + +/* one arg */ + +#define SAVEt_BOOL 5 +#define SAVEt_COMPILE_WARNINGS 6 +#define SAVEt_COMPPAD 7 +#define SAVEt_FREECOPHH 8 +#define SAVEt_FREEOP 9 +#define SAVEt_FREEPV 10 +#define SAVEt_FREESV 11 +#define SAVEt_I16 12 +#define SAVEt_I32_SMALL 13 +#define SAVEt_I8 14 +#define SAVEt_INT_SMALL 15 +#define SAVEt_MORTALIZESV 16 +#define SAVEt_NSTAB 17 +#define SAVEt_OP 18 +#define SAVEt_PARSER 19 +#define SAVEt_STACK_POS 20 + +#define SAVEt_ARG1_MAX 20 + +/* two args */ + +#define SAVEt_ADELETE 21 +#define SAVEt_APTR 22 +#define SAVEt_AV 23 +#define SAVEt_DESTRUCTOR 24 +#define SAVEt_DESTRUCTOR_X 25 +#define SAVEt_GENERIC_PVREF 26 +#define SAVEt_GENERIC_SVREF 27 +#define SAVEt_GP 28 +#define SAVEt_GVSV 29 +#define SAVEt_HINTS 30 +#define SAVEt_HPTR 31 +#define SAVEt_HV 32 +#define SAVEt_I32 33 +#define SAVEt_INT 34 +#define SAVEt_ITEM 35 +#define SAVEt_IV 36 +#define SAVEt_LONG 37 +#define SAVEt_PPTR 38 +#define SAVEt_SAVESWITCHSTACK 39 +#define SAVEt_SHARED_PVREF 40 +#define SAVEt_SPTR 41 +#define SAVEt_STACK_CXPOS 42 +#define SAVEt_SV 43 +#define SAVEt_SVREF 44 +#define SAVEt_VPTR 45 + +#define SAVEt_ARG2_MAX 45 + +/* three args */ + +#define SAVEt_AELEM 46 +#define SAVEt_DELETE 47 +#define SAVEt_HELEM 48 +#define SAVEt_PADSV_AND_MORTALIZE 49 +#define SAVEt_SET_SVFLAGS 50 +#define SAVEt_GVSLOT 51 #define SAVEf_SETMAGIC 1 #define SAVEf_KEEPOLDELEM 2 @@ -72,8 +93,12 @@ #define SCOPE_SAVES_SIGNAL_MASK 0 #endif -#define SSCHECK(need) if (PL_savestack_ix + (I32)(need) > PL_savestack_max) savestack_grow() -#define SSGROW(need) if (PL_savestack_ix + (I32)(need) > PL_savestack_max) savestack_grow_cnt(need) +/* the maximum number of entries that might be pushed using the SS_ADD* + * macros */ +#define SS_MAXPUSH 4 + +#define SSCHECK(need) if (PL_savestack_ix + (I32)(need) + SS_MAXPUSH > PL_savestack_max) savestack_grow() +#define SSGROW(need) if (PL_savestack_ix + (I32)(need) + SS_MAXPUSH > PL_savestack_max) savestack_grow_cnt(need + SS_MAXPUSH) #define SSPUSHINT(i) (PL_savestack[PL_savestack_ix++].any_i32 = (I32)(i)) #define SSPUSHLONG(i) (PL_savestack[PL_savestack_ix++].any_long = (long)(i)) #define SSPUSHBOOL(p) (PL_savestack[PL_savestack_ix++].any_bool = (p)) @@ -82,6 +107,40 @@ #define SSPUSHPTR(p) (PL_savestack[PL_savestack_ix++].any_ptr = (void*)(p)) #define SSPUSHDPTR(p) (PL_savestack[PL_savestack_ix++].any_dptr = (p)) #define SSPUSHDXPTR(p) (PL_savestack[PL_savestack_ix++].any_dxptr = (p)) + +/* SS_ADD*: newer, faster versions of the above. Don't mix the two sets of + * macros. These are fast because they save reduce accesses to the PL_ + * vars and move the size check to the end. Doing the check last means + * that values in registers will have been pushed and no longer needed, so + * don't need saving around the call to grow. Also, tail-call elimination + * of the grow() can be done. These changes reduce the code of something + * like save_pushptrptr() to half its former size. + * Of course, doing the size check *after* pushing means we must always + * ensure there are SS_MAXPUSH free slots on the savestack + * + * These are for internal core use only and are subject to change */ + +#define dSS_ADD \ + I32 ix = PL_savestack_ix; \ + ANY *ssp = &PL_savestack[ix]; + +#define SS_ADD_END(need) \ + assert((need) <= SS_MAXPUSH); \ + ix += (need); \ + PL_savestack_ix = ix; \ + assert(ix <= PL_savestack_max); \ + if ((ix + SS_MAXPUSH) > PL_savestack_max) savestack_grow(); \ + assert(PL_savestack_ix + SS_MAXPUSH <= PL_savestack_max); + +#define SS_ADD_INT(i) ((ssp++)->any_i32 = (I32)(i)) +#define SS_ADD_LONG(i) ((ssp++)->any_long = (long)(i)) +#define SS_ADD_BOOL(p) ((ssp++)->any_bool = (p)) +#define SS_ADD_IV(i) ((ssp++)->any_iv = (IV)(i)) +#define SS_ADD_UV(u) ((ssp++)->any_uv = (UV)(u)) +#define SS_ADD_PTR(p) ((ssp++)->any_ptr = (void*)(p)) +#define SS_ADD_DPTR(p) ((ssp++)->any_dptr = (p)) +#define SS_ADD_DXPTR(p) ((ssp++)->any_dxptr = (p)) + #define SSPOPINT (PL_savestack[--PL_savestack_ix].any_i32) #define SSPOPLONG (PL_savestack[--PL_savestack_ix].any_long) #define SSPOPBOOL (PL_savestack[--PL_savestack_ix].any_bool) @@ -91,6 +150,7 @@ #define SSPOPDPTR (PL_savestack[--PL_savestack_ix].any_dptr) #define SSPOPDXPTR (PL_savestack[--PL_savestack_ix].any_dxptr) + /* =head1 Callback Functions @@ -162,7 +222,9 @@ scope has the given name. Name must be a literal string. #define ENTER_with_name(name) ENTER #define LEAVE_with_name(name) LEAVE #endif -#define LEAVE_SCOPE(old) if (PL_savestack_ix > old) leave_scope(old) +#define LEAVE_SCOPE(old) STMT_START { \ + if (PL_savestack_ix > old) leave_scope(old); \ + } STMT_END #define SAVEI8(i) save_I8((I8*)&(i)) #define SAVEI16(i) save_I16((I16*)&(i)) @@ -198,10 +260,11 @@ scope has the given name. Name must be a literal string. save_destructor_x((DESTRUCTORFUNC_t)(f), (void*)(p)) #define SAVESTACK_POS() \ - STMT_START { \ - SSCHECK(2); \ - SSPUSHINT(PL_stack_sp - PL_stack_base); \ - SSPUSHUV(SAVEt_STACK_POS); \ + STMT_START { \ + dSS_ADD; \ + SS_ADD_INT(PL_stack_sp - PL_stack_base); \ + SS_ADD_UV(SAVEt_STACK_POS); \ + SS_ADD_END(2); \ } STMT_END #define SAVEOP() save_op() @@ -225,25 +288,23 @@ scope has the given name. Name must be a literal string. #define SAVECOMPILEWARNINGS() save_pushptr(PL_compiling.cop_warnings, SAVEt_COMPILE_WARNINGS) #define SAVESTACK_CXPOS() \ - STMT_START { \ - SSCHECK(3); \ - SSPUSHINT(cxstack[cxstack_ix].blk_oldsp); \ - SSPUSHINT(cxstack_ix); \ - SSPUSHUV(SAVEt_STACK_CXPOS); \ + STMT_START { \ + dSS_ADD; \ + SS_ADD_INT(cxstack[cxstack_ix].blk_oldsp); \ + SS_ADD_INT(cxstack_ix); \ + SS_ADD_UV(SAVEt_STACK_CXPOS); \ + SS_ADD_END(3); \ } STMT_END #define SAVEPARSER(p) save_pushptr((p), SAVEt_PARSER) #ifdef USE_ITHREADS -# define SAVECOPSTASH(c) (SAVEPPTR(CopSTASHPV(c)), \ - SAVEI32(CopSTASH_len(c))) -# define SAVECOPSTASH_FREE(c) (SAVESHAREDPV(CopSTASHPV(c)), \ - SAVEI32(CopSTASH_len(c))) +# define SAVECOPSTASH_FREE(c) SAVEIV((c)->cop_stashoff) # define SAVECOPFILE(c) SAVEPPTR(CopFILE(c)) # define SAVECOPFILE_FREE(c) SAVESHAREDPV(CopFILE(c)) #else -# define SAVECOPSTASH(c) SAVESPTR(CopSTASH(c)) -# define SAVECOPSTASH_FREE(c) SAVECOPSTASH(c) /* XXX not refcounted */ +# /* XXX not refcounted */ +# define SAVECOPSTASH_FREE(c) SAVESPTR(CopSTASH(c)) # define SAVECOPFILE(c) SAVESPTR(CopFILEGV(c)) # define SAVECOPFILE_FREE(c) SAVEGENERICSV(CopFILEGV(c)) #endif @@ -272,7 +333,14 @@ scope has the given name. Name must be a literal string. #define save_freesv(op) save_pushptr((void *)(op), SAVEt_FREESV) #define save_mortalizesv(op) save_pushptr((void *)(op), SAVEt_MORTALIZESV) -#define save_freeop(op) save_pushptr((void *)(op), SAVEt_FREEOP) + +# define save_freeop(op) \ +STMT_START { \ + OP * const _o = (OP *)(op); \ + assert(!_o->op_savefree); \ + _o->op_savefree = 1; \ + save_pushptr((void *)(_o), SAVEt_FREEOP); \ + } STMT_END #define save_freepv(pv) save_pushptr((void *)(pv), SAVEt_FREEPV) #define save_op() save_pushptr((void *)(PL_op), SAVEt_OP) @@ -280,8 +348,8 @@ scope has the given name. Name must be a literal string. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/sv.h b/Master/tlpkg/tlperl/lib/CORE/sv.h index 7f79c016479..984121fa83d 100644 --- a/Master/tlpkg/tlperl/lib/CORE/sv.h +++ b/Master/tlpkg/tlperl/lib/CORE/sv.h @@ -19,26 +19,101 @@ An enum of flags for Perl types. These are found in the file B<sv.h> in the C<svtype> enum. Test these flags with the C<SvTYPE> macro. -=for apidoc AmU||SVt_PV -Pointer type flag for scalars. See C<svtype>. +The types are: + + SVt_NULL + SVt_BIND (unused) + SVt_IV + SVt_NV + SVt_RV + SVt_PV + SVt_PVIV + SVt_PVNV + SVt_PVMG + SVt_REGEXP + SVt_PVGV + SVt_PVLV + SVt_PVAV + SVt_PVHV + SVt_PVCV + SVt_PVFM + SVt_PVIO + +These are most easily explained from the bottom up. + +SVt_PVIO is for I/O objects, SVt_PVFM for formats, SVt_PVCV for +subroutines, SVt_PVHV for hashes and SVt_PVAV for arrays. + +All the others are scalar types, that is, things that can be bound to a +C<$> variable. For these, the internal types are mostly orthogonal to +types in the Perl language. + +Hence, checking C<< SvTYPE(sv) < SVt_PVAV >> is the best way to see whether +something is a scalar. + +SVt_PVGV represents a typeglob. If !SvFAKE(sv), then it is a real, +incoercible typeglob. If SvFAKE(sv), then it is a scalar to which a +typeglob has been assigned. Assigning to it again will stop it from being +a typeglob. SVt_PVLV represents a scalar that delegates to another scalar +behind the scenes. It is used, e.g., for the return value of C<substr> and +for tied hash and array elements. It can hold any scalar value, including +a typeglob. SVt_REGEXP is for regular expressions. + +SVt_PVMG represents a "normal" scalar (not a typeglob, regular expression, +or delegate). Since most scalars do not need all the internal fields of a +PVMG, we save memory by allocating smaller structs when possible. All the +other types are just simpler forms of SVt_PVMG, with fewer internal fields. + SVt_NULL can only hold undef. SVt_IV can hold undef, an integer, or a +reference. (SVt_RV is an alias for SVt_IV, which exists for backward +compatibility.) SVt_NV can hold any of those or a double. SVt_PV can only +hold undef or a string. SVt_PVIV is a superset of SVt_PV and SVt_IV. +SVt_PVNV is similar. SVt_PVMG can hold anything SVt_PVNV can hold, but it +can, but does not have to, be blessed or magical. + +=for apidoc AmU||SVt_NULL +Type flag for scalars. See L</svtype>. =for apidoc AmU||SVt_IV -Integer type flag for scalars. See C<svtype>. +Type flag for scalars. See L</svtype>. =for apidoc AmU||SVt_NV -Double type flag for scalars. See C<svtype>. +Type flag for scalars. See L</svtype>. + +=for apidoc AmU||SVt_PV +Type flag for scalars. See L</svtype>. + +=for apidoc AmU||SVt_PVIV +Type flag for scalars. See L</svtype>. + +=for apidoc AmU||SVt_PVNV +Type flag for scalars. See L</svtype>. =for apidoc AmU||SVt_PVMG -Type flag for blessed scalars. See C<svtype>. +Type flag for scalars. See L</svtype>. + +=for apidoc AmU||SVt_REGEXP +Type flag for regular expressions. See L</svtype>. + +=for apidoc AmU||SVt_PVGV +Type flag for typeglobs. See L</svtype>. + +=for apidoc AmU||SVt_PVLV +Type flag for scalars. See L</svtype>. =for apidoc AmU||SVt_PVAV -Type flag for arrays. See C<svtype>. +Type flag for arrays. See L</svtype>. =for apidoc AmU||SVt_PVHV -Type flag for hashes. See C<svtype>. +Type flag for hashes. See L</svtype>. =for apidoc AmU||SVt_PVCV -Type flag for code refs. See C<svtype>. +Type flag for subroutines. See L</svtype>. + +=for apidoc AmU||SVt_PVFM +Type flag for formats. See L</svtype>. + +=for apidoc AmU||SVt_PVIO +Type flag for I/O objects. See L</svtype>. =cut */ @@ -108,6 +183,7 @@ typedef struct hek HEK; IV svu_iv; \ UV svu_uv; \ SV* svu_rv; /* pointer to another SV */ \ + struct regexp* svu_rx; \ SV** svu_array; \ HE** svu_hash; \ GP* svu_gp; \ @@ -168,7 +244,7 @@ struct p5rx { Returns the value of the object's reference count. =for apidoc Am|SV*|SvREFCNT_inc|SV* sv -Increments the reference count of the given SV. +Increments the reference count of the given SV, returning the SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. @@ -208,7 +284,12 @@ to return a meaningful value, or check for NULLness, so it's smaller and faster. =for apidoc Am|void|SvREFCNT_dec|SV* sv -Decrements the reference count of the given SV. +Decrements the reference count of the given SV. I<sv> may be NULL. + +=for apidoc Am|void|SvREFCNT_dec_NN|SV* sv +Same as SvREFCNT_dec, but can only be used if you know I<sv> +is not NULL. Since we don't have to check the NULLness, it's faster +and smaller. =for apidoc Am|svtype|SvTYPE|SV* sv Returns the type of the SV. See C<svtype>. @@ -224,42 +305,10 @@ perform the upgrade if necessary. See C<svtype>. #define SvFLAGS(sv) (sv)->sv_flags #define SvREFCNT(sv) (sv)->sv_refcnt -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define SvREFCNT_inc(sv) \ - ({ \ - SV * const _sv = MUTABLE_SV(sv); \ - if (_sv) \ - (SvREFCNT(_sv))++; \ - _sv; \ - }) -# define SvREFCNT_inc_simple(sv) \ - ({ \ - if (sv) \ - (SvREFCNT(sv))++; \ - MUTABLE_SV(sv); \ - }) -# define SvREFCNT_inc_NN(sv) \ - ({ \ - SV * const _sv = MUTABLE_SV(sv); \ - SvREFCNT(_sv)++; \ - _sv; \ - }) -# define SvREFCNT_inc_void(sv) \ - ({ \ - SV * const _sv = MUTABLE_SV(sv); \ - if (_sv) \ - (void)(SvREFCNT(_sv)++); \ - }) -#else -# define SvREFCNT_inc(sv) \ - ((PL_Sv=MUTABLE_SV(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) -# define SvREFCNT_inc_simple(sv) \ - ((sv) ? (SvREFCNT(sv)++,MUTABLE_SV(sv)) : NULL) -# define SvREFCNT_inc_NN(sv) \ - (PL_Sv=MUTABLE_SV(sv),++(SvREFCNT(PL_Sv)),PL_Sv) -# define SvREFCNT_inc_void(sv) \ - (void)((PL_Sv=MUTABLE_SV(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) -#endif +#define SvREFCNT_inc(sv) S_SvREFCNT_inc(MUTABLE_SV(sv)) +#define SvREFCNT_inc_simple(sv) SvREFCNT_inc(sv) +#define SvREFCNT_inc_NN(sv) S_SvREFCNT_inc_NN(MUTABLE_SV(sv)) +#define SvREFCNT_inc_void(sv) S_SvREFCNT_inc_void(MUTABLE_SV(sv)) /* These guys don't need the curly blocks */ #define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END @@ -267,22 +316,8 @@ perform the upgrade if necessary. See C<svtype>. #define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) #define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define SvREFCNT_dec(sv) \ - ({ \ - SV * const _sv = MUTABLE_SV(sv); \ - if (_sv) { \ - if (SvREFCNT(_sv)) { \ - if (--(SvREFCNT(_sv)) == 0) \ - Perl_sv_free2(aTHX_ _sv); \ - } else { \ - sv_free(_sv); \ - } \ - } \ - }) -#else -#define SvREFCNT_dec(sv) sv_free(MUTABLE_SV(sv)) -#endif +#define SvREFCNT_dec(sv) S_SvREFCNT_dec(aTHX_ MUTABLE_SV(sv)) +#define SvREFCNT_dec_NN(sv) S_SvREFCNT_dec_NN(aTHX_ MUTABLE_SV(sv)) #define SVTYPEMASK 0xff #define SvTYPE(sv) ((svtype)((sv)->sv_flags & SVTYPEMASK)) @@ -292,7 +327,10 @@ perform the upgrade if necessary. See C<svtype>. them all by using a consistent macro. */ #define SvIS_FREED(sv) ((sv)->sv_flags == SVTYPEMASK) -#define SvUPGRADE(sv, mt) (SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt), 1)) +/* this is defined in this peculiar way to avoid compiler warnings. + * See the <20121213131428.GD1842@iabyn.com> thread in p5p */ +#define SvUPGRADE(sv, mt) \ + ((void)(SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt),1))) #define SVf_IOK 0x00000100 /* has valid public integer value */ #define SVf_NOK 0x00000200 /* has valid public numeric value */ @@ -302,14 +340,15 @@ perform the upgrade if necessary. See C<svtype>. #define SVp_IOK 0x00001000 /* has valid non-public integer value */ #define SVp_NOK 0x00002000 /* has valid non-public numeric value */ #define SVp_POK 0x00004000 /* has valid non-public pointer value */ -#define SVp_SCREAM 0x00008000 /* has been studied? */ +#define SVp_SCREAM 0x00008000 /* method name is DOES */ #define SVphv_CLONEABLE SVp_SCREAM /* PVHV (stashes) clone its objects */ #define SVpgv_GP SVp_SCREAM /* GV has a valid GP */ #define SVprv_PCS_IMPORTED SVp_SCREAM /* RV is a proxy for a constant subroutine in another package. Set the - CvIMPORTED_CV_ON() if it needs to be + GvIMPORTED_CV_on() if it needs to be expanded to a real GV */ -/* 0x00010000 *** FREE SLOT */ +#define SVf_IsCOW 0x00010000 /* copy on write (shared hash key if + SvLEN == 0) */ #define SVs_PADTMP 0x00020000 /* in use as tmp; only if ! SVs_PADMY */ #define SVs_PADSTALE 0x00020000 /* lexical has gone out of scope; only valid for SVs_PADMY */ @@ -324,18 +363,12 @@ perform the upgrade if necessary. See C<svtype>. #define SVf_FAKE 0x01000000 /* 0: glob is just a copy 1: SV head arena wasn't malloc()ed - 2: in conjunction with SVf_READONLY - marks a shared hash key scalar - (SvLEN == 0) or a copy on write - string (SvLEN != 0) [SvIsCOW(sv)] - 3: For PVCV, whether CvUNIQUE(cv) + 2: For PVCV, whether CvUNIQUE(cv) refers to an eval or once only [CvEVAL(cv), CvSPECIAL(cv)] - 4: On a pad name SV, that slot in the + 3: On a pad name SV, that slot in the frame AV is a REFCNT'ed reference to a lexical from "outside". */ -#define SVphv_REHASH SVf_FAKE /* 5: On a PVHV, hash values are being - recalculated */ #define SVf_OOK 0x02000000 /* has valid offset value. For a PVHV this means that a hv_aux struct is present after the main array */ @@ -348,7 +381,7 @@ perform the upgrade if necessary. See C<svtype>. -#define SVf_THINKFIRST (SVf_READONLY|SVf_ROK|SVf_FAKE) +#define SVf_THINKFIRST (SVf_READONLY|SVf_ROK|SVf_FAKE|SVs_RMG|SVf_IsCOW) #define SVf_OK (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \ SVp_IOK|SVp_NOK|SVp_POK|SVpgv_GP) @@ -378,7 +411,7 @@ perform the upgrade if necessary. See C<svtype>. SVf_POK, SVp_POK also set: 0x00004400 Normal - 0x0000C400 Studied (SvSCREAM) + 0x0000C400 method name for DOES (SvSCREAM) 0x40004400 FBM compiled (SvVALID) 0x4000C400 pad name. @@ -416,7 +449,12 @@ perform the upgrade if necessary. See C<svtype>. HV* xmg_stash; /* class package */ \ union _xmgu xmg_u; \ STRLEN xpv_cur; /* length of svu_pv as a C string */ \ - STRLEN xpv_len /* allocated size */ + union { \ + STRLEN xpvlenu_len; /* allocated size */ \ + char * xpvlenu_pv; /* regexp string */ \ + } xpv_len_u + +#define xpv_len xpv_len_u.xpvlenu_len union _xnvu { NV xnv_nv; /* numeric value, if any */ @@ -494,8 +532,6 @@ struct xpvgv { union _xnvu xnv_u; }; -/* This structure must match XPVCV in cv.h */ - typedef U16 cv_flags_t; #define _XPVCV_COMMON \ @@ -508,19 +544,24 @@ typedef U16 cv_flags_t; OP * xcv_root; \ void (*xcv_xsub) (pTHX_ CV*); \ } xcv_root_u; \ - GV * xcv_gv; \ + union { \ + GV * xcv_gv; \ + HEK * xcv_hek; \ + } xcv_gv_u; \ char * xcv_file; \ - AV * xcv_padlist; \ + PADLIST * xcv_padlist; \ CV * xcv_outside; \ U32 xcv_outside_seq; /* the COP sequence (at the point of our \ * compilation) in the lexically enclosing \ * sub */ \ - cv_flags_t xcv_flags + cv_flags_t xcv_flags; \ + I32 xcv_depth /* >= 2 indicates recursive call */ + +/* This structure must match XPVCV in cv.h */ struct xpvfm { _XPV_HEAD; _XPVCV_COMMON; - IV xfm_lines; }; @@ -611,13 +652,17 @@ Unsets the IV status of an SV. Tells an SV that it is an integer and disables all other OK bits. =for apidoc Am|void|SvIOK_only_UV|SV* sv -Tells and SV that it is an unsigned integer and disables all other OK bits. +Tells an SV that it is an unsigned integer and disables all other OK bits. =for apidoc Am|bool|SvIOK_UV|SV* sv -Returns a boolean indicating whether the SV contains an unsigned integer. +Returns a boolean indicating whether the SV contains an integer that must be +interpreted as unsigned. A non-negative integer whose value is within the +range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. =for apidoc Am|bool|SvUOK|SV* sv -Returns a boolean indicating whether the SV contains an unsigned integer. +Returns a boolean indicating whether the SV contains an integer that must be +interpreted as unsigned. A non-negative integer whose value is within the +range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. =for apidoc Am|bool|SvIOK_notUV|SV* sv Returns a boolean indicating whether the SV contains a signed integer. @@ -685,7 +730,8 @@ Only use when you are sure SvNOK is true. See also C<SvNV()>. =for apidoc Am|char*|SvPVX|SV* sv Returns a pointer to the physical string in the SV. The SV must contain a -string. +string. Prior to 5.9.3 it is not safe to execute this macro unless the SV's +type >= SVt_PV. This is also used to store the name of an autoloaded subroutine in an XS AUTOLOAD routine. See L<perlguts/Autoloading with XSUBs>. @@ -719,7 +765,12 @@ C<SvIV_set> instead of the lvalue assignment to C<SvIVX>. Set the value of the NV pointer in sv to val. See C<SvIV_set>. =for apidoc Am|void|SvPV_set|SV* sv|char* val -Set the value of the PV pointer in sv to val. See C<SvIV_set>. +Set the value of the PV pointer in sv to val. See also C<SvIV_set>. + +Beware that the existing pointer may be involved in copy-on-write or other +mischief, so do C<SvOOK_off(sv)> and use C<sv_force_normal> or +C<SvPV_force> (or check the SvIsCOW flag) first to make sure this +modification is safe. =for apidoc Am|void|SvUV_set|SV* sv|UV val Set the value of the UV pointer in sv to val. See C<SvIV_set>. @@ -748,17 +799,10 @@ Set the actual length of the string which is in the SV. See C<SvIV_set>. #define SvNIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \ SVp_IOK|SVp_NOK|SVf_IVisUV)) -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -#define assert_not_ROK(sv) ({assert(!SvROK(sv) || !SvRV(sv));}), -#define assert_not_glob(sv) ({assert(!isGV_with_GP(sv));}), -#else -#define assert_not_ROK(sv) -#define assert_not_glob(sv) -#endif +#define assert_not_ROK(sv) assert_(!SvROK(sv) || !SvRV(sv)) +#define assert_not_glob(sv) assert_(!isGV_with_GP(sv)) -#define SvOK(sv) ((SvTYPE(sv) == SVt_BIND) \ - ? (SvFLAGS(SvRV(sv)) & SVf_OK) \ - : (SvFLAGS(sv) & SVf_OK)) +#define SvOK(sv) (SvFLAGS(sv) & SVf_OK || isREGEXP(sv)) #define SvOK_off(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV|SVf_UTF8), \ @@ -808,8 +852,8 @@ Set the actual length of the string which is in the SV. See C<SvIV_set>. =for apidoc Am|U32|SvUTF8|SV* sv Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up properly, this indicates whether or not the SV contains UTF-8 encoded data. -Call this after SvPV() in case any call to string overloading updates the -internal flag. +You should use this I<after> a call to SvPV() or one of its variants, in +case any call to string overloading updates the internal flag. =for apidoc Am|void|SvUTF8_on|SV *sv Turn on the UTF-8 status of an SV (the data is not changed, just the flag). @@ -879,21 +923,39 @@ in gv.h: */ #define SvRMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_RMG) #define SvRMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_RMG) -#define SvAMAGIC(sv) (SvROK(sv) && (SvFLAGS(SvRV(sv)) & SVf_AMAGIC)) -#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define SvAMAGIC_on(sv) ({ SV * const kloink = sv; \ - assert(SvROK(kloink)); \ - SvFLAGS(SvRV(kloink)) |= SVf_AMAGIC; \ - }) -# define SvAMAGIC_off(sv) ({ SV * const kloink = sv; \ - if(SvROK(kloink)) \ - SvFLAGS(SvRV(kloink)) &= ~SVf_AMAGIC;\ - }) -#else -# define SvAMAGIC_on(sv) (SvFLAGS(SvRV(sv)) |= SVf_AMAGIC) -# define SvAMAGIC_off(sv) \ - (SvROK(sv) && (SvFLAGS(SvRV(sv)) &= ~SVf_AMAGIC)) -#endif +#define SvAMAGIC(sv) (SvROK(sv) && SvOBJECT(SvRV(sv)) && \ + HvAMAGIC(SvSTASH(SvRV(sv)))) + +/* To be used on the stashes themselves: */ +#define HvAMAGIC(hv) (SvFLAGS(hv) & SVf_AMAGIC) +#define HvAMAGIC_on(hv) (SvFLAGS(hv) |= SVf_AMAGIC) +#define HvAMAGIC_off(hv) (SvFLAGS(hv) &=~ SVf_AMAGIC) + + +#define SvPOK_nog(sv) ((SvFLAGS(sv) & (SVf_POK|SVs_GMG)) == SVf_POK) +#define SvIOK_nog(sv) ((SvFLAGS(sv) & (SVf_IOK|SVs_GMG)) == SVf_IOK) +#define SvUOK_nog(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVs_GMG)) == (SVf_IOK|SVf_IVisUV)) +#define SvNOK_nog(sv) ((SvFLAGS(sv) & (SVf_NOK|SVs_GMG)) == SVf_NOK) +#define SvNIOK_nog(sv) (SvNIOK(sv) && !(SvFLAGS(sv) & SVs_GMG)) + +#define SvPOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) +#define SvIOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_THINKFIRST|SVs_GMG)) == SVf_IOK) +#define SvUOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVf_THINKFIRST|SVs_GMG)) == (SVf_IOK|SVf_IVisUV)) +#define SvNOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_NOK|SVf_THINKFIRST|SVs_GMG)) == SVf_NOK) +#define SvNIOK_nogthink(sv) (SvNIOK(sv) && !(SvFLAGS(sv) & (SVf_THINKFIRST|SVs_GMG))) + +#define SvPOK_utf8_nog(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVs_GMG)) == (SVf_POK|SVf_UTF8)) +#define SvPOK_utf8_nogthink(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST|SVs_GMG)) == (SVf_POK|SVf_UTF8)) + +#define SvPOK_byte_nog(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVs_GMG)) == SVf_POK) +#define SvPOK_byte_nogthink(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) + +#define SvPOK_pure_nogthink(sv) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_IOK|SVf_NOK|SVf_ROK|SVpgv_GP|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) +#define SvPOK_utf8_pure_nogthink(sv) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_IOK|SVf_NOK|SVf_ROK|SVpgv_GP|SVf_THINKFIRST|SVs_GMG)) == (SVf_POK|SVf_UTF8)) +#define SvPOK_byte_pure_nogthink(sv) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_IOK|SVf_NOK|SVf_ROK|SVpgv_GP|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) /* =for apidoc Am|U32|SvGAMAGIC|SV* sv @@ -911,7 +973,10 @@ the scalar's value cannot change unless written to. #define SvGAMAGIC(sv) (SvGMAGICAL(sv) || SvAMAGIC(sv)) -#define Gv_AMG(stash) (PL_amagic_generation && Gv_AMupdate(stash, FALSE)) +#define Gv_AMG(stash) \ + (HvNAME(stash) && Gv_AMupdate(stash,FALSE) \ + ? 1 \ + : (HvAMAGIC_off(stash), 0)) #define SvWEAKREF(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \ == (SVf_ROK|SVprv_WEAKREF)) @@ -923,6 +988,30 @@ the scalar's value cannot change unless written to. #define SvPCS_IMPORTED_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_PCS_IMPORTED)) #define SvPCS_IMPORTED_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_PCS_IMPORTED)) +/* +=for apidoc m|U32|SvTHINKFIRST|SV *sv + +A quick flag check to see whether an sv should be passed to sv_force_normal +to be "downgraded" before SvIVX or SvPVX can be modified directly. + +For example, if your scalar is a reference and you want to modify the SvIVX +slot, you can't just do SvROK_off, as that will leak the referent. + +This is used internally by various sv-modifying functions, such as +sv_setsv, sv_setiv and sv_pvn_force. + +One case that this does not handle is a gv without SvFAKE set. After + + if (SvTHINKFIRST(gv)) sv_force_normal(gv); + +it will still be a gv. + +SvTHINKFIRST sometimes produces false positives. In those cases +sv_force_normal does nothing. + +=cut +*/ + #define SvTHINKFIRST(sv) (SvFLAGS(sv) & SVf_THINKFIRST) #define SvPADMY(sv) (SvFLAGS(sv) & SVs_PADMY) @@ -934,33 +1023,10 @@ the scalar's value cannot change unless written to. #define SvPADSTALE(sv) ((SvFLAGS(sv) & (SVs_PADMY|SVs_PADSTALE)) \ == (SVs_PADMY|SVs_PADSTALE)) -#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define SvPADTMP_on(sv) ({ \ - SV *const _svpad = MUTABLE_SV(sv); \ - assert(!(SvFLAGS(_svpad) & SVs_PADMY)); \ - SvFLAGS(_svpad) |= SVs_PADTMP; \ - }) -# define SvPADTMP_off(sv) ({ \ - SV *const _svpad = MUTABLE_SV(sv); \ - assert(!(SvFLAGS(_svpad) & SVs_PADMY)); \ - SvFLAGS(_svpad) &= ~SVs_PADTMP; \ - }) -# define SvPADSTALE_on(sv) ({ \ - SV *const _svpad = MUTABLE_SV(sv); \ - assert(SvFLAGS(_svpad) & SVs_PADMY); \ - SvFLAGS(_svpad) |= SVs_PADSTALE; \ - }) -# define SvPADSTALE_off(sv) ({ \ - SV *const _svpad = MUTABLE_SV(sv); \ - assert(SvFLAGS(_svpad) & SVs_PADMY); \ - SvFLAGS(_svpad) &= ~SVs_PADSTALE; \ - }) -#else -# define SvPADTMP_on(sv) (SvFLAGS(sv) |= SVs_PADTMP) -# define SvPADTMP_off(sv) (SvFLAGS(sv) &= ~SVs_PADTMP) -# define SvPADSTALE_on(sv) (SvFLAGS(sv) |= SVs_PADSTALE) -# define SvPADSTALE_off(sv) (SvFLAGS(sv) &= ~SVs_PADSTALE) -#endif +#define SvPADTMP_on(sv) S_SvPADTMP_on(MUTABLE_SV(sv)) +#define SvPADTMP_off(sv) S_SvPADTMP_off(MUTABLE_SV(sv)) +#define SvPADSTALE_on(sv) S_SvPADSTALE_on(MUTABLE_SV(sv)) +#define SvPADSTALE_off(sv) S_SvPADSTALE_off(MUTABLE_SV(sv)) #define SvTEMP(sv) (SvFLAGS(sv) & SVs_TEMP) #define SvTEMP_on(sv) (SvFLAGS(sv) |= SVs_TEMP) @@ -1072,7 +1138,7 @@ the scalar's value cannot change unless written to. # define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) /* Don't test the core XS code yet. */ # if defined (PERL_CORE) && PERL_DEBUG_COW > 1 -# define SvPVX(sv) (0 + (assert(!SvREADONLY(sv)), (sv)->sv_u.svu_pv)) +# define SvPVX(sv) (0 + (assert_(!SvREADONLY(sv)) (sv)->sv_u.svu_pv)) # else # define SvPVX(sv) SvPVX_mutable(sv) # endif @@ -1080,13 +1146,8 @@ the scalar's value cannot change unless written to. # define SvLEN(sv) (0 + ((XPV*) SvANY(sv))->xpv_len) # define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur) -# ifdef DEBUGGING -# define SvMAGIC(sv) (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*) SvANY(sv))->xmg_u.xmg_magic)) -# define SvSTASH(sv) (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*) SvANY(sv))->xmg_stash)) -# else -# define SvMAGIC(sv) (0 + ((XPVMG*) SvANY(sv))->xmg_u.xmg_magic) -# define SvSTASH(sv) (0 + ((XPVMG*) SvANY(sv))->xmg_stash) -# endif +# define SvMAGIC(sv) (0 + *(assert_(SvTYPE(sv) >= SVt_PVMG) &((XPVMG*) SvANY(sv))->xmg_u.xmg_magic)) +# define SvSTASH(sv) (0 + *(assert_(SvTYPE(sv) >= SVt_PVMG) &((XPVMG*) SvANY(sv))->xmg_stash)) #else # define SvLEN(sv) ((XPV*) SvANY(sv))->xpv_len # define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur) @@ -1103,7 +1164,8 @@ the scalar's value cannot change unless written to. })) # define SvCUR(sv) \ (*({ const SV *const _svcur = (const SV *)(sv); \ - assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]); \ + assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK] \ + || SvTYPE(_svcur) == SVt_REGEXP); \ assert(!isGV_with_GP(_svcur)); \ assert(!(SvTYPE(_svcur) == SVt_PVIO \ && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP))); \ @@ -1195,8 +1257,9 @@ the scalar's value cannot change unless written to. STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \ (void) SvIV(sv); } STMT_END #define SvIV_please_nomg(sv) \ - STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \ - (void) SvIV_nomg(sv); } STMT_END + (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv)) \ + ? (SvIV_nomg(sv), SvIOK(sv)) \ + : SvIOK(sv)) #define SvIV_set(sv, val) \ STMT_START { \ assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]); \ @@ -1234,7 +1297,8 @@ the scalar's value cannot change unless written to. (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END #define SvCUR_set(sv, val) \ STMT_START { \ - assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]); \ + assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK] \ + || SvTYPE(sv) == SVt_REGEXP); \ assert(!isGV_with_GP(sv)); \ assert(!(SvTYPE(sv) == SVt_PVIO \ && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ @@ -1323,7 +1387,7 @@ the scalar's value cannot change unless written to. #endif -#define FmLINES(sv) ((XPVFM*) SvANY(sv))->xfm_lines +#define FmLINES(sv) ((XPVIV*) SvANY(sv))->xiv_iv #define LvTYPE(sv) ((XPVLV*) SvANY(sv))->xlv_type #define LvTARG(sv) ((XPVLV*) SvANY(sv))->xlv_targ @@ -1388,28 +1452,36 @@ attention to precisely which outputs are influenced by which inputs. #define sv_taint(sv) sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0) -#define SvTAINTED(sv) (SvMAGICAL(sv) && sv_tainted(sv)) -#define SvTAINTED_on(sv) STMT_START{ if(PL_tainting){sv_taint(sv);} }STMT_END -#define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END +#if NO_TAINT_SUPPORT +# define SvTAINTED(sv) 0 +#else +# define SvTAINTED(sv) (SvMAGICAL(sv) && sv_tainted(sv)) +#endif +#define SvTAINTED_on(sv) STMT_START{ if(TAINTING_get){sv_taint(sv);} }STMT_END +#define SvTAINTED_off(sv) STMT_START{ if(TAINTING_get){sv_untaint(sv);} }STMT_END #define SvTAINT(sv) \ STMT_START { \ - if (PL_tainting) { \ - if (PL_tainted) \ + if (TAINTING_get) { \ + if (TAINT_get) \ SvTAINTED_on(sv); \ } \ } STMT_END /* =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len -Like C<SvPV> but will force the SV into containing just a string -(C<SvPOK_only>). You want force if you are going to update the C<SvPVX> -directly. +Like C<SvPV> but will force the SV into containing a string (C<SvPOK>), and +only a string (C<SvPOK_only>), by hook or by crook. You need force if you are +going to update the C<SvPVX> directly. Processes get magic. + +Note that coercing an arbitrary scalar into a plain PV will potentially +strip useful data from it. For example if the SV was C<SvROK>, then the +referent will have its reference count decremented, and the SV itself may +be converted to an C<SvPOK> scalar with a string buffer containing a value +such as C<"ARRAY(0x1234)">. =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len -Like C<SvPV> but will force the SV into containing just a string -(C<SvPOK_only>). You want force if you are going to update the C<SvPVX> -directly. Doesn't process magic. +Like C<SvPV_force>, but doesn't process get magic. =for apidoc Am|char*|SvPV|SV* sv|STRLEN len Returns a pointer to the string in the SV, or a stringified form of @@ -1417,6 +1489,15 @@ the SV if the SV does not contain a string. The SV may cache the stringified version becoming C<SvPOK>. Handles 'get' magic. See also C<SvPVx> for a version which guarantees to evaluate sv only once. +Note that there is no guarantee that the return value of C<SvPV()> is +equal to C<SvPVX(sv)>, or that C<SvPVX(sv)> contains valid data, or that +successive calls to C<SvPV(sv)) will return the same pointer value each +time. This is due to the way that things like overloading and +Copy-On-Write are handled. In these cases, the return value may point to +a temporary buffer or similar. If you absolutely need the SvPVX field to +be valid (for example, if you intend to write to it), then see +L</SvPV_force>. + =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len A version of C<SvPV> which guarantees to evaluate C<sv> only once. Only use this if C<sv> is an expression with side effects, otherwise use the @@ -1426,9 +1507,7 @@ more efficient C<SvPV>. Like C<SvPV> but doesn't process magic. =for apidoc Am|char*|SvPV_nolen|SV* sv -Returns a pointer to the string in the SV, or a stringified form of -the SV if the SV does not contain a string. The SV may cache the -stringified form becoming C<SvPOK>. Handles 'get' magic. +Like C<SvPV> but doesn't set a length variable. =for apidoc Am|char*|SvPV_nomg_nolen|SV* sv Like C<SvPV_nolen> but doesn't process magic. @@ -1468,7 +1547,7 @@ Like C<SvUV> but doesn't process magic. =for apidoc Am|UV|SvUVx|SV* sv Coerces the given SV to an unsigned integer and -returns it. Guarantees to C<sv> only once. Only +returns it. Guarantees to evaluate C<sv> only once. Only use this if C<sv> is an expression with side effects, otherwise use the more efficient C<SvUV>. @@ -1549,9 +1628,9 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. */ /* Let us hope that bitmaps for UV and IV are the same */ -#define SvIV(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) -#define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) -#define SvNV(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv)) +#define SvIV(sv) (SvIOK_nog(sv) ? SvIVX(sv) : sv_2iv(sv)) +#define SvUV(sv) (SvUOK_nog(sv) ? SvUVX(sv) : sv_2uv(sv)) +#define SvNV(sv) (SvNOK_nog(sv) ? SvNVX(sv) : sv_2nv(sv)) #define SvIV_nomg(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv_flags(sv, 0)) #define SvUV_nomg(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv_flags(sv, 0)) @@ -1559,23 +1638,23 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. /* ----*/ -#define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC) -#define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) +#define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC) +#define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) #define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) #define SvPV_flags(sv, lp, flags) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) #define SvPV_flags_const(sv, lp, flags) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) #define SvPV_flags_const_nolen(sv, flags) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? SvPVX_const(sv) : \ (const char*) sv_2pv_flags(sv, 0, flags|SV_CONST_RETURN)) #define SvPV_flags_mutable(sv, lp, flags) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) @@ -1587,26 +1666,28 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. #define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) #define SvPV_force_flags(sv, lp, flags) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ - ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) + (SvPOK_pure_nogthink(sv) \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) + #define SvPV_force_flags_nolen(sv, flags) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ - ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags)) + (SvPOK_pure_nogthink(sv) \ + ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags)) + #define SvPV_force_flags_mutable(sv, lp, flags) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ - ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ + (SvPOK_pure_nogthink(sv) \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #define SvPV_nolen(sv) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? SvPVX(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC)) #define SvPV_nomg_nolen(sv) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? SvPVX(sv) : sv_2pv_flags(sv, 0, 0)) #define SvPV_nolen_const(sv) \ - ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + (SvPOK_nog(sv) \ ? SvPVX_const(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC|SV_CONST_RETURN)) #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) @@ -1616,33 +1697,31 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. /* ----*/ #define SvPVutf8(sv, lp) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8) \ + (SvPOK_utf8_nog(sv) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp)) #define SvPVutf8_force(sv, lp) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \ + (SvPOK_utf8_pure_nogthink(sv) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp)) - #define SvPVutf8_nolen(sv) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8)\ + (SvPOK_utf8_nog(sv) \ ? SvPVX(sv) : sv_2pvutf8(sv, 0)) /* ----*/ #define SvPVbyte(sv, lp) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ + (SvPOK_byte_nog(sv) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) #define SvPVbyte_force(sv, lp) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK) \ + (SvPOK_byte_pure_nogthink(sv) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyten_force(sv, &lp)) #define SvPVbyte_nolen(sv) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)\ + (SvPOK_byte_nog(sv) \ ? SvPVX(sv) : sv_2pvbyte(sv, 0)) - /* define FOOx(): idempotent versions of FOO(). If possible, use a local * var to evaluate the arg once; failing that, use a global if possible; @@ -1653,6 +1732,20 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp) #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp) +#define SvTRUE(sv) ((sv) && (SvGMAGICAL(sv) ? sv_2bool(sv) : SvTRUE_common(sv, sv_2bool_nomg(sv)))) +#define SvTRUE_nomg(sv) ((sv) && ( SvTRUE_common(sv, sv_2bool_nomg(sv)))) +#define SvTRUE_NN(sv) (SvGMAGICAL(sv) ? sv_2bool(sv) : SvTRUE_common(sv, sv_2bool_nomg(sv))) +#define SvTRUE_nomg_NN(sv) ( SvTRUE_common(sv, sv_2bool_nomg(sv))) +#define SvTRUE_common(sv,fallback) ( \ + !SvOK(sv) \ + ? 0 \ + : SvPOK(sv) \ + ? SvPVXtrue(sv) \ + : (SvFLAGS(sv) & (SVf_IOK|SVf_NOK)) \ + ? ( (SvIOK(sv) && SvIVX(sv) != 0) \ + || (SvNOK(sv) && SvNVX(sv) != 0.0)) \ + : (fallback)) + #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvIVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvIV(_sv); }) @@ -1665,39 +1758,8 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. # define SvPVutf8x(sv, lp) ({SV *_sv = (sv); SvPVutf8(_sv, lp); }) # define SvPVbytex(sv, lp) ({SV *_sv = (sv); SvPVbyte(_sv, lp); }) # define SvPVbytex_nolen(sv) ({SV *_sv = (sv); SvPVbyte_nolen(_sv); }) -# define SvTRUE(sv) ( \ - !sv \ - ? 0 \ - : SvPOK(sv) \ - ? (({XPV *nxpv = (XPV*)SvANY(sv); \ - nxpv && \ - (nxpv->xpv_cur > 1 || \ - (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \ - ? 1 \ - : 0) \ - : \ - SvIOK(sv) \ - ? SvIVX(sv) != 0 \ - : SvNOK(sv) \ - ? SvNVX(sv) != 0.0 \ - : sv_2bool(sv) ) -# define SvTRUE_nomg(sv) ( \ - !sv \ - ? 0 \ - : SvPOK(sv) \ - ? (({XPV *nxpv = (XPV*)SvANY(sv); \ - nxpv && \ - (nxpv->xpv_cur > 1 || \ - (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \ - ? 1 \ - : 0) \ - : \ - SvIOK(sv) \ - ? SvIVX(sv) != 0 \ - : SvNOK(sv) \ - ? SvNVX(sv) != 0.0 \ - : sv_2bool_flags(sv,0) ) -# define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); }) +# define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); }) +# define SvTRUEx_nomg(sv) ({SV *_sv = (sv); SvTRUE_nomg(_sv); }) #else /* __GNUC__ */ @@ -1714,42 +1776,24 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. # define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp)) # define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp)) # define SvPVbytex_nolen(sv) ((PL_Sv = (sv)), SvPVbyte_nolen(PL_Sv)) -# define SvTRUE(sv) ( \ - !sv \ - ? 0 \ - : SvPOK(sv) \ - ? ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) && \ - (PL_Xpv->xpv_cur > 1 || \ - (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0')) \ - ? 1 \ - : 0) \ - : \ - SvIOK(sv) \ - ? SvIVX(sv) != 0 \ - : SvNOK(sv) \ - ? SvNVX(sv) != 0.0 \ - : sv_2bool(sv) ) -# define SvTRUE_nomg(sv) ( \ - !sv \ - ? 0 \ - : SvPOK(sv) \ - ? ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) && \ - (PL_Xpv->xpv_cur > 1 || \ - (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0')) \ - ? 1 \ - : 0) \ - : \ - SvIOK(sv) \ - ? SvIVX(sv) != 0 \ - : SvNOK(sv) \ - ? SvNVX(sv) != 0.0 \ - : sv_2bool_flags(sv,0) ) -# define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv)) +# define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv)) +# define SvTRUEx_nomg(sv) ((PL_Sv = (sv)), SvTRUE_nomg(PL_Sv)) #endif /* __GNU__ */ -#define SvIsCOW(sv) ((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \ - (SVf_FAKE | SVf_READONLY) && !isGV_with_GP(sv) \ - && SvTYPE(sv) != SVt_REGEXP) +#define SvPVXtrue(sv) ( \ + ((XPV*)SvANY((sv))) \ + && ( \ + ((XPV*)SvANY((sv)))->xpv_cur > 1 \ + || ( \ + ((XPV*)SvANY((sv)))->xpv_cur \ + && *(sv)->sv_u.svu_pv != '0' \ + ) \ + ) \ +) + +#define SvIsCOW(sv) (SvFLAGS(sv) & SVf_IsCOW) +#define SvIsCOW_on(sv) (SvFLAGS(sv) |= SVf_IsCOW) +#define SvIsCOW_off(sv) (SvFLAGS(sv) &= ~SVf_IsCOW) #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0) #define SvSHARED_HEK_FROM_PV(pvx) \ @@ -1818,6 +1862,13 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>. ((SvIsCOW(sv) ? sv_force_normal_flags(sv, 0) : (void) 0), 0) # define SvIsCOW_normal(sv) (SvIsCOW(sv) && SvLEN(sv)) # define SvRELEASE_IVX_(sv) SvRELEASE_IVX(sv), +# define SvCANCOW(sv) \ + (SvIsCOW(sv) || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS) +/* This is a pessimistic view. Scalar must be purely a read-write PV to copy- + on-write. */ +# define CAN_COW_MASK (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \ + SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \ + SVf_OOK|SVf_BREAK|SVf_READONLY) #else # define SvRELEASE_IVX(sv) 0 /* This little game brought to you by the need to shut this warning up: @@ -1825,11 +1876,26 @@ mg.c: In function 'Perl_magic_get': mg.c:1024: warning: left-hand operand of comma expression has no effect */ # define SvRELEASE_IVX_(sv) /**/ +# ifdef PERL_NEW_COPY_ON_WRITE +# define SvCANCOW(sv) \ + (SvIsCOW(sv) \ + ? SvLEN(sv) ? CowREFCNT(sv) != SV_COW_REFCNT_MAX : 1 \ + : (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS \ + && SvCUR(sv)+1 < SvLEN(sv)) + /* Note: To allow 256 COW "copies", a refcnt of 0 means 1. */ +# define CowREFCNT(sv) (*(U8 *)(SvPVX(sv)+SvLEN(sv)-1)) +# define SV_COW_REFCNT_MAX ((1 << sizeof(U8)*8) - 1) +# ifndef SV_COW_THRESHOLD +# define SV_COW_THRESHOLD 0 /* min string length for cow */ +# endif +# ifndef SV_COWBUF_THRESHOLD +# define SV_COWBUF_THRESHOLD 1250 /* min string length for cow */ +# endif /* over existing buffer */ +# define CAN_COW_MASK (SVf_POK|SVf_ROK|SVp_POK|SVf_FAKE| \ + SVf_OOK|SVf_BREAK|SVf_READONLY) +# endif #endif /* PERL_OLD_COPY_ON_WRITE */ -#define CAN_COW_MASK (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \ - SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \ - SVf_OOK|SVf_BREAK|SVf_READONLY) #define CAN_COW_FLAGS (SVp_POK|SVf_POK) #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \ @@ -1854,8 +1920,9 @@ mg.c:1024: warning: left-hand operand of comma expression has no effect #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0) #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC) #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC) -#define sv_catpvn_mg(sv, sstr, slen) \ - sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC); +#define sv_catpvn_mg(sv, sstr, slen) sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC); +#define sv_copypv(dsv, ssv) sv_copypv_flags(dsv, ssv, SV_GMAGIC) +#define sv_copypv_nomg(dsv, ssv) sv_copypv_flags(dsv, ssv, 0) #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC) #define sv_2pv_nolen(sv) sv_2pv(sv, 0) #define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0) @@ -1871,12 +1938,15 @@ mg.c:1024: warning: left-hand operand of comma expression has no effect #define sv_cmp_locale(sv1, sv2) sv_cmp_locale_flags(sv1, sv2, SV_GMAGIC) #define sv_collxfrm(sv, nxp) sv_cmp_flags(sv, nxp, SV_GMAGIC) #define sv_2bool(sv) sv_2bool_flags(sv, SV_GMAGIC) +#define sv_2bool_nomg(sv) sv_2bool_flags(sv, 0) #define sv_insert(bigstr, offset, len, little, littlelen) \ Perl_sv_insert_flags(aTHX_ (bigstr),(offset), (len), (little), \ (littlelen), SV_GMAGIC) +#define sv_mortalcopy(sv) \ + Perl_sv_mortalcopy_flags(aTHX_ sv, SV_GMAGIC|SV_DO_COW_SVSETSV) /* Should be named SvCatPVN_utf8_upgrade? */ -#define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv) \ +#define sv_catpvn_nomg_utf8_upgrade(dsv, sstr, slen, nsv) \ STMT_START { \ if (!(nsv)) \ nsv = newSVpvn_flags(sstr, slen, SVs_TEMP); \ @@ -1884,8 +1954,18 @@ mg.c:1024: warning: left-hand operand of comma expression has no effect sv_setpvn(nsv, sstr, slen); \ SvUTF8_off(nsv); \ sv_utf8_upgrade(nsv); \ - sv_catsv(dsv, nsv); \ + sv_catsv_nomg(dsv, nsv); \ } STMT_END +#define sv_catpvn_nomg_maybeutf8(dsv, sstr, slen, is_utf8) \ + sv_catpvn_flags(dsv, sstr, slen, (is_utf8)?SV_CATUTF8:SV_CATBYTES) + +#ifdef PERL_CORE +# define sv_or_pv_len_utf8(sv, pv, bytelen) \ + (SvGAMAGIC(sv) \ + ? utf8_length((U8 *)(pv), (U8 *)(pv)+(bytelen)) \ + : sv_len_utf8(sv)) +# define sv_or_pv_pos_u2b(sv,s,p,lp) S_sv_or_pv_pos_u2b(aTHX_ sv,s,p,lp) +#endif /* =for apidoc Am|SV*|newRV_inc|SV* sv @@ -1904,11 +1984,14 @@ incremented. =head1 Magical Functions =for apidoc Am|void|SvGETMAGIC|SV* sv -Invokes C<mg_get> on an SV if it has 'get' magic. This macro evaluates its +Invokes C<mg_get> on an SV if it has 'get' magic. For example, this +will call C<FETCH> on a tied variable. This macro evaluates its argument more than once. =for apidoc Am|void|SvSETMAGIC|SV* sv -Invokes C<mg_set> on an SV if it has 'set' magic. This macro evaluates its +Invokes C<mg_set> on an SV if it has 'set' magic. This is necessary +after modifying a scalar, in case it is a magical variable like C<$|> +or a tied variable (it calls C<STORE>). This macro evaluates its argument more than once. =for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv @@ -1943,7 +2026,8 @@ has been loaded. Expands the character buffer in the SV so that it has room for the indicated number of bytes (remember to reserve space for an extra trailing NUL character). Calls C<sv_grow> to perform the expansion if necessary. -Returns a pointer to the character buffer. +Returns a pointer to the character buffer. SV must be of type >= SVt_PV. One +alternative is to call C<sv_grow> if you are not sure of the type of SV. =cut */ @@ -1988,7 +2072,14 @@ Returns a pointer to the character buffer. #define SvPEEK(sv) "" #endif -#define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder) +#define SvIMMORTAL(sv) (SvREADONLY(sv) && ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder)) + +#ifdef DEBUGGING + /* exercise the immortal resurrection code in sv_free2() */ +# define SvREFCNT_IMMORTAL 1000 +#else +# define SvREFCNT_IMMORTAL ((~(U32)0)/2) +#endif /* =for apidoc Am|SV *|boolSV|bool b @@ -2020,9 +2111,18 @@ See also C<PL_sv_yes> and C<PL_sv_no>. assert (!SvIOKp(sv)); \ (SvFLAGS(sv) &= ~SVpgv_GP); \ } STMT_END +#define isREGEXP(sv) \ + (SvTYPE(sv) == SVt_REGEXP \ + || (SvFLAGS(sv) & (SVTYPEMASK|SVp_POK|SVpgv_GP|SVf_FAKE)) \ + == (SVt_PVLV|SVf_FAKE)) -#define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) +#ifdef PERL_NEW_COPY_ON_WRITE +# define SvGROW(sv,len) \ + (SvIsCOW(sv) || SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) +#else +# define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) +#endif #define SvGROW_mutable(sv,len) \ (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX_mutable(sv)) #define Sv_Grow sv_grow @@ -2052,6 +2152,18 @@ C<SvUTF8_on> on the new SV. Implemented as a wrapper around C<newSVpvn_flags>. #define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) /* +=for apidoc Amx|SV*|newSVpadname|PADNAME *pn + +Creates a new SV containing the pad name. This is currently identical +to C<newSVsv>, but pad names may cease being SVs at some point, so +C<newSVpadname> is preferable. + +=cut +*/ + +#define newSVpadname(pn) newSVsv(pn) + +/* =for apidoc Am|void|SvOOK_offset|NN SV*sv|STRLEN len Reads into I<len> the offset from SvPVX back to the true start of the @@ -2071,23 +2183,23 @@ Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false. # define SvOOK_offset(sv, offset) STMT_START { \ assert(sizeof(offset) == sizeof(STRLEN)); \ if (SvOOK(sv)) { \ - const U8 *crash = (U8*)SvPVX_const(sv); \ - offset = *--crash; \ - if (!offset) { \ - crash -= sizeof(STRLEN); \ - Copy(crash, (U8 *)&offset, sizeof(STRLEN), U8); \ + const U8 *_crash = (U8*)SvPVX_const(sv); \ + (offset) = *--_crash; \ + if (!(offset)) { \ + _crash -= sizeof(STRLEN); \ + Copy(_crash, (U8 *)&(offset), sizeof(STRLEN), U8); \ } \ { \ /* Validate the preceding buffer's sentinels to \ verify that no-one is using it. */ \ - const U8 *const bonk = (U8 *) SvPVX_const(sv) - offset; \ - while (crash > bonk) { \ - --crash; \ - assert (*crash == (U8)PTR2UV(crash)); \ + const U8 *const _bonk = (U8*)SvPVX_const(sv) - (offset);\ + while (_crash > _bonk) { \ + --_crash; \ + assert (*_crash == (U8)PTR2UV(_crash)); \ } \ } \ } else { \ - offset = 0; \ + (offset) = 0; \ } \ } STMT_END #else @@ -2095,13 +2207,13 @@ Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false. # define SvOOK_offset(sv, offset) STMT_START { \ assert(sizeof(offset) == sizeof(STRLEN)); \ if (SvOOK(sv)) { \ - offset = ((U8*)SvPVX_const(sv))[-1]; \ - if (!offset) { \ + (offset) = ((U8*)SvPVX_const(sv))[-1]; \ + if (!(offset)) { \ Copy(SvPVX_const(sv) - 1 - sizeof(STRLEN), \ - (U8 *)&offset, sizeof(STRLEN), U8); \ + (U8*)&(offset), sizeof(STRLEN), U8); \ } \ } else { \ - offset = 0; \ + (offset) = 0; \ } \ } STMT_END #endif @@ -2112,8 +2224,8 @@ Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false. * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/sys/socket.h b/Master/tlpkg/tlperl/lib/CORE/sys/socket.h index 26a92c78dd4..6009572725b 100644 --- a/Master/tlpkg/tlperl/lib/CORE/sys/socket.h +++ b/Master/tlpkg/tlperl/lib/CORE/sys/socket.h @@ -195,8 +195,6 @@ extern "C" { #undef EAFNOSUPPORT #define EAFNOSUPPORT WSAEAFNOSUPPORT -#ifdef USE_SOCKETS_AS_HANDLES - #ifndef PERL_FD_SETSIZE #define PERL_FD_SETSIZE 64 #endif @@ -221,16 +219,6 @@ typedef struct Perl_fd_set { #define PERL_FD_ISSET(n,p) \ ((p)->bits[(n)/PERL_NFDBITS] & ((unsigned)1 << ((n)%PERL_NFDBITS))) -#else /* USE_SOCKETS_AS_HANDLES */ - -#define Perl_fd_set fd_set -#define PERL_FD_SET(n,p) FD_SET(n,p) -#define PERL_FD_CLR(n,p) FD_CLR(n,p) -#define PERL_FD_ISSET(n,p) FD_ISSET(n,p) -#define PERL_FD_ZERO(p) FD_ZERO(p) - -#endif /* USE_SOCKETS_AS_HANDLES */ - SOCKET win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen); int win32_bind (SOCKET s, const struct sockaddr *addr, int namelen); int win32_closesocket (SOCKET s); @@ -331,7 +319,6 @@ void win32_endservent(void); #define setprotoent win32_setprotoent #define setservent win32_setservent -#ifdef USE_SOCKETS_AS_HANDLES #undef fd_set #undef FD_SET #undef FD_CLR @@ -342,7 +329,6 @@ void win32_endservent(void); #define FD_CLR(n,p) PERL_FD_CLR(n,p) #define FD_ISSET(n,p) PERL_FD_ISSET(n,p) #define FD_ZERO(p) PERL_FD_ZERO(p) -#endif /* USE_SOCKETS_AS_HANDLES */ #endif /* WIN32SCK_IS_STDSCK */ diff --git a/Master/tlpkg/tlperl/lib/CORE/thread.h b/Master/tlpkg/tlperl/lib/CORE/thread.h index 3b84f369f74..03965c8b52f 100644 --- a/Master/tlpkg/tlperl/lib/CORE/thread.h +++ b/Master/tlpkg/tlperl/lib/CORE/thread.h @@ -40,9 +40,6 @@ # define NEED_PTHREAD_INIT # define PTHREAD_CREATE_JOINABLE (1) # endif -# ifdef __OPEN_VM -# define pthread_addr_t void * -# endif # ifdef OEMVS # define pthread_addr_t void * # define pthread_create(t,a,s,d) pthread_create(t,&(a),s,d) @@ -65,7 +62,7 @@ # define pthread_mutexattr_init(a) pthread_mutexattr_create(a) # define pthread_mutexattr_settype(a,t) pthread_mutexattr_setkind_np(a,t) # endif -# if defined(DJGPP) || defined(__OPEN_VM) || defined(OEMVS) +# if defined(DJGPP) || defined(OEMVS) # define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,&(s)) # define YIELD pthread_yield(NULL) # endif @@ -441,8 +438,8 @@ * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/uconfig.h b/Master/tlpkg/tlperl/lib/CORE/uconfig.h index 20b1f23f022..82664c47a48 100644 --- a/Master/tlpkg/tlperl/lib/CORE/uconfig.h +++ b/Master/tlpkg/tlperl/lib/CORE/uconfig.h @@ -527,7 +527,7 @@ * This symbol, if defined, indicates that the strtol routine is available * to provide better numeric string conversion than atoi() and friends. */ -/*#define HAS_STRTOL / **/ +#define HAS_STRTOL /**/ /* HAS_STRXFRM: * This symbol, if defined, indicates that the strxfrm() routine is @@ -916,13 +916,10 @@ /* MEM_ALIGNBYTES: * This symbol contains the number of bytes required to align a * double, or a long double when applicable. Usual values are 2, - * 4 and 8. The default is eight, for safety. + * 4 and 8. The default is eight, for safety. For cross-compiling + * or multiarch support, Configure will set a minimum of 8. */ -#if defined(USE_CROSS_COMPILE) || defined(MULTIARCH) -# define MEM_ALIGNBYTES 8 -#else #define MEM_ALIGNBYTES 4 -#endif /* ARCHLIB: * This variable, if defined, holds the name of the directory in @@ -937,8 +934,8 @@ * This symbol contains the ~name expanded version of ARCHLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ -/*#define ARCHLIB "/usr/local/lib/perl5/5.16/unknown" / **/ -/*#define ARCHLIB_EXP "/usr/local/lib/perl5/5.16/unknown" / **/ +/*#define ARCHLIB "/usr/local/lib/perl5/5.18/unknown" / **/ +/*#define ARCHLIB_EXP "/usr/local/lib/perl5/5.18/unknown" / **/ /* ARCHNAME: * This symbol holds a string representing the architecture name. @@ -962,7 +959,7 @@ */ #define BIN "/usr/local/bin" /**/ #define BIN_EXP "/usr/local/bin" /**/ -/*#define PERL_RELOCATABLE_INC / **/ +#define PERL_RELOCATABLE_INC "undef" /**/ /* INTSIZE: * This symbol contains the value of sizeof(int) so that the C @@ -984,7 +981,7 @@ * This symbol holds the hexadecimal constant defined in byteorder, * in a UV, i.e. 0x1234 or 0x4321 or 0x12345678, etc... * If the compiler supports cross-compiling or multiple-architecture - * binaries (eg. on NeXT systems), use compiler-defined macros to + * binaries (e.g. on NeXT systems), use compiler-defined macros to * determine the byte order. * On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture * Binaries (MAB) on either big endian or little endian machines. @@ -2359,10 +2356,22 @@ * This symbol, if defined, indicates that the struct sockaddr_in6 * structure has a member called sin6_scope_id. */ +/* HAS_IP_MREQ: + * This symbol, if defined, indicates the availability of + * struct ip_mreq; + */ +/* HAS_IP_MREQ_SOURCE: + * This symbol, if defined, indicates the availability of + * struct ip_mreq_source; + */ /* HAS_IPV6_MREQ: * This symbol, if defined, indicates the availability of * struct ipv6_mreq; */ +/* HAS_IPV6_MREQ_SOURCE: + * This symbol, if defined, indicates the availability of + * struct ipv6_mreq_source; + */ /*#define HAS_SOCKET / **/ /*#define HAS_SOCKETPAIR / **/ /*#define HAS_SOCKADDR_SA_LEN / **/ @@ -2374,7 +2383,10 @@ /*#define HAS_SCM_RIGHTS / **/ /*#define HAS_SOCKADDR_IN6 / **/ /*#define HAS_SIN6_SCOPE_ID / **/ +/*#define HAS_IP_MREQ / **/ +/*#define HAS_IP_MREQ_SOURCE / **/ /*#define HAS_IPV6_MREQ / **/ +/*#define HAS_IPV6_MREQ_SOURCE / **/ /* HAS_SRAND48_R: * This symbol, if defined, indicates that the srand48_r routine @@ -2661,10 +2673,17 @@ #define DOUBLESIZE 8 /**/ /* EBCDIC: - * This symbol, if defined, indicates that this system uses + * This symbol, if defined, indicates that this system uses * EBCDIC encoding. */ +/* BOOTSTRAP_CHARSET: + * This symbol, if defined, indicates that this system needs + * converting various files to the native character set before + * bringing up perl on a system that has a non-ASCII character + * set and no working perl. + */ /*#define EBCDIC / **/ +/*#define BOOTSTRAP_CHARSET / **/ /* Fpos_t: * This symbol holds the type used to declare file positions in libc. @@ -2679,7 +2698,7 @@ #define Gid_t_f "lu" /**/ /* Gid_t_sign: - * This symbol holds the signedess of a Gid_t. + * This symbol holds the signedness of a Gid_t. * 1 for unsigned, -1 for signed. */ #define Gid_t_sign 1 /* GID sign */ @@ -3026,8 +3045,8 @@ * This symbol contains the ~name expanded version of PRIVLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ -#define PRIVLIB "/usr/local/lib/perl5/5.16" /**/ -#define PRIVLIB_EXP "/usr/local/lib/perl5/5.16" /**/ +#define PRIVLIB "/usr/local/lib/perl5/5.18" /**/ +#define PRIVLIB_EXP "/usr/local/lib/perl5/5.18" /**/ /* CAN_PROTOTYPE: * If defined, this macro indicates that the C compiler can handle @@ -3170,8 +3189,8 @@ * This symbol contains the ~name expanded version of SITEARCH, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ -/*#define SITEARCH "/usr/local/lib/perl5/5.16/unknown" / **/ -/*#define SITEARCH_EXP "/usr/local/lib/perl5/5.16/unknown" / **/ +/*#define SITEARCH "/usr/local/lib/perl5/5.18/unknown" / **/ +/*#define SITEARCH_EXP "/usr/local/lib/perl5/5.18/unknown" / **/ /* SITELIB: * This symbol contains the name of the private library for this package. @@ -3193,8 +3212,8 @@ * removed. The elements in inc_version_list (inc_version_list.U) can * be tacked onto this variable to generate a list of directories to search. */ -#define SITELIB "/usr/local/lib/perl5/5.16" /**/ -#define SITELIB_EXP "/usr/local/lib/perl5/5.16" /**/ +#define SITELIB "/usr/local/lib/perl5/5.18" /**/ +#define SITELIB_EXP "/usr/local/lib/perl5/5.18" /**/ #define SITELIB_STEM "/usr/local/lib/perl5" /**/ /* Size_t_size: @@ -3238,7 +3257,7 @@ #define Uid_t_f "lu" /**/ /* Uid_t_sign: - * This symbol holds the signedess of a Uid_t. + * This symbol holds the signedness of a Uid_t. * 1 for unsigned, -1 for signed. */ #define Uid_t_sign 1 /* UID sign */ @@ -3701,7 +3720,7 @@ /*#define HAS_INT64_T / **/ /* HAS_ISBLANK: - * This manifest constant lets the C program know that isblank + * This manifest constant lets the C program know that isblank * is available. */ /*#define HAS_ISBLANK / **/ @@ -4581,7 +4600,7 @@ * This variable contains the size of struct stat's st_ino in bytes. */ /* ST_INO_SIGN: - * This symbol holds the signedess of struct stat's st_ino. + * This symbol holds the signedness of struct stat's st_ino. * 1 for unsigned, -1 for signed. */ #define ST_INO_SIGN 1 /* st_ino sign */ @@ -4734,6 +4753,6 @@ #endif /* Generated from: - * d9b6a68b192c72c0695b560fae6e4916b381f55df5fdf7911b0ef434840f092e config_h.SH - * 2678333a6d6676f8aa39b7011bf5133dce5be453df10a8d04cb3187103a10caf uconfig.sh + * 2c9dc3f21d37b1665f6a59dfc6d79e6cb08bdf36a9c3e427d11d6b9ddffe2439 config_h.SH + * 26ab9b4aa382d32761cb91084ba59e7e4b190799502a43366ccb3d2f584783ca uconfig.sh * ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/unicode_constants.h b/Master/tlpkg/tlperl/lib/CORE/unicode_constants.h new file mode 100755 index 00000000000..19f3acd33f9 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/CORE/unicode_constants.h @@ -0,0 +1,44 @@ +/* -*- buffer-read-only: t -*- + * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! + * This file is built by regen/unicode_constants.pl from Unicode data. + * Any changes made here will be lost! + */ + + +#ifndef H_UNICODE_CONSTANTS /* Guard against nested #includes */ +#define H_UNICODE_CONSTANTS 1 + +/* This file contains #defines for various Unicode code points. The values + * the macros expand to are the native Unicode code point, or all or portions + * of the UTF-8 encoding for the code point. In the former case, the macro + * name has the suffix "_NATIVE"; otherwise, the suffix "_UTF8". + * + * The macros that have the suffix "_UTF8" may have further suffixes, as + * follows: + * "_FIRST_BYTE" if the value is just the first byte of the UTF-8 + * representation; the value will be a numeric constant. + * "_TAIL" if instead it represents all but the first byte. This, and + * with no additional suffix are both string constants */ + + +#define COMBINING_GRAVE_ACCENT_UTF8 "\xCC\x80" /* U+0300 */ +#define COMBINING_ACUTE_ACCENT_UTF8 "\xCC\x81" /* U+0301 */ +#define COMBINING_DIAERESIS_UTF8 "\xCC\x88" /* U+0308 */ + +#define GREEK_SMALL_LETTER_IOTA_UTF8 "\xCE\xB9" /* U+03B9 */ + +#define GREEK_SMALL_LETTER_UPSILON_UTF8 "\xCF\x85" /* U+03C5 */ + +#define HYPHEN_UTF8 "\xE2\x80\x90" /* U+2010 */ +#define FIRST_SURROGATE_UTF8_FIRST_BYTE 0xED /* U+D800 */ + +#define DEL_NATIVE 0x7F /* U+007F */ +#define LATIN_SMALL_LETTER_SHARP_S_NATIVE 0xDF /* U+00DF */ +#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE_NATIVE 0xE5 /* U+00E5 */ +#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE_NATIVE 0xC5 /* U+00C5 */ +#define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS_NATIVE 0xFF /* U+00FF */ +#define MICRO_SIGN_NATIVE 0xB5 /* U+00B5 */ + +#endif /* H_UNICODE_CONSTANTS */ + +/* ex: set ro: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/unixish.h b/Master/tlpkg/tlperl/lib/CORE/unixish.h index 781b0494a51..c129ed18b30 100644 --- a/Master/tlpkg/tlperl/lib/CORE/unixish.h +++ b/Master/tlpkg/tlperl/lib/CORE/unixish.h @@ -150,8 +150,8 @@ * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/utf8.h b/Master/tlpkg/tlperl/lib/CORE/utf8.h index 8b5700dd619..01d8f5fa204 100644 --- a/Master/tlpkg/tlperl/lib/CORE/utf8.h +++ b/Master/tlpkg/tlperl/lib/CORE/utf8.h @@ -1,5 +1,11 @@ /* utf8.h * + * This file contains definitions for use with the UTF-8 encoding. It + * actually also works with the variant UTF-8 encoding called UTF-EBCDIC, and + * hides almost all of the differences between these from the caller. In other + * words, someone should #include this file, and if the code is being compiled + * on an EBCDIC platform, things should mostly just work. + * * Copyright (C) 2000, 2001, 2002, 2005, 2006, 2007, 2009, * 2010, 2011 by Larry Wall and others * @@ -8,6 +14,9 @@ * */ +#ifndef H_UTF8 /* Guard against recursive inclusion */ +#define H_UTF8 1 + /* Use UTF-8 as the default script encoding? * Turning this on will break scripts having non-UTF-8 binary * data (such as Latin-1) in string literals. */ @@ -20,8 +29,14 @@ /* For to_utf8_fold_flags, q.v. */ #define FOLD_FLAGS_LOCALE 0x1 #define FOLD_FLAGS_FULL 0x2 +#define FOLD_FLAGS_NOMIX_ASCII 0x4 -#define to_uni_fold(c, p, lenp) _to_uni_fold_flags(c, p, lenp, 1) +/* For _core_swash_init(), internal core use only */ +#define _CORE_SWASH_INIT_USER_DEFINED_PROPERTY 0x1 +#define _CORE_SWASH_INIT_RETURN_IF_UNDEF 0x2 +#define _CORE_SWASH_INIT_ACCEPT_INVLIST 0x4 + +#define to_uni_fold(c, p, lenp) _to_uni_fold_flags(c, p, lenp, FOLD_FLAGS_FULL) #define to_utf8_fold(c, p, lenp) _to_utf8_fold_flags(c, p, lenp, \ FOLD_FLAGS_FULL, NULL) #define to_utf8_lower(a,b,c) _to_utf8_lower_flags(a,b,c,0, NULL) @@ -61,16 +76,25 @@ START_EXTERN_C #ifdef DOINIT EXTCONST unsigned char PL_utf8skip[] = { -1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ -1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ -1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ -1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ -1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus */ -1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus */ -2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* scripts */ -3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6, /* cjk etc. */ -7,13, /* Perl extended (not official UTF-8). Up to 72bit allowed (64-bit + - reserved). */ +/* 0x00 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x20 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x30 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x70 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ +/* 0x80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus: continuation byte */ +/* 0x90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus: continuation byte */ +/* 0xA0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus: continuation byte */ +/* 0xB0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus: continuation byte */ +/* 0xC0 */ 2,2, /* overlong */ +/* 0xC2 */ 2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* U+0080 to U+03FF */ +/* 0xD0 */ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* U+0400 to U+07FF */ +/* 0xE0 */ 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, /* U+0800 to U+FFFF */ +/* 0xF0 */ 4,4,4,4,4,4,4,4,5,5,5,5,6,6, /* above BMP to 2**31 - 1 */ +/* 0xFE */ 7,13, /* Perl extended (never was official UTF-8). Up to 72bit + allowed (64-bit + reserved). */ }; #else EXTCONST unsigned char PL_utf8skip[]; @@ -78,12 +102,17 @@ EXTCONST unsigned char PL_utf8skip[]; END_EXTERN_C +#include "regcharclass.h" +#include "unicode_constants.h" + /* Native character to iso-8859-1 */ #define NATIVE_TO_ASCII(ch) (ch) #define ASCII_TO_NATIVE(ch) (ch) /* Transform after encoding */ #define NATIVE_TO_UTF(ch) (ch) +#define NATIVE_TO_I8(ch) NATIVE_TO_UTF(ch) /* a clearer synonym */ #define UTF_TO_NATIVE(ch) (ch) +#define I8_TO_NATIVE(ch) UTF_TO_NATIVE(ch) /* Transforms in wide UV chars */ #define UNI_TO_NATIVE(ch) (ch) #define NATIVE_TO_UNI(ch) (ch) @@ -93,6 +122,7 @@ END_EXTERN_C /* As there are no translations, avoid the function wrapper */ #define utf8n_to_uvchr utf8n_to_uvuni +#define valid_utf8_to_uvchr valid_utf8_to_uvuni #define uvchr_to_utf8 uvuni_to_utf8 /* @@ -106,29 +136,33 @@ END_EXTERN_C U+0800..U+0FFF E0 * A0..BF 80..BF U+1000..U+CFFF E1..EC 80..BF 80..BF U+D000..U+D7FF ED 80..9F 80..BF - U+D800..U+DFFF +++++++ utf16 surrogates, not legal utf8 +++++++ + U+D800..U+DFFF ED A0..BF 80..BF (surrogates) U+E000..U+FFFF EE..EF 80..BF 80..BF U+10000..U+3FFFF F0 * 90..BF 80..BF 80..BF U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF U+100000..U+10FFFF F4 80..8F 80..BF 80..BF + Below are non-Unicode code points + U+110000..U+13FFFF F4 90..BF 80..BF 80..BF + U+110000..U+1FFFFF F5..F7 80..BF 80..BF 80..BF + U+200000..: F8.. * 88..BF 80..BF 80..BF 80..BF Note the gaps before several of the byte entries above marked by '*'. These are caused by legal UTF-8 avoiding non-shortest encodings: it is technically possible to UTF-8-encode a single code point in different ways, but that is explicitly forbidden, and the shortest possible encoding should always be used -(and that is what Perl does). +(and that is what Perl does). The non-shortest ones are called 'overlongs'. */ /* Another way to look at it, as bits: - Code Points 1st Byte 2nd Byte 3rd Byte 4th Byte + Code Points 1st Byte 2nd Byte 3rd Byte 4th Byte - 0aaaaaaa 0aaaaaaa - 00000bbbbbaaaaaa 110bbbbb 10aaaaaa - ccccbbbbbbaaaaaa 1110cccc 10bbbbbb 10aaaaaa - 00000dddccccccbbbbbbaaaaaa 11110ddd 10cccccc 10bbbbbb 10aaaaaa + 0aaa aaaa 0aaa aaaa + 0000 0bbb bbaa aaaa 110b bbbb 10aa aaaa + cccc bbbb bbaa aaaa 1110 cccc 10bb bbbb 10aa aaaa + 00 000d ddcc cccc bbbb bbaa aaaa 1111 0ddd 10cc cccc 10bb bbbb 10aa aaaa As you can see, the continuation bytes all begin with C<10>, and the leading bits of the start byte tell how many bytes there are in the @@ -138,26 +172,62 @@ Perl's extended UTF-8 means we can have start bytes up to FF. */ +/* Is the representation of the Unicode code point 'c' the same regardless of + * being encoded in UTF-8 or not? */ #define UNI_IS_INVARIANT(c) (((UV)c) < 0x80) -#define UTF8_IS_START(c) (((U8)c) >= 0xc2) -#define UTF8_IS_CONTINUATION(c) (((U8)c) >= 0x80 && (((U8)c) <= 0xbf)) + +/* Is the UTF8-encoded byte 'c' part of a variant sequence in UTF-8? This is + * the inverse of UTF8_IS_INVARIANT */ #define UTF8_IS_CONTINUED(c) (((U8)c) & 0x80) -/* Masking with 0xfe allows low bit to be 0 or 1; thus this matches 0xc[23] */ -#define UTF8_IS_DOWNGRADEABLE_START(c) (((U8)c & 0xfe) == 0xc2) +/* Is the byte 'c' the first byte of a multi-byte UTF8-8 encoded sequence? + * This doesn't catch invariants (they are single-byte). It also excludes the + * illegal overlong sequences that begin with C0 and C1. */ +#define UTF8_IS_START(c) (((U8)c) >= 0xc2) + +/* Is the byte 'c' part of a multi-byte UTF8-8 encoded sequence, and not the + * first byte thereof? */ +#define UTF8_IS_CONTINUATION(c) ((((U8)c) & 0xC0) == 0x80) + +/* Is the UTF8-encoded byte 'c' the first byte of a two byte sequence? Use + * UTF8_IS_NEXT_CHAR_DOWNGRADEABLE() instead if the input isn't known to + * be well-formed. Masking with 0xfe allows the low bit to be 0 or 1; thus + * this matches 0xc[23]. */ +#define UTF8_IS_DOWNGRADEABLE_START(c) (((U8)(c) & 0xfe) == 0xc2) +/* Is the UTF8-encoded byte 'c' the first byte of a sequence of bytes that + * represent a code point > 255? */ +#define UTF8_IS_ABOVE_LATIN1(c) ((U8)(c) >= 0xc4) + +/* This defines the 1-bits that are to be in the first byte of a multi-byte + * UTF-8 encoded character that give the number of bytes that comprise the + * character. + * */ #define UTF_START_MARK(len) (((len) > 7) ? 0xFF : (0xFE << (7-(len)))) + +/* Masks out the initial one bits in a start byte, leaving the real data ones. + * Doesn't work on an invariant byte */ #define UTF_START_MASK(len) (((len) >= 7) ? 0x00 : (0x1F >> ((len)-2))) +/* This defines the bits that are to be in the continuation bytes of a multi-byte + * UTF-8 encoded character that indicate it is a continuation byte. */ #define UTF_CONTINUATION_MARK 0x80 + +/* This is the number of low-order bits a continuation byte in a UTF-8 encoded + * sequence contributes to the specification of the code point. In the bit + * maps above, you see that the first 2 bits are a constant '10', leaving 6 of + * real information */ #define UTF_ACCUMULATION_SHIFT 6 + +/* 2**UTF_ACCUMULATION_SHIFT - 1 */ #define UTF_CONTINUATION_MASK ((U8)0x3f) -/* This sets the UTF_CONTINUATION_MASK in the upper bits of a word. If a value - * is anded with it, and the result is non-zero, then using the original value - * in UTF8_ACCUMULATE will overflow, shifting bits off the left */ +/* If a value is anded with this, and the result is non-zero, then using the + * original value in UTF8_ACCUMULATE will overflow, shifting bits off the left + * */ #define UTF_ACCUMULATION_OVERFLOW_MASK \ - (((UV) UTF_CONTINUATION_MASK) << ((sizeof(UV) * CHARBITS) - UTF_ACCUMULATION_SHIFT)) + (((UV) UTF_CONTINUATION_MASK) << ((sizeof(UV) * CHARBITS) \ + - UTF_ACCUMULATION_SHIFT)) #ifdef HAS_QUAD #define UNISKIP(uv) ( (uv) < 0x80 ? 1 : \ @@ -177,6 +247,25 @@ Perl's extended UTF-8 means we can have start bytes up to FF. (uv) < 0x80000000 ? 6 : 7 ) #endif +/* How wide can a single UTF-8 encoded character become in bytes. */ +/* NOTE: Strictly speaking Perl's UTF-8 should not be called UTF-8 since UTF-8 + * is an encoding of Unicode, and Unicode's upper limit, 0x10FFFF, can be + * expressed with 4 bytes. However, Perl thinks of UTF-8 as a way to encode + * non-negative integers in a binary format, even those above Unicode */ +#define UTF8_MAXBYTES 13 + +/* The maximum number of UTF-8 bytes a single Unicode character can + * uppercase/lowercase/fold into. Unicode guarantees that the maximum + * expansion is 3 characters. On ASCIIish platforms, the highest Unicode + * character occupies 4 bytes, therefore this number would be 12, but this is + * smaller than the maximum width a single above-Unicode character can occupy, + * so use that instead */ +#if UTF8_MAXBYTES < 12 +#error UTF8_MAXBYTES must be at least 12 +#endif + +#define UTF8_MAXBYTES_CASE UTF8_MAXBYTES + #endif /* EBCDIC vs ASCII */ /* Rest of these are attributes of Unicode and perl's internals rather than the @@ -186,7 +275,16 @@ Perl's extended UTF-8 means we can have start bytes up to FF. #define NATIVE8_TO_UNI(ch) NATIVE_TO_ASCII(ch) /* a clearer synonym */ -#define UTF8_ACCUMULATE(old, new) (((old) << UTF_ACCUMULATION_SHIFT) | (((U8)new) & UTF_CONTINUATION_MASK)) +/* Adds a UTF8 continuation byte 'new' of information to a running total code + * point 'old' of all the continuation bytes so far. This is designed to be + * used in a loop to convert from UTF-8 to the code point represented */ +#define UTF8_ACCUMULATE(old, new) (((old) << UTF_ACCUMULATION_SHIFT) \ + | (((U8)new) & UTF_CONTINUATION_MASK)) + +/* This works in the face of malformed UTF-8. */ +#define UTF8_IS_NEXT_CHAR_DOWNGRADEABLE(s, e) (UTF8_IS_DOWNGRADEABLE_START(*s) \ + && ( (e) - (s) > 1) \ + && UTF8_IS_CONTINUATION(*((s)+1))) /* Convert a two (not one) byte utf8 character to a unicode code point value. * Needs just one iteration of accumulate. Should not be used unless it is @@ -197,9 +295,16 @@ Perl's extended UTF-8 means we can have start bytes up to FF. UTF8_ACCUMULATE((NATIVE_TO_UTF(HI) & UTF_START_MASK(2)), \ NATIVE_TO_UTF(LO)) +/* How many bytes in the UTF-8 encoded character whose first (perhaps only) + * byte is pointed to by 's' */ #define UTF8SKIP(s) PL_utf8skip[*(const U8*)(s)] +/* Is the byte 'c' the same character when encoded in UTF-8 as when not. This + * works on both UTF-8 encoded strings and non-encoded, as it returns TRUE in + * each for the exact same set of bit patterns. (And it works on any byte in a + * UTF-8 encoded string) */ #define UTF8_IS_INVARIANT(c) UNI_IS_INVARIANT(NATIVE_TO_UTF(c)) + #define NATIVE_IS_INVARIANT(c) UNI_IS_INVARIANT(NATIVE8_TO_UNI(c)) #define MAX_PORTABLE_UTF8_TWO_BYTE 0x3FF /* constrained by EBCDIC */ @@ -208,8 +313,10 @@ Perl's extended UTF-8 means we can have start bytes up to FF. * bytes from an ordinal that is known to fit into two bytes; it must be less * than 0x3FF to work across both encodings. */ /* Nocast allows these to be used in the case label of a switch statement */ -#define UTF8_TWO_BYTE_HI_nocast(c) UTF_TO_NATIVE(((c) >> UTF_ACCUMULATION_SHIFT) | (0xFF & UTF_START_MARK(2))) -#define UTF8_TWO_BYTE_LO_nocast(c) UTF_TO_NATIVE(((c) & UTF_CONTINUATION_MASK) | UTF_CONTINUATION_MARK) +#define UTF8_TWO_BYTE_HI_nocast(c) NATIVE_TO_I8(((c) \ + >> UTF_ACCUMULATION_SHIFT) | (0xFF & UTF_START_MARK(2))) +#define UTF8_TWO_BYTE_LO_nocast(c) NATIVE_TO_I8(((c) & UTF_CONTINUATION_MASK) \ + | UTF_CONTINUATION_MARK) #define UTF8_TWO_BYTE_HI(c) ((U8) (UTF8_TWO_BYTE_HI_nocast(c))) #define UTF8_TWO_BYTE_LO(c) ((U8) (UTF8_TWO_BYTE_LO_nocast(c))) @@ -228,30 +335,13 @@ Perl's extended UTF-8 means we can have start bytes up to FF. #define isIDFIRST_lazy_if(p,UTF) ((IN_BYTES || !UTF ) \ ? isIDFIRST(*(p)) \ : isIDFIRST_utf8((const U8*)p)) -#define isALNUM_lazy_if(p,UTF) ((IN_BYTES || (!UTF )) \ - ? isALNUM(*(p)) \ - : isALNUM_utf8((const U8*)p)) - -#define isIDFIRST_lazy(p) isIDFIRST_lazy_if(p,1) -#define isALNUM_lazy(p) isALNUM_lazy_if(p,1) +#define isWORDCHAR_lazy_if(p,UTF) ((IN_BYTES || (!UTF )) \ + ? isWORDCHAR(*(p)) \ + : isWORDCHAR_utf8((const U8*)p)) +#define isALNUM_lazy_if(p,UTF) isWORDCHAR_lazy_if(p,UTF) -#define UTF8_MAXBYTES 13 -/* How wide can a single UTF-8 encoded character become in bytes. - * NOTE: Strictly speaking Perl's UTF-8 should not be called UTF-8 - * since UTF-8 is an encoding of Unicode and given Unicode's current - * upper limit only four bytes is possible. Perl thinks of UTF-8 - * as a way to encode non-negative integers in a binary format. */ #define UTF8_MAXLEN UTF8_MAXBYTES -/* The maximum number of UTF-8 bytes a single Unicode character can - * uppercase/lowercase/fold into; this number depends on the Unicode - * version. An example of maximal expansion is the U+03B0 which - * uppercases to U+03C5 U+0308 U+0301. The Unicode databases that - * tell these things are UnicodeData.txt, CaseFolding.txt, and - * SpecialCasing.txt. The value is 6 for strict Unicode characters, but it has - * to be as big as Perl allows for a single character */ -#define UTF8_MAXBYTES_CASE UTF8_MAXBYTES - /* A Unicode character can fold to up to 3 characters */ #define UTF8_MAX_FOLD_CHAR_EXPAND 3 @@ -313,24 +403,11 @@ Perl's extended UTF-8 means we can have start bytes up to FF. * problematic in some contexts. This allows code that needs to check for * those to to quickly exclude the vast majority of code points it will * encounter */ -#ifdef EBCDIC -# define UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE UTF_TO_NATIVE(0xF1) -#else -# define UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE 0xED -#endif +#define UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE \ + FIRST_SURROGATE_UTF8_FIRST_BYTE -/* ASCII EBCDIC I8 - * U+D7FF: \xED\x9F\xBF \xF1\xB5\xBF\xBF last before surrogates - * U+D800: \xED\xA0\x80 \xF1\xB6\xA0\xA0 1st surrogate - * U+DFFF: \xED\xBF\xBF \xF1\xB7\xBF\xBF final surrogate - * U+E000: \xEE\x80\x80 \xF1\xB8\xA0\xA0 next after surrogates - */ -#ifdef EBCDIC /* Both versions assume well-formed UTF8 */ -# define UTF8_IS_SURROGATE(s) (*(s) == UTF_TO_NATIVE(0xF1) \ - && ((*((s) +1) == UTF_TO_NATIVE(0xB6)) || *((s) + 1) == UTF_TO_NATIVE(0xB7))) -#else -# define UTF8_IS_SURROGATE(s) (*(s) == 0xED && *((s) + 1) >= 0xA0) -#endif +#define UTF8_IS_SURROGATE(s) cBOOL(is_SURROGATE_utf8(s)) +#define UTF8_IS_REPLACEMENT(s, send) cBOOL(is_REPLACEMENT_utf8_safe(s,send)) /* ASCII EBCDIC I8 * U+10FFFF: \xF4\x8F\xBF\xBF \xF9\xA1\xBF\xBF\xBF max legal Unicode @@ -338,67 +415,20 @@ Perl's extended UTF-8 means we can have start bytes up to FF. * U+110001: \xF4\x90\x80\x81 \xF9\xA2\xA0\xA0\xA1 */ #ifdef EBCDIC /* Both versions assume well-formed UTF8 */ -# define UTF8_IS_SUPER(s) (*(s) >= UTF_TO_NATIVE(0xF9) \ - && (*(s) > UTF_TO_NATIVE(0xF9) || (*((s) + 1) >= UTF_TO_NATIVE(0xA2)))) +# define UTF8_IS_SUPER(s) (NATIVE_TO_I8(* (U8*) (s)) >= 0xF9 \ + && (NATIVE_TO_I8(* (U8*) (s)) > 0xF9 \ + || (NATIVE_TO_I8(* (U8*) ((s)) + 1 >= 0xA2)))) #else -# define UTF8_IS_SUPER(s) (*(s) >= 0xF4 \ - && (*(s) > 0xF4 || (*((s) + 1) >= 0x90))) +# define UTF8_IS_SUPER(s) (*(U8*) (s) >= 0xF4 \ + && (*(U8*) (s) > 0xF4 || (*((U8*) (s) + 1) >= 0x90))) #endif -/* ASCII EBCDIC I8 - * U+FDCF: \xEF\xB7\x8F \xF1\xBF\xAE\xAF last before non-char block - * U+FDD0: \xEF\xB7\x90 \xF1\xBF\xAE\xB0 first non-char in block - * U+FDEF: \xEF\xB7\xAF \xF1\xBF\xAF\xAF last non-char in block - * U+FDF0: \xEF\xB7\xB0 \xF1\xBF\xAF\xB0 first after non-char block - * U+FFFF: \xEF\xBF\xBF \xF1\xBF\xBF\xBF - * U+1FFFF: \xF0\x9F\xBF\xBF \xF3\xBF\xBF\xBF - * U+2FFFF: \xF0\xAF\xBF\xBF \xF5\xBF\xBF\xBF - * U+3FFFF: \xF0\xBF\xBF\xBF \xF7\xBF\xBF\xBF - * U+4FFFF: \xF1\x8F\xBF\xBF \xF8\xA9\xBF\xBF\xBF - * U+5FFFF: \xF1\x9F\xBF\xBF \xF8\xAB\xBF\xBF\xBF - * U+6FFFF: \xF1\xAF\xBF\xBF \xF8\xAD\xBF\xBF\xBF - * U+7FFFF: \xF1\xBF\xBF\xBF \xF8\xAF\xBF\xBF\xBF - * U+8FFFF: \xF2\x8F\xBF\xBF \xF8\xB1\xBF\xBF\xBF - * U+9FFFF: \xF2\x9F\xBF\xBF \xF8\xB3\xBF\xBF\xBF - * U+AFFFF: \xF2\xAF\xBF\xBF \xF8\xB5\xBF\xBF\xBF - * U+BFFFF: \xF2\xBF\xBF\xBF \xF8\xB7\xBF\xBF\xBF - * U+CFFFF: \xF3\x8F\xBF\xBF \xF8\xB9\xBF\xBF\xBF - * U+DFFFF: \xF3\x9F\xBF\xBF \xF8\xBB\xBF\xBF\xBF - * U+EFFFF: \xF3\xAF\xBF\xBF \xF8\xBD\xBF\xBF\xBF - * U+FFFFF: \xF3\xBF\xBF\xBF \xF8\xBF\xBF\xBF\xBF - * U+10FFFF: \xF4\x8F\xBF\xBF \xF9\xA1\xBF\xBF\xBF - */ -#define UTF8_IS_NONCHAR_(s) ( \ - *(s) >= UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE \ - && ! UTF8_IS_SUPER(s) \ - && UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_FIRST_PROBLEMATIC(s) \ - -#ifdef EBCDIC /* Both versions assume well-formed UTF8 */ -# define UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC(s) \ - ((*(s) == UTF_TO_NATIVE(0xF1) \ - && (*((s) + 1) == UTF_TO_NATIVE(0xBF) \ - && ((*((s) + 2) == UTF_TO_NATIVE(0xAE) \ - && *((s) + 3) >= UTF_TO_NATIVE(0xB0)) \ - || (*((s) + 2) == UTF_TO_NATIVE(0xAF) \ - && *((s) + 3) <= UTF_TO_NATIVE(0xAF))))) \ - || (UTF8SKIP(*(s)) > 3 \ - /* (These were all derived by inspection and experimentation with an */ \ - /* editor) The next line checks the next to final byte in the char */ \ - && *((s) + UTF8SKIP(*(s)) - 2) == UTF_TO_NATIVE(0xBF) \ - && *((s) + UTF8SKIP(*(s)) - 3) == UTF_TO_NATIVE(0xBF) \ - && (NATIVE_TO_UTF(*((s) + UTF8SKIP(*(s)) - 4)) & 0x81) == 0x81 \ - && (NATIVE_TO_UTF(*((s) + UTF8SKIP(*(s)) - 1)) & 0xBE) == 0XBE)) -#else -# define UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC(s) \ - ((*(s) == 0xEF \ - && ((*((s) + 1) == 0xB7 && (*((s) + 2) >= 0x90 && (*((s) + 2) <= 0xAF)))\ - /* Gets U+FFF[EF] */ \ - || (*((s) + 1) == 0xBF && ((*((s) + 2) & 0xBE) == 0xBE)))) \ - || ((*((s) + 2) == 0xBF \ - && (*((s) + 3) & 0xBE) == 0xBE \ - /* Excludes things like U+10FFE = \xF0\x90\xBF\xBE */ \ - && (*((s) + 1) & 0x8F) == 0x8F))) -#endif +/* These are now machine generated, and the 'given' clause is no longer + * applicable */ +#define UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC(s) \ + cBOOL(is_NONCHAR_utf8(s)) +#define UTF8_IS_NONCHAR_(s) \ + UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC(s) #define UNICODE_SURROGATE_FIRST 0xD800 #define UNICODE_SURROGATE_LAST 0xDFFF @@ -417,10 +447,10 @@ Perl's extended UTF-8 means we can have start bytes up to FF. #define UNICODE_DISALLOW_NONCHAR 0x0020 #define UNICODE_DISALLOW_SUPER 0x0040 #define UNICODE_DISALLOW_FE_FF 0x0080 -#define UNICODE_WARN_ILLEGAL_INTERCHANGE \ - (UNICODE_WARN_SURROGATE|UNICODE_WARN_NONCHAR|UNICODE_WARN_SUPER) -#define UNICODE_DISALLOW_ILLEGAL_INTERCHANGE \ - (UNICODE_DISALLOW_SURROGATE|UNICODE_DISALLOW_NONCHAR|UNICODE_DISALLOW_SUPER) +#define UNICODE_WARN_ILLEGAL_INTERCHANGE \ + (UNICODE_WARN_SURROGATE|UNICODE_WARN_NONCHAR|UNICODE_WARN_SUPER) +#define UNICODE_DISALLOW_ILLEGAL_INTERCHANGE \ + (UNICODE_DISALLOW_SURROGATE|UNICODE_DISALLOW_NONCHAR|UNICODE_DISALLOW_SUPER) /* For backward source compatibility, as are now the default */ #define UNICODE_ALLOW_SURROGATE 0 @@ -445,6 +475,14 @@ Perl's extended UTF-8 means we can have start bytes up to FF. # define UTF8_QUAD_MAX UINT64_C(0x1000000000) #endif +#define LATIN_SMALL_LETTER_SHARP_S LATIN_SMALL_LETTER_SHARP_S_NATIVE +#define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS \ + LATIN_SMALL_LETTER_Y_WITH_DIAERESIS_NATIVE +#define MICRO_SIGN MICRO_SIGN_NATIVE +#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE \ + LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE_NATIVE +#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE \ + LATIN_SMALL_LETTER_A_WITH_RING_ABOVE_NATIVE #define UNICODE_GREEK_CAPITAL_LETTER_SIGMA 0x03A3 #define UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA 0x03C2 #define UNICODE_GREEK_SMALL_LETTER_SIGMA 0x03C3 @@ -452,20 +490,15 @@ Perl's extended UTF-8 means we can have start bytes up to FF. #define GREEK_CAPITAL_LETTER_MU 0x039C /* Upper and title case of MICRON */ #define LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS 0x0178 /* Also is title case */ #define LATIN_CAPITAL_LETTER_SHARP_S 0x1E9E +#define LATIN_SMALL_LETTER_LONG_S 0x017F +#define KELVIN_SIGN 0x212A +#define ANGSTROM_SIGN 0x212B #define UNI_DISPLAY_ISPRINT 0x0001 #define UNI_DISPLAY_BACKSLASH 0x0002 #define UNI_DISPLAY_QQ (UNI_DISPLAY_ISPRINT|UNI_DISPLAY_BACKSLASH) #define UNI_DISPLAY_REGEX (UNI_DISPLAY_ISPRINT|UNI_DISPLAY_BACKSLASH) -#ifndef EBCDIC -# define LATIN_SMALL_LETTER_SHARP_S 0x00DF -# define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0x00FF -# define MICRO_SIGN 0x00B5 -# define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x00C5 -# define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x00E5 -#endif - #define ANYOF_FOLD_SHARP_S(node, input, end) \ (ANYOF_BITMAP_TEST(node, LATIN_SMALL_LETTER_SHARP_S) && \ (ANYOF_NONBITMAP(node)) && \ @@ -475,138 +508,71 @@ Perl's extended UTF-8 means we can have start bytes up to FF. toLOWER((input)[1]) == 's') #define SHARP_S_SKIP 2 +/* If you want to exclude surrogates, and beyond legal Unicode, see the blame + * log for earlier versions which gave details for these */ + #ifndef EBCDIC -# define IS_UTF8_CHAR_1(p) \ - ((p)[0] <= 0x7F) -# define IS_UTF8_CHAR_2(p) \ - ((p)[0] >= 0xC2 && (p)[0] <= 0xDF && \ - (p)[1] >= 0x80 && (p)[1] <= 0xBF) -# define IS_UTF8_CHAR_3a(p) \ - ((p)[0] == 0xE0 && \ - (p)[1] >= 0xA0 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF) -# define IS_UTF8_CHAR_3b(p) \ - ((p)[0] >= 0xE1 && (p)[0] <= 0xEC && \ - (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF) -# define IS_UTF8_CHAR_3c(p) \ - ((p)[0] == 0xED && \ - (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF) - /* In IS_UTF8_CHAR_3c(p) one could use - * (p)[1] >= 0x80 && (p)[1] <= 0x9F - * if one wanted to exclude surrogates. */ -# define IS_UTF8_CHAR_3d(p) \ - ((p)[0] >= 0xEE && (p)[0] <= 0xEF && \ - (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF) -# define IS_UTF8_CHAR_4a(p) \ - ((p)[0] == 0xF0 && \ - (p)[1] >= 0x90 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF && \ - (p)[3] >= 0x80 && (p)[3] <= 0xBF) -# define IS_UTF8_CHAR_4b(p) \ - ((p)[0] >= 0xF1 && (p)[0] <= 0xF3 && \ - (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF && \ - (p)[3] >= 0x80 && (p)[3] <= 0xBF) -/* In IS_UTF8_CHAR_4c(p) one could use - * (p)[0] == 0xF4 - * if one wanted to stop at the Unicode limit U+10FFFF. - * The 0xF7 allows us to go to 0x1fffff (0x200000 would - * require five bytes). Not doing any further code points - * since that is not needed (and that would not be strict - * UTF-8, anyway). The "slow path" in Perl_is_utf8_char() - * will take care of the "extended UTF-8". */ -# define IS_UTF8_CHAR_4c(p) \ - ((p)[0] >= 0xF4 && (p)[0] <= 0xF7 && \ - (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ - (p)[2] >= 0x80 && (p)[2] <= 0xBF && \ - (p)[3] >= 0x80 && (p)[3] <= 0xBF) - -# define IS_UTF8_CHAR_3(p) \ - (IS_UTF8_CHAR_3a(p) || \ - IS_UTF8_CHAR_3b(p) || \ - IS_UTF8_CHAR_3c(p) || \ - IS_UTF8_CHAR_3d(p)) -# define IS_UTF8_CHAR_4(p) \ - (IS_UTF8_CHAR_4a(p) || \ - IS_UTF8_CHAR_4b(p) || \ - IS_UTF8_CHAR_4c(p)) +/* This was generated by regen/regcharclass.pl, and then moved here. The lines + * that generated it were then commented out. This was done solely because it + * takes on the order of 10 minutes to generate, and is never going to change. + * The EBCDIC equivalent hasn't been commented out in regcharclass.pl, so it + * should generate and run the correct stuff */ +/* + UTF8_CHAR: Matches utf8 from 1 to 4 bytes + + 0x0 - 0x1FFFFF +*/ +/*** GENERATED CODE ***/ +#define is_UTF8_CHAR_utf8_safe(s,e) \ +( ((e)-(s) > 3) ? \ + ( ( ( ((U8*)s)[0] & 0x80 ) == 0x00 ) ? 1 \ + : ( 0xC2 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xDF ) ? \ + ( ( ( ((U8*)s)[1] & 0xC0 ) == 0x80 ) ? 2 : 0 ) \ + : ( 0xE0 == ((U8*)s)[0] ) ? \ + ( ( ( ( ((U8*)s)[1] & 0xE0 ) == 0xA0 ) && ( ( ((U8*)s)[2] & 0xC0 ) == 0x80 ) ) ? 3 : 0 )\ + : ( 0xE1 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xEF ) ? \ + ( ( ( ( ((U8*)s)[1] & 0xC0 ) == 0x80 ) && ( ( ((U8*)s)[2] & 0xC0 ) == 0x80 ) ) ? 3 : 0 )\ + : ( 0xF0 == ((U8*)s)[0] ) ? \ + ( ( ( ( 0x90 <= ((U8*)s)[1] && ((U8*)s)[1] <= 0xBF ) && ( ( ((U8*)s)[2] & 0xC0 ) == 0x80 ) ) && ( ( ((U8*)s)[3] & 0xC0 ) == 0x80 ) ) ? 4 : 0 )\ + : ( ( ( ( 0xF1 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xF7 ) && ( ( ((U8*)s)[1] & 0xC0 ) == 0x80 ) ) && ( ( ((U8*)s)[2] & 0xC0 ) == 0x80 ) ) && ( ( ((U8*)s)[3] & 0xC0 ) == 0x80 ) ) ? 4 : 0 )\ +: ((e)-(s) > 2) ? \ + ( ( ( ((U8*)s)[0] & 0x80 ) == 0x00 ) ? 1 \ + : ( 0xC2 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xDF ) ? \ + ( ( ( ((U8*)s)[1] & 0xC0 ) == 0x80 ) ? 2 : 0 ) \ + : ( 0xE0 == ((U8*)s)[0] ) ? \ + ( ( ( ( ((U8*)s)[1] & 0xE0 ) == 0xA0 ) && ( ( ((U8*)s)[2] & 0xC0 ) == 0x80 ) ) ? 3 : 0 )\ + : ( ( ( 0xE1 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xEF ) && ( ( ((U8*)s)[1] & 0xC0 ) == 0x80 ) ) && ( ( ((U8*)s)[2] & 0xC0 ) == 0x80 ) ) ? 3 : 0 )\ +: ((e)-(s) > 1) ? \ + ( ( ( ((U8*)s)[0] & 0x80 ) == 0x00 ) ? 1 \ + : ( ( 0xC2 <= ((U8*)s)[0] && ((U8*)s)[0] <= 0xDF ) && ( ( ((U8*)s)[1] & 0xC0 ) == 0x80 ) ) ? 2 : 0 )\ +: ((e)-(s) > 0) ? \ + ( ( ((U8*)s)[0] & 0x80 ) == 0x00 ) \ +: 0 ) +#endif /* IS_UTF8_CHAR(p) is strictly speaking wrong (not UTF-8) because it * (1) allows UTF-8 encoded UTF-16 surrogates * (2) it allows code points past U+10FFFF. * The Perl_is_utf8_char() full "slow" code will handle the Perl * "extended UTF-8". */ -# define IS_UTF8_CHAR(p, n) \ - ((n) == 1 ? IS_UTF8_CHAR_1(p) : \ - (n) == 2 ? IS_UTF8_CHAR_2(p) : \ - (n) == 3 ? IS_UTF8_CHAR_3(p) : \ - (n) == 4 ? IS_UTF8_CHAR_4(p) : 0) - -# define IS_UTF8_CHAR_FAST(n) ((n) <= 4) - -#else /* EBCDIC */ - -/* This is an attempt to port IS_UTF8_CHAR to EBCDIC based on eyeballing. - * untested. If want to exclude surrogates and above-Unicode, see the - * definitions for UTF8_IS_SURROGATE and UTF8_IS_SUPER */ -# define IS_UTF8_CHAR_1(p) \ - (NATIVE_TO_ASCII((p)[0]) <= 0x9F) -# define IS_UTF8_CHAR_2(p) \ - (NATIVE_TO_I8((p)[0]) >= 0xC5 && NATIVE_TO_I8((p)[0]) <= 0xDF && \ - NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF) -# define IS_UTF8_CHAR_3(p) \ - (NATIVE_TO_I8((p)[0]) == 0xE1 && NATIVE_TO_I8((p)[1]) <= 0xEF && \ - NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF) -# define IS_UTF8_CHAR_4a(p) \ - (NATIVE_TO_I8((p)[0]) == 0xF0 && \ - NATIVE_TO_I8((p)[1]) >= 0xB0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ - NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) -# define IS_UTF8_CHAR_4b(p) \ - (NATIVE_TO_I8((p)[0]) >= 0xF1 && NATIVE_TO_I8((p)[0]) <= 0xF7 && \ - NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ - NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) -# define IS_UTF8_CHAR_5a(p) \ - (NATIVE_TO_I8((p)[0]) == 0xF8 && \ - NATIVE_TO_I8((p)[1]) >= 0xA8 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ - NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) -# define IS_UTF8_CHAR_5b(p) \ - (NATIVE_TO_I8((p)[0]) >= 0xF9 && NATIVE_TO_I8((p)[1]) <= 0xFB && \ - NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ - NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ - NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) - -# define IS_UTF8_CHAR_4(p) \ - (IS_UTF8_CHAR_4a(p) || \ - IS_UTF8_CHAR_4b(p)) -# define IS_UTF8_CHAR_5(p) \ - (IS_UTF8_CHAR_5a(p) || \ - IS_UTF8_CHAR_5b(p)) -# define IS_UTF8_CHAR(p, n) \ - ((n) == 1 ? IS_UTF8_CHAR_1(p) : \ - (n) == 2 ? IS_UTF8_CHAR_2(p) : \ - (n) == 3 ? IS_UTF8_CHAR_3(p) : \ - (n) == 4 ? IS_UTF8_CHAR_4(p) : \ - (n) == 5 ? IS_UTF8_CHAR_5(p) : 0) +#define IS_UTF8_CHAR(p, n) (is_UTF8_CHAR_utf8_safe(p, (p) + (n)) == n) +/* regen/regcharclass.pl generates is_UTF8_CHAR_utf8_safe() macros for up to + * these number of bytes. So this has to be coordinated with it */ +#ifdef EBCDIC # define IS_UTF8_CHAR_FAST(n) ((n) <= 5) +#else +# define IS_UTF8_CHAR_FAST(n) ((n) <= 4) +#endif -#endif /* IS_UTF8_CHAR() for UTF-8 */ +#endif /* H_UTF8 */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/utfebcdic.h b/Master/tlpkg/tlperl/lib/CORE/utfebcdic.h index eff444e7fde..e7f5f32c69f 100644 --- a/Master/tlpkg/tlperl/lib/CORE/utfebcdic.h +++ b/Master/tlpkg/tlperl/lib/CORE/utfebcdic.h @@ -152,7 +152,7 @@ unsigned char PL_utf8skip[] = { * remains 'A' */ #if '^' == 95 /* if defined(__MVS__) || defined(??) (VM/ESA?) 1047 */ -EXTCONST unsigned char PL_utf2e[] = { /* I8 to EBCDIC (IBM-1047) */ +EXTCONST unsigned char PL_utf2e[] = { /* I8 to UTFEBCDIC (IBM-1047) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, @@ -171,7 +171,7 @@ EXTCONST unsigned char PL_utf2e[] = { /* I8 to EBCDIC (IBM-1047) */ 0xDC, 0xDD, 0xDE, 0xDF, 0xE1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }; -EXTCONST unsigned char PL_e2utf[] = { /* EBCDIC (IBM-1047) to I8 */ +EXTCONST unsigned char PL_e2utf[] = { /* UTFEBCDIC (IBM-1047) to I8 */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, @@ -192,7 +192,7 @@ EXTCONST unsigned char PL_e2utf[] = { /* EBCDIC (IBM-1047) to I8 */ #endif /* 1047 */ #if '^' == 106 /* if defined(_OSD_POSIX) POSIX-BC */ -unsigned char PL_utf2e[] = { /* I8 to EBCDIC (POSIX-BC) */ +unsigned char PL_utf2e[] = { /* I8 to UTFEBCDIC (POSIX-BC) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, @@ -211,7 +211,7 @@ unsigned char PL_utf2e[] = { /* I8 to EBCDIC (POSIX-BC) */ 0xDC, 0xC0, 0xDE, 0xDF, 0xE1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xFA, 0xDD, 0xFC, 0xE0, 0xFE }; -unsigned char PL_e2utf[] = { /* EBCDIC (POSIX-BC) to I8 */ +unsigned char PL_e2utf[] = { /* UTFEBCDIC (POSIX-BC) to I8 */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, @@ -232,7 +232,7 @@ unsigned char PL_e2utf[] = { /* EBCDIC (POSIX-BC) to I8 */ #endif /* POSIX-BC */ #if '^' == 176 /* if defined(??) (OS/400?) 037 */ -unsigned char PL_utf2e[] = { /* I8 to EBCDIC (IBM-037) */ +unsigned char PL_utf2e[] = { /* I8 to UTFEBCDIC (IBM-037) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, @@ -251,7 +251,7 @@ unsigned char PL_utf2e[] = { /* I8 to EBCDIC (IBM-037) */ 0xDC, 0xDD, 0xDE, 0xDF, 0xE1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }; -unsigned char PL_e2utf[] = { /* EBCDIC (IBM-037) to I8 */ +unsigned char PL_e2utf[] = { /* UTFEBCDIC (IBM-037) to I8 */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x85, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x0A, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, @@ -295,12 +295,6 @@ EXTCONST unsigned char PL_a2e[] = { /* ASCII (iso-8859-1) to EBCDIC (IBM-1047) * 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, 0x70, 0xDD, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; -#define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0xDF -#define LATIN_SMALL_LETTER_SHARP_S 0x59 -#define MICRO_SIGN 0xA0 -#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x0067 -#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x0047 - EXTCONST unsigned char PL_e2a[] = { /* EBCDIC (IBM-1047) to ASCII (iso-8859-1) */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, @@ -377,12 +371,6 @@ EXTCONST unsigned char PL_a2e[] = { /* ASCII (ISO8859-1) to EBCDIC (POSIX-BC) */ 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, 0x70, 0xC0, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; -#define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0xDF -#define LATIN_SMALL_LETTER_SHARP_S 0x59 -#define MICRO_SIGN 0xA0 -#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x0067 -#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x0047 - EXTCONST unsigned char PL_e2a[] = { /* EBCDIC (POSIX-BC) to ASCII (ISO8859-1) */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, @@ -459,13 +447,6 @@ EXTCONST unsigned char PL_a2e[] = { /* ASCII (ISO8859-1) to EBCDIC (IBM-037) */ 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, 0x70, 0xDD, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; - -#define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0xDF -#define LATIN_SMALL_LETTER_SHARP_S 0x59 -#define MICRO_SIGN 0xA0 -#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x0067 -#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x0047 - EXTCONST unsigned char PL_e2a[] = { /* EBCDIC (IBM-037) to ASCII (ISO8859-1) */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x85, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, @@ -522,6 +503,10 @@ EXTCONST unsigned char PL_fold[] = { /* fast EBCDIC case folding table, 'A' => }; #endif /* 037 */ +/* Since the EBCDIC code pages are isomorphic to Latin1, that table is merely a + * duplicate */ +EXTCONST unsigned char * PL_fold_latin1 = PL_fold; + #else EXTCONST unsigned char PL_utf8skip[]; EXTCONST unsigned char PL_e2utf[]; @@ -529,12 +514,9 @@ EXTCONST unsigned char PL_utf2e[]; EXTCONST unsigned char PL_e2a[]; EXTCONST unsigned char PL_a2e[]; EXTCONST unsigned char PL_fold[]; +EXTCONST unsigned char * PL_fold_latin1; #endif -/* Since the EBCDIC code pages are isomorphic to Latin1, that table is merely a - * duplicate */ -EXTCONST unsigned char * PL_fold_latin1 = PL_fold; - END_EXTERN_C /* EBCDIC-happy ways of converting native code to UTF-8 */ @@ -560,8 +542,6 @@ END_EXTERN_C Unicode Bit pattern 1st Byte 2nd Byte 3rd Byte 4th Byte 5th Byte 6th Byte 7th byte U+0000..U+007F 000000000xxxxxxx 0xxxxxxx U+0080..U+009F 00000000100xxxxx 100xxxxx - U+00A0..U+00FF 00000000yyyxxxxx 11000yyy 101xxxxx - U+00A0..U+03FF 000000yyyyyxxxxx 110yyyyy 101xxxxx U+0400..U+3FFF 00zzzzyyyyyxxxxx 1110zzzz 101yyyyy 101xxxxx U+4000..U+3FFFF 0wwwzzzzzyyyyyxxxxx 11110www 101zzzzz 101yyyyy 101xxxxx @@ -581,14 +561,17 @@ END_EXTERN_C (uv) < 0x400000 ? 5 : \ (uv) < 0x4000000 ? 6 : 7 ) - #define UNI_IS_INVARIANT(c) ((c) < 0xA0) -/* UTF-EBCDIC semantic macros - transform back into I8 and then compare */ + +/* UTF-EBCDIC semantic macros - transform back into I8 and then compare + * Comments as to the meaning of each are given at their corresponding utf8.h + * definitions */ #define UTF8_IS_START(c) (NATIVE_TO_UTF(c) >= 0xC5 && NATIVE_TO_UTF(c) != 0xE0) #define UTF8_IS_CONTINUATION(c) ((NATIVE_TO_UTF(c) & 0xE0) == 0xA0) #define UTF8_IS_CONTINUED(c) (NATIVE_TO_UTF(c) >= 0xA0) #define UTF8_IS_DOWNGRADEABLE_START(c) (NATIVE_TO_UTF(c) >= 0xC5 && NATIVE_TO_UTF(c) <= 0xC7) +#define UTF8_IS_ABOVE_LATIN1(c) (NATIVE_TO_I8(c) >= 0xC8) #define UTF_START_MARK(len) (((len) > 7) ? 0xFF : ((U8)(0xFE << (7-(len))))) #define UTF_START_MASK(len) (((len) >= 6) ? 0x01 : (0x1F >> ((len)-2))) @@ -596,12 +579,25 @@ END_EXTERN_C #define UTF_CONTINUATION_MASK ((U8)0x1f) #define UTF_ACCUMULATION_SHIFT 5 +/* How wide can a single UTF-8 encoded character become in bytes. */ +/* NOTE: Strictly speaking Perl's UTF-8 should not be called UTF-8 since UTF-8 + * is an encoding of Unicode, and Unicode's upper limit, 0x10FFFF, can be + * expressed with 5 bytes. However, Perl thinks of UTF-8 as a way to encode + * non-negative integers in a binary format, even those above Unicode */ +#define UTF8_MAXBYTES 7 + +/* The maximum number of UTF-8 bytes a single Unicode character can + * uppercase/lowercase/fold into. Unicode guarantees that the maximum + * expansion is 3 characters. On EBCDIC platforms, the highest Unicode + * character occupies 5 bytes, therefore this number is 15 */ +#define UTF8_MAXBYTES_CASE 15 + /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/util.h b/Master/tlpkg/tlperl/lib/CORE/util.h index 3981656eae9..ed133c464bd 100644 --- a/Master/tlpkg/tlperl/lib/CORE/util.h +++ b/Master/tlpkg/tlperl/lib/CORE/util.h @@ -13,7 +13,7 @@ (*(f) == '/' \ || (strchr(f,':') \ || ((*(f) == '[' || *(f) == '<') \ - && (isALNUM((f)[1]) || strchr("$-_]>",(f)[1]))))) + && (isWORDCHAR((f)[1]) || strchr("$-_]>",(f)[1]))))) #else /* !VMS */ # if defined(WIN32) || defined(__CYGWIN__) @@ -27,11 +27,11 @@ || ((f)[0] == '\\' && (f)[1] == '\\') /* UNC path */ \ || ((f)[3] == ':')) /* volume name, currently only sys */ # else /* !NETWARE */ -# if defined(DOSISH) || defined(EPOC) || defined(__SYMBIAN32__) +# if defined(DOSISH) || defined(__SYMBIAN32__) # define PERL_FILE_IS_ABSOLUTE(f) \ (*(f) == '/' \ || ((f)[0] && (f)[1] == ':')) /* drive name */ -# else /* NEITHER DOSISH NOR EPOCISH NOR SYMBIANISH */ +# else /* NEITHER DOSISH NOR SYMBIANISH */ # define PERL_FILE_IS_ABSOLUTE(f) (*(f) == '/') # endif /* DOSISH */ # endif /* NETWARE */ @@ -57,8 +57,8 @@ This is a synonym for (! foldEQ_locale()) * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 - * indent-tabs-mode: t + * indent-tabs-mode: nil * End: * - * ex: set ts=8 sts=4 sw=4 noet: + * ex: set ts=8 sts=4 sw=4 et: */ diff --git a/Master/tlpkg/tlperl/lib/CORE/vmem.h b/Master/tlpkg/tlperl/lib/CORE/vmem.h index 460f55793a8..d691635db59 100644 --- a/Master/tlpkg/tlperl/lib/CORE/vmem.h +++ b/Master/tlpkg/tlperl/lib/CORE/vmem.h @@ -9,8 +9,8 @@ * Options: * * Defining _USE_MSVCRT_MEM_ALLOC will cause all memory allocations - * to be forwarded to MSVCRT.DLL. Defining _USE_LINKED_LIST as well will - * track all allocations in a doubly linked list, so that the host can + * to be forwarded to the compiler's MSVCR*.DLL. Defining _USE_LINKED_LIST as + * well will track all allocations in a doubly linked list, so that the host can * free all memory allocated when it goes away. * If _USE_MSVCRT_MEM_ALLOC is not defined then Knuth's boundary tag algorithm * is used; defining _USE_BUDDY_BLOCKS will use Knuth's algorithm R @@ -65,13 +65,10 @@ inline void MEMODSlx(char *str, long x) #endif /* - * Pass all memory requests throught to msvcrt.dll - * optionaly track by using a doubly linked header + * Pass all memory requests through to the compiler's msvcr*.dll. + * Optionaly track by using a doubly linked header. */ -typedef void (*LPFREE)(void *block); -typedef void* (*LPMALLOC)(size_t size); -typedef void* (*LPREALLOC)(void *block, size_t size); #ifdef _USE_LINKED_LIST class VMem; typedef struct _MemoryBlockHeader* PMEMORY_BLOCK_HEADER; @@ -87,14 +84,14 @@ class VMem public: VMem(); ~VMem(); - virtual void* Malloc(size_t size); - virtual void* Realloc(void* pMem, size_t size); - virtual void Free(void* pMem); - virtual void GetLock(void); - virtual void FreeLock(void); - virtual int IsLocked(void); - virtual long Release(void); - virtual long AddRef(void); + void* Malloc(size_t size); + void* Realloc(void* pMem, size_t size); + void Free(void* pMem); + void GetLock(void); + void FreeLock(void); + int IsLocked(void); + long Release(void); + long AddRef(void); inline BOOL CreateOk(void) { @@ -121,30 +118,20 @@ protected: } MEMORY_BLOCK_HEADER m_Dummy; + CRITICAL_SECTION m_cs; // access lock #endif long m_lRefCount; // number of current users - CRITICAL_SECTION m_cs; // access lock - HINSTANCE m_hLib; - LPFREE m_pfree; - LPMALLOC m_pmalloc; - LPREALLOC m_prealloc; }; VMem::VMem() { m_lRefCount = 1; - InitializeCriticalSection(&m_cs); #ifdef _USE_LINKED_LIST + InitializeCriticalSection(&m_cs); m_Dummy.pNext = m_Dummy.pPrev = &m_Dummy; m_Dummy.owner = this; #endif - m_hLib = LoadLibrary("msvcrt.dll"); - if (m_hLib) { - m_pfree = (LPFREE)GetProcAddress(m_hLib, "free"); - m_pmalloc = (LPMALLOC)GetProcAddress(m_hLib, "malloc"); - m_prealloc = (LPREALLOC)GetProcAddress(m_hLib, "realloc"); - } } VMem::~VMem(void) @@ -153,17 +140,15 @@ VMem::~VMem(void) while (m_Dummy.pNext != &m_Dummy) { Free(m_Dummy.pNext+1); } -#endif - if (m_hLib) - FreeLibrary(m_hLib); DeleteCriticalSection(&m_cs); +#endif } void* VMem::Malloc(size_t size) { #ifdef _USE_LINKED_LIST GetLock(); - PMEMORY_BLOCK_HEADER ptr = (PMEMORY_BLOCK_HEADER)m_pmalloc(size+sizeof(MEMORY_BLOCK_HEADER)); + PMEMORY_BLOCK_HEADER ptr = (PMEMORY_BLOCK_HEADER)malloc(size+sizeof(MEMORY_BLOCK_HEADER)); if (!ptr) { FreeLock(); return NULL; @@ -172,7 +157,7 @@ void* VMem::Malloc(size_t size) FreeLock(); return (ptr+1); #else - return m_pmalloc(size); + return malloc(size); #endif } @@ -190,7 +175,7 @@ void* VMem::Realloc(void* pMem, size_t size) GetLock(); PMEMORY_BLOCK_HEADER ptr = (PMEMORY_BLOCK_HEADER)(((char*)pMem)-sizeof(MEMORY_BLOCK_HEADER)); UnlinkBlock(ptr); - ptr = (PMEMORY_BLOCK_HEADER)m_prealloc(ptr, size+sizeof(MEMORY_BLOCK_HEADER)); + ptr = (PMEMORY_BLOCK_HEADER)realloc(ptr, size+sizeof(MEMORY_BLOCK_HEADER)); if (!ptr) { FreeLock(); return NULL; @@ -200,7 +185,7 @@ void* VMem::Realloc(void* pMem, size_t size) return (ptr+1); #else - return m_prealloc(pMem, size); + return realloc(pMem, size); #endif } @@ -212,9 +197,8 @@ void VMem::Free(void* pMem) if (ptr->owner != this) { if (ptr->owner) { #if 1 - dTHX; int *nowhere = NULL; - Perl_warn(aTHX_ "Free to wrong pool %p not %p",this,ptr->owner); + Perl_warn_nocontext("Free to wrong pool %p not %p",this,ptr->owner); *nowhere = 0; /* this segfault is deliberate, so you can see the stack trace */ #else @@ -226,22 +210,26 @@ void VMem::Free(void* pMem) GetLock(); UnlinkBlock(ptr); ptr->owner = NULL; - m_pfree(ptr); + free(ptr); FreeLock(); } -#else - m_pfree(pMem); +#else /*_USE_LINKED_LIST*/ + free(pMem); #endif } void VMem::GetLock(void) { +#ifdef _USE_LINKED_LIST EnterCriticalSection(&m_cs); +#endif } void VMem::FreeLock(void) { +#ifdef _USE_LINKED_LIST LeaveCriticalSection(&m_cs); +#endif } int VMem::IsLocked(void) @@ -413,14 +401,14 @@ class VMem public: VMem(); ~VMem(); - virtual void* Malloc(size_t size); - virtual void* Realloc(void* pMem, size_t size); - virtual void Free(void* pMem); - virtual void GetLock(void); - virtual void FreeLock(void); - virtual int IsLocked(void); - virtual long Release(void); - virtual long AddRef(void); + void* Malloc(size_t size); + void* Realloc(void* pMem, size_t size); + void Free(void* pMem); + void GetLock(void); + void FreeLock(void); + int IsLocked(void); + long Release(void); + long AddRef(void); inline BOOL CreateOk(void) { diff --git a/Master/tlpkg/tlperl/lib/CORE/warnings.h b/Master/tlpkg/tlperl/lib/CORE/warnings.h index 39ebe6a78c1..5c40d5c398b 100644 --- a/Master/tlpkg/tlperl/lib/CORE/warnings.h +++ b/Master/tlpkg/tlperl/lib/CORE/warnings.h @@ -29,67 +29,75 @@ /* Warnings Categories added in Perl 5.008 */ -#define WARN_ALL 0 -#define WARN_CLOSURE 1 -#define WARN_DEPRECATED 2 -#define WARN_EXITING 3 -#define WARN_GLOB 4 -#define WARN_IO 5 -#define WARN_CLOSED 6 -#define WARN_EXEC 7 -#define WARN_LAYER 8 -#define WARN_NEWLINE 9 -#define WARN_PIPE 10 -#define WARN_UNOPENED 11 -#define WARN_MISC 12 -#define WARN_NUMERIC 13 -#define WARN_ONCE 14 -#define WARN_OVERFLOW 15 -#define WARN_PACK 16 -#define WARN_PORTABLE 17 -#define WARN_RECURSION 18 -#define WARN_REDEFINE 19 -#define WARN_REGEXP 20 -#define WARN_SEVERE 21 -#define WARN_DEBUGGING 22 -#define WARN_INPLACE 23 -#define WARN_INTERNAL 24 -#define WARN_MALLOC 25 -#define WARN_SIGNAL 26 -#define WARN_SUBSTR 27 -#define WARN_SYNTAX 28 -#define WARN_AMBIGUOUS 29 -#define WARN_BAREWORD 30 -#define WARN_DIGIT 31 -#define WARN_PARENTHESIS 32 -#define WARN_PRECEDENCE 33 -#define WARN_PRINTF 34 -#define WARN_PROTOTYPE 35 -#define WARN_QW 36 -#define WARN_RESERVED 37 -#define WARN_SEMICOLON 38 -#define WARN_TAINT 39 -#define WARN_THREADS 40 -#define WARN_UNINITIALIZED 41 -#define WARN_UNPACK 42 -#define WARN_UNTIE 43 -#define WARN_UTF8 44 -#define WARN_VOID 45 +#define WARN_ALL 0 +#define WARN_CLOSURE 1 +#define WARN_DEPRECATED 2 +#define WARN_EXITING 3 +#define WARN_GLOB 4 +#define WARN_IO 5 +#define WARN_CLOSED 6 +#define WARN_EXEC 7 +#define WARN_LAYER 8 +#define WARN_NEWLINE 9 +#define WARN_PIPE 10 +#define WARN_UNOPENED 11 +#define WARN_MISC 12 +#define WARN_NUMERIC 13 +#define WARN_ONCE 14 +#define WARN_OVERFLOW 15 +#define WARN_PACK 16 +#define WARN_PORTABLE 17 +#define WARN_RECURSION 18 +#define WARN_REDEFINE 19 +#define WARN_REGEXP 20 +#define WARN_SEVERE 21 +#define WARN_DEBUGGING 22 +#define WARN_INPLACE 23 +#define WARN_INTERNAL 24 +#define WARN_MALLOC 25 +#define WARN_SIGNAL 26 +#define WARN_SUBSTR 27 +#define WARN_SYNTAX 28 +#define WARN_AMBIGUOUS 29 +#define WARN_BAREWORD 30 +#define WARN_DIGIT 31 +#define WARN_PARENTHESIS 32 +#define WARN_PRECEDENCE 33 +#define WARN_PRINTF 34 +#define WARN_PROTOTYPE 35 +#define WARN_QW 36 +#define WARN_RESERVED 37 +#define WARN_SEMICOLON 38 +#define WARN_TAINT 39 +#define WARN_THREADS 40 +#define WARN_UNINITIALIZED 41 +#define WARN_UNPACK 42 +#define WARN_UNTIE 43 +#define WARN_UTF8 44 +#define WARN_VOID 45 /* Warnings Categories added in Perl 5.011 */ -#define WARN_IMPRECISION 46 -#define WARN_ILLEGALPROTO 47 +#define WARN_IMPRECISION 46 +#define WARN_ILLEGALPROTO 47 /* Warnings Categories added in Perl 5.013 */ -#define WARN_NON_UNICODE 48 -#define WARN_NONCHAR 49 -#define WARN_SURROGATE 50 +#define WARN_NON_UNICODE 48 +#define WARN_NONCHAR 49 +#define WARN_SURROGATE 50 -#define WARNsize 13 -#define WARN_ALLstring "\125\125\125\125\125\125\125\125\125\125\125\125\125" -#define WARN_NONEstring "\0\0\0\0\0\0\0\0\0\0\0\0\0" +/* Warnings Categories added in Perl 5.017 */ + +#define WARN_EXPERIMENTAL 51 +#define WARN_EXPERIMENTAL__LEXICAL_SUBS 52 +#define WARN_EXPERIMENTAL__LEXICAL_TOPIC 53 +#define WARN_EXPERIMENTAL__REGEX_SETS 54 +#define WARN_EXPERIMENTAL__SMARTMATCH 55 + +#define WARNsize 14 +#define WARN_ALLstring "\125\125\125\125\125\125\125\125\125\125\125\125\125\125" +#define WARN_NONEstring "\0\0\0\0\0\0\0\0\0\0\0\0\0\0" #define isLEXWARN_on (PL_curcop->cop_warnings != pWARN_STD) #define isLEXWARN_off (PL_curcop->cop_warnings == pWARN_STD) diff --git a/Master/tlpkg/tlperl/lib/CORE/win32.h b/Master/tlpkg/tlperl/lib/CORE/win32.h index e906266a4ad..3065867bd28 100644 --- a/Master/tlpkg/tlperl/lib/CORE/win32.h +++ b/Master/tlpkg/tlperl/lib/CORE/win32.h @@ -13,6 +13,38 @@ # define _WIN32_WINNT 0x0500 /* needed for CreateHardlink() etc. */ #endif +#ifdef PERL_IS_MINIPERL +/* this macro will remove Winsock only on miniperl, PERL_IMPLICIT_SYS and + * makedef.pl create dependencies that will keep Winsock linked in even with + * this macro defined, even though sockets will be umimplemented from a script + * level in full perl + */ +# define WIN32_NO_SOCKETS +#endif + +#ifdef WIN32_NO_SOCKETS +# undef HAS_SOCKET +# undef HAS_GETPROTOBYNAME +# undef HAS_GETPROTOBYNUMBER +# undef HAS_GETPROTOENT +# undef HAS_GETNETBYNAME +# undef HAS_GETNETBYADDR +# undef HAS_GETNETENT +# undef HAS_GETSERVBYNAME +# undef HAS_GETSERVBYPORT +# undef HAS_GETSERVENT +# undef HAS_GETHOSTBYNAME +# undef HAS_GETHOSTBYADDR +# undef HAS_GETHOSTENT +# undef HAS_SELECT +# undef HAS_IOCTL +# undef HAS_NTOHL +# undef HAS_HTONL +# undef HAS_HTONS +# undef HAS_NTOHS +# define WIN32SCK_IS_STDSCK +#endif + #if defined(PERL_IMPLICIT_SYS) # define DYNAMIC_ENV_FETCH # define HAS_GETENV_LEN @@ -46,12 +78,15 @@ */ /* now even GCC supports __declspec() */ - -#if defined(PERLDLL) -#define DllExport -/*#define DllExport __declspec(dllexport)*/ /* noises with VC5+sp3 */ +/* miniperl has no reason to export anything */ +#if defined(PERL_IS_MINIPERL) && !defined(UNDER_CE) && defined(_MSC_VER) +# define DllExport #else -#define DllExport __declspec(dllimport) +# if defined(PERLDLL) +# define DllExport __declspec(dllexport) +# else +# define DllExport __declspec(dllimport) +# endif #endif /* The Perl APIs can only be called directly inside the perl5xx.dll. @@ -66,11 +101,26 @@ #if !defined(PERLDLL) && !defined(PERL_EXT_RE_BUILD) # ifdef __cplusplus # define PERL_CALLCONV extern "C" __declspec(dllimport) +# ifdef _MSC_VER +# define PERL_CALLCONV_NO_RET extern "C" __declspec(dllimport) __declspec(noreturn) +# endif # else # define PERL_CALLCONV __declspec(dllimport) +# ifdef _MSC_VER +# define PERL_CALLCONV_NO_RET __declspec(dllimport) __declspec(noreturn) +# endif +# endif +#else /* MSVC noreturn support inside the interp */ +# ifdef _MSC_VER +# define PERL_CALLCONV_NO_RET __declspec(noreturn) # endif #endif +#ifdef _MSC_VER +# define PERL_STATIC_NO_RET __declspec(noreturn) static +# define PERL_STATIC_INLINE_NO_RET __declspec(noreturn) PERL_STATIC_INLINE +#endif + #define WIN32_LEAN_AND_MEAN #include <windows.h> @@ -147,34 +197,18 @@ struct utsname { #define DOSISH 1 /* no escaping our roots */ #define OP_BINARY O_BINARY /* mistake in in pp_sys.c? */ -/* Define USE_SOCKETS_AS_HANDLES to enable emulation of windows sockets as - * real filehandles. XXX Should always be defined (the other version is untested) */ -#define USE_SOCKETS_AS_HANDLES - /* read() and write() aren't transparent for socket handles */ -#define PERL_SOCK_SYSREAD_IS_RECV -#define PERL_SOCK_SYSWRITE_IS_SEND +#ifndef WIN32_NO_SOCKETS +# define PERL_SOCK_SYSREAD_IS_RECV +# define PERL_SOCK_SYSWRITE_IS_SEND +#endif #define PERL_NO_FORCE_LINK /* no need for PL_force_link_funcs */ -/* Define PERL_WIN32_SOCK_DLOAD to have Perl dynamically load the winsock - DLL when needed. Don't use if your compiler supports delayloading (ie, VC++ 6.0) - -- BKS 5-29-2000 */ -#if !(defined(_M_IX86) && _MSC_VER >= 1200) -#define PERL_WIN32_SOCK_DLOAD -#endif #define ENV_IS_CASELESS #define PIPESOCK_MODE "b" /* pipes, sockets default to binmode */ -#ifndef VER_PLATFORM_WIN32_WINDOWS /* VC-2.0 headers don't have this */ -#define VER_PLATFORM_WIN32_WINDOWS 1 -#endif - -#ifndef FILE_SHARE_DELETE /* VC-4.0 headers don't have this */ -#define FILE_SHARE_DELETE 0x00000004 -#endif - /* access() mode bits */ #ifndef R_OK # define R_OK 4 @@ -192,13 +226,11 @@ struct utsname { /* Compiler-specific stuff. */ -#if defined(_MSC_VER) || defined(__MINGW32__) /* VC uses non-standard way to determine the size and alignment if bit-fields */ -/* MinGW will compiler with -mms-bitfields, so should use the same types */ -# define PERL_BITFIELD8 unsigned char -# define PERL_BITFIELD16 unsigned short -# define PERL_BITFIELD32 unsigned int -#endif +/* MinGW will compile with -mms-bitfields, so should use the same types */ +#define PERL_BITFIELD8 unsigned char +#define PERL_BITFIELD16 unsigned short +#define PERL_BITFIELD32 unsigned int #ifdef _MSC_VER /* Microsoft Visual C++ */ @@ -210,9 +242,6 @@ typedef unsigned short mode_t; #pragma warning(disable: 4102) /* "unreferenced label" */ -/* Visual C thinks that a pointer to a member variable is 16 bytes in size. */ -#define PERL_MEMBER_PTR_SIZE 16 - #define isnan _isnan #define snprintf _snprintf #define vsnprintf _vsnprintf @@ -255,14 +284,11 @@ typedef long gid_t; # endif #endif -#endif /* __MINGW32__ */ - -/* both GCC/Mingw32 and MSVC++ 4.0 are missing this, so we put it here */ #ifndef CP_UTF8 # define CP_UTF8 65001 #endif -/* compatibility stuff for other compilers goes here */ +#endif /* __MINGW32__ */ #ifndef _INTPTR_T_DEFINED typedef int intptr_t; @@ -278,6 +304,7 @@ START_EXTERN_C /* For UNIX compatibility. */ +#ifdef PERL_CORE extern uid_t getuid(void); extern gid_t getgid(void); extern uid_t geteuid(void); @@ -293,6 +320,7 @@ extern void *sbrk(ptrdiff_t need); extern char * getlogin(void); extern int chown(const char *p, uid_t o, gid_t g); extern int mkstemp(const char *path); +#endif #undef Stat #define Stat win32_stat @@ -332,9 +360,6 @@ typedef struct { DllExport void win32_get_child_IO(child_IO_table* ptr); DllExport HWND win32_create_message_window(void); -#ifndef USE_SOCKETS_AS_HANDLES -extern FILE * my_fdopen(int, char *); -#endif extern int my_fclose(FILE *); extern char * win32_get_privlib(const char *pl, STRLEN *const len); extern char * win32_get_sitelib(const char *pl, STRLEN *const len); @@ -344,7 +369,7 @@ extern char * win32_get_vendorlib(const char *pl, STRLEN *const len); extern void win32_delete_internal_host(void *h); #endif -extern char * staticlinkmodules[]; +extern const char * const staticlinkmodules[]; END_EXTERN_C @@ -387,9 +412,7 @@ struct thread_intern { char Wstrerror_buffer[512]; struct servent Wservent; char Wgetlogin_buffer[128]; -# ifdef USE_SOCKETS_AS_HANDLES int Winit_socktype; -# endif char Wcrypt_buffer[30]; # ifdef USE_RTL_THREAD_API void * retv; /* slot for thread return value */ diff --git a/Master/tlpkg/tlperl/lib/CORE/win32iop-o.h b/Master/tlpkg/tlperl/lib/CORE/win32iop-o.h index 6633f7a76ba..2b766dc5540 100644 --- a/Master/tlpkg/tlperl/lib/CORE/win32iop-o.h +++ b/Master/tlpkg/tlperl/lib/CORE/win32iop-o.h @@ -16,11 +16,7 @@ #endif #ifndef UNDER_CE -#if defined(_MSC_VER) || defined(__MINGW32__) -# include <sys/utime.h> -#else -# include <utime.h> -#endif +#include <sys/utime.h> #endif /* diff --git a/Master/tlpkg/tlperl/lib/CORE/win32iop.h b/Master/tlpkg/tlperl/lib/CORE/win32iop.h index 373e3e37ce9..207c9176e56 100644 --- a/Master/tlpkg/tlperl/lib/CORE/win32iop.h +++ b/Master/tlpkg/tlperl/lib/CORE/win32iop.h @@ -13,11 +13,7 @@ #endif #endif -#if defined(_MSC_VER) || defined(__MINGW32__) -# include <sys/utime.h> -#else -# include <utime.h> -#endif +#include <sys/utime.h> /* * defines for flock emulation @@ -126,6 +122,8 @@ DllExport void win32_rewinddir(DIR *dirp); DllExport int win32_closedir(DIR *dirp); DllExport DIR* win32_dirp_dup(DIR *const dirp, CLONE_PARAMS *const param); +DllExport char* win32_getenvironmentstrings(void); +/* also see win32_freeenvironmentstrings macro */ DllExport char* win32_getenv(const char *name); DllExport int win32_putenv(const char *name); @@ -162,6 +160,8 @@ DllExport Sighandler_t win32_signal(int sig, Sighandler_t subcode); END_EXTERN_C +/* see comment in win32_getenvironmentstrings */ +#define win32_freeenvironmentstrings(x) win32_free(x) #undef alarm #define alarm win32_alarm #undef strerror |