locale.c: Stop compiler warning

S_less_dicey_bool_setlocale_r() is a short function that makes a
complete set of similar functions, but there is no current use of it.
So just #ifdef it out.

This resolves #20338

VMS now has mkostemp

toke.c - silence build warning for non DEBUGGING mode

A previous commit introduced the variable 'bool syntax_error' which
was only used under DEBUGGING, which produced unused variable
warnings on "production" builds. This reworks the code to not need
the variable at all.

Warning fixed:

    toke.c: In function ‘Perl_yyerror_pvn’:
    toke.c:12662:14: warning: unused variable ‘syntax_error’ [-Wunused-variable]
    12662 |         bool syntax_error = PERL_PARSE_IS_SYNTAX_ERROR(PL_error_count);
  |              ^~~~~~~~~~~~

Reclaim unused bits in ${^WARNING_BITS}

`no warnings 'experimental::foo';` is effectively a no-op
if the `foo` feature is not experimental any more.

So, stop reserving bits in `${^WARNING_BITS}` for them,
and silently do nothing when they are enabled or disabled
via `use warnings` or `no warnings`.

Warnings turned into no-op in this commit:
* experimental::alpha_assertions
* experimental::bitwise
* experimental::isa
* experimental::lexical_subs
* experimental::postderef
* experimental::script_run
* experimental::signatures

SO_SNDBUF requires elevated privileges on VMS

So we can't reasonably run a test that tries to change the socket
buffer size.

Don't export win32-only symbols on non-Windows

This was causing link-time errors in the VMS build because it was
trying to export symbols that don't exist.

Remove ~~ from autodoc.pl

pp_undef w/ TARGMY: push sv, not &PL_sv_undef, onto the stack

Closes #20336.

regcomp.c - use _simple functions where apparently safe to do so

`av_push`, `av_store`, and `av_fetch` have been changed to their
inline `_simple` variants in a number of places. No test failures
have resulted from these changes.

The remaining uses of the full-fat functions are not suitable to
change because either the AVs have magic, or existing tests show
that the `key` parameter is not > -1 when that is a pre-requisite
of a replacement inline function.

SvPVCLEAR_FRESH - change from macro to inline function

This is to prevent warnings due to the char * frequently being
unused.

locale.c: Refactor internal debugging function

setlocale_debug_string() variants  now use Perl_form, a function I
didn't know existed when I originally wrote this code.

makedef.pl: Rmv obsolete symbol

This routine is now a static function, so needn't be in makedef.pl

locale.c: Mitigate unsafe threaded locales

This a new set of macros and functions to do locale changing and
querying for platforms where perl is compiled with threads, but the
platform doesn't have thread-safe locale handling.

All it does is:

1) The return of setlocale() is always safely saved in a per-thread
buffer, and
2) setlocale() is protected by a mutex from other threads which are
using perl's locale functions.

This isn't much, but it might be enough to get some programs to work on
such platforms which rarely change or query the locale.

perl.h: Remove now empty block

Previous commits have left this empty except for comments, and
equivalent comments have also been added elsewhere

perl.h: Move LOCALE_READ_LOCK #definition

To enable future simplifications

perl.h: Move #defining SETLOCALE_LOCK

This simplifies slightly, and will allow further simplification

Add POSIX_SETLOCALE_LOCK/UNLOCK

This macro is used to surround raw setlocale() calls so that the return
value in a global static buffer can be saved without interference with
other threads.

perl5374delta: fix pod markup

Warnings thrown by GetOptions suffice; no need to dump POD

Many times bisect.pl will die quickly because we have misspecified our
command-line switches in ways that Getopt::Long::GetOptions() can
detect.  In this case, rather than having pod2usage() dump all the
documentation on us, let's simply rely on GetOptions() to warn us about
bad switches and then exit with same value (255) that we do in other cases.

This can be tested with an invocation like the following:

    $ perl Porting/bisect.pl \
      --start=b9d9f9ab79a4bbe3c10743b2b22828dbb8bd2a46 \
      --end=2b8a1552e222c049b05bc141f97d7349b40b3f2f \
      --target=miniperl \
      -e 'q|ace| =~ /c(?=.$)/; print ((($#{^CAPTURE} == -1) ? q|AAA| : q|BBB|), "\n") && exit 0' \
      --sumac --bluefin -j seven --validate=7 --jobs

    Unknown option: sumac
    Unknown option: bluefin
    Value "seven" invalid for option j (number expected)
    Option validate does not take an argument
    Option jobs requires an argument

(Commit began with tidying of Porting/bisect-runner.pl GetOptions call
in preparation for revisions.)

Module::CoreList is now version 5.20220920

make expr parameter to newLOOPOP() NN, it was required anyway

Coverity picked up that while we checked that expr was non-NULL
in newLOOPOP(), the call to new_logop() dereferenced it anyway,
the address of expr is passed to new_logop(), which sees it as firstp
(so firstp == &expr), that is then derefed to first (first == expr)
and then switches on first->op_type, hence dereferencing expr.

Since both callers always pass in an expr value, and the code
would have crashed anyway with a NULL expr, make it required.

Prepare Module::Corelist for 5.37.5

Bump the perl version in various places for 5.37.5

New perldelta for 5.37.5

tick off 5.37.4 release

add epigraph for 5.37.4

add perlhist entry

final perldelta fixes

update perldelta for module updates

update Module::CoreList for 5.37.4

bump XSLoader version: see commit a635e7229b

bump Safe version: see commit 3b5ec3ec

finalize perldelta, except for module updates

whitespace

locale.c: Workaround for attributes.pm breakage

See https://github.com/Perl/perl5/issues/20155

The root cause of that problem is that under POSIX 2008, when a thread
terminates, it causes thread 0 (the controller) to change to the global
locale.  Commit a7ff7ac caused perl to pay attention to the environment
variables in effect at startup for setting the global locale when using
the POSIX 2008 locale API.  (Previously only the initial per-thread
locale was affected.)

This causes problems when the initial setting was for a locale that uses
a comma as the radix character, but the thread 0 is set to a locale that
is expecting a dot as a radix character.  Whenever another thread
terminates, thread 0 was silently changed to using the global locake,
and hence a comma.  This caused parse errors.

The real solution is to fix thread 0 to remain in its chosen locale.
But that fix is not ready in time for 5.37.4, and it is deemed important
to get something working for this monthly development release.

This commit changes the initial global LC_NUMERIC locale to always be C,
hence uses a dot radix.  The vast majority of code is expecting a dot.
This is not the ultimate fix, but it works around the immediate problem
at hand.

The test case is courtesy @bram-perl

wording fix

Fix links in perldelta

This is a correction for f1cc674150b9408466f484c1bd08faaa989000de

The I<...> formatting code is to be used generally for descriptive text
that is to be replaced by the user with whatever is appropriate.

C<...> is for text that is to be typed as-is.  That would be more
appropriate for these module names, which are as-is.

But in this case, these are links to modules.  perl doesn't currently
know if those are valid or not, so podcheck.t fails them.  It has to be
told that the spellings indeed are real modules.  So instead of changing
the L<...> to something else, a better solution that will allow
hyperlinks to be followed (when formatted by e.g., a browser), is to
inform podcheck.t that these are valid links.  This is trivially done by

 perl t/porting/podcheck.t --add-link Test::Vars

for example.  This revises its knowledge database, which will need to be
committed.

perlexperiment: fix warning category for defer and extra parired delimiters

perldelta - change pod markup for non-core modules

move a paren to improve wording

CI/macos: Switch to macos-11

As far as I can find: macos-11 is called Big Sur and uses xcode 13.2.1.
See also: https://github.com/actions/runner-images/blob/main/images/macos/macos-11-Readme.md

(Reason for the change: macos-10 is deprecated in GitHub CI and is
 planned to be removed on 1 December 2022.)

Fixes #20167

CI/macos: Remove `export SDK`

I'm not sure tho that what was ever added..
The build and test appear to work fine when it's not set.

README.macosx does mention it but there it does get used.

From README.macosx#sdk-support :

    First, export the path to the SDK into the build environment:
        export SDK=....

    ...

    You can use the SDK by exporting some additions to Perl's 'ccflags'
    and '..flags' config variables:
        ./Configure -Accflags="-nostdinc -B$SDK/usr/include/gcc \
                               -B$SDK/usr/lib/gcc -isystem$SDK/usr/include \
                               -F$SDK/System/Library/Frameworks" \
                    -Aldflags="-Wl,-syslibroot,$SDK" \
                    -de

But nothing in the ci worflow appears to do that..
So as far as I can tell `$SDK` is never used.

perldelta - add GH#20114 to Known Problems section

Skip 'pending changes' test for automated testing

This code is called via t/porting/authors.t; it basically checks
if there are pending/uncommitted changes and if the author is a known
contributor.

That test doesn't really work too well in combination with Test::Smoke since
that does create some files in the build-directory and may patch some files
(for example patching 'patchlevel.h' to include the commit id).

The end result: on several smokers the t/porting/authors.t test was failing
[because they lack a git config for user+email or because the configured
 name/email is not a known contributor].

Unfortunately Test::Smoke does not set the AUTOMATED_TESTING flag so
detect if Test::Smoke is running by checking for the 'mktest.out' file.

This commit also reverts the temporary work-around that was added in
commit 6c19d6c6d4db446fa9513b7d617134c938c89a4e. (That work-around
didn't cover all cases; there are smokers running with a different name/email
configured then the one in AUTHORS and for those the test still failed with
the temp work-around.)

Fixes #20141

Use `git symbolic-ref` instead of `git branch`

`git branch` is a porcelain command and should not be used in scripts.[^1]

It can also cause failures when:
- color.ui in git config is set to 'always'
- HEAD is detached (i.e. `git checkout blead^0`)

In that case the current branch is colored and (partially) ends up in
the `$branch` var. (The code did check that the branch name didn't start
with `(` but that check doesn't really work when it's colored. In that case
the 'branch name' starts with an escape sequence for the color)

Example (without the patch):

$ git config color.ui always
$ git checkout blead^0
$ ./miniperl -Ilib make_patchnum.pl
sh: -c: line 0: syntax error near unexpected token `('
sh: -c: line 0: `git config branch.(detached.merge'
sh: -c: line 0: syntax error near unexpected token `('
sh: -c: line 0: `git config branch.(detached.remote'
$ grep git_branch lib/Config_git.pl
git_branch='(detached'
$ grep git_branch lib/Config_git.pl | cat -A
git_branch='^[[32m(detached'$

With the patch applied:

$ ./miniperl -Ilib make_patchnum.pl
Updating 'git_version.h' and 'lib/Config_git.pl'
$ grep git_branch lib/Config_git.pl
git_branch=''
$ grep git_branch lib/Config_git.pl | cat -A
git_branch=''$

[^1]: See https://git-blame.blogspot.com/2013/06/checking-current-branch-programatically.html
      which is a blog post from the git maintainer.

vnewSVpvf - inline & reduce call to sv_vsetpvfn

sv_vsetpvfn does just two things:
* SvPVCLEAR on the sv passed in
* calls sv_vcatpvfn_flags

Since the SV passed into sv_vsetpvfn by vnewSVpvf is a brand new SV,
it is more efficient to inline sv_vsetpvfn and change the SvPVCLEAR
to SvPVCLEAR_FRESH.

S_regclass - use SvPVCLEAR_FRESH on new SV

S_scan_heredoc - use SvPVCLEAR_FRESH on new SV

sv.c - add SvPVCLEAR_FRESH macro for new PVs with buffer

SvPVCLEAR(tmpstr) is a macro that calls sv_setpv_bufsize(tmpstr,0,0).
If called on a newly minted PV/PVIV/PVNV/PVMG that has a fresh PV
buffer assigned, many of the checks in SvPVCLEAR are unnecessary:
    * SvTHINKFIRST - won't be set
    * upgrade to SVt_PV - won't be necessary
    * SvGROW - we assert that this isn't necessary

It then does some useful, but small actions:
    * sets SvCUR(sv, 0);
    * sets the last byte in the PV buffer to \0
    * sets SvPOK_only_UTF8
    * does SvTAINT

Then does a final irrelevant check:
    * is tmpstr a PVCV - no it is not

This commit introduces SvPVCLEAR_FRESH as a drop-in replacement
for compatible SVs, that only does the relevant small actions.

S_scan_heredoc: fresh sv functions close to point of use

S_scan_heredoc does a SvGROW on a fresh PVIV. A sv_grow_fresh is
more efficient, plus it seems only really needed in the nearby "else"
branch. In the "if" branch, sv_setsv_fresh can be used directly.

perl.h: Fix typo

sv_setsv_cow - directly create desired SVt_COW SV

It's more efficient to directly create the desired SV type than create
a SVt_NULL and then call sv_upgrade to get the desired type.

perlhacktips: Add a section on symbol naming

pod - remove references to PrePAN (now defunct)

perlguts - document newAV_alloc_x/z and _simple funcs

Perl_sv_setsv_flags: return after invlist_clone case

In the "first_ switch" statement in Perl_sv_setsv_flags, there's this case:
    case SVt_INVLIST:
        invlist_clone(ssv, dsv);
        break;

When the INVLIST code was added, it was unclear whether the logic following
that switch needed to apply to INVLISTs or not. Early returns were also seen
as risky from a future maintenance perspective. As a precaution, this case
was written to `break` rather than `return`.

With later analysis though, it seems like the code below this switch does
not apply to INVLISTs, apart from one unintended interaction.

* invlist_clone() - in regcomp.c - copies the PV buffer of ssv to dsv.
* However, whenever an invlist is initialized, SvPOK_on is called on its SV;
according to the nearby comment "/* This allows B to extract the PV */".
* Because the switch case does not return, the later `if (sflags & SVp_POK)`
branch will try to swipe/cow/copy the PV buffer of ssv to dsv. This is an
unnecessary double copy.

On that analysis, this commit changes the break into a return.

CI/cygwin: clone the repo similar to 'checkout@v2'

The primary reason for doing is to make it similar to all the
other CI configs.

The second reason for doing this is because it makes the checkout
faster. (old: 1m14s, new: 9s)

CI/cygwin: use test harness with 2 jobs

It was running the tests using t/TEST; change it to use t/harness
and use two jobs for doing so.

This decreases the total run-time from about 1h to 38m.

CI/cygwin: use `shell: sh`

Before it was using powershell (or cmd) to run a 'sh -c' command.
Change it to use `shell: sh` so it becomes a bit more readable.

For using `shell: sh` two problems had to be fixed:
- the GitHub runner creates a file with the 'run'-contents but it uses
  a CRLF line ending which doesn't work with `sh`. The work-around for
  that is to include `igncr` in SHELLOPTS (the 'igncr' option is
  a cygwin patch to bash)
- SHELLOPTS contain 'errexit' which breaks ./Configure since it
  stopped on the first non-zero exit status (which happened to be
  a `grep`)

CI/linux-i386: use shallow clone (fetch-depth: 1)

The other CI configurations use `checkout@v2' which defaults to making
a shallow clone (i.e. with fetch-depth set to 1).

Do the same for linux-i386.

CI/linux-i386: Remove fetching of tags

For linux-i386 `checkout@v1` is used which automatically fetches all tags.
It uses the command (slightly altered for readability):
git -c http.extraheader="AUTHORIZATION: basic ***" fetch \
--tags \
--prune \
--progress \
--no-recurse-submodules \
origin +refs/heads/*:refs/remotes/origin/*

So fetching the tags again is not needed.

Note: this also makes it possible to get rid of the `git remote set-url`
      command. (This was added to add 'Authorization' header which is
      needed when using a private repo when using `git fetch`. Since the
      `git fetch` is gone the changing of the remote is no longer needed)

CI/linux-i386: Explain why 'checkout@v2' fails

TLDR: it uses a 64-bit binary inside a 32-bit container.
(For details see the code)

testsuite.yml: Remove fetching of tags

The only test that need the git tags (afaik) is porting/cmp_version.t;
But the fetching of tags isn't really working for that test.

Basically the repo is cloned with:
$ git clone --depth 1 https://github.com/perl/perl5
$ git fetch --depth=1 origin +refs/tags/*:refs/tags/*

And then later the test uses:
$ git describe --abbrev=0 HEAD

and it expects to find a tag.

However doing that:
$ git describe --abbrev=0 HEAD
fatal: No tags can describe '6a011f13d7690dbe2e03ad7500756c983bcb1834'.

So it's not really working..

This can also be seen in the CI logs[^1], the output contains:
porting/cmp_version.t ..... skipped: Git found, but no Git tags found

There are only 3 CI configs that do run the porting/cmp_version.t test:
- 'Sanity: Linux -Dusethreads' - this is intended
- 'linux i386/ubuntu (-Dusedevel)'[^2]
- 'cygwin'[^3]

[^1]: CI logs of: 'linux (-Uusethreads)', 'linux (-Duseshrplib ...)',
      'linux (-Duserelocatableinc)', 'linux (-Dcc='clang')', 'linux (-Dcc='g++')',
      'install', 'macOS (catalina) xcode 12 (-Uusethreads)',
      'macOS (catalina) xcode 12 (-Duseithreads -Duseshrplib)', 'Windows msvc142',
      'Windows mingw64', 'ASAN (-Accflags=-DPURIFY)', 'ASAN (-DDEBUGGING)',
      'ASAN (-Dusethreads)', 'PERL_UNICODE (-Uusethreads)',
      'PERL_UNICODE (-Dusethreads ...')

[^2]: it uses 'actions/checkout@v1' to do the checkout which does a full clone
[^3]: it manually runs `git clone`, doing a full clone (with all history)

Net-Ping: No longer need to TODO some tests when on FreeBSD

See Net-Ping maintainer's comment:
https://github.com/rurban/Net-Ping/pull/18#issuecomment-1234223370

Regenerate customized database.

For: https://github.com/Perl/perl5/pull/20216

Fix t/porting/authors.t breakgage for people with non-ASCII names

The lack of decoding of git config values in Porting/updateAUTHORS.pm
would make it erroneously claim that anyone with a non-ASCII character
in their name was an unknown author.

The decoding and encoding in updateAUTHORS.pl is not strictly
necessary, since that's just passing things through to the terminal,
but let's be consistent.

locale.c: Use LC_ALL only if available on platform

These are the final (unless I missed something) cases where LC_ALL could
be referred to even if undefined on the system.

Win32 should start new threads in C locale

Prior to this commit, wrong cpp directives did not guarantee this.

thread.h Save errno around lock/unlock

It may be necessary to unlock a mutext before raising a diagnostic about
a failure.  The unlock can then destroy the errno value needed to
diagnose the original problem.  This commit solves this in one place.

thread.h: White-space, braces only

perlfilter.pod: Retain entry in customized database

pod/perlfilter.pod is (for historical reasons, apparently) maintained
upstream on CPAN as part of the Filter distribution.  As such, (i) it
should, generally speaking, only be edited upstream and synched into
core; (ii) needs to be referenced in several places in the
Filter::Util::Call element in %Maintainers::Modules
(Porting/Maintainers.pl); (iii) needs to have an entry in
t/porting/customized.dat (the "customized database") to protect it from
being "overwritten" or accidentally removed.

For all of the above conditions to work together, the
filter_customized() subroutine in t/porting/customized.t needs to be
able to construct a regex which recognizes pod/perlfilter.pod's
weirdness.  Prior to this patch it was failing to do so.  Thus when
pod/perlfilter.pod was accidentally edited in commit d84bd0bd47, the
need to regenerate the customized database was not recognized.  Later,
review of a different pull request which required regeneration of the
customized database spotted the unintentional deletion of the entry for
pod/perlfilter.pod from t/porting/customized.dat.

Addressing this problem is inevitably going to be kludgy, but it will be
less kludgy if done in t/porting/customized.t than in
Porting/Maintainers.pl.  This patch modifies the former file to
guarantee that the string 'pod/perlfilter.pod' is matched.  After that
modification, 'cd t; ./perl -I../lib porting/customized.t --regen; cd -'
was run.  This accomplished the (previously overlooked) removal of
certain entries for Memoize in the customized database while leaving the
entry for pod/perlfilter.pod in that database intact.

If at some point in the future we decide that pod/perlfilter.pod should
be maintained directly in core, we can remove this kludge and simplify
the Filter::Util::Call element in %Maintainers::Modules in
Porting/Maintainers.pl.

For: https://github.com/Perl/perl5/issues/20228.

Should (partially) unblock https://github.com/Perl/perl5/pull/20216.

pod/perldelta - add entries to the incompatible changes section

One is about syntax errors changing. The other is about -v stacking
precedence over -c and related issues of making the BEGIN{exit(0)}
work properly.

re/pat_advanced.t: remove `todo_skip` from test

This test is skipped when running as threads (i.e. via t/re/pat_advanced_thr.t)
since 20 Mar 2011 (commit 2feceb76bc07c8978188ab67f91851845258b0e1) because of
a bug.

That bug `[perl #86550]` is GH #7533 and that was fixed in Oct 2015 with
commit 0ee3fa26f660ac426e3e082f77d806c9d1471f93.

So I think it's safe to remove the `todo_skip` since the bug for why it was
skipped looks resolved. (A smoke-me branch also revealed no unexpected
problems)

locale.c: Clean up two DEBUG stmts

STMT_START...END aren't required in DEBUG() calls, as that macro already
wraps its argument with those.  So, they are just clutter here.

perl.h: Rmv duplicate #define

LOCALE_LOCK has already been defined in all circumstances earlier in the
file

Revert "perl.h: Move #defining SETLOCALE_LOCK"

This reverts commit d0b8b8e8a48798446382161f988e6081140578d6.
I got ahead of myself.  This commit was premature

perl.h: Move #defining SETLOCALE_LOCK

This simplifies slightly, and will allow further simplification

Move #include from locale.c to perl.h

Without this commit, Perl won't compile if -DUSE_NL_LOCALE_NAME is
specified to Configure.  This is an undocumented feature that uses an
undocumented glibc feature that is effectively the querylocale() found
on Darwin and some other systems.  POSIX 2017 has added a
querylocale-like function to the repertoire, and should eventually
supplant this option.

Update POSIX synopsis

Merge branch 'Change init of certain locale categories' into blead

This series of commits adds initialization for an object, and changes
the initialization process to call, for each locale category that has
one, the specialty function that handles locale changes for that
category, instead of duplicating the logic in the initialization
section.

This allows for the removal of a couple of conditionals that otherwise
would need to be executed each time the locale changes.

locale.c: Remove no-longer necessary conditionals

The previous commit initialized this variable early in start up, so that
we never have to now check that it is non-NULL.

locale.c: Use locale change subs at initialization

There are currently 4 functions that do special handling when the locale
for their respective categories changes.  One of these is for LC_ALL,
which has and continues to be called at the end of initialization.

But the other three have changed in recent commits to handle the trivial
case specially of the locale being "C".  These changes now avoid the
complexities required for the general case (that needs everything to be
set up at the time of the call).

They can thus be called early in the initialization precess.  This
avoids having to duplicate their logics in the initialization code,
which has led to some things being overlooked there.  Now everything is
guaranteed to stay in sync.

locale.c: Initialize PL_underlying_numeric_obj

This probably doesn't matter, but it's better form to initialize it to a
sane value.

locale.c More new_ctype() refactoring

Merge commit e4bbbfe02b9e9aae521b164eba0e518ca478945f refactored this
function some.  Most of the commits in that series dated to before when
we could assume C99.  In re-reading the result, I saw some opportunities
to take advantage of C99, by, for example, moving declarations closer to
their use.

I also hadn't previously noticed that when changing to the C locale (a
frequent occurrence), various things that we being recalculated are
determinable at compile time.  So this commit returns early under this
circumstance.

And, an obsolete comment is removed

locale.c: Silence compiler warning when no LC_COLLATE

On Configurations without LC_COLLATE, various unused warnings were
being generated.

locale.c: Silence compiler warning when no LC_CTYPE

On Configurations without LC_CTYPE, various unused warnings were
being generated.

locale.c: Silence compiler warning about S_mortalixzed_pv_copy

This function is not used unless locales are enabled, so need not be
defined unless that is true.

locale.c: Silence compiler warning about S_new_numeric

This function is not used unless LC_NUMERIC is enabled, so need not be
defined unless that is true.

locale.c: Silence C_codeset compiler warning

This fixes #20140

This static variable is used in just one or (unlikely) two places, and
only in some Configureations.  Rather than add #ifdefs, or make a
PERL_UNUSED call somewhere, making it a #define fixes the issue without
taking up extra memory except in some dumb compilers under unlikely
Configurations.

locale.c: Change macro name 'porcelain' => 'posix'

When I wrote this I tought porcelain in git meant something different
than it does.  But what this macro does is to hide the non-POSIX vs
POSIX differences from its callers.

sv.c: Comments white-space only

locale.c: Clarify comment

Merge branch 'Start cleaning up mutexes for locales and functions that access global memory' into blead

This series of commit first cleans up some locale initialization
gotchas, and adds asserts.

And it cleans up where a few locale-related definitions are done

It converts the locale mutex to a general semaphore from a binary one,
which allows for simplification in switching the LC_NUMERIC locale.

And certain mutex macros now use the newly-general one

perl.h: Remove LOCALECONV_LOCK

This is needed in just one function, in locale.c, so more it there.

perl.h: Remove NL_LANGINFO_LOCK

This is needed in precisely one place in the code, so move it to there.

Redefine the POSIX.xs locale macros using prev commit

This commit uses the new macro introduced in the previous commit to
define the internal locale mutex macros in POSIX.xs

Add locale macro to wrap global-memory-using functions

Some functions return a result in a global-to-the-program buffer, or
they use global memory internally.  Other threads must be kept from
simultaneously using that function.  This macro is to be used for all
such ones dealing with locales.  Ideally, there would be a separate mutex
for each such buffer space.  But these functions also have to lock the
locale from changing during their execution, and there aren't that many
such functions, and they actually are rarely executed.  So a single lock
will do.

This will allow future commits to have more targeted locking for
functions that don't affect the global locale.

Use general locale mutex for numeric operations

This commit removes the separate mutex for locking locale-related
numeric operations on threaded perls; instead using the general locale
one.  The previous commit made that a general semaphore, so now suitable
for use for this purpose as well.

This means that the locale can be locked for the duration of some
sprintf operations, longer than before this commit.  But on most modern
platforms, thread-safe locales cause this lock to expand just to a
no-op; so there is no effect on these.  And on the impacted platforms,
one is not supposed to be using locales and threads in combination, as
races can occur.  This lock is used on those perls to keep Perl's
manipulation of LC_NUMERIC thread-safe.  And for those there is also no
effect, as they already lock around those sprintf's.

Make the locale mutex a general semaphore

Future commits will use this new capability, and in Configurations where
no locale locking is currently necessary.

perl.h: Reorder cpp branches

Disposing of the trivial case first makes things easier to read.

perl.h: Move some code around

This is purely to make future commits have smaller real difference
listings, and involves a temporary (complemented) copy of a preprocessor
conditional.