hide private functions with __attribute__((visibility("hidden")))

This allows us to enforce API boundaries and potentially enables
compiler optimisations.

We've been always hiding non-public symbols on Windows. This commit
brings that to the other platforms.

t/porting/libperl.t: don't check for non-public symbols

Both Perl_peep and Perl_pp_uc are private. Check for Perl_croak instead;
it's a part of the public API.

define POSIX:: constants from limits.h when building with mingw

autodoc.pl: s/guts/intern/ (mostly)

The terms 'guts' and 'intern' are conflated in this file prior to this
commit.  perlguts and perlintern are separate entties.

perlapi: Document ASCIIish

perlapi: PERL_USE_GCC_BRACE_GROUPS is defined or not

Use the new perldoc flag for symbols that don't have a value when defined.

Add '#' flag for autodoc entries

This indicates the symbol is accessed via #ifdef and is not a function
or a macro with a returned value

Sidney Markowitz is now a Perl author

handy.h: White space only

These shouldn't be indented

GH19478: applying taint is no reason to mess with pos

25fdce4a16 introduced a chunk in sv_magic() to "force pos to be stored
as characters, not bytes" whenever any magic was applied to a string
marked UTF8.

It is not clear why a random call to sv_magic(), eg to mark a string as
tainted, needs to do this - it would seem more logical for the check to
happen either earlier (when the string first qualifies as SvMAGICAL(sv)
&& DO_UTF8(sv)) or later (eg on mg_find).

Experimentally remove this block - it appears to cause no test failures,
and allows the new test cases to pass.

locale.c: Move unreachable code so is reachable

It turns out this code, setting errno, is unreachable.  Move it to the
place where it would do some good, removing an extraneous, unreachable
return;

locale.c: Simplify S_category_name

We can use the new function S_get_category_index() to simplify this.
Also, when I wrote it I didn't know about Perl_form(), and had
reimplemented a portion of it here; which is yanked as well.

locale.c: Change S_emulate_setlocale name and sig

It turns out this function is called only from places where we have the
category index already computed; so change the signature to use the
index and remove the re-calculation.

It renames it to emulate_setlocale_i() to indicate that the category
parameter is an index.

This also means, that it's very unlikely that it will be called with an
out-of-bounds value.  Remove the debugging statement for that case (but
retain the error return value).

locale.c: Use get_category_index()

This creates the first uses of the function added in the previous commit.

It changes the name of a function that now takes an index to have the
suffix _i to indicate its calling parameter is a category index rather
than a category.  This will become a common paradigm in this file in
later commits.

Two macros are also created to call that function; they have suffixes _c
(to indicate the parameter is a category known at compile time, and _r
(to indicate it needs to be computed at runtime).  This is in keeping
with the already existing paradigm in this file.

locale.c: Create S_get_category_index()

libc locale categories, like LC_NUMERIC, are opaque integers.  This
makes it inconvenient to have table-driven code.  Instead, we have
tables that are indexed by small positive integers, which are a
compile-time mapping from the libc values.

This commit creates a run-time function to also do that mapping.  It
will first be used in the next commit.

The function does a loop through the available categories, looking for a
match.  It could be replaced by some sort of quick hash lookup, but the
largest arrays in the field have a max of 12 elements, with almost all
searches finding their quarry in the first 6.  It doesn't seem
worthwhile to me to replace a linear search of 6 elements by something
more complicated.  The design intent is this search will be used only at
the edges of the locale-handling code; once found the index is used in
future bits of the current operation.

locale.c: Cast return of setlocale() to const

If they had it to do over again, the libc makers would have made the
return of this function 'const char *'.  We can cast it that way
internally to catch erroneous uses at compile time.

locale.c: Change macro name

Adopt the git convention of 'porcelain' meaning without special
handling.  This makes it clear that porcelain_setlocale() is the base
level.

Regularize HAS_POSIX_2008_LOCALE, USE_POSIX_2008_LOCALE

A platform shouldn't be required to use the Posix 2008 locale handling
functions if they are present.  Perhaps they are buggy.  So, a separate
define for using them was introduced, USE_POSIX_2008_LOCALE.  But until
this commit there were cases that were looking at the underlying
availability of the functions, not if the Configuration called for their
use.

Add USE_LOCALE_THREADS #define

This is in preparation for supporting configurations where there threads
are available, but the locale handling code should ignore that fact.

This stems from the unusual locale handling of z/OS, where any attempt
is ignored to change locales after the first thread is created.

Mark newly moved symbols as private

The previous commit made certain symbols that previously were local to
locale.c now available everywhere.  Add a trailing underscore to their
names to mark them as private.

Move some locale.c #defines to perl.h

This is in preparation for them to be used in macros from outside
locale.c

Avoid using ' version of isnt

Nicolas Mendoza is now a Perl author

perlapi: Document hv_ksplit

allow building with -DPERL_MEM_LOG on Win32

This appears to have been broken for a while, and became more broken
with 75acd14e, which made newSV_type() inline.

This will also prevent warnings about calls to undeclared functions
on systems that don't need symbols to be exported.

pp_aelemfast: include fast return for non-lvals

Within the "inlined av_fetch() for simple cases" fast path, we already
operate within the bounding conditions of the if() statement. Once
AvARRAY(av)[key] is found to be null, a call of av_fetch(av,key,lval)
here just boils down to a single line:

    return lval ? av_store(av,key,newSV_type(SVt_NULL)) : NULL;

Checking the rest of pp_aelemfast, it's clear that within the fast
path, if (!sv) and (!lval), the function must eventually
PUSHs(&PL_sv_undef). So the fast path might as well do that directly.

Porting/release_schedule.pod: Fix verbatim line len

Added release managers through January 2023

Update cygwin README file from downstream

Update libsearch paths for cygwin

Use cygwin's own hints/cygwin.sh

Use auto-image-base on cygwin

Revert "Do per-word hop back"

This reverts commit d6ad3b72778369a84a215b498d8d60d5b03aa1af
and adds comments that it existed.  This is so that this work which
isn't really needed based on current usage in core isn't lost, and can
be used in the future.

Do per-word hop back

This should speed up backing up a large distance in a UTF-8 string.  But
we don't actually do that in core.  I did this work 5 years ago before I
realized this.  Rather than throw it away, this commit gets it into the
history, and the next commit will revert it.

Add comment to inline.h noting perlstatic.h

Create perlstatic.h

This is used for functions that we don't suggest should be inlined, but
we think the compiler will generate better code if it has full knowledge
about them.

At the moment, it only contains a single function which can be tail-call
optimized.

The Lord of the Rings quote for this file was suggested by Leon
Timmermans.

The proximal cause of this commit can be gleaned from this email:

From - Mon Nov 16 09:20:50 2020
X-Mozilla-Status: 0001
X-Mozilla-Status2: 00800000
X-Mozilla-Keys:
Subject: Re: about commit "Revert "croak_memory_wrap is an inline function.""
 (khw)
To: bulk88 <bulk88@hotmail.com>, perl5-porters@perl.org
References: <20200429011948.14287.qmail@lists-nntp.develooper.com>
From: Karl Williamson <public@khwilliamson.com>
Message-ID: <6f38382c-8fb5-ba1a-51c6-409fa5b56d2b@khwilliamson.com>
Date: Mon, 16 Nov 2020 09:20:41 -0700
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101
 Thunderbird/78.4.3
MIME-Version: 1.0
In-Reply-To: <20200429011948.14287.qmail@lists-nntp.develooper.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit

On 4/28/20 7:19 PM, bulk88 wrote:
> https://perl5.git.perl.org/perl5.git/commitdiff/d68c938a1e6c6b4bfe907decbb4929780ee06eae
>
>
> Why was this done? Perl_croak_memory_wrap is supposed to be a static
> linkage, not globally visible C function, in every perl .o file that the
> CC/linker should toss the static func if its not used. I wanted to avoid
> the PLT/GOT runtime C symbol substitution/LDPRELOAD mechanism and let
> the CC turn Perl_croak_memory_wrap into a single conditional jump
> (offset from current instruction pointer), with no return and no C stack
> entry, jump instruction instead of
>
> call get_EIP //x86 32 only
> mov eax, *(eax_aka_eip+offset into PLT)
> call eax

I reverted this because, first of all, gcc with the appropriate -W
options raised warnings that it was disregarding the request and was not
inlining this function, and 2nd of all, there was no indication in the
comments as to why this function had been inlined.

regen/embed.pl: Add static Perl_ not_inlined capability

This will be used in the next commit

regen/embed.pl: Use $var to avoid duplicate string

Change autodoc flag

This should be being used only in core, as its only use is for autodoc.
Change the flag name to be more mnemonic, freeing up its current name
for another use.

Convert '!!' to cBOOL()

I believe the '!!' is somewhat obscure; I for one didn't know about it
for years of programming C, and it was buggy in one compiler, which is why
cBOOL was created, I believe.  And it is graphically dense, and
generally harder to read than the cBOOL() construct.

This commit dates from before we moved to C99 where we can simply cast
to (bool), and cBOOL() has been rewritten to do that.  But the vast
majority of code uses cBOOL(), and this commit brings the remainder of
the core .[ch] files into uniformity.

lib/locale.t: AIX now works

Previous commits have fixed the AIX locale anomalies, so we don't have
to skip tests on that platform.

A better error message for `try {} catch {}` missing its (VAR)

As suggested in https://github.com/Perl/perl5/issues/19811, this now
outputs the message:

  $ ./perl -Mexperimental=try
  try { A() }
  catch { B() }

  catch block requires a (VAR) at - line 2, near "catch {"
  Execution of - aborted due to compilation errors.

Evaluate SET_SVANY_FOR_BODYLESS_[IN]V() param just once

Since these are defined for just the core, we can add
    STMT_START { ...  } STMT_END
without repercussions

Evaluate isGV_with_GP(on|off)() param just once

Evaluate Sv[INURU}V_set() params just once

Evaluate SvSetSV_(nosteal_)?and() params just once

Evaluate SvIV_please() param just once

Evaluate SvREFCNT_inc_simple_void() param just once

regexec.c: Refactor switch default()

It seems clearer to me to have the panic at the end of the routine
instead of as the default: of a switch().

regexec.c: Use new macros; refactor switch()

These case statements in a switch all had the same prelude for checking
if the locale is UTF-8 and handling that case separately.  A few commits
ago created macros closer to the base level.  This commit factors out
the common UTF-8 handling, and then puts the lower lever things in the
switch().  Perhaps the C optimizer would have been smart enough to do
this too, but we might as well do it ourselves, now that it is
convenient.

locale.c: Use macros from previous commits

The last few commits have introduced layers of the locale character
classification macros, so that quirks of certain platforms are
compensated for at the lowest levels.  Change locale.c to use those
compensating macros instead of the porcelain libc ones.

This causes these platforms to work in Perl more closely to the POSIX
standard.

handy.h: Add layer for char classification/case change

This layer currently expands to just the layer below it, but that will
be changed in a future commit.

handy.h: Add isCASED_LC

As a convenience to other code.

handy.h: Add wrapper layer macros for isalnum() etc

This adds a new set of macros, forming a lower layer to what is currently
there, to wrap the character classification libc functions, isdigit()
etc, and case changing ones, tolower(), toupper().

On most platforms these expand simply to the libc function call.  But on
Windows, they expand to something more complex, to bring the Windows
calls into POSIX compliance.  Similarly, but not as extensive,  IBM
products have some non-compliant behavior, and one macro is made more
comples to fix that.  Previously compliance  was achieved at a higher
level, with the result that lower level calls were broken.  This
resulted in parts of the test suite being skipped on Windows and IBM,
which remain for now.

The current level is rewritten to use the new lower layer, with the
result that it is simpler, as the complexity is now done further down.

handy.h: Collapse some macros

These 3 sets of macros can be collapsed trivially into 3 macros.

handy.h: Move some macro defns around

This is to make the difference listing in future commits smaller.

This change includes some comment changes, and some extra parens around
some subexpressions

handy.h: Collapse two sets of macros

By redefining a wrapper macro used in one set based on compile-time
info; the other set can be defined in terms of it, and the separate
entries removed.

No locales => don't use isspace(), toLower() etc.

This commit changes what happens on platforms without locale handling to
use our precomputed definitions of what the various character class
definitions and case changing operations are.  Previously, it just
called the libc locale-dependent functions and made sure the result was
ASCII.  I think this is a holdover from before we had the precomputed
definitions

handy.h: #define one macro in terms of another

These two macros are equivalent as folding and lowercasing are the same
for this input domain.  Better to say so rather than to replicate the
definitions.

handy.h: Rmv unnecessary parameter to internal macros

The cast is required to be U8 by the POSIX standard.  There is no need
to have this added generality.

handy.h: Refactor some internal macros

This changes the parameters etc, in preparation for further changes

handy.h: Rmv internal macro

LC_CAST_ was my attempt at generality, but I didn't realize that the
POSIX standard specifies the type that this was meant to generalize, so
there isn't any need for it.

Change handy.h macro names to be C standard conformant

C reserves symbols beginning with underscores for its own use.  This
commit moves the underscore so it is trailing, which is legal.  The
symbols changed here are many of the ones in handy.h that have
significant uses outside it.

handy.h: Don't use char class if no LC_CTYPE

It is possible to compile perl to not pay attention to LC_CTYPE.  This
was testing for no locales at all; whereas the stricter requirement
should be used.

handy.h: White-space, comment only

handy.h: Add some branch predictions

handy.h: Refactor some #ifdef's for commonality

This changes these compilation conditionals so that things in common
between Windows and other platforms are only defined once.

It changes the isIDFIRST_LC and isWORDCHAR_LC definitions for
non-Windows to match that platform superficially, though expanding to
what it previously did to.

handy.h: Remove the only 2 calls to internal macro

Replace isIDFIRST_LC and isWORD_CHAR_LC isIDFIRST_LC  with slightly
faster implementations.

Change handy.h macro names to be C standard conformant

C reserves symbols beginning with underscores for its own use.  This
commit moves the underscore so it is trailing, which is legal.  The
symbols changed here are most of the ones in handy.h that have few uses
outside it.

Minor update to perl -h to display newly added -g option.

regcomp.c: Add ASSERT

Mohammad S Anwar is now a Perl author

Note gotchas, workarounds in STMT_START..STMT_END

Discourage use of GCC brace groups

These days, static inline functions are the better bet, as you don't
have to maintain two code paths.

Make fc(), qr//i thread-safe on participating platforms

A long standing bug in Perl that has gone undetected is that the array
is global that is created when changing locales and tells fc() and qr//i
matching what the folds are in the new locale.

What this means is that any program only has one set of fold definitions
that apply to all threads within it, even if we claim that the locales
are thread-safe on the given platform.  One possibility for this going
undetected so long is that no one is using locales on multi-threaded
systems much.  Another possibility is that modern UTF-8 locales have the
same set of folds as any other one.

It is a simple matter to make the fold array per-thread instead of
per-process, and that solves the problem transparently to other code.

I discovered this stress-testing locale handling under threads.  That
test will be added in a future commit.

In order to keep from having a dTHX inside foldEQ_locale, it has to have
a pTHX_ parameter.  This means that the other functions that function
pointer variables get assigned to point to have to have an identical
signature, which means adding pTHX_ to functions that don't require it.
The bodies of all these are known to the compiler, since they are all
in inline.h or in the same .c file as where they are called.  Hence the
compiler can optimize out the unused parameter.

Two calls of STR_WITH_LEN also have to be changed because of C
preprocessor limitations; perhaps there is another way to do it that I'm
unfamiliar with.

mg.c: Fix to compile under g++

Commit 00a5df846e035280750985222a693ac58022ee36 fixed some c undefined
behavior, but it will not compile with g++, because a goto crosses
initialization.

https://stackoverflow.com/questions/14274225/statement-goto-can-not-cross-variable-definition

and its links sort of explains why

This commit works around this limitation

Restore wrongly deleted pod for sv_pvutf8

Remove pod for non-existent functions

7008caa915ad99e650acf2aea40612b5e48b7ba2 removed several deprecated
functions, but did not remove all the pods thereof.

toke.c: Remove Undefined C behavior

Spotted by clang 14.

mg.c: Remove Undedfined C behavior

Spotted by clang-14.

op.c: Improve comments

Remove support for Ultrix

Ultrix has been removed.  Ultrix was the native Unix-like operating
system for various Digital Equipment Corporation machines.  Its final
release was in 1995.

perlapi: Document hv_name_set

SvGETMAGIC: evaluate its argument just once

This required making it into an inline function.  I tried using
STMT_START{ ... } STMT_END, which should work since it has a void
return, but there were places where it was used in a comma operator, and
those did not compile.

Capitalize Perl

Capitalize Perl when referring to the language (rather than the interpreter).

Also pluralize "built-ins" and format "CORE" package.

POSIX.xs: White-space only

Properly indent some nested preprocessor directives

POSIX.xs: Use macro to reduce complexity

This #defines a macro and uses it to populate a structure, so that
strings don't have to be typed twice.

regexec.c: Handle Turkish locale if large ANYOF bitmap

Perl defaults to the bitmap for ANYOF nodes being for the lowest 256
characters, but it is possible to compile the bitmap to be up to size
2**16.  Doing so, prior to this commit, broke Turkish locale handling.

regexec.c: Avoid using a more general fcn

The regnodes in the ANYOFH series by definition don't have a bitmap used
in the other ANYOF-type nodes.  Instead they have an inversion list.  We
can avoid the overhead of calling the general function that looks first
in the bitmap.

locale.c: Replace most #ifdef DEBUGGING lines

THe previous commit enhanced the DEBUG macros so that they contain the
logic that previously had to be done with conditional compilation
statements.  Removing them makes the code easier to read.

DEBUG_L now also looks at environment variable

Because locale initialization happens before command line processing,
one can't pass a -DL argument to enable debugging of locale
initialization.  Instead, an environment variable is read then, and is
used to enable debugging or not.  In the past, code specifically had to
test for this being set.  This commit changes that so that debugging can
automatically be enabled without having to write special code.  Future
commits will strip out those special checks.

XSLoader: convert from Test::More to internal test helpers

The XSLoader tests need to play with the XS bits of various modules,
which can interfere with testing modules like Test::More. For example,
Test::More now loads Time::HiRes. This results in redefinition warnings,
and could lead to more serious problems.

Avoid this by creating some test helpers inside the XSLoader test, and
using those rather than Test::More.

The helpers implemented include roughly the same features used by the
test itself, so that the impact on the rest of the test code is minimal.

Fix building with clang-cl

As mentioned in https://lists.llvm.org/pipermail/llvm-dev/2015-July/088122.html
and https://github.com/llvm/llvm-project/issues/24625 building with clang-cl currently fails due to the declaration of __PL_nan_u.
By declaring it like this, cl and clang-cl are happy to parse it.

perldelta for ea43bc00e1113f

minitest_prep conflict on building $(MINIPERL_EXE)

minitest depends on $(MINIPERL_EXE) and minitest_prep, but
minitest_prep calls back into make to build lib/Config.pm which
indirectly depends on $(MINIPERL_EXE).

This can result in a race between the parallel work of the parent
make and the work of the child make, as they both try to build
$(MINIPERL_EXE) and its dependencies, causing some of the errors
described in the ticket.

Note that trying to `make -j6 minitest all` could lead to
similar conflicts, but I think that's an unlikely and not worth
supporting anyway.

Fixes #19829 (I think)

perldelta for bbaab2c3cd9

use Off_t for file offsets in sdbm.c

On Win32 long is only 32-bits (even for x86_64), which meant
file sizes were limited to 2GB.

This successfully runs the example code, and can successfully read
all the keys back.

I didn't add a test, since creating a 2GB (or 8GB for the issue test)
would be unfriendly.

handy.h: WIDEST_UTYPE is just PERL_UINTMAX_T

No need to re-derive it

perl5dp.pl: Bump version

Data::Dumper: bump version