t/run/locale.t: use 'warnings'

A symobl it was testing is either defined or not; was testing the wrong
thing

loc_tools.pl: use 'warnings'

loc_tools.pl: Fix locales_enabled()

This commit properly returns the new list it is supposed to, clarifies
the documentation.

Fixes GH #18245

t/loc_tools.pl: Don't destroy caller's array

This changes to make a copy of the input array, which can then be
modified without affecting the caller.

remove assertion that collation magic has data

This broke on some smokers where the locale collation data was
broken in some way (and rejected by the collation setup code.)

It also broke if collation magic was generated for an SV and then
the SV was modified, freeing the collation data before the SV was
destroyed.

remove dead code when using Perl_strtod for numeric conversion

which is the common case.

If strtod() is disabled, (and USE_PERL_ATOF isn't also disabled) this
code is used, so I moved it into the #elif block.

It's also possible to Configure disabling both strtod() and
USE_PERL_ATOF with:

  ./Configure ... -Ud_strtod -Accflags=-DUSE_PERL_ATOF=0 ...

which resulted in a build with a broken Perl_my_atof3(), so fail the
build early with #error in that case.

embed.h: Add caution about PERL_NO_SHORT_NAMES

Fix GH #17278

This was an assertion failure in regexec.c under rare circumstances.  A
reduction of the fuzzed test case is now in pat_advanced.t

The root cause of this was that the pattern being compiled was encoded in
UTF-8 and 'use locale' was in effect, equivalent to the /l charset, and
then the charset was reset inside the pattern, to /d.  But /d in a UTF-8
patterns is illegal, hence the later assertion failure.

The solution is to reset instead to /u when the pattern is UTF-8.

[MERGE] don't do special-cases in S_mg_free_struct

Move all the special-case handling of various magic types out into
vtable->free() methods.

add Perl_magic_freemglob() magic vtable method

S_mg_free_struct() has a workaround to never free mg->mg_ptr for
PERL_MAGIC_regex_global.

Move this logic into a new magic vtable free method instead, so that
S_mg_free_struct() (which gets called for every type of magic) doesn't
have the overhead of checking every time for mg->mg_type ==
PERL_MAGIC_regex_global.

[ No, I don't know why PERL_MAGIC_regex_global's vtable and methods
  are suffixed mglob rather than regex_global or vice versa ]

add Perl_magic_freeutf8() magic vtable method

S_mg_free_struct() has a workaround to free mg->mg_ptr in
PERL_MAGIC_utf8 even if mg_len is zero.

Move this logic into a new magic vtable free method instead, so that
S_mg_free_struct() (which gets called for every type of magic) doesn't
have the overhead of checking every time for mg->mg_type ==
PERL_MAGIC_utf8.

add Perl_magic_freecollxfrm() magic vtable method

v5.29.9-139-g44955e7de8 added a workaround to S_mg_free_struct() to
free mg->mg_ptr in PERL_MAGIC_collxfrm even if mg_len is zero.

Move this logic into a new magic vtable free method instead, so that
S_mg_free_struct() (which gets called for every type of magic) doesn't
have the overhead of checking every time for mg->mg_type ==
PERL_MAGIC_collxfrm.

t/loc_tools.pl: Consider thread 0 always locale-safe

Test files call this code to see if locales are enabled.  Prior to this
commit, it returned that they were disabled on builds where there are
possible races between threads.  This was to silence some rarely
occurring smoke failures.  But that had the result that such builds
didn't get locales tested at all, even if there was just a single thread
operating.  This commit changes it so that when called from other than
the main thread on such a system, it returns disabled, but enabled for
the main thread.

perlguts: some items are actually documented in config.h

autodoc: Add clarifying info to error messages

perl.h: Fix rarely compiled syntax errors

This #ifdef'd code clearly doesn't get compiled, as it would fail.

perl.h: Fix typo in comment

perl.h: Call macro instead of expanding it out

perlapi: Add markup

utf8.c: Add blank line for visual clarity

perlapi: PTRV is a typedef

autodoc.pl: Use $scalars to hold heading names

Prior to this, the headings were kept as string keys in a hash.  This
allows for easier tweaking of their contents, and to more easily catch
typos.

autodoc.pl: Output undocumented fcns in multi columns

This is just a list, with nothing to be gained by having a single entry
per line, and making multiple columns shortens it significantly.

autodoc.pl: Extract code into a function

This is in preparation of it becoming more complex in a future commit

autodoc.pl: Rename sort function for clarity of purpose

Devel::PPPort Makefile.PL is not customized since 46677718f1

perlintro - Use single hyphen in NAME section

Module-CoreList-5.20201020 is on CPAN

Prepare Module::CoreList for 5.33.4

Bump version to 5.33.4

Create new perldelta for 5.33.4

Tick off 5.33.3

Add epigraph for 5.33.3

5.33.3 today

Finalize perldelta

Including a final Porting/corelist-perldelta.pl run.

Update Module::CoreList for 5.33.3

sysconf.t: close() takes filehandle, not file descriptor

Per suggestion from Leon Timmermans in
https://github.com/Perl/perl5/issues/18249.

Update Devel-PPPort to release 3.62

perldelta - Various updates

perldelta - Remove boilerplate

perldelta - Update Modules and Pragmata

perlbug - remove obsolete paragraph

INSTALL - Correct section about upgrading from previous version

Consolidate and revise pod for toLOWERfoo()

regcomp.c: Do some extra folding

Generally we have to wait until runtime to do folding for regnodes that
are locale dependent, because we don't know what the locale at runtime
will be, and hence what the folds will be.

But UTF-8 locales all have the same folding behavior, no matter what the
locale is, with the exception of two fold pairs in Turkish.  (Lithuanian
too, but Perl doesn't support that language's special folding rules.)
UTF-8 is the only locale type that Perl supports that can represent code
points above 255.  Therefore we do know at compile time what the
above-255 folds are (again excepting the two in Turkish), and so we can
do the folding then.  But only if both the components are above 255.
There are a few folds that cross the 255/256 boundary, and they must be
deferred.

However, there are two instances where there are three characters that
fold together in which two of them are above 255, and the third isn't.
That the two high ones are equivalent under /i is known at compile time,
and so that equivalence can be stated then.

regexec.c: Store expression in a variable

This makes the text look cleaner, and prepares for a future commit,
where we will want to change the variable (which can't be done with the
expression).

regexec.c: Change variable name in a function

This makes it like a corresponding variable.

regexec.c: Rename local variable; change type

I found myself getting confused, as this most likely was named before
UTF-8 came along.  It actually is just a byte, plus an out-of-bounds
value.

While I'm at it, I'm also changing the type from I32, to the perl
equivalent of the C99 'int_fast16_t', as it doesn't need to be 32 bits,
and we should let the compiler choose what size is the most efficient
that still meets our needs.

charclass_invlists.h: Add some inverse folds.

The MICRO SIGN folds to above the Latin1 range, the only character that
does so in Unicode (or ever likely to).  This requires special handling.
This commit reduces some of the need for that handling by creating the
inversion map for it, which can be used in certain instances in pattern
matching, without having to have a special case.  The actual use of this
will come in a future commit.

regen/regcharclass.pl: White space only

This does some line wrapping, etc

regen/regcharclass.pl: Rmv unused macro

regen/regcharclass_multi_char_folds.pl: Use case fold

Prior to this commit, only the upper case of Latin1 characters was dealt
with.  But we really want case folding, and there are a few other
characters that fold to Latin1.  This commit acknowledges them.

regen/regcharclass_multi_char_folds.pl: White space, comment only

Outdent and remove lines from changes in the previous commit.

regcharclass.h: multi-folds: Add some unfoldeds

Prior to this commit, the generated macros for dealing with multi-char
folds in UTF-8 strings only recognized completely folded strings.  This
commit changes that to add the uppercase for characters in the Latin1
range.  Hopefully an example will clarify.

The fold for U+0130: LATIN CAPITAL LETTER I WITH DOT ABOVE is 'i'
followed by U+0307: COMBINING DOT ABOVE.  But since we are doing /i
matching, an 'I' followed by U+307 should also match.  This commit
changes the macros to know this.  Before this, if the fold were entirely
ASCII, the macros would know all the possible combinations.  This commit
extends that to all code points < 256.  (Since there are no folds to the
upper latin1 range), that really means all code points below 128.  But
making it general means it wouldn't have to be revised if a fold were
ever added to the upper half range.)

The reason to make this change is that it makes some future code less
complicated.  And it adds very little complexity to the generated
macros; less than the code it will save.  I originally thought it would
be more complext than it now turns out to be.  Much of that is because
the infrastructure has advanced since that decision.

I couldn't find any current places that this change will allow to be
simplified.  There could be if the macros were extended to do this on
all code points, not just the low ones.  I tried that, but the generated
macros were at least 400 lines longer than before.  That does add
significant complexity, so I backed that out.

regen/regcharclass.pl: Use char instead of hex

This changes the generated macros to use a printable character or
mnemonic instead of a hex value.  This makes the macros easier to read.

regen/regcharclass.pl: Move parameter to caller

This commit changes a sub in this file to be passed a new parameter.
This is in preparation for the value to be used in the caller.  No need
to derive it twice.

regen/regcharclass.pl: Change member to method

This will allow more flexibility in future commits to instead of using a
static format, to use one based on the input value.

The only non-white space change from this commit, is the reordering of a
couple tests; I'm not sure why that happened.

regcomp.c: Simplify

This was a case statement of every type of EXACTish node.  Instead,
there is a simple way to see if something is EXACTish.

regcomp.c,regexec.c: Simplify

This commit uses the new macros from the previous commit to simply come
code.

regnodes.h: Add two convenience bit masks

These categorize the many types of EXACT nodes, so that code can refer
to a particular subset of such nodes without having to list all of them
out.  This simplifies some 'if' statements, and makes updating things
easier.

regcomp.c: Simplify

The previous commit made the opcodes for two regops adjacent, so that we
can refer to them by a single range.  This commit takes  advantage of
that change.

regcomp.sym: Make adjacent opcodes for 2 similar regnodes

These are often tested together.  By making them adjacent we can use
inRANGE.

regcomp.sym: Update node comments

regcomp.c: Clarify comment

regen/unicode_constants.pl: Add a couple constants

which will be needed in a future commit

regexp.h: White-space only

Indent preprocessor lines for clarity of program structure

Make some flags accessible from /ext

Nothing in the test suite (nor apparently CPAN) had exercised this area
of the code, and so this flaw hadn't been discovered.  But new code
about to be commited does.

ext/B/Makefile.PL: #define can have interior white space

As a result, it would fail to see legal preprocessor lines like

 # define foo

Porting/checkAUTHORS.pl --update --from=v5.33.2

(The new "author" relates to commit ac175de77d.)

Porting/checkAUTHORS.pl - Don't switch EOLs on Windows

t/porting/customized.dat - Pod::Checker no longer has any CUSTOMIZED files

RMG - Spelling and grammar tweaks

HP cc can't handle NOT_REACHED

Like solaris, trying to give the hint to the compiler that we know this
area of the code is unreachable, merely results in the warning we were
trying to suppress.  So turn it off.

Change name of intermediary macro, and #undef it

Instead of using an underscore to mark this as private, we can #undef
this intermediary after use, as it isn't needed to be defined outside
the small area is is used in in perl.h

Fix __builtin_unreachable

Tomasz Konojacki pointed out on #irc that the formulation in
5d5b9c460e2a06563d2b5e35a1a79991460696eb was wrong, and the correction
here is the right way of doing it.

version - Fixes from recent CPAN update (966a34475a)

The customization of vutil.c in 51b56f5c7c was lost.

The customization of vxs.inc restored by 2351bb7334 was not recorded in
the usual places, which is probably why it got lost before.

Memoize - t/expmod_t.t and t/speed.t were CUSTOMIZED by 53379bfd2f and f0206e8198

Math::Complex - t/underbar.t was CUSTOMIZED by cde2523b3a

Tie::RefHash - Some files are EXCLUDED from blead

regcomp.c: Zero width constructs shouldn't be SIMPLE

This is reserved for length-1 constructs.

Refactor and document ASSUME()

The blead definition doesn't compile when I use Devel::PPPort earlier than
some point in the 5.19 series.

Examining the code, I noticed that there was a potential cyclic
definition: ASSUME can call NOTREACHED, and NOTREACHED can call assume.

Blead also assumed without checking that __builtin_unreachable() exists.

So, I refactored things so that there is no cycle, and changed a few
words in the comments to turn them into pod, and the new version
compiles all the way back.

Document NOOP, dNOOP, dVAR

This commit also moves the definition of dVAR down so its
controlling #ifdef is combined with the next #ifdef

win32: use the same manifest for Visual C++ and gcc builds

Before this commit, MSVC builds were using /manifestdependency flag
instead of embedding perlexe.manifest. That was causing issues like
GetVersionEx() returning the wrong version number on Windows 10.

pod/perlfunc.pod:  Remove misleading code example (#18105)

* pod/perlfunc.pod:  Remove misleading code example

For: GH 18016

* Additional correction suggested by Dan Book

perlsub - Link to constant pragma

regexec.c: Macroize another common paradigm

regexec.c: Macroize a common paradigm

regexec.c: Rename a static variable

This is to distinguish it from a similar variable being added in a
future commit

regexec.c: find_byclass(): Restructure

This is a follow-on to the previous commit.  The case number of the main
switch statement now includes three things: the regnode op, the UTF8ness
of the target, and the UTF8ness of the pattern.

This allows the conditionals within the previous cases (which only
encoded the op), to be removed, and things to be moved around so that
there is more fall throughs and fewer gotos, and the macros that are
called no longer have to test for UTF8ness; so I teased the UTF8 ones
apart from the non_UTF8 ones.

regexec.c: S_find_byclass(): utf8ness in switch()

This uses the #defines created in the previous commit to make the switch
statement in this function incorporate the UTF8ness of both the pattern
and the target string.

The reason for this is that the first statement in nearly every case of
the switch is to test if the target string being matched is UTF-8 or
not.  By putting that information into the the case number, those
conditionals can be eliminated, leading to cleaner, more modular code.
I had hoped that this would also improve performance since there are
fewer conditionals, but Sergey Aleynikov did performance testing of this
change for me, and found no real noticeable gain nor loss.

Further, the cases involving matching EXACTish nodes have to also test
if the pattern is UTF-8 or not before doing anything else.  I added that
information as well to the case number, so that those conditionals can
be eliminated.  For the non-EXACTish nodes, it simply means that that
two case statements execute the same code.

This is an intermediate commit, which only does the expansion of the
current cases into four for each.  The refactoring that takes advantage
of this is in the following commit.

regen/regcomp.pl: Generate #defines for UTF8ness

This causes #defines to be generated for regexec.c to use in switch
statements, so that for each opcode there that is a case: there are
actually 4 cases, for the the target being UTF-8 or not, combined with
the pattern being UTF-8 or not.

This will be used in future commits to simplify things.

regen/regcomp.pl: Change variable name

The more specific name this is changed to will make code clearer in
future commits.

regen_lib: Output blanks; not tabs

This makes it easier to calculate widths; and our policy is to not use
tabs anyway.

Add exec bit to Porting/Maintainers.pl

This was inadvertently recently cleared

Fix t/porting/cmp_version.t following Pod-Usage update

Update DB_File from version 1.854 to 1.855

No need for empty CUSTOMIZED section

Update Pod-Usage from version 1.70 to 2.01

t/opbasic/arith.t - extra tests to better exercise dleft/dright paths in pp_modulo

perl5db.pl - remove redundant share()