prefer https URLs.

bump $Time::HiRes::VERSION

Time::HiRes: implement clock_gettime() and clock_getres() for win32

To make the implementation easier, the guts of gettimeofday() were
moved to a separate function named GetSystemTimePreciseAsFileTime().

[perl #134398]

(perl #133981) fix my stupid mistake

Improve grammar in pod

for  SvPV..._or_null, sv_utf8_downgraded_flags

Remove deprecated flag from sv_nosharing.

I  recently introduced this by mistake.

Merge branch 'ppport fixes' into blead

This branch contains a large number of changes related to the next
release of Devel::PPPort, which will regenerate its API list for the
first time in many years.

Documentation for 20-ish items is furnished, and the fact that some
dozens more are documented outside perlapi is now noted.

There is a new flag, h, to the =apidoc lines that indicates to hide the
documentation from perlapi, but tie it to the current place, like
perlapio.  It would be not too difficult to have such things
automagically pulled into perlapi from these, should that be desirable.

It turns out there were several undocumented conventions between D:P and
the core code, like having a parameter name of 'cast' or 'type' (in a
macro prototype apidoc line) that allowed D:P to generate proper code to
test the macro in the face of this parameter not being a legal C type.
I have documented these conventions, and added a couple more that the
next release of D:P will understand.  One of those is a parameter of
'block' as used in the recently added WITH_LC_NUMERIC_foo macros.  The
usage example in perlapi now displays correctly.

And for the few macros that I didn't add a way to test in D:P, there is
a new flag, 'u' to indicate that they are unorthodox or unconventional
in some way; that is they won't compile as-is.  This is applied, for
example, to the STR_WITH_LEN() macro which returns a comma separated
pair.

One thing that I hadn't realized before is that moving a function to
mathoms when there is no macro allowing it to be bypassed is effectively
deprecating the use of that function.  mathoms can be cleaned out at any
time, and installations may Configure to not even compile it.  I changed
to require the deprecated flag if something is in mathoms with no macro.

In an earlier commit, I had added the M flag as opposed to the m flag,
which previously had done double duty: 1) the function was implemented
only via a macro; 2) the function is a real function, but there is an
(extra) macro that you can use to get the same functionality as the
function.  I did this to help downstream processing.  And it turns out
that D:P needs that too, and needs it for functions in mathoms.  There
really is no need for an m flag with the mathoms (b) flag.  So the
existing ones that have an extra macro to bypass them are changed to use
the M flag instead of m.  This was done in an earlier commit for other
functions in this file.

embed.fnc: Clarify and fix 'b' flag description

embed.fnc: Fix typo in comment

embed.fnc: Correct grammar in comment

embed.fnc: Trivial comment only

Remove M flag from several functions

These do have an extra macro, but it's not relevant to the situation

embed.fnc: Remove experimental status from some internal fcns

These have been around long enough that they aren't going away.

embed.fnc: Restrict the 'ref' function's accessibility

This could otherwise cause name collisions.  It is only used in two .c
files in the core

Note that config.h contains usable API macros

Things like UVSIZE...

Fix documentation of WITH_LC_NUMERIC_foo

Now that Devel::PPPort can handle a macro whose argument is a {...}
block, we can appropriately document these.

Document STMT_START .. STMT_END

Now that we have the 'u' flag we can document these macros and not have
to break downstream processing.

Mark BHK macros as unorthodox

This is because they take a preprocessor token as an argument

Note that STR_WITH_LEN() is unorthodox

Now that we have the 'u' flag for macros, this one returns
a pair of values, so should be marked as such.

Change pod for macros that require "literal strings"

Now that Devel::PPPort  has the ability to handle these, we can loosen
the syntax for clarity.

embed.fnc: Clarify comments, and note 'u' flag exceptions

The next release of Devel::PPPort will know how to handle all these
unorthodox functions, so no need to declare them as such, and in fact
they shouldn't be declared so.

embed.fnc: Add 'u' flag for unorthodox parameter macros

This tells downstream processors, such as Devel::PPPort that compiling
macros like these will be won't work, as they have some issue.  For
example, aTHX_ expands to have a trailing comma.

Refer to CopLABEL_len[_flags] in pod for cop_fetch_label

Document CopLABEL[_len[_flags]]

Note that various items in perlguts are documented

perlguts: Document save_item

sv.c: Note that some SV flags are documented

Remove redundant documentation for PL_parser

Note that various XS macros are documented

Note that AvFILLp is not for public use

Note that PERL_VERSION and kin are documented

Note that mro[gs]et_private_data are documented

Note that filter_add, filter_read are documented

Note that PL_errgv is documented

Note that G_METHOD[_NAMED] are documented

Note that PERL_MAGIC_foo are documented

Document PERL_INT_MAX, and similar

Document my_exit()

numeric.c: Note that flag bit names are documented

Note that [cm]alloc, realloc are documented

As they are really Unix calls

Document HvFILL

Document WIDEST_UTYPE

gv.c: Note that some GV_foo constants are documented

dump.c: Note that constants to pass are documented

Config: mention it is generated by configpm

Document UTF8_MAXBYTES

Document rsignal()

Document my_setenv()

Document instr()

Note that the PerlIO functions and macros are documented

in perlapio

Note that the warnings categories are documented

This generates a hidden apidoc entry for the warnings categories, for
downstream processing, like Devel::PPPort.

warnings.h: Add pod about finding the XS warning category

The XS category names are easily derivable from the chart of perl-space
categories.

regen/embed.pl: Enforce 'b' without 'M' requires 'D'

embed.fnc: Functions in mathoms are deprecated

(unless there is a macro to bypass them)

These functions can be removed at any time, and any installation may
disallow them.  So they are effectively deprecated.  Make this explicit.

regen/embed.pl: Enforce mutual exclusivity of 'b', 'm'

embed.fnc: pack_cat, pad_compname_type have macro

contrary to what was specified here

embed.fnc: Use M flag generally with b, not m.

Commit 54c193aee0eb1f20806952d8fcd2ddadd5e57600 introduced the M flag,
to indicate an extra macro in addition to a regular function, beyond the
m flag which indicates a macro that replaces the function.  This
distinction matters to downstream processes.

But some of the functions with the b flag (hence in mathoms) still had
an m flag, but the macro is actually extra.  This commit changes those
from m to M.

embed.fnc: There is no macro for sv_nolocking()

Contrary to what this said.

perlapi: Formally give prototypes for isFOO variants

These macros are documented unconventionally, with the main one of a
type documented, and the corresponding variants listed with a pointer to
how the variant differs from the main entry.  This is because they all
have similar corresponding variants, and doing it this way makes the
documentation more compact.  But downstream software is looking for
an apidoc entry to know about the existence of these.  This commit adds
that, using the new 'h', or hidden flag to suppress them from being
displayed.

autodoc.pl: Add h flag for hidden documentation

This is to be used when the documentation exists, but isn't the typical
sort in perlapi or perlintern.

perlapi: Document memEQs memNEs

perlapi: Document C_ARRAY_LENGTH, END

perlapi: Document __ASSERT_

perlapi: Document cBOOL

perlapi: Document XST_mUV

This one was missing from the set

perlapi: Document GROK_NUMERIC_RADIX, PERL_ABS

perlapi: Document my_strotod, Strtod

perlapi: Document IN_LOCALE, and related

perlapi: Document LIKELY, UNLIKELY

perlapi: Document SvUVXx()

I'm doing so because Devel::PPPort provides this function.

perlapi: Document UNICODE_REPLACEMENT

perlapi: Document NATIVE_to_foo, converse functions

perlapi: Generalize SEE ALSO lists

This makes sure perlintern and perlapi are consistent

regen/embed.pl: Improve error msg

by indicating which function the problem occurs in

regen/embed.pl: Sort accepted flags list; N n s are legal

This makes it easier to look up a flag in the list.  It had gotten out
of order due to an earlier renaming of a flag.  And several legal flags
(though not used in embed.fnc) were missing

perlapi: Clarify pod for cop_store_label

perlapi: Fix pod for perl_clone()

There were grammar mistakes, and the example it cited is no longer
valid.

t/re/pat.t: Use ASCII ' in comment, not Unicode char

perldelta for 6c3320363f6cd

(perl #133981) fix for Win32 setlocale() abort

This appears to abort because the supplied locale string isn't validly
encoded in the current code page, so we see the following steps:

1) an internal sizing call to mbstowcs_s() fails, but

2) the calling (CRT) code doesn't handle that, allocating a zero length
buffer

3) mbstowcs_s() is called with a buffer and a zero size, causing the
exception.

Since it's the conversion that fails, perform our own conversion.

Rather than using the current code page always use CP_UTF8, since
this is perl's typical non-Latin1 encoding.

Unfortunately we don't have the SVf_UTF8 flag at this point, so
all we can do is assume UTF-8.

This introduces a change in behaviour - previously locale names
were interpreted in the current code page, but most locale names
are ASCII, so it shouldn't matter.

One issue is that the return value is freed on the next LEAVE, but
all callers immediately use or copy the string.

perldelta for 05a03c0da6f3

(perl #134390) don't leak the SV we just created on an early return

More SvPV* macros

bump $XS::APItest::VERSION

Implement SvPV*_or_null*

Implement SvPVutf8_nomg and SvPVbyte_nomg

test for desired magic fetches/stores for vec()

for #132782

Fix do_vecget and do_vecset to process GET magic only once

Implement sv_utf8_downgrade_nomg

Supply missing right brace in regex example

As suggested by Jim Avera in RT 134395.

-DDEBUGGING does not go in ccflags on VMS.

But there is a platform-specific %Config entry for it so use that
and avoid the assertion-induced failure of uv.t in debugging builds.

Fix parent directory in pod2usage auxiliary script.

File::Basename::dirname does not always remove the last component
of the path if that component is already a directory, depending on
platform.  This behavior is documented. pod2usage.t has been
failing on VMS because we get the wrong directory into @INC.

So, since we already have File::Spec loaded, just use the more
obvious and portable method for getting the parent directory.

Reported upstream at:

   <https://rt.cpan.org/Ticket/Display.html?id=130418>

(perl #134365) IFF -> iff and talk about strict a bit

The IFF can be confusing, since "iff" for "if and only if" is
normally presented in lower case.

Since we really want people using strict, firstly tell users about
the behaviour under strict.

Avoid 2 arg open and bareword handles

Rewrite paragraph on using strict and warnings

PATCH: [perl #134329] Use after free in regcomp.c

A compiled regex is composed of nodes, forming a linked list, with
normally a maximum of 16 bits used to specify the offset of the next
link.  For patterns that require more space than this, the nodes that
jump around are replaced with ones that have wider offsets.  Most nodes
are unaffected, as they just contain the offset of the next node, and
that number is always small.  The jump nodes are the ones affected.

When compiling a pattern, the 16 bit mechanism is used, until it
overflows, at which point the pattern is recompiled with the long jumps
instead.

When I rewrote the compiler last year to make it generally one pass, I
noticed a lot of the cases where a node was added didn't check if the
result overflowed (the function that does this returns FALSE in that
case).  I presumed the prior authors knew better, and did not change
things, except to put in a bogus value in the link (offset) field that
should cause a crash if it were used.  That's what's happening in this
ticket.

But seeing this example, it's clear that the return value should be
checked every time, because you can reach the limit at any time.  This
commit changes to do that, and to require the function's return value to
not be ignored, to guard against future changes.

My guess is that the reason it generally worked when there were multiple
passes is that the first pass didn't do anything except count space, and
that at some point before the end of the pass the return value did get
checked, so by the time the nodes were allocated for real, it knew
enough to use the long jumps.

Elvis has left the building

PATCH: [perl #134325] Heap buffer overflow

This was the result of trying to continue to parse after realizing that
we were going to have to reparse using long jumps.  This continuing only
happened when we realized we were going to have to reparse in order to
count parentheses anyway, and it was an attempt to save a pass in the
regex compiler, as without doing the continuing we'd restart the parse
to use long jumps from the beginning, and then when finished, would
restart the parse to count the parentheses.

However, in most cases this doesn't help, as when we get towards the end
of the parse (as in the test case in this ticket), we need the long
jump, and will segfault because we don't have it.  So we need the extra
pass anyway.

So this commit restarts the parse as soon as we discover we are going to
need longjumps

NVMANTBITS is 64 on mingw-w64 'long double' builds

perldelta: Fix typo