From 3f427fd9b3d9172856d6247beacfaedb3a38b17d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Feb 2012 11:42:58 -0700 Subject: [PATCH] Add compile-time inversion lists for POSIX classes These will be used in regcomp.c to replace the existing bit-wise handling of these, enabling subsequent optimizations. These are compiled-in, and hence affect the memory footprint of every program, including those that don't use Unicode. The lists that aren't tiny are therefore currently restricted to only the Latin1 range; anything needed beyond that will have to be read in at execution time, just as before. The design allows for easy conversion from Latin1 to use the full Unicode range, should it be deemed desirable for some or all of these. --- charclass_invlists.h | 498 +++++++++++++++++++++++++++++++++++++++++++ embedvar.h | 29 +++ intrpvar.h | 45 ++++ regcomp.c | 48 +++++ regen/mk_invlists.pl | 70 +++++- sv.c | 51 ++++- 6 files changed, 739 insertions(+), 2 deletions(-) diff --git a/charclass_invlists.h b/charclass_invlists.h index dbb32d857b3..2cfcac6155c 100644 --- a/charclass_invlists.h +++ b/charclass_invlists.h @@ -36,4 +36,502 @@ UV ASCII_invlist[] = { 0 }; +UV HorizSpace_invlist[] = { + 18, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 10, + 32, + 33, + 160, + 161, + 5760, + 5761, + 6158, + 6159, + 8192, + 8203, + 8239, + 8240, + 8287, + 8288, + 12288, + 12289 +}; + +UV VertSpace_invlist[] = { + 6, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 14, + 133, + 134, + 8232, + 8234 +}; + +UV PerlSpace_invlist[] = { + 6, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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 */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 133, + 134, + 160, + 161, + 5760, + 5761, + 6158, + 6159, + 8192, + 8203, + 8232, + 8234, + 8239, + 8240, + 8287, + 8288, + 12288, + 12289 +}; + +UV PosixAlnum_invlist[] = { + 6, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 65, + 91, + 97, + 123 +}; + +UV L1PosixAlnum_invlist[] = { + 18, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 65, + 91, + 97, + 123, + 170, + 171, + 181, + 182, + 186, + 187, + 192, + 215, + 216, + 247, + 248, + 706 +}; + +UV PosixAlpha_invlist[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 97, + 123 +}; + +UV L1PosixAlpha_invlist[] = { + 16, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 97, + 123, + 170, + 171, + 181, + 182, + 186, + 187, + 192, + 215, + 216, + 247, + 248, + 706 +}; + +UV PosixBlank_invlist[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 10, + 32, + 33 +}; + +UV XPosixBlank_invlist[] = { + 18, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 10, + 32, + 33, + 160, + 161, + 5760, + 5761, + 6158, + 6159, + 8192, + 8203, + 8239, + 8240, + 8287, + 8288, + 12288, + 12289 +}; + +UV PosixCntrl_invlist[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 127, + 128, + 0 +}; + +UV XPosixCntrl_invlist[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 127, + 160, + 0 +}; + +UV PosixDigit_invlist[] = { + 2, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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[] = { + 2, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 161, + 888 +}; + +UV PosixLower_invlist[] = { + 2, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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[] = { + 12, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 170, + 171, + 181, + 182, + 186, + 187, + 223, + 247, + 248, + 256 +}; + +UV PosixPrint_invlist[] = { + 2, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 160, + 888 +}; + +UV PosixPunct_invlist[] = { + 8, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 48, + 58, + 65, + 91, + 97, + 123, + 127 +}; + +UV L1PosixPunct_invlist[] = { + 21, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 48, + 58, + 65, + 91, + 97, + 123, + 127, + 161, + 162, + 167, + 168, + 171, + 172, + 182, + 184, + 187, + 188, + 191, + 192, + 894 +}; + +UV PosixSpace_invlist[] = { + 4, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 14, + 32, + 33 +}; + +UV XPosixSpace_invlist[] = { + 22, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 14, + 32, + 33, + 133, + 134, + 160, + 161, + 5760, + 5761, + 6158, + 6159, + 8192, + 8203, + 8232, + 8234, + 8239, + 8240, + 8287, + 8288, + 12288, + 12289 +}; + +UV PosixUpper_invlist[] = { + 2, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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[] = { + 7, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 192, + 215, + 216, + 223, + 256 +}; + +UV PosixWord_invlist[] = { + 8, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 65, + 91, + 95, + 96, + 97, + 123 +}; + +UV L1PosixWord_invlist[] = { + 20, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 65, + 91, + 95, + 96, + 97, + 123, + 170, + 171, + 181, + 182, + 186, + 187, + 192, + 215, + 216, + 247, + 248, + 706 +}; + +UV PosixXDigit_invlist[] = { + 6, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 65, + 71, + 97, + 103 +}; + +UV XPosixXDigit_invlist[] = { + 12, /* Number of elements */ + 0, /* Current iteration position */ + 1064334010, /* 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, + 65, + 71, + 97, + 103, + 65296, + 65306, + 65313, + 65319, + 65345, + 65351 +}; + /* ex: set ro: */ diff --git a/embedvar.h b/embedvar.h index 0aa20e11513..d12de90121a 100644 --- a/embedvar.h +++ b/embedvar.h @@ -53,6 +53,15 @@ #define PL_DBtrace (vTHX->IDBtrace) #define PL_Dir (vTHX->IDir) #define PL_Env (vTHX->IEnv) +#define PL_HorizSpace (vTHX->IHorizSpace) +#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_LIO (vTHX->ILIO) #define PL_Latin1 (vTHX->ILatin1) #define PL_Mem (vTHX->IMem) @@ -61,10 +70,30 @@ #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_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_Xpv (vTHX->IXpv) #define PL_amagic_generation (vTHX->Iamagic_generation) #define PL_an (vTHX->Ian) diff --git a/intrpvar.h b/intrpvar.h index 96125b6027b..43e4e051c2b 100644 --- a/intrpvar.h +++ b/intrpvar.h @@ -570,6 +570,51 @@ 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, PosixCntrl, SV *) +PERLVAR(I, XPosixCntrl, SV *) + +PERLVAR(I, PosixDigit, SV *) + +PERLVAR(I, L1PosixGraph,SV *) +PERLVAR(I, PosixGraph, SV *) + +PERLVAR(I, HorizSpace, 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 *) + /* utf8 character class swashes */ PERLVAR(I, utf8_alnum, SV *) PERLVAR(I, utf8_alpha, SV *) diff --git a/regcomp.c b/regcomp.c index d5c5ff220c9..f55b3618814 100644 --- a/regcomp.c +++ b/regcomp.c @@ -4820,6 +4820,54 @@ Perl_re_compile(pTHX_ SV * const pattern, U32 orig_pm_flags) PL_AboveLatin1 = _new_invlist_C_array(AboveLatin1_invlist); PL_ASCII = _new_invlist_C_array(ASCII_invlist); PL_Latin1 = _new_invlist_C_array(Latin1_invlist); + + PL_L1PosixAlnum = _new_invlist_C_array(L1PosixAlnum_invlist); + PL_PosixAlnum = _new_invlist_C_array(PosixAlnum_invlist); + + PL_L1PosixAlpha = _new_invlist_C_array(L1PosixAlpha_invlist); + PL_PosixAlpha = _new_invlist_C_array(PosixAlpha_invlist); + + PL_PosixBlank = _new_invlist_C_array(PosixBlank_invlist); + PL_XPosixBlank = _new_invlist_C_array(XPosixBlank_invlist); + + PL_PosixCntrl = _new_invlist_C_array(PosixCntrl_invlist); + PL_XPosixCntrl = _new_invlist_C_array(XPosixCntrl_invlist); + + PL_PosixDigit = _new_invlist_C_array(PosixDigit_invlist); + + PL_L1PosixGraph = _new_invlist_C_array(L1PosixGraph_invlist); + PL_PosixGraph = _new_invlist_C_array(PosixGraph_invlist); + + PL_L1PosixAlnum = _new_invlist_C_array(L1PosixAlnum_invlist); + PL_PosixAlnum = _new_invlist_C_array(PosixAlnum_invlist); + + PL_HorizSpace = _new_invlist_C_array(HorizSpace_invlist); + + PL_L1PosixLower = _new_invlist_C_array(L1PosixLower_invlist); + PL_PosixLower = _new_invlist_C_array(PosixLower_invlist); + + PL_L1PosixPrint = _new_invlist_C_array(L1PosixPrint_invlist); + PL_PosixPrint = _new_invlist_C_array(PosixPrint_invlist); + + PL_L1PosixPunct = _new_invlist_C_array(L1PosixPunct_invlist); + PL_PosixPunct = _new_invlist_C_array(PosixPunct_invlist); + + PL_PerlSpace = _new_invlist_C_array(PerlSpace_invlist); + PL_XPerlSpace = _new_invlist_C_array(XPerlSpace_invlist); + + PL_PosixSpace = _new_invlist_C_array(PosixSpace_invlist); + PL_XPosixSpace = _new_invlist_C_array(XPosixSpace_invlist); + + PL_L1PosixUpper = _new_invlist_C_array(L1PosixUpper_invlist); + PL_PosixUpper = _new_invlist_C_array(PosixUpper_invlist); + + PL_VertSpace = _new_invlist_C_array(VertSpace_invlist); + + PL_PosixWord = _new_invlist_C_array(PosixWord_invlist); + PL_L1PosixWord = _new_invlist_C_array(L1PosixWord_invlist); + + PL_PosixXDigit = _new_invlist_C_array(PosixXDigit_invlist); + PL_XPosixXDigit = _new_invlist_C_array(XPosixXDigit_invlist); } exp = SvPV(pattern, plen); diff --git a/regen/mk_invlists.pl b/regen/mk_invlists.pl index 5b69708b46e..46114bcfb10 100644 --- a/regen/mk_invlists.pl +++ b/regen/mk_invlists.pl @@ -71,12 +71,80 @@ ($$) output_invlist("Latin1", [ 0, 256 ]); output_invlist("AboveLatin1", [ 256 ]); +# We construct lists for all the POSIX and backslash sequence character +# classes in two forms: +# 1) ones which match only in the ASCII range +# 2) ones which match either in the Latin1 range, or the entire Unicode range +# +# These get compiled in, and hence affect the memory footprint of every Perl +# program, even those not using Unicode. To minimize the size, currently +# the Latin1 version is generated for the beyond ASCII range except for those +# lists that are quite small for the entire range, such as for \s, which is 22 +# UVs long plus 4 UVs (currently) for the header. +# +# To save even more memory, the ASCII versions could be derived from the +# larger ones at runtime, saving some memory (minus the expense of the machine +# instructions to do so), but these are all small anyway, so their total is +# about 100 UVs. +# +# In the list of properties below that get generated, the L1 prefix is a fake +# property that means just the Latin1 range of the full property (whose name +# has an X prefix instead of L1). + for my $prop (qw( ASCII + HorizSpace + VertSpace + PerlSpace + XPerlSpace + PosixAlnum + L1PosixAlnum + PosixAlpha + L1PosixAlpha + PosixBlank + XPosixBlank + PosixCntrl + XPosixCntrl + PosixDigit + PosixGraph + L1PosixGraph + PosixLower + L1PosixLower + PosixPrint + L1PosixPrint + PosixPunct + L1PosixPunct + PosixSpace + XPosixSpace + PosixUpper + L1PosixUpper + PosixWord + L1PosixWord + PosixXDigit + XPosixXDigit ) ) { - my @invlist = prop_invlist($prop); + # For the Latin1 properties, we change to use the eXtended version of the + # base property, then go through the result and get rid of everything not + # in Latin1 (above 255). Actually, we retain the element that crosses the + # 255/256 boundary. For example, in the Word property, there is a range + # of code points that start at U+00F8 and goes through U+02C1. Instead of + # artifically cutting that off at 256 because 256 is the first code point + # above Latin1, we let the range go to its natural ending. That gives us + # extra information with no added space taken. + my $lookup_prop = $prop =~ s/^L1/X/r; + my @invlist = prop_invlist($lookup_prop); + + if ($lookup_prop ne $prop) { + for my $i (0 .. @invlist - 1 - 1) { + if ($invlist[$i] > 255) { + splice @invlist, $i+1; + last; + } + } + } + output_invlist($prop, \@invlist); } diff --git a/sv.c b/sv.c index fe10362ab2a..068be55607a 100644 --- a/sv.c +++ b/sv.c @@ -13382,7 +13382,56 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags, PL_numeric_radix_sv = sv_dup_inc(proto_perl->Inumeric_radix_sv, param); #endif /* !USE_LOCALE_NUMERIC */ - /* utf8 character classes */ + /* Unicode inversion lists */ + PL_ASCII = sv_dup_inc(proto_perl->IASCII, param); + PL_Latin1 = sv_dup_inc(proto_perl->ILatin1, param); + + PL_PerlSpace = sv_dup_inc(proto_perl->IPerlSpace, param); + PL_XPerlSpace = sv_dup_inc(proto_perl->IXPerlSpace, param); + + PL_L1PosixAlnum = sv_dup_inc(proto_perl->IL1PosixAlnum, param); + PL_PosixAlnum = sv_dup_inc(proto_perl->IPosixAlnum, param); + + PL_L1PosixAlpha = sv_dup_inc(proto_perl->IL1PosixAlpha, param); + PL_PosixAlpha = sv_dup_inc(proto_perl->IPosixAlpha, param); + + PL_PosixBlank = sv_dup_inc(proto_perl->IPosixBlank, param); + PL_XPosixBlank = sv_dup_inc(proto_perl->IXPosixBlank, param); + + PL_PosixCntrl = sv_dup_inc(proto_perl->IPosixCntrl, param); + PL_XPosixCntrl = sv_dup_inc(proto_perl->IXPosixCntrl, param); + + PL_PosixDigit = sv_dup_inc(proto_perl->IPosixDigit, param); + + PL_L1PosixGraph = sv_dup_inc(proto_perl->IL1PosixGraph, param); + PL_PosixGraph = sv_dup_inc(proto_perl->IPosixGraph, param); + + PL_HorizSpace = sv_dup_inc(proto_perl->IHorizSpace, param); + + PL_L1PosixLower = sv_dup_inc(proto_perl->IL1PosixLower, param); + PL_PosixLower = sv_dup_inc(proto_perl->IPosixLower, param); + + PL_L1PosixPrint = sv_dup_inc(proto_perl->IL1PosixPrint, param); + PL_PosixPrint = sv_dup_inc(proto_perl->IPosixPrint, param); + + PL_L1PosixPunct = sv_dup_inc(proto_perl->IL1PosixPunct, param); + PL_PosixPunct = sv_dup_inc(proto_perl->IPosixPunct, param); + + PL_PosixSpace = sv_dup_inc(proto_perl->IPosixSpace, param); + PL_XPosixSpace = sv_dup_inc(proto_perl->IXPosixSpace, param); + + PL_L1PosixUpper = sv_dup_inc(proto_perl->IL1PosixUpper, param); + PL_PosixUpper = sv_dup_inc(proto_perl->IPosixUpper, param); + + PL_L1PosixWord = sv_dup_inc(proto_perl->IL1PosixWord, param); + PL_PosixWord = sv_dup_inc(proto_perl->IPosixWord, param); + + PL_PosixXDigit = sv_dup_inc(proto_perl->IPosixXDigit, param); + PL_XPosixXDigit = sv_dup_inc(proto_perl->IXPosixXDigit, param); + + PL_VertSpace = sv_dup_inc(proto_perl->IVertSpace, param); + + /* utf8 character class swashes */ PL_utf8_alnum = sv_dup_inc(proto_perl->Iutf8_alnum, param); PL_utf8_alpha = sv_dup_inc(proto_perl->Iutf8_alpha, param); PL_utf8_space = sv_dup_inc(proto_perl->Iutf8_space, param);