Txoic tpyo.

FreeBSD may not have the C99 long double math interfaces.

(This sanity logic could migrated to Configure)

Don’t allow OPpTARGET_MY on postdec/inc

I was wrong in 9e319cc4f.  postfix ++/-- writes to its return value
before reading its argument.  If we optimise away the scalar
assignment in

    $a = $b++;

(that’s what OPpTARGET_MY does), then $a gets written to before $b is
read.  If $a and $b are the same, we get the wrong answer.  This bug
has been present under ‘use integer’ since 5.6.0.  I accidentally
extended it to non-integer ++/-- in 9e319cc4f.

(It’s not likely that someone will write $a = $b++, but it could hap-
pen inadvertently in more complex code.)

tr_utf8.t: Suppress warning

sv.c:find_uninit_var: use newSVpvs_flags

This makes the machine code smaller.

op.c:bind_match: remove redundant var

This shrinks the machine code slightly.

Skip padsv op in $lex =~ ...

m//, s/// and y/// already have logic to deal with implicit lexical
$_.  The pad offset of $_ is stored in the match op itself.  We can
take advantage of that and extend it to lexical variables in general.
That way we have fewer ops to execute, as $lex =~ // no longer calls
pp_padsv.  It also allows lexical variables’ names to be mentioned in
uninitialized warnings for y///.

Don’t check OPpTARGET_MY on match ops at run time

The offset in op_targ is sufficient.  The next commit will take advan-
tage of this.

util.c: fix comiler warnings

A recent commit gave some warnings about format types,
and assignments without extra parens within an if condition.

Version bump for File::Spec::VMS.

Simplify abs2rel.t.

Factor out all the things that were common for the different test
cases (which was everything except the filename).  And use made-up
names that indicate what's being tested rather than special system
filenames commonly found on Unix systems.  Otherwise, if, for
example, a test for "'init.d' is a directory" fails, you'd be
wondering whether something is wrong with your system rather than
looking for problems in File::Spec, which is what we're testing.

Fix undefined warning in File::Spec::VMS::catfile.

We had very carefully created a lexical variable to hold a default
result when the filename was undefined.  Then we forgot to use it.

Now we use it.

Force barename base to be a directory in File::Spec::VMS:abs2rel.

The docs say that the filename portion of base is ignored, but they
don't specify what happens when base is a single component without
directory syntax, leaving ambiguous whether it's a file or a Unix-
style directory spec.  Let's default to the latter for greatest
consistency with what happens elsewhere.

Revise Unix syntax detection File::Spec::VMS::abs2rel.

For a long time we've punted to the Unix method if either path or
base has a forward slash in it.  But that really only works if
*both* are not native specs.  So check for that by making sure we
don't have unescaped left bracket (square or angle) or colon in
either parameter before handing off to File::Spec::Unix::abs2rel.

Move rel2abs earlier in File::Spec::VMS::abs2rel.

We need to make the path and base parameters absolute before
splitting them apart and comparing their pieces.  Since rel2abs
will do its own canonpath, we don't need to do that anymore here.

Extend y/// warnings to utf8

release_schedule.pod: Correct some versions

release schedule: 5.18.4 shipped, 5.18.5 may happen

release schedule: the v5.22 landing plan

op.c:scalarvoid: Remove redundant scalar(o)

op.c:ck_sassign: Simplify freeing of sassign op

Instead of detaching both the rhs and lhs and then freeing the assign-
ment and the lhs, just detach the rhs and free the assignment.  This
results in smaller machine code.

Don’t use OP_SIBLING(o) in op.c:ck_sassign

When this is called, the op is not part of a larger tree yet, so its
sibling is always NULL.

Shrink PL_op_private_bitdefs

It doesn’t matter whether things in this table are ordered by opcode,
because the indices into it are stored in PL_op_private_bitdef_ix.

If we have multiple ops with exactly the same private flags, we don’t
need multiple entries in PL_op_private_bitdefs.

One practical advantage is that patches are less likely to conflict,
which will make rebasing easier.  (I hope.)

[Merge] More OA_DANGEROUS stuff

The OA_DANGEROUS op type flag indicates that an op might return a
value referenced elsewhere, so list assignment should make tempor-
ary copies.

Some ops had this flag needlessly.  Some lacked it erroneously,
resulting in bugs.

values and each are OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

values and each can both return scalars that are referenced elsewhere,
causing list assignment to behave erratically if temporary copies
are not made.

smartkve.t doesn’t need to disable dep warnings

kill is not OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

kill only ever returns a target unused elsewhere, so it does not
necessitate temp copies in list assignment.

exec is not OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

When exec fails, it only ever returns a target unused elsewhere, so it
does not necessitate temp copies in list assignment.

enterwrite is not OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

‘write’ only ever returns a read-only true or false, so temp copies
are not necessary for its sake.

Fix ext/B/t tests after OA_DANGEROUS removals

tied is OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

tied returns the same scalar that the tied variables uses to hold a
reference to the object (so weaken(tied(...)) works).  tie uses the
very scalar that TIESCALAR (or TIEWHATEVER) returns and attaches it to
the tied variable by magic.  That returned scalar could be referenced
elsewhere.  That means

    ($a, $b) = ($c, tied $d)

could have common vars on either side, if the tie constructor for $d
happened to return $a or $b.  (Normally it would have to be an XSUB or
an lvalue sub for its return value not to have been copied.)

Remove OA_DANGEROUS from exit

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

exit usually doesn’t return.  When it fails, it returns a read-only
undef, so we don’t need temp copies for its sake.

Remove OA_DANGEROUS from loopctl-type ops

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

These operators never return, so they shouldn’t necessitate
temp copies.

(This could probably apply to dump, too, but I don’t fully under-
stand dump.)

Remove OA_DANGEROUS from die

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

die never returns, so it shouldn’t necessitate temp copies.

Remove OA_DANGEROUS from cond_expr

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

?: always returns one of its arguments.  Since aassign_common_vars,
which does the danger check, also checks the kids of the cond_expr op,
it is not necessary for cond_expr to be flagged this way.

Remove OA_DANGEROUS from grep and map

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

grep returns its arguments, while map returns the results of its first
expression.  Since aassign_common_vars, which does the danger check,
will also check the kids of the mapstart/grepstart ops, it is not nec-
essary for grep and map themselves to be flagged this way.

Remove OA_DANGEROUS from sort

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

pp_sort returns its arguments.  aassign_common_vars will check its kid
ops for danger as well, so it’s not necessary for sort itself to be
flagged this way.  This will allow cases like ($a,$b) = sort($c,$d) to
forego the temp copy.

Don’t copy VMS hints to cop->op_private

Commit d5ec29879 in 2006 started storing all the hints in COPs.  Some
VMS-specific hints have nonetheless still been copied from PL_hints to
cop->op_private, though that is no longer necessary.

FV_ISFINITE, not FV_ISINITE.

Remove OA_DANGEROUS from non-integer postdec/inc

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

While pp_postinc may return a lexical scalar, that only happens when
the OPpTARGET_MY optimisation is happening; and aassign_common_vars in
op.c checks specifically for that.

Otherwise, it only returns a mortal or target, so it is not
OA_DANGEROUS.

Allow OPpTARGET_MY on non-integer postdec/inc

I don’t know why this was not done to begin with.  The previous two
commits fixed the only outstanding problems I am aware of.

Make pp_postinc call set-magic on its target

Its target may be a lexical scalar (under ‘use integer’ currently, and
soon even outside of ‘use integer’).  The assignment in $lex = $foo++
currently gets optimised away and ++ writes directly to $lex.

Fix $lex = $ref++ under use integer

Operators generally have targets, that is, scalars in the pad that are
used to return values.  The same scalar is used again and again for
efficiency.

If the value assigned to a target is a reference, that can be bad,
because the referent will last longer than expected, even forever.
$ref++ used to have this problem (bug #9466).

So commit v5.13.4-148-g7dcb9b9 fixed it by returning a new mortal if
the return value was a reference.

However, under ‘use integer’, the OPpTARGET_MY optimisation is per-
mitted on postdec and postinc (why only under ‘use integer’ I don’t
know).  Under that optimisation, $lexicalvariable = <some op> has the
assignment optimised away and the lexical variable becomes the operat-
or’s target.

If we skip assigning to the target and it is a lexical variable, then
the assignment never happens:

$ perl5.14.4  -le 'my $x=7; $_={}; $x = $_++; print $x'
HASH(0x7ff4a8806d00)
$ perl5.14.4 -Minteger -le 'my $x=7; $_={}; $x = $_++; print $x'
7

Using bignum needs skip_if_miniperl().

skip_all, not skip, if only miniperl.

Wrong (non-existent) Config var name.

Fix one test message, add two tests.

undef the temp variables between tests.

This way a failing result doesn't carry over between subtests.

Perl_isfinitel is not necessarily always there.

Drop uselongdouble unless it really gives longer doubles.

Remove OA_DANGEROUS from subst(cont)

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

pp_subst and pp_substcont only push new mortal scalars or read-only
values on to the stack.  Hence they are not OA_DANGEROUS.

Remove OA_DANGEROUS from match

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

pp_match pushes new mortals on to the stack in list context (or a
read-only boolean; read-only values don’t matter), so they can’t
occur elsewhere.  Hence it is not OA_DANGEROUS.

Fix up f_map.t following "\L$_" optimisation

Make B constants depend on perl headers

Making the Makefile depend on the headers where the constants are
found will force Makefile.PL to be re-run, and it is Makefile.PL that
generates the constants.

Optimise stringify away for "\Q$_" "\u$_" etc.

Allow OPpTARGET_MY optimisation for split

Many operators have a special SV allocated in the pad which is used
for return values (the target).  If we make that pad offset point to
a lexical variable, then we can optimise, say, $lexical = "$foo" into
just "$foo", where $lexical is stringify’s ‘target’.  And pp_stringify
doesn’t need to know any better.  We already do that for many ops.

This is safe to extend to split.  split only uses its target in this
code at the end:

    GETTARGET;
    PUSHi(iters);

so there is no danger of modifying its argument before reading it.

Fix Deparse OPpLVAL_INTRO handling in lists

The renumbering of private flags a few commits ago caused an exist-
ing Deparse bug to occur more often.  It was assuming that the
OPpLVAL_INTRO and OPpOUR_INTRO flags could occur on any ops for which
it did not have explicit exceptions.

This commit changes it to check for only those ops known to use those
flags, thus fixing bug #119815.

Renumber op flags so TARGET_MY and OUR_INTRO differ

I need split to be able to take both flags.  Renumbering OUR_INTRO
sets off a chain reaction requiring that various other flags be renum-
bered.  These are the affected ops:

      gvsv  rv2sv rv2av rv2hv  enteriter split rv2gv padsv aelem helem entersub padav padhv lvavref lvref refassign pushmark rv2cv
----------------------------------------------------------------------------------------------------------------------------------
0                                                                      inargs
1           strct strct strct                  strct                   strct                                                 strct
2                 slicw silcw  reversed        noinit                  targ     slicw slicw         elem  elem               targ
3                 lvsub lvsub  def             lvsub       lvsub lvsub amper    lvsub lvsub         iter  iter               amper
4     our   our   our   our    our       our   fake  state defer defer dbg      state state state   state state     state    dbg
5-6         dref        bool                   dref  dref  dref  dref  dref           bool          type  type               const(6)
7     intro intro intro intro  intro    implim intro intro intro intro intro    intro intro intro   intro intro     intro    nopar

If we use 6 for OUR_INTRO and shift 5-6 down to 4-5, that frees up 4
(aka OPpTARGET_MY) for use on split.

op.c:scalarvoid was testing the OPpOUR_INTRO flag on ops that don’t
take it, so it needed adjustment.

op_private: Remove incorrect OPpLVREF_TYPE comment

At the time, I was trying to rearrange the magic flags so that
OPpLVREF_TYPE could be copied into mg->mg_flags for lvref magic.  Then
I saw that mg_private was available and gave up on the whole idea; but
this comment remained.

optimize Perl_boot_core_UNIVERSAL and Perl_nextargv

Perl_nextargv fuse 2 tests into 1

Perl_boot_core_UNIVERSAL reorder instructions to avoid using a non-vol
registers (save cv across the Safefree), not reread CV body * after
Safefree. Compute address of CvFILE once.

for Perl_boot_core_UNIVERSAL on VC 2003 before 0x66 bytes of 32 bit x86
machine code, after 0x61.

add xs_handshake API

This API elevates the amount of ABI compatibility protection between XS
modules and the interp. It also makes each boot XSUB smaller in machine
code by removing function calls and factoring out code into the new
Perl_xs_handshake and Perl_xs_epilog functions.

sv.c :
- revise padlist duping code to reduce code bloat/asserts on DEBUGGING

ext/DynaLoader/dlutils.c :
- disable version checking so interp startup is faster, ABI mismatches are
  impossible because DynaLoader is never available as a shared library

ext/XS-APItest/XSUB-redefined-macros.xs :
- "" means dont check the version, so switch to " " to make the test in
  xsub_h.t pass, see ML thread "XS_APIVERSION_BOOTCHECK and XS_VERSION
  is CPP defined but "", mow what?"

ext/re/re.xs :
- disable API version checking until #123007 is resolved

ParseXS/Utilities.pm :
109-standard_XS_defs.t :
- remove context from S_croak_xs_usage similar to core commit cb077ed296 .
  CvGV doesn't need a context until 5.21.4 and commit ae77754ae2 and
  by then core's croak_xs_uage API has been long available and this
  backport doesn't need to account for newer perls
- fix test where lack of having PERL_IMPLICIT_CONTEXT caused it to fail

Update B::Deparse for last two commits

Allow OPpTARGET_MY optimisation for x

Many operators have a special SV allocated in the pad which is used
for return values (the target).  If we make that pad offset point to
a lexical variable, then we can optimise, say, $lexical = "$foo" into
just "$foo", where $lexical is stringify’s ‘target’.  And pp_stringify
doesn’t need to know any better.  We already do that for many ops.

This can be extended to x.  Despite what the comment in op_private
says, list return values do not matter here, because the OPpTARGET_MY
optimisation only happens when the operator is in scalar context.  And
the scalar code paths use TARG and push TARG on to the stack.

Allow OPpTARGET_MY optimisation for vec

Many operators have a special SV allocated in the pad which is used
for return values (the target).  If we make that pad offset point to
a lexical variable, then we can optimise, say, $lexical = "$foo" into
just "$foo", where $lexical is stringify’s ‘target’.  And pp_stringify
doesn’t need to know any better.  We already do that for many ops.

This can be extended to vec().  Despite what the comment in op_pri-
vate says, lvalue usage does not matter here, because the OPpTARGET_MY
optimisation only happens when the operator is in rvalue context.  And
the rvalue code paths use TARG and push TARG on to the stack.

remove obsolete PL_apiversion

Commit 0e42d607f5 made PL_apiversion unused. Remove it to save memory in
interp struct.

remove cargo culted redundant PL_perldb test

Inseperable changes commit 8490252049 and specifically ML post
"Perldb rehaul" by Ilya Zakharevich added a completely redundant
"if(PL_perldb)" test. This was probably cargo culted from the code prior
to that patch where PL_perldb was a (I think) a bool. Neither GCC 4.6.3
nor VC 2003  optimized away the test. Before this patch, .text section in
perl521.dll compiled with VC 2003 was 0xc62d3 bytes of machine code long,
after 0xc6203.

Update Test-Harness to CPAN version 3.34

  [DELTA]

3.34    2014-11-02
        - Enable printing CPU times spent per test (Jarkko Hietaniemi)

Update Test-Simple to CPAN version 1.001009

Update Encode to CPAN version 2.64

  [DELTA]

$Revision: 2.64 $ $Date: 2014/10/29 15:37:54 $
! t/utf8warnings.t MANIFEST
  Retouch pull #26 so it works with perl < 5.14
! Encode.pm
+ t/utf8warnings.t
  Pulled: Catch and re-issue utf8 warnings at a higher level
  https://github.com/dankogai/p5-encode/pull/26
+ Encode.xs
  Pulled: Validate continuations in the incremental UTF-X decoder
  https://github.com/dankogai/p5-encode/pull/25

Revert "t/TEST: move our @found out to its real scope"

This reverts commit 448bc2e91e255b2610f23d9fe8092c9143dac28e.

Revert "t/TEST: $failure doesnt need to use defined"

This reverts commit 861a58daef615e7ade791b887911ef3caba8c539.

Revert "t/TEST: add a common timestamp"

This reverts commit 3c8571535150a64cf1163a15106d0f9e57fdd6a7.

Revert "t/TEST: comment some of the <$results> loop vars"

This reverts commit 861aa4195fddf02db2d2d1412c83a273daae9f05.

Revert "t/TEST: move do_nothing test after option-handling code"

This reverts commit 922487b2e3c980db625829f57958aac6a3e33552.

Revert "t/TEST: add -lxperf option to run tests under linux's perf stat"

This reverts commit 02a483e9608abd0f822d7c8ec6d64c07c4689e55.

Revert "t/TEST: simplify <$results> processing loop. - TAP13.1+"

This reverts commit b8059a1db50cef0ea798275144b6d2f54a288946.

Revert "t/TEST: change timings Storable key: perf -> times, a better description"

This reverts commit ba369d6f39f2f98f9e999dc978baeba4d4efba25.

Revert "t/TEST: suppress 2 uninitialized envars under make test.valgrind"

This reverts commit e28ec392de528ba135a100709ce789a168286f86.

Revert "t/TEST: RFC start to separate out valgrind test support."

This reverts commit 08ac0af6a0260a3939c4904c299200adee71010d.

Revert "manisort"

This reverts commit b22d640684f6001bfd63316a6a3ce69127745943.

Deparse Devel::Peek::Dump

I’m not sure how or where to test this.  Maybe we should document this
‘accidental’ plug-in interface for B::Deparse and custom ops.

Better B::Deparse warning for custom ops

Update B::Deparse docs about BEGIN blocks

Spell optimise consistently in Deparse pod

also add a missing hyphen.

Mention Data::Dump::Streamer in B::Deparse docs

[perl #77452] Deparse BEGIN blocks in the right place

In the op tree, a statement consists of a nextstate/dbstate op (of
class cop) followed by the contents of the statement.  This cop is
created after the statement has been parsed.  So if you have nested
statements, the outermost statement has the highest sequence number
(cop_seq).  Every sub (including BEGIN blocks) has a sequence number
indicating where it occurs in its containing sub.

So

 BEGIN { } #1
 # seq 2
 {
   # seq 1
   ...
 }

is indistinguishable from

 # seq 2
 {
   BEGIN { } #1
   # seq 1
   ...
 }

because the sequence number of the BEGIN block is 1 in both examples.

By reserving a sequence number at the start of every block and using
it once the block has finished parsing, we can do this:

 BEGIN { } #1
 # seq 1
 {
   # seq 2
   ...
 }

 # seq 1
 {
   BEGIN { } #2
   # seq 2
   ...
 }

and now B::Deparse can tell where to put the blocks.

PL_compiling.cop_seq was unused, so this is where I am stashing
the pending sequence number.

Increase $B::Concise::VERSION to 0.995

Adjust Peek.t for SEQ dumping

dump.c: Use same code for cops and ex-cops

This also allows ex-dbstate ops to have their cop fields dumped, which
was not the case before.

dump.c: Dump seq field of nextstate ops

This is very useful for debugging.

Remove Mac Classic code from B::Concise

Fix perldiag typo

spotted by Lukas Mai.

perldiag: rewrap an entry for better splain output

sort perldiag

simplify Perl_xs_apiversion_bootcheck

We control both strings. Perl API versions are not old decimal or alphas
versions. Maints dont increase Perl API ver. Just do a memcmp. Faster and
less machine code. Before 0xA6 bytes of machine code on VC 2003 32b,
after 0x35. This patch is related to [perl #123136].

perldelta for aa9d125313d7

[perl #108276] re-indent the loop body

move the closing ) out of the #ifdef USE_ITHREADS to avoid confusing tools

emacs, in my case

[perl #108276] avoid deep scalarvoid() self-recursion

This fixes the original test case from the ticket.

It may be possible for code that alternates recursion between
scalarvoid() and scalar() to cause deep recursion, but I haven't seen
an example that does it.

This doesn't indent the scalarvoid() loop, which will be done in another
change.

perldelta for ab4e48c10a / #123135