utf8.c: swash_to_invlist() handle EXTRAS

This function has not been able to handle what are called EXTRAS in
its input.  These are things like:

    !utf8::InHiragana
    -utf8::InKatakana
    +utf8::IsCn

besides the normal list of ranges.

This commit allows this function to handle all the same constructs as
the regular swash input function, from which most of the new code was
copied.

mktables: Use inverted tables for disk space

This patch changes large tables that are the complement of other
tables to just be the single line indicating to use the complement

Restrict some inversion list functions

These functions are internal only with names beginning with underscore.
I hadn't realized that their definitions could be restricted.

Allow utf8.c to access 4 inversion list functions

Change 4 inversion list functions from S_ to Perl_

This is in preparation for them to be called from another file.  Note
that they are still protected by an #ifdef in embed.fnc.

Change _invlist_invert() from being in-line

This is in preparation for it to be called from another file.  If
for performance reasons it needs to be made inline again, it could
then be moved into a header.

Change names of some inversion list functions

The names now begin with an underscore to emphasize that they are
for internal use only.  This is in preparation for making them
accessible beyond regcomp.c.

embed.fnc: Move entries around

This is in preparation for making these functions available
outside regcomp.c

regexp_unicode_prop.t: Improve output

The ok statements were not giving the correct pattern; the not ok
statements were not giving the failure reason.

regcomp.c: White space only

regcomp.c: Do some [^abc] inversion at compile time

The new facilities with inversion lists enables us to do
some more compile-time inversions.

Add 3 methods for inversion lists

This adds inversion, cloning, and set subtraction

Add inversion list dump routine, #ifdef'd out to prevent compiler warning, for use when debugging

Add flag to num groks to silence non-portable warnings

Unicode inversion lists commonly will contain UV_MAX, which may
trigger these warnings.  Add a flag to suppress them to the numeric
grok functions, which can be set by the code that is dealing with
these lists

Add an element to inversion list data structure

This element is restricted to either 0 or 1.  The comments detail
how its use enables an inversion list to be efficiently inverted.

regcomp.c: Add comments

regcomp.c: Parenthesize rhs of #define

regcomp.c: Move a function around

This is so functions that operate on the same data are adjacent

Add length element to inversion lists

Future changes will make the length no longer the same as SvCUR,
so create an element to hold the correct length

regcomp.c: Use inversion list iterator

This changes to use the iterator when traversing an inversion list.

Add iterator for inversion lists

Allow a header in inversion lists.

An inversion list is an array of UVs.  This allows for other UVs
to be added at the beginning for ancillary purposes.  This patch
does not allocate any space for these, however.

regcomp.c: Correct comment

regcomp.c: Macroize two expressions

This is in preparation for making things more complex in a later commit

regcomp.c: Rmv no longer called function

This hasn't been used since 626725768b7b17463e9ec7b92e2da37105036252
Author: Nicholas Clark <nick@ccl4.org>
 Date:   Thu May 26 22:29:40 2011 -0600

regcomp.c: Fix memory leak regression

 here was a remaining memory leak in the new inversion lists data
structure under threading.  This solves it by changing the
implementation to use a SVpPV instead of doing our own memory
management.  Then the already existing code for handling SVs
returns the memory when done.

regcomp.c: Remove no longer called function

The invlist_destroy function was misleading, as it has changed to
just decrement the reference count, which may or may not lead to
immediate destruction

regcomp.c: Remove invlist_destroy calls

This is in preparation to removing the function

regcomp.c: #undef after finished

regcomp.c has a subsection dealing with the implementation of the
inversion list class(-like object).  Undef its macros so they
can't possibly interfere with the rest of regcomp.c

regcomp.c: Remove unneeded temporary

A previous commit changed things so that this is no longer necessary

regcomp.c: Revise inversion list API

These are static functions so no external effect.  Revise the calling
sequence of two functions so that they can know enough to free
memory if appropriate of the other parameters.  This hides from the
callers the need for tracking when to free memory.

regcomp.c: PL_utf8_foldclosures is a HV

It is not an inversion list, contrary to what this line used to say.

Change inversion lists to SVs

The inversion list is an opaque object, currently implemented as an SV.
Even if it ends up being an HV in the future, Nicholas is of the opinion
that it should be presented to the world as an SV*.

overload.pm: Fix broken link

The list this link tries to refer to is a bullet list, and so
doesn't get anchors generated for it, so clicking on the link
fails

fix broken links in old perldeltas

We aren't keeping old perldeltas up-to-date, but I had these fixes lying
around, so decided to commit them

Convert B::Deparse's core.t to Test::More.

Bring the joy of strict to it, remove the unused variable @bin, and convert a
literal carriage return to a newline.

Use C<< >> to avoid tripping a podchecker heuristic for "don't you mean F<>?"

In this case, commiters/somework is not a file, hence C<> is correct.

add when/how to merge/rebase to perlgit.pod

remove another duplicated section

(unrelated whitespace fixes also included)

remove duplicated "topic branches" section

Revert "x"

This reverts commit a91756ea8ef881f776fe68ca460c433b728977ec.

This commit was accidentally pushed by RJBS, who is abject and sorrowful.

x

README.foo: Change NAME to perlfoo

This fixes broken links to these

Add terse changelog entry for 2.29

Add another address for John Peacock

Revise check for negative versions plus test

Dual-life Text::Abbrev

For shorter strings, store C<study>'s data as U8s or U16s, instead of U32s.

The assumption is that most studied strings are fairly short, hence the pain
of the extra code is worth it, given the memory savings.
80 character string, 336 bytes as U8, down from 1344 as U32
800 character string, 2112 bytes as U16, down from 4224 as U32

Store C<study>'s data as U32s, instead of I32s.

The "no more" condition is now represented as ~0, instead of -1.

Tidy code in pp_study and Perl_screaminstr()

In pp_study eliminate the variable pos, which duplicates len. ch should be U8,
not I32.

In Perl_screaminstr(), move the declarations of s and x to their point of use,
convert a for loop to a while loop, and avoid incrementing and decrementing s.
found is a boolean.

Store C<study>'s data in in mg_ptr instead of interpreter variables.

This allows more than one C<study> to be active at the same time.
It eliminates PL_screamfirst, PL_lastscream, PL_maxscream.

Merge PL_scream{first,next} into one allocated buffer.

Effectively, PL_screamnext is now PL_screamfirst + 256. The actual interpreter
variable PL_screamnext is eliminated.

Change PL_screamnext to store absolute positions.

PL_screamnext gives the position of the next occurrence of the current octet.
Previously it stored this as an offset from the current position, with -pos
stored for "no more", so that the calculated new offset would be zero,
allowing a zero/non-zero loop exit test in Perl_screaminstr().

Now it stores absolute position, with -1 for "no more". Also codify -1 as the
"not present" value for PL_screamfirst, instead of any negative value.

Split out study magic from pos magic.

study uses magic to call SvSCREAM_off() if the scalar is modified. Allocate it
its own magic type ('G' for now - pos magic is 'g'). Share the same "set"
routine and vtable as regexp/bm/fm (setregxp and vtbl_regexp).

Stop podcheck.t --add-link from chomping a new line

    # The rest of the db file is output unchanged.
    my_safer_print($copy_fh, join "\n", @existing_issues);

Well, actually that *does* change the file.  See the diff.

Add another address for Claes Jakobsson

Report a better error when trying to use negative version numbers instead of 'Invalid version format (non-numeric data)' as it currently does. Also update documentation that version should be a positive number.

Change the example in the Changes file to be more generic.

Remove the releng step which required altering the Changes file
with a meaningless version bump

The regex engine can't assume that SvSCREAM() remains set on its target.

Callers to the engine set REXEC_SCREAM in the flags when the target scalar is
studied, and the engine should use the study data. It's possible for embedded
code blocks to cause the target scalar to stop being studied. Hence the engine
needs to check for this, instead of simply assuming that the study data is
present and valid to read. This resolves #92696.

charnames.pm: Nits in pod

Updated Locale-Codes to CPAN version 3.17

  [DELTA]

  VERSION 3.17 (2011-06-28)

  NEW CODE(s)

  Added new types of codes

    Added Language Extension codes (langext) and Language Variation codes (langvar) as defined in the IANA language registry.

  Added new codeset(s)

    Added language codes from ISO 639-5

    Added language/script codes from the IANA language subtag registry

  Bug fixes

    Fixed an uninitialized value warning. RT 67438

    Fixed the return value for the all_XXX_codes and all_XXX_names functions. RT 69100

  Reorganized code

    Reorganized modules to move Locale::MODULE to Locale::Codes::MODULE to allow for cleaner future additions. The original
    four modules (Locale::Language, Locale::Currency, Locale::Country, Locale::Script) will continue to work, but all new
    sets of codes will be added in the Locale::Codes namespace.

RT 64804: tainting with index() of a constant

At compile time, ck_index with a tainted constant set PL_tainted,
which remained on during the rest of compilation, tainting all other
constants.

Fix this by saving and restoring PL_tainted across the call to
fbm_compile, which is what sets PL_tainted.

TODO test for index() of a tainted constant

As reported by Adrian Irving-Beer in <http://bugs.debian.org/291450>,
this unexpectedly throws a fatal taint error:

    #!/usr/bin/perl -T
    use constant C_A => $ARGV[0];
    use constant C_B => $ARGV[1];
    index(C_A, C_B);
    open(FOO, "-|");

The TODO test is reduced from the above.

perlrun: reflow to fit vertabims in 80 cols

This leaves a couple > 80 which are hard to reflow

Push the atime and mtime of generated Makefile.PLs back 4 seconds in make_ext.pl

In certain circumstances ( on virtual machines ) the generated Makefile.PL can
produce a Makefile that is older than the Makefile.PL

Altering the atime and mtime backwards by 4 seconds seems to resolve the issue.

Fix context propagation below return()

A.k.a. "RT #38809 strikes back".

Back in the time of perl 5.003, there was no void context, so "do" blocks
below a return needed special handling to use the dynamic context of the
caller instead of the static context implied by the return op location.

But nowadays context is applied by the scalarvoid(), scalar() and list()
functions, and they all already skip the return ops. "do" blocks below a
return don't get a static context, and GIMME_V ought to correctly return
the caller's context. The old workaround isn't even required anymore.

Test taintedness of values returned by given/when

In leavewhen, put the SP back when returning

It may have changed in adjust_stack_on_leave() if the stack needed to be
extended.

Make sure break() resets the sp at its original level

Correctly preserve the stack on an implicit break.

Perl generates a 'break' op with the special flag set at the end of every
'when' block. This makes it difficult to handle both the case of an
implicit break, where the stack has to be preserved, and the case of an
explicit break, which must obliterate the stack, with the same pp function.
Stack handling should naturally occur in 'leavewhen', but it is effectively
called only when the block issues a 'continue'.

In order to preserve the stack, we change the respective roles of 'break',
'continue' and 'leavewhen' ops :
- Special 'break' ops are no longer generated for implicit breaks. Just as
before, they give the control back to the 'leavegiven' op.
- 'continue' ops now directly forward to the op *following* the 'leavewhen'
op of the current 'when' block.
- 'leavewhen' is now only called at the natural end of a 'when' block.
It adjusts the stack to make sure returned values survive the temp cleanup,
then issues a 'next' or go to the current 'leavegiven' depending on whether
it is enclosed in a for loop or a given block.

This fixes [perl #93548].

Convert pp_leave() to adjust_stack_on_leave()

Move pp_enter() and pp_leave() with their friends in pp_ctl.c

Factor stack adjustments on leave in a new static function

This is just a refactoring. There should be no functional changes.

fold_grind.t: Add comments

autodoc.pl: Don't list experimental functions in API

Don't quote target name in make_ext.pl.

Even though it's presumably doing case-blind lookups of target
names, MMS currently (V3.9-00) falls down hard when passed a
target name in lower case.

Fix two podchecker errors on perlunicode.pod

Add Unicode::Regex::Set to the list of known CPAN modules.
Reflow a verbatim block to fit within the column limit.

add do_ncmp fn and make pp_ncmp, pp_eq etc use it

Extract most of the body of pp_ncmp() (numeric compare) into a separate
function, do_ncmp(), then make the following ops use it:
    pp_ncmp
    pp_lt
    pp_le
    pp_eq
    pp_ne
    pp_ge
    pp_gt

This removes a lot of similar or duplicated code, most of which is
dedicated to handling the various combinations of IV verses UV verses NV
verses NaN.

The various ops first check for, and directly process, the simple and common
case of both args being SvIOK_notUV(), and pass the processing on to
do_ncmp() otherwise. Benchmarking seems to indicate (but with a lot of
noise) that the SvIOK_notUV case is slightly faster than before, and the
do_ncmp() branch slightly slower.

pp_ncmp: favour the non- Perl_isnan route

Currently pp_ncmp(), when comparing two NVs, prefers to check its two args
for NaNness first, and if either of them are, then return undef.  Only if
Perl_isnan isn't defined does it fall back to doing three compares (<, >,
=) where if all three fail it returns undef.

This is in contrast to the other compare functions (e.g. pp_lt), which
only use Perl_isnan if NAN_COMPARE_BROKEN is defined - i.e. they prefer to
rely on the '<' (or whatever) test to handle NaNs implicitly.

Change pp_ncmp to favour not using Perl_isnan(). This has two advantages:

First, speed: in the normal case we replace:
    two function calls to Perl_isnan plus two comparisons,
with:
    three comparisons.

Second, this makes pp_ncmp more similar to the other comparison functions,
allowing for code reuse in the future.

remove unreachable code from various compare ops

All the compare ops (such as pp_le), have an initial:

    tryAMAGICbin_MG(le_amg, AMGf_numeric);

The effect of the AMGf_numeric flag is that, if the le overloading fails,
but either of the args on the stack is a reference, then that arg is
replaced with a temporary non-ref arg that is either the result of
'0+' overloading, or is a UV with the numerical value of the ref's
address.  So by the time the main body of the op is called, neither arg
can be a ref.

Thus a whole bunch of nearly identical blocks can be removed, which *used*
to handle comparing refs:

    if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
        SP--;
        SETs(boolSV(SvRV(TOPs) <= SvRV(TOPp1s)));
        RETURN;
    }

Expand bump RT version number in Porting/release_managers_guide.pod

Robert generally adds future versions, so check first whether he
has first.

fix `perldoc -v '$0'`

Presently, `perldoc -v '$0'` fetches the entry for $<digits> ($1, $2,
...) instead of $0 ($PROGRAM_NAME).

Increase $Pod::Perldoc::VERSION

in preparation for the next commit.

perldelta entry for #93454

Tiny comment typo fix in handy.h

Correct comment that 903fd87c missed

perlunicode: Nits

a missing word, remove L<> from a verbatim block, add L<> for a module,
clarify wording

cast unsigned to avoid warning

Add a cast C<(unsigned)> to silence a compiler warning [-Wsign-compare]

[perl #93454] Free deleted iterator when freeing hash

Commit 7d6175e, which did a fix-up after commit e0171a1a3, which
introduced hfree_next_entry, did not account for the fact that
hfree_next_entry frees the hash iterator before removing and returning
the next value.

It changed the callers to check the number of keys to determine
whether anything else needed to be freed, which meant that
hfree_next_entry was called one time less than necessary on hashes
whose current iterator had been deleted and which consequently
appeared empty.

This fixes that.

I don’t know how to test it, but the string table warnings were caus-
ing test failures on VMS, so maybe that’s good enough.

Bypass a switch in gv_fetchpvn for 2-char symbols

The switch that checks for ISA, EXPORT, etc. in packages other
than main was guarded with an if(len>1) statement.  Since ISA is
three characters, we can bypass that entire switch for two-charac-
ter symbols.

Update proto docs after prev commit

Allow the \$ proto to accept any scalar lvalue [perl #91846]

This makes the \$ prototype’s parsing the same as the second argument
to read(), making it possible to create a custom myread() function
that has the same syntax.

This is handled in two places in the prototype-parsing code, to avoid
calling scalar() on the op if another character in \[...] will accept
it.  I don’t know what the consequences of that would be.  So it calls
Perl_op_lvalue_flags in the $ case only if it is not inside brackets.
Then in the ] case it checks to see whether there was a $.

OP_READ, not OP_ENTERSUB, is passed as the type to
Perl_op_lvalue_flags, since OP_ENTERSUB would allow sub foo(\$) to
accept an array as an argument.  OP_RECV and OP_SYSREAD would have
worked, too.

Make Perl_op_lvalue_flags provide a no-croak option

This is in preparation for making the \$ prototype accept any lvalue.

op_lvalue .= _flags

Add flags param to op_lvalue, so that the caller can ask it not to
croak when encountering an unmodifiable op (upcoming).

This is in preparation for making the \$ prototype accept any lvalue.

There is no mathom, as the changes that this will support
are by no means suitable for maint.

proto.t: Test \$ with subcall()->[elem]

This syntax was documented, but there was no test for it.

Remove two tests from proto.t

These have been superseded by t/op/cproto.t, which came later.

Make pp_leavesublv use S_return_lvalues

The returning code is now almost identical, due to the preceding com-
mits, so they can be merged.

realclean clean-up on VMS.

Update a few missing or moved items in the realclean target.

preplibrary needs an explicit action in descrip_mms.template.

Even if that action says "Don't do anything."  MMK silently ignores
this but MMS falls down hard with:

%MMS-F-GWKNOACTS, Actions to update PREPLIBRARY are unknown.

This was broken in ebca06e95b02d1a8cf073328af30c9f4b9af6891.

Fix explicit return of pad var in list lv context

This is something that commit e08be60 missed, though it never worked
properly, even in 5.14, as explicit return from lvalue subs used to
copy return values.

As the commit message for e08be60 states, returning a scalar itself
from an lvalue sub does not work if it is a pad variable with a refer-
ence count of 1, because the sub-popping code clears it on exit.

The one code path that did not account for this was list lvalue con-
text (real lvalue context, not just potentially lvalue).  The only
observable effect this has is that assigning to a magic pad variable
returned from a subroutine in list context will not trigger set-magic.

This commit fixes it and also adds tests for returned magic pad vars
in all combinations of list/scalar lvalue/ref context.

Collapse the list context code in pp_leavesublv

Two branches of this three-branch if/elsif were doing the same thing.
One was written out longhand.