new perldelta

Add file existence test for Porting/makerel

This came up in the release of 5.39.7. Previously autodie.pm had been
upgraded, which removed the file touch_me from the Perl distribution.
The name touch_me was still mentioned in Porting/makerel , but this
only became apparent when makerel was used to actually build a tarball.

This test crudely parses the list of filenames from Porting/makerel
and checks that all the files referenced there exist.

Clean up perldelta.pod

Update Module::CoreList for 5.39.8

Bump the Perl version in various places for 5.39.8

Tick off release 5.39.7

Add 5.39.7 epigraph

Note Windows installation issues

autodie v2.37 removed the touch_me file

Add new release to perlhist

Update Perldelta for 5.39.7

Update Module::CoreList for 5.39.7

Bump the perl version in various places for 5.39.7

`README`: Bump copyright year

It's 2024 now, so update ©️ to reflect that.

Update `perl.c` too because `copyright.t`
fails without it.

nostdio.h: Properly indent #nested lines

Change some USE_ITHREADS to USE_THREADS

These are where the underlying implementation should not matter.

Handle Linux extra locale categories

Linux has six locale categories that aren't in the POSIX standard.  This
commit enables their use.  For example there is meta data about a
locale, and information about how telephone numbers are formatted for
it.

On non-Linux boxes, you can now request them as well, but you will get
stub values, as if the locale were C.

Add locale-related #macro for simplification

This conditionally defines a macro in perl_langinfo.h that leads
currently to just a single simplification in the code, dealing with
platforms that don't have LC_MESSAGES, such as Windows.  But the next
commit will use it more extensively

locale.c: Prepare for SV not always being PV

Prior to two commits hence, these SVs always contained PVs.  But it will
change so sometimes they can be numbers.  The SvPVX shortcuts need to be
changed to SvPV_nolen instead.

nostdio.h: Fix comment

This #endif didn't end the conditional the comment said it did

Langinfo: Improve pod about CRNCYSTR

This adds detail about the Standard-mandated character that is prefixed
to the returned currency string.

Add some locale tests to APItest

locale.c: Remove unnecessary Perl_form() call

There is nothing to format here; just a constant string.

Langinfo.t; Add comment

locale.c: Don't compile unreachable code

The switch statement affected by this commit has numerous case:
statements within it.  Prior to this commit, if any of them was
required, all would be compiled.  But in many Configurations only a
portion of them are required.  Skip the others.

This takes advantage of the fact that an undefined preprocessor macro
evaluates to 0 (false) when used in an #if conditional.  In this
case, #foo_AVAIL is often undefined, so evaluates to false.
(Although locale_table.h could be changed to always define it to
'false', should it become necessary.)

lib/locale.t: Add more debug output

This file tries out every locale it can find on the system.  And, in
debug mode, outputs information about each locale, in addition to the
testing.

This commit adds at least one bit of information from every possible
information type.  So, for example, it displays the name of the first
month of the year (but not the rest of the months), the name of the
first day of the week (but not the rest), etc.

This enables someone to get a good idea what a locale is like.

lib/locale.t: Use a list for display item source

This file displays some items related to the current locale;
haphazardly.  This commit creates a list that is then used instead of
individual statements.  It then becomes easy to add items to display

lib/locale.t: Reorder a list

This is to make the next commits have fewer differences

win32/GNUmakefile: enable warnings for gcc

Warnings are already enabled for MSVC, so enable them for GCC too.

-Wformat is disabled since the default "__printf__" format checker
doesn't understand the C99-isms like "%zd", resulting in many spurious
warnings.  The __gnu_printf__ checker does understand them, but it
doesn't understand the Windows specific "%I64d" and similar formats.

loc_tools: Generally return at least C locale

If a category exists on the system, but we are supposed to keep it in
the C locale, it still is testable as C or POSIX.

Prior to this commit, it wasn't considered testable, and as a result
tests in our suite were wrongly skipped.

Perl_amagic_call(): don't assume non-NULL PL_op

This line in Perl_amagic_call():

    U8 gimme = (force_scalar || PL_op->op_type == OP_MULTICONCAT)

relies on either PL_op always being non-null, or for the times that
PL_op is null, that force_scalar always ends up being true.

As it happens, qr// with constant overloading calls Perl_amagic_call()
with a null PL_op, but also with method=string_amg, which happens to set
force_scalar.

Add a check for PL_op being non-null, partly to future-proof the code,
but mainly to shut up Coverity, which rightly pointed out that some new
code added by me with v5.39.6-107-g547324acdb *does* check for PL_op
being non-null earlier in the function, and if there's one thing
Coverity can't abide, it's inconsistency.

locale.c: Use strtod over snprintf for radix determination

I have been a little leery of parsing a formatted number to look for the
radix character, which is what has been done with snprintf on MingW.  It
just seems brittle; it's possible (if unlikely) for the output to be
right-to-left, for example.

And then I saw cases where snprintf always used a dot on MingW; and the
Windows documentation makes no mention of the possibility of another
radix character.  Experimentation by Tony Cook showed that it could
output a comma instead; and the dots I was getting were probably cockpit
errors.

But almost all locales in the world use either a dot or a comma, and I
think it better to start with a string "1,5" or "1.5" and see which
strtod() parses correctly.  We then don't have to ourselves parse, but
see how strtod parses known strings by looking at what it calculates as
the value.  In a dot locale, for example, "1,5" will not yield anything
like 1.5.

Should we encounter a locale not using either a dot nor a comma, the
code drops down to call localeconv() to return the actual character
string.  On platforms where using localeconv() isn't known to have a
race (MSVC since VS2015, for example), the code previously always used
localeconv(), because of my leeriness about parsing an unknown string.

But now strtod is used, being less buggy and faster than localeconv; and
less brittle thant snprintf.

This change also avoids the malloc that the snprintf() version required.

locale.c: Rmv extraneous statement

Since 60e050beb2e45ebd7ead7f1bf93f845b23c474b5, this isn't necessary.

Spotted by Tony Cook

Return C values if localeconv() not available

localeconv() is a C89 function.  But the existing code handled the case
if it isn't available anyway by returning an empty hash if
POSIX::localeconv() is called.  Prior commits have made it actually
easier to instead return the hash populated with the values that the C
locale has, which is more desirable than the current state.  And that is
what this commit does.

There are reasons that localeconv() might not be available.  We recently
had a case where Configure didn't catch its existence.  And it still is
broken on MingW, and until recently on older Windows releases that we
now no longer support.  Workarounds were developed for those cases, but
there may be other platforms where it ends up broken without a
workaround, and this code handles them better and more simply than
before this commit.

Add API function sv_langinfo()

This performs the same task as Perl_langinfo8(), but returns an SV.
This is typically more convenient for the caller.

It turns out that nl_langinfo() has some weird returns that aren't yet
exposed by perl, but future commits will.  An SV makes these easier to
cope with.

perlapi: Emphasize that setpv() doesn't change the UTF-8 flag

I keep getting tripped up by this.

Configure: Handle case of no localeconv() found

If not found, there certainly won't be a subset of its returns

Langinfo.pm: Change list init indents; sort order

10 should come after 9

locale.c: White space only

Unmatched {} in C file generated by Configure issue#21730 m-hilgendorf

locale.c: Skip an intermediate copy

This commit takes advantage of the previous ones to pass the desired SV
directly to the langinfo() function, rather than getting a string and
then putting it into the SV

locale.c: Avoid extra copying in langinfo

The functions that are the interface to libc nl_langinfo() have two
masters.  One is for internal use in the file to get a result that is to
be used and discarded immediately.  The other is to external callers who
may want to keep the result around for a while.

Historically this was done by having the functions both return a value,
and place it into a malloc'd buffer.

Sometimes the result is trivial, and needs to be copied to the buffer.
Other times, other functions are called that return a buffer themselves,
and for which the return value must be extracted from.  In other words,
sometimes it is more convenient to have a simple value; and sometimes it
is more convenient to have a buffer.

Previous commits have paved the way for this one, which knows which
vehicle the desired result should be returned in.

In S_emulate_langinfo(), the most convenient vehicle is used for the
calculation, and just before returning, if the caller wants that one, it
is done; but if the caller wants the other one, the result must be
coerced into that vehicle.

locale.c: Change to use SVs for buffers for langinfo()

Prior to this commit, the code implementing the langinfo interface used
malloc'd buffers to store results in.

However, I discovered that perl has never implemented one langinfo item
properly, because its documentation is misleading.  And that item is not
a standard C string, but instead contains embedded NUL characters.

I started to implement an extension to the existing buffer interface to
handle that.  But then I realized it would need the equivalent of SvCUR
and SvLEN.

And then, I realized that the glibc extensions to nl_langinfo() return
values that are better interpreted as UVs than PVs.

To cope with all that, my implementation would be starting to smell like
perl's already-existing SV implementation.

So this commit changes to use SVs behind the scenes.

This presents some advantages here and in the next commit, due to the
maturity of the perl SV code.  The same SV can be reused for scratch
with potential for PV stealing, COW, fewer mallocs, etc.  The explicit
freeing of that SV can be delayed until global destruction.

locale.c: Add langinfo_i()

This is just a small extension of langinfo_c(), allowing another place
in the code to use this interface.

locale.c: Remove params from langinfo_c()

The second parameter removed here is always NULL

The first parameter removed here is now always '&scratch_buffer', as
previous commits have changed the name to.

This commit now removes the ability to pass anything else to the
langinfo_c() macro.  This would normally be brittle, but a couple of
commits down the line will resolve that.

locale.c: Use same function interface throughout file

S_langinfo_sv_i() is passed a buffer to use, and also returns a value.
This commit changes all calls to it that don't stem from an external
caller to it to only look at the returned value, and to ignore the
buffer (which should have an identical value).  This is in preparation
for future commits which will avoid having a duplicated value.

locale.c: Rename variable

This makes all calls to this function use variables with the same name
uniformly througout the file.  This is in preparation for the next
commits.

locale.c: Rename static function

This is in preparation for a future commit which will change its
parameter types

locale.c: Rename macro

I got tired of typing the prefix 'my_' and there is no good reason since
there is no symbol that differs only in that.

locale.c: Use an SV instead of a PV in one place

This was creating a temporary PV; the commit changes to use a mortal SV.
This is in preparation for a future commit where the SV can be passed in
by a caller, and there will be fewer wasted mallocs and frees.

locale.c: Change name and API of static function

This now is passed a pointer to the value that may need to be
overridden, and returns a bool (ignored for the time being) as to
whether it changed it or not.

This is in preparation for a future commit.

locale.c: Add/clarify some comments

locale.c: Move a small block of code

This moves this conditional and function call to when the locale is
still toggled.  Prior to this change, it is possible that we would have
to re-toggle within the function call.

The extra indentation will make sense in a future commit

locale.c: Indent a couple statements

This will allow them to vertically align with code added in a future
commit

locale.c: Refactor use of Perl_form

This commit creates #define's for the format to use in that function
call.  This will make a future commit easier.

locale.c: Move some langinfo emulation code

Some paths through this section of code don't require the result to be
saved to a buffer.  Move the code so to avoid that unnecessary work.

The result is indented an extra amount to prepare for a future commit.

S_my_langinfo_i: Always return both a buffer and a value

This function returns a value, and also copies that value into a buffer.
Certain rare Configurations failed to fill in the buffer in some
circumstances.

This commit fixes bugs on those Configurations, and is the first step in
the next several commits in not doing unnecessary copies, which will
obsolete this commit.

t/re/charset: spell the locale when setlocale() fails

Closes https://github.com/Perl/perl5/issues/21805

dilyanpalauzov is now a Perl author

[doc] Minor spelling issues in C file comments

Correct duplicate words and convert links
to HTTPS where supported

Update Exporter version number to 0.78

This was released to CPAN with changes from the blead Makefile.PL
( via 04528e741d17821b6c5e65bfb24935e912d182d3 )
under a new version number but the version number bump was not
done in bleadperl.

Found via

  ./perl Porting/core-cpan-diff -d Exporter

after editing the version number in Porting/Maintainers.pl to 5.78.

Applied via

  ./perl Porting/core-cpan-diff -d Exporter -r | patch -p0

Correct Locale::Maketext version number in Maintainers.pl to 1.33

... also update the Changes file to the 1.33 version. No other differences
found via

  ./perl Porting/core-cpan-diff -d Locale::Maketext

Diff applied via

    ./perl Porting/core-cpan-diff -d Locale::Maketext -r | patch -p0

Update IO version number in Porting/Maintainers.pl

The code is 1.55 but the version number in Maintainers.pl was at 1.51

Checking that the stuff is identical was done with

./perl Porting/core-cpan-diff -d IO

cpan/Math-BigInt-FastCalc - Update to version 0.5018

0.5018 2024-01-06

 * Sync test files with Math-BigInt.

cpan/Math-BigInt - Update to version 2.003002

2.003002 2024-01-05

 * Improved interaction between Math::BigInt and the backend libraries.

 * Much faster versions of _ilog2() and _clog2() implemented in the
   Math::BigInt::Calc backend library. This should speed up bilog2() and
   bclog2() in Math::BigInt when "Calc" is used as the backend liberary.

cpan/Pod-Checker - Update to version 1.76

 Version 1.76
 + CPAN#149267: "OK" message should go to STDOUT, not STDERR
 + CPAN#150660: podchecker -quiet does not print "OK" message

 21-May-2022           Marek Rouchal                        <marekr@cpan.org>

locale.c: Change S_emulate_langinfo formal arg type

The type of this parameter changed recently from an enum to an int,
and embed.fnc was updated, but not the actual function definition.

No compilers except the OpenBSD one complained so far.

Fixes GH #21811

Remove full stops from POD headings

Headings are not sentences and should not have a trailing full stop
unless the last word is an abbreviation or as part of an ellipsis.

locale.c Use macro to avoid conditionals

We know at compile time what these conditionals always evaluate to.  Use
a macro to replace the confitional with nothing when its always going to
be true.  (The section of code doesn't even get compiled when its going
to always be false.)

Fix blead not compiling with -DNO_LOCALE

This recently introduced failure was due to yet another problem with my
doing a 'rebase -i'.  embed.fnc nowadays gets re-sorted as part of the
build process, and I need to manually verify each time that the new
ordering didn't screw anything up.  Anyway, this function declaration
got placed in the wrong bucket of #ifdefs in embed.fnc.  This commit
fixes that.

perldelta for 11c545feea

XSUB.h: use Stack_off_t for AX and items

I hadn't expected code to be taking pointers or references to AX,
which turned out to be wrong, so make them Stack_off_t.

This allows XS::Framework or similar code to build with a default
build of perl, but it will still fail to build if perl is built
with -DPERL_STACK_OFFSET_SSIZET, which can only be fixed by updating
XS::Framework to use Stack_off_t itself.

Fixes #21782

perlapi: Rmv obsolete advice regarding Perl_langinfo

The header files have long been adjusted so that the programmer doesn't
have to concern themselves with this bookkeeping.

locale.c: Use macros to avoid some #ifdef's

This #defines these macros once depending on the Configuration to be
either no-ops, or the appropriate expansion.  Then in the code just the
macros instead of #ifdef's.

Renée and Max swapped their release dates/versions

[MERGE] handle/optimise some ops in void context

This branch:

Fixes a couple of ops which weren't getting their context set correctly.
This doesn't make any change to the correct operation of those ops (they
don't change their behaviour based on context), but could allow for
future optimisations.

Skips a couple of portmanteau OP optimisations ({padv,elemfast}_store) in
non-void context. This allows those two be ops to be slightly faster in void
context (which is overwhelmingly how they are likely to be used(*)), and
falls back to the old separate padsv/sassign op pair otherwise.

Updates a few other ops to handle void context slightly more efficiently.

(*) Tony Cook profiled the test suite: 83.7% of calls to
pp_padsv_store()s were in void context and 99.9% of
aelemfastlex_store()s.

pp_push, pp_unshift: don't push TARG in void cxt

pp_undef(): optimise for void return

This function is typically called in void context; don't push a result
in void context which will will only be immediately popped again by the
following nextstate or unstack op. On PERL_RC_STACK builds, this
also avoids ++ing and --ing the return value's ref count.

In unknown context it just assumes non-void, rather than incurring the
cost of determining the caller's context.

pp_print() optimise for void return

This function is often called in void context; don't push a result
in void context which will will only be immediately popped again by the
following nextstate or unstack op. On PERL_RC_STACK builds, this
also avoids ++ing and --ing the return value's ref count.

In unknown context it just assumes non-void, rather than incurring the
cost of determining the caller's context.

pp_sassign: make return more efficient.

Currently scalar assign effectively always pops the original two
arguments, then pushes the result.

This commit makes it so that

1) in void context (the most usual), it just pops 2 and skips pushing 1.

2) In scalar context, it still logically pops 2 and pushes 1, but since
the return value is also the original left arg, just shuffle that
argument around on the stack rather than messing around with its
reference count in the meantime. The right arg is still freed.

To make it so that *PL_stack_sp remains equal to left, a couple of
non-hot codepaths which break this rule now update the stack to keep
things consistent.

OP_AELEMFASTLEX_STORE: only in void context

For the optimisation which converts $lex[N] = expr into an
OP_AELEMFASTLEX_STORE op, only optimise if the scalar assign is in VOID
context.

(See the previous commit for a very similar change to OP_PADSV_STORE.)

This allows us to stop pp_aelemfastlex_store() from uselessly pushing the
result onto the stack, only to be immediately popped again by the
following nextstate or unstack op. This becomes more important on
PERL_RC_STACK builds, as each push or pop involves manipulating the SV's
reference count.

I'm working on the assumption that scalar/list/unknown cxt lexical
array element assigns are rare enough that not optimising them is less
of a loss than optimising the void case. So:

    $lex[0] = ....;             # void:    now even faster
    $other = $lex[0] = ...;     # scalar:  now slow again
    foo($lex[0] = ..., ....);   # list:    now slow again

    sub {
        ....
        $lex[0] = ...;          # unknown: now slow again
    }

OP_PADSV_STORE: only in void context

For the optimisation which converts $lex  = expr into an OP_PADSV_STORE
op, only optimise if the scalar assign is in VOID context.

This allows us to stop pp_padsv_store() from uselessly pushing the
result onto the stack, only to be immediately popped again by the
following nextstate or unstack op. This becomes more important on
PERL_RC_STACK builds, as each push or pop involves manipulating the SV's
reference count.

I'm working on the assumption that scalar/list/unknown cxt lexical
assigns are rare enough that not optimising them is less of a loss than
optimising the void case. So:

    $lex = ....;             # void:    now even faster
    $other = $lex = ...;     # scalar:  now slow again
    foo($lex = ..., ....);   # list:    now slow again

    sub {
        ....
        $lex = ...;          # unknown: now slow again
    }

Give OPpTARGET_MY ops real context

Perl has an optimisation whereby an op which returns the RHS of a scalar
assignment to a lexical, and which would normally store its result in
a PADTMP, instead skips the following PADSV and SASSIGN ops and assigns
to the lexical directly, instead of to the PADTMP. For example in

    $lex = $a + $b;

the ops (in execution-order) would be changed from

    add[t5] sK/2
    gvsv[*lex] s
    sassign vKS/2
    nextstate(main 2 -e:1) v:{

to

    add[$lex:1,2] sK/TARGMY,2
    nextstate(main 2 -e:1) v:{

However, note that although that the add op is now essentially called in
void context, it is still marked as being in scalar context. This commit
changes it to be be marked as void, i.e.

    add[$lex:1,2] vK/TARGMY,2

The main reason for this is to allow for future optimisations in
functions like pp_add(), which will be able to skip pushing the result
onto the stack in in void context. It just so happens that scalar
assignments to lexical vars are typically in void context.

However, since this is a visible change from the perspective of modules
which examine ops or optrees, I'll leave doing any optimisations until
later, in case this commit needs to be reverted.

The main things this commit had to fix up following the change were:
- still call overload methods in scalar context, even though the op is
  now marked as void;
- not issuing "useless use of add in void context" style warnings on
  such ops;
- making pp_push and pp_unshift still set TARG in void context

No matter whether the op's context is marked as scalar or as void, some
parts of perl will misunderstand, and will need to be special-cased
(since the op is really both, depending on your perspective). So this
commit changes the burden of the special-casing code to be in the
non-hot code paths, like during complication or when calling out to an
overload method.

set context in 'state' expressions

The ops associated with a state variable declaration and initial
assignment weren't getting their context (GIMME) assigned.

Background:

    state $x = ...;

gets compiled to something similar to

    if (first_time)
        $x = ...;
    else
        $x;

Except that the 'if' is performed by an OP_ONCE logop, which checks and
updates a flag in the pad, and branches to op_next or op_other as
appropriate.

During compilation, the context of the state expression wasn't being
passed on to the children of the OP_ONCE. So the assignment (optimised
into a padsv_store) and the padsv were left as UNKNOWN rather than VOID
or SCALAR as appropriate, as in these two examples:

    state $x = 1;         # should be void
    $y = (state $x = 1);  # should be scalar

This commit fixes that. Note that at the moment it makes no practical
difference, since the padsv/padsv_store ops  don't currently change
their behaviour based on context, but that might change.

add Concise tests for state var assignment

Add tests for

    state $x = 1;
    my $y = state $x = 1;

to check what context is allocated to the various ops. At the moment it
is actually wrong in places, and this commit captures that wrongness.
The next commit will fix this, and those diffs to the tests added in this
commit will help make it clear what has changed.

locale.c: Add clarifying comment

locale.c: Can now call my_langinfo_i() in all circumstances

Prior to this commit, the caller had to know if the category in question
was being ignored in this Configuration.  Now, that is transparent.

locale.c: Extract code into a separate function

This new function does not have to be compiled in all Configurations,
and placing it separately removes some #ifdefs, and allows its absence
to be more transparent from its callers.

locale.c: langinfo: Better handle unknown input item

On systems with <langinfo.h>, the 'item' parameter here must be a member
of an enum.  If it isn't something we recognize, it's a real problem.

On other systems any int can be passed, and it could just be that the
caller got a wrong value.  For these, we don't know if it is a perl
error or a user error, so just set EINVAL and return failure

locale.c: No strftime() implies empty formats

When returning an nl_langinfo() format when we are emulating
nl_langinfo() when there is no strftime() on the system, return an
empty format.  A non-empty return is useless.

locale.c: Consolidate handling of remaining TIME items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Remove redundant handling of the AM_PM format

This format is identical whether or not LC_TIME is usable on this
platform or not.  Previously, it was actually handled in two functions,
emulate_langinfo() when LC_TIME is usable, and Perl_langinfo8() when
not.  Previous commits have enabled the format handling in
emulate_langinfo() to be returned instead of having separate cases,
depending on LC_TIME's availability.  That means the handling of this
format in Perl_langinfo8() is redundant and this commit removes it.

locale.c: Consolidate handling of ERA format langinfo items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Consolidate handling of ALT_DIGITS langinfo item

Without nl_langinfo(), some Configurations handled this nl_langinfo()
item associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Move handling of ERA langinfo item

This commit moves the handling of the ERA langinfo item to
emulate_langinfo() away from Perl_langinfo8().

locale.c: Consolidate handling of AM/PM langinfo items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Consolidate handling of MON langinfo items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Consolidate handling of ABMON langinfo items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Consolidate handling of DAY langinfo items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().

locale.c: Consolidate handling of ABDAY langinfo items

Without nl_langinfo(), some Configurations handled these nl_langinfo()
items associated with the LC_TIME category in Perl_langinfo8(), and some
Configurations in emulate_langinfo().  This commit consolidates all the
handling to emulate_langinfo().