regcomp.c: White-space, comment only
handy.h: Guard against recursive #inclusion
intrpvar.h: #include handy.h

This will allow some mnemonics to be used in future commits
intrpvar.h: Place some swash pointers in an array
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
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.)
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: Move some back compat macros

Move them to the section that is for back-compat definitions.
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, and this commit changes to use it.
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.
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.
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.
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.
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
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: Collapse some switch cases

Previous commits have caused some of the cases in this switch to be
identical, so they can be collapsed.
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 two identical cases in a switch
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 some switch casses

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