Remove temporary back-compat PL_ variable names

These names are synonyms for specific array elements, and were used
temporarily until all uses of them were removed.  This commit removes
the remaining uses, and the definitions

utf8.c: Remove two internal now unused functions.

These functions were used internally as helpers for matching \X in
regular expressions.  They are no longer used.

regexec.c: Revamp the macros to load swashes

This changes the swash-load macros to use swash_init() and swash_fetch()
instead of calling is_utf8_xxx() functions that may only be needed for
this purpose (which will hence become eligible for removal because of
this commit).

The check that a known character matches the loaded swash is now only
done in DEBUGGING builds.  And the macro to load the DIGIT swash is
removed, as there are no remaining calls of it.

handy.h: Improve some comments

regexec.c: Remove unused macro definitions

These are no longer used.

regcomp.c: Reorder two if-elses

It is generally easier to understand an
    if () { few statements } else { many statements}
than the other way around.

Consolidate some regex OPS

The regular rexpression operation POSIXA works on any of the (currently)
16 posix classes (like \w and [:graph:]) under the regex modifier /a.
This commit creates similar operations for the other modifiers: POSIXL
(for /l), POSIXD (for /d), POSIXU (for /u), plus their complements.

It causes these ops to be generated instead of the ALNUM, DIGIT,
HORIZWS, SPACE, and VERTWS ops, as well as all their variants.  The net
saving is 22 regnode types.

The reason to do this is for maintenance.  As of this commit, there are
now 22 fewer node types for which code has to be maintained.  The code
for each variant was essentially the same logic, but on different
operands.  It would be easy to make a change to one copy and forget to
make the corresponding change in the others.  Indeed, this patch fixes
[perl #114272] in which one copy was out of sync with others.

This patch actually reduces the number of separate code paths to 5:
POSIXA, NPOSIXA, POSIXL, POSIXD, and POSIXU.  The complements of the
last 3 use the same code path as their non-complemented version, except
that a variable is initialized differently.  The code then XORs this
variable with its result to do the complementing or not.  Further, the
POSIXD branch now just checks if the target string being matched is
UTF-8 or not, and then jumps to either the POSIXU or POSIXA code
respectively.  So, there are effectively only 4 cases that are coded:
POSIXA, NPOSIXA, POSIXL, and POSIXU.  (POSIXA doesn't have to worry
about UTF-8, while NPOSIXA does, hence these for efficiency are coded
separately.)

Removing all this code saves memory.  The output of the Linux size
command shows that the perl executable was shrunk by 33K bytes on my
platform compiled under -O0 (.7%) and by 18K bytes (1.3%) under -O2.

The reason this patch was doable was previous work in numbering the
POSIX classes, so that they could be indexed in arrays and bit
positions.  This is a large patch; I didn't see how to break it into
smaller components.

I chose to make this code more efficient as opposed to saving even more
memory.  Thus there is a separate loop that is jumped to after we know
we have to load a swash; this just saves having to test if the swash is
loaded each time through the loop.  I avoid loading the swash until
absolutely necessary.  In places in the previous version of this code,
the swash was loaded when the input was UTF-8, even if it wasn't yet
needed (and might never be if the input didn't contain anything above
Latin1); apparently to avoid the extra test per iteration.

The Perl test suite runs slightly faster on my platform with this patch
under -O0, and the speeds are indistinguishable under -O2.  This is in
spite of these new POSIX regops being unknown to the regex optimizer
(this will be addressed in future commits), and extra machine
instructions being required for each character (the xor, and some
shifting and masking).  I expect this is a result of better caching, and
not loading swashes unless absolutely necessary.

regexec.c: comments, white-space only

No code changes

handy.h: Refactor some internal macro calls

I didn't plan very well when I added these macros recently.  This
refactors them to be more logical.

regcomp.c: Expand only call of a macro

regcomp.c: Combine two cases in a switch()

Like [[:^digit]] done in a previous commit, the non-complemented
[[:digit:]] can be combined with its kin, provided we override a
variable setting for just it.

regcomp.c: Replace macro by expansion in only place called

Previous commits have removed all but one call of this macro.  Replace
that call by its expansion.  It also adds some comments.

regcomp.c: Collapse switch() case

This combines one switch case with another, overriding a variable
setting is all that is needed to make these identical.

regcomp.c: Expand single instance of macro

This small macro has only one call of it

regcomp.c: Collapse cases in a switch()

[:upper:] and [:lower:] have the same logic as some other cases in the
switch statement, but differ in that under /i they match more than just
themselves, and this has to be accounted for.

By moving the test for /i to outside the switch(), these cases can be
collapsed.  There is a small performance penalty in having to test for
all classes if /i is active, and if so, if the class is one of these
two.

regcomp.c: Use auto variables set to array elements

This permits slightly clearer reading of the code, and will be useful in
a future commit to allow further collapsing of cases int the switch()

regcomp.c: Collapse some switch() cases

Careful inspection of these 4 cases shows that each pair differs only in
one spot, which varies only a compile time, so a #ifdef can be used to
control that, and the cases can be collapsed.  This results in an extra
test for those platforms that don't have isblank().

regcomp.c: Move some code to later in block

These two code snippets are currently unrelated to anything else going
on in their respective blocks.  A future commit, however, will want
things like this to happen after the 'posixes' variable has been
updated.

regcomp.c: Combine some cases in a switch()

These cases differ only in the operand.  The logic is identical.

regcomp.c: Replace macro call by goto

The macros are called with identical parameters.  This avoids the extra
expansion of them.

regcomp.c: Slight refactor of [[:blank:]]

The C library function isblank() is not available on every platform.  A
Configure probe determines if it exists on the current platform.  If so,
compiling it can be done just like all the similar ones.  Only if
isblank() is not present does there need to be special handling.

This commit changes the cases of a switch statement so that if isblank()
is present, there is no special handling.

regcomp.c: Remove dead code

The commit just prior to this one created a different way of using
compile-time values, which bypasses this one.

regcomp.c: Use values if known at compile time

When compiling a regular expression, it is too expensive to go out and
load from disk the list of code points that match a particular Posix
character class.  Some of these classes have so few code points, that
the lists are compiled in, but others are too large for that, for
example the list of code points that match \w.  (Also, it is known at
compile time which of the 256 code points within the Latin-1 range match
any Posix character class.)

The lists for beyond Latin-1 are demand-loaded upon first need for each,
thus the loading is deferred to execution time.  This is less efficient
than doing it at compilation time, but many many programs will never need
to load them, so the deferral is a big gain.  However, once loaded, they
stay loaded (in the current and all sub threads).  It may be that at the
time a regex is being compiled that a list it needs has already been
loaded for some other reason.  Then, the data is already available for
free, and this commit changes to use it for most Posix character
classes, and their complements.  This method replaces one that was
instituted just a few commits ago (I can't refer to its commit number,
because it is subject to change before the final push to blead; but it
has the same title as this commit.)

Future commits will expand the number of classes that use the mechanism
started in this commit

regcomp.c: Move some cases in a switch around

This is so future commits can have a FALL THROUGH

regcomp.c: Collapse some switch casses

Previous commits have caused these cases in this switch to be identical,
so they can be collapsed.

Use an array for some inversion lists

Previous commits have placed some inversion list pointers into arrays.
This commit extends that to another group of inversion lists

regcomp.c: Collapse two identical cases in a switch

regcomp.c: Use calculated value instead of hard-coded

After this commit, these two cases in the switch are identical, and can
be collapsed.  This also reverses the sense of the 'if', to avoid a
negative, which is harder to read.

regcomp.c: Collapse some switch cases

Previous commits have caused some of the cases in this switch to be
identical, so they can be collapsed.

Use an array for some inversion lists

An earlier commit placed some inversion list pointers into an array.
This commit extends that to another group of inversion lists.

regcomp.c: Use computed value instead of hard-coded one

The cases of this switch have used the hard-coded character class
number, depending on which case it is.  However, there is a mapping from
the switch case value to its equivalent class number.  This changes to
use that mapping

regcomp.c: Move #define to earlier in file

This will be needed by code being added earlier in the file than the
define is currently.  It also makes sure that it is integer division.

Use array for some inversion lists

This patch creates an array pointing to the inversion lists that cover
the Latin-1 ranges for Posix character classes, and uses it instead of
the individual variables previously referred to.

perl.c: Use loop to clear array

These SV* variables are now in an array, and its cleaner to use a loop
instead of doing it individually.

regcomp.c: Use table look-up instead of individual strings.

This changes to get the name for the character class's Unicode property
via table lookup.  This is in preparation for making most of the cases
in this switch identical, so they can be collapsed.

regcomp.c: Use values if known at compile time

When compiling a regular expression, it is too expensive to go out and
load from disk the list of code points that match a particular Posix
character class.  Some of these classes have so few code points, that
the lists are compiled in, but others are too large for that, for
example the list of code points that match \w.  Also, it is known at
compile time which of the 256 code points within the Latin-1 range match
any Posix character class.

The lists for beyond Latin-1 are demand-loaded upon first need for each,
thus the loading is deferred to execution time.  This is less efficient
than doing it a compilation time, but many many programs will never need
to load them, so the deferral is a big gain.  However, once loaded, they
stay loaded (in this thread and all sub threads).  It may be that at the
time a regex is being compiled that a list it needs has already been
loaded for some other reason.  Then, the data is already available for
free.

This commit changes to use this for some character classes whose
non-complemented forms are wanted.  Before pushing this to blead, I
realized a better way to do this, and so the code in this commit gets
ripped out some commits hence.  If I try to rebase this commit away, it
turns up too many "failure to apply" messages for the intermediate
commits, so I'm leaving this one in.

handy.h: Move some back compat macros

Move them to the section that is for back-compat definitions.

Add generic _is_(uni|utf8)_FOO() function

This function uses table lookup to replace 9 more specific functions,
which can be deprecated.  They should not have been exposed to the
public API in the first place

handy.h: Create isALPHANUMERIC() and kin

Perl has had an undocumented macro isALNUMC() for a long time.  I want
to document it, but the name is very obscure.  Neither Yves nor I are
sure what it is.  My best guess is "C's alnum".  It corresponds to
/[[:alnum:]]/, and so its best name would be isALNUM().  But that is the
name long given to what matches \w.  A new synonym, isWORDCHAR(), has
been in place for several releases for that, but the old isALNUM()
should remain for backwards compatibility.

I don't think that the name isALNUMC() should be published, as it is too
close to isALNUM().  I finally came to the conclusion that
isALPHANUMERIC() is the best name; it describes its purpose clearly; the
disadvantage is its long length.  I doubt that it will get much use, but
we need something, I think, that we can publish to accomplish this
functionality.

This commit also converts core uses of isALNUMC to isALPHANUMERIC.  (I
intended to that separately, but made a mistake in rebasing, and
combined the two patches; and it seemed like not a big enough problem to
separate them out again.)

handy.h: Move some #defines

I'm moving this block of back-compat macros to later in the file, so
it comes after all the other definitions that may need to have backwards
compatibility equivalents

intrpvar.h: Place some swash pointers in an array

intrpvar.h: #include handy.h

This will allow some mnemonics to be used in future commits

handy.h: Guard against recursive #inclusion

regcomp.c: White-space, comment only

perlapi: Grammar nit

utf8.c: Fix reference count in swash_to_invlist()

The return SV* from this function was inconsistent in its reference
count.  In some cases it creates a new SV, which has a reference count
of 1, and in some cases it returned an existing SV without incrementing
the reference count.  If the caller thought it was getting its own copy,
and decremented the reference count, it could lead to a double free.

perlapi: Clarify return value of SvREFCNT_inc()

regexec.c: Remove redundant calculation

Commit 9a902117f5d8a3ebc669e3a90eeb7cee78286a33 introduced a redundancy.
It calculates a value twice.

XS-Typemap: bump version

I'm getting cmp_version.t failures from the recent T_BOOL changes.  I
don't know why others don't seem to be.

Update Unicode-Collate to CPAN version 0.97

  [DELTA]

  0.97  Sat Dec 22 14:25:50 2012
    - bug fix: XS of 0.96 (if UCA_Version is 9 to 11) wrongly referred to
      DUCET for completely ignorable characters, even though the collator
      don't use DUCET.
    - separated t/notable.t from t/test.t.

Sync Module-CoreList version in Maintainers.pl with CPAN

a better perldelta for d1bee06989

a better perldelta for d1bee06989

Better POD for newSVrv

It takes me a couple times to slowly read the description to realize
what this does. The "its reference count is 1" can be misread to mean
someone must mortalize the return value of newSVrv. The "Creates
a new SV for the RV, C<rv>, to point to." can be misread to mean that
newSVrv is a macro, and will do an &() on rv to create a total of
two new SVs. An SvRV pointing to a posssibly blessed undef SV.
This is also wrong. Adding "existing" makes the point that rv
will not be created in this call.

perldelta for d1bee06989

[perl #115796] fix the T_BOOL OUTPUT typemap for parameters

when the output isn't RETVAL, update the SV instead of replacing it

Previously OUTPUT argument parameters would replace ST(n) instead of
updating it, this meant that the caller's supplied value would not be
updated.

This change means that OUTPUT T_BOOL arguments called RETVAL won't be
handled correctly, but since the OUTPUT didn't work previously for
*any* case, this is a net improvement.

TODO the failing T_BOOL tests

also update one test so it actually fails

T_BOOL failure example

[perl #115796] T_BOOL failure example

The T_BOOL_2 tests should have failed, rewrite and TODO

regexec.c: Remove some read beyond buffer ends

It turns out that this paradigm used in several places in regexec.c is
wrong:

while (s + (len = UTF8SKIP(s)) <= PL_regeol) {
    ...
    s += len;
}

The reason it is wrong is that PL_regeol points to one past the end, and
this will inevitably end up reading the character at PL_regeol, which is
hence out-of-bounds.  I don't know how many times I've looked at this
code and missed this, but valgrind found it after I tried Dave
Mitchell's hack to remove the trailing NUL for testing purposes.

The way to make sure that there isn't malformed UTF-8 pointing us to
read too far would be:

while (s < PL_regeol && s + (len = UTF8SKIP(s)) <= PL_regeol) {}

This commit converts the one place that uses this safe thing to the
others:

while (s < PL_regeol) {}

In many places (but not all) in this file, we assume that the input is
well formed.  If we're going to be paranoid, it seems to me we should do
it consistently.  So I've converted this one relevant instance of
paranoia to not be, to be in line with the rest of the code.

silence g++ warning with PL_magic_vtable_names

See this p5p thread for more details

    <20121218144018.GQ1842@iabyn.com>

test the resetting of refcnt for immortals

PL_sv_undef etc get given a very high ref count, which if it ever reaches
zero, is set back to a high value. On debugging builds, use a lower value
(1000) so that the resetting code gets exercised occasionally.

Also, replace literal (~(U32)0)/2 with the constant SvREFCNT_IMMORTAL.

The 5.17.7 release is done, give it a check mark on the schedule

skip this test if we can't get an absolute path

fixes testing as root on at least solaris and openbsd

Bump the perl version in various places for 5.17.8

Make a new perldelta for 5.17.8-to-be

Add the 5.17.7 epigraph to epigraphs.pod

Add known t/op/require_errors.t failure to known problems

Add 5.17.7 to perlhist

Update Module::CoreList for 5.17.7

The 23b7025ebc commit is sufficiently documented in perldelta

Better description of hash assignment bug fixes

Clarify hash assignment bug fix in list context

Trim description of one bug fix in perldelta

Add more build configurations to test in the RMG

Add placeholder for additional 23b7025ebc changes in case no one gets back to me

Add an =item marker for sub-list in perldelta

Add delta for Storable & Locale::Maketext security issues

Fix typo in Locale-Maketext ChangeLog

Fix some weird formatting in perldelta

s/5.17.5/5.17.6/ in the INSTALL document

Add the generated Acknowledgements section to perldelta

Remove all the boilerplate notes from perldelta

Look up RT authors in the DATA section aliases as well as AUTHORS

This patch is a little gross but if fixes a bug where an author wasn't found
at all. The author in question was in the git log as "bulk88 (via RT)
<perlbug-followup@perl.org>". Note the lack of a name before the "(via RT)"
part.

This whole thing is a bit of a mess. I think this whole script could be
re-organized in a simpler way, perhaps.

Work in progress on perldelta for 23b7025ebc

I still need to figure out what some of the changes described in
http://www.nntp.perl.org/group/perl.perl5.porters/2012/10/msg194211.html
actually mean.

use PERL_UNUSED_VAR rather than PERL_UNUSED_DECL

PERL_UNUSED_DECL doesn't do anything under g++, so doing this silences
some g++ warnings.

Update ExtUtils-MakeMaker to CPAN version 6.64

  [DELTA]

  6.64  Sun Dec 16 18:27:40 PST 2012
    Build Fixes
    * Update the home page in the meta file.  makemaker.org has been
      unmaintained for a while.

  6.63_04  Thu Nov 22 13:18:06 PST 2012
    Test Fixes
    * Eliminated the problematic and not very useful PASTHRU test
      on Windows.  A better test will come after stable. [github 41]
      (Michael G Schwern)
    * Avoid a new regex warning in 5.17.x in t/MM_OS2.t. (Craig A. Berry)

    VMS Fixes
    * Better ignore files due to non-case-preserving filesystems.
      (Craig A. Berry)

Update Scalar-List-Utils to CPAN version 1.26

  [DELTA]

  1.26 -- Sun Dec 16 19:39

    * Merge patch from JDHEDDEN - Add Scalar::Util::isdual() RT#76150

  1.25_01 -- Wed Nov 21 09:47

    * Fix a hash order dependency bug t/tainted.t
      (Currently this is a core only version to fix perl5 smokes)

GDBM_File must cast fatal_func appropriately for the version of gdbm.h

The fifth argument to gdbm_open() is an optional callback function for fatal
errors. The prototype for this function has changed between gdbm 1.8.3 and
1.9.0, from void (*)() to void(*)(const char *). This distinction doesn't
matter to a C compiler, but does to a C++ compiler, which we use to test the
core build. So, cast appropriately, depending on the version macros in
gdbm.h

skip the \N{...} unloaded charnames croak test when PERL_UNICODE set

This has been causing failures for a while.

SKIP in run_multiple_progs() was parsed but unimplemented, implement it

fix the debugger t expr command regression

rough TODO test for t expr

Make DosGlob.t more resilient

If the sv count goes *down* (which doesn’t happen on my machine, but see
<CANgJU+W8_nVg9-YVRBe2r=ZYCbu9-R3RPf0tbH-XWrtVxYhGpA@mail.gmail.com>), we
certainly don’t have a leak.

perl5180delta: Mention 2 more broken+patched modules

eliminate PL_regsize

This var (or rather PL_reg_state.re_state_regsize, which it is #deffed to)
just holds the index of the maximum opening paren index seen so far in
S_regmatch(). So make it a local var of S_regmatch() and pass it as a
param to the couple of static functions called from there that need it.

(Also give the local var the more meaningful name 'maxopenparen'.)

mktables, regexec.c: Comments, white-space; no code changes

Rename property involved in \X matching, for clarity

I was re-reading some code and got confused.  This table matches just
the first character of a sequence that may or may not contain others.

regen/unicode_constants.pl: Add option to skip if undef

I thought I would need this new functionality in this regen script, but
ended up going a different route.  But just in case someone might find
this useful in the future, here it is.

regexec.c: More efficient Korean \X processing

This refactors the code slightly that checks for Korean precomposed
syllables in \X.  It eliminates the PL_variable formerly used to keep
track of things.