This is a live mirror of the Perl 5 development currently hosted at
10 years agoadd epigraphs for 5.16.1
Ricardo Signes [Thu, 9 Aug 2012 13:03:21 +0000 (09:03 -0400)]
add epigraphs for 5.16.1

and fix some whitespace on 5.16.0

10 years agoDon't write Windows EOLs in CoreList.(pm|pod) when updating them on Windows
Steve Hay [Thu, 9 Aug 2012 12:54:24 +0000 (13:54 +0100)]
Don't write Windows EOLs in CoreList.(pm|pod) when updating them on Windows

10 years agoDon't write Windows EOLs in MANIFEST when sorting it on Windows
Steve Hay [Thu, 9 Aug 2012 12:54:10 +0000 (13:54 +0100)]
Don't write Windows EOLs in MANIFEST when sorting it on Windows

10 years agoUpgrade Module-Build to 0.4002
Steve Hay [Thu, 9 Aug 2012 12:41:46 +0000 (13:41 +0100)]
Upgrade Module-Build to 0.4002

10 years agoUpgrade Encode to 2.45
Steve Hay [Thu, 9 Aug 2012 11:51:05 +0000 (12:51 +0100)]
Upgrade Encode to 2.45

10 years agoUpgrade to Time-Local 1.2300
Steve Hay [Thu, 9 Aug 2012 07:31:43 +0000 (08:31 +0100)]
Upgrade to Time-Local 1.2300

Files are already up to date, but is not.

10 years agoUpgrade Module-Metadata to 1.000010
Steve Hay [Thu, 9 Aug 2012 07:21:59 +0000 (08:21 +0100)]
Upgrade Module-Metadata to 1.000010

10 years agoUpgrade Module-Load-Conditional to 0.52
Steve Hay [Thu, 9 Aug 2012 07:18:27 +0000 (08:18 +0100)]
Upgrade Module-Load-Conditional to 0.52

10 years ago[perl #114018] Let eval close over stale vars in active sub
Father Chrysostomos [Wed, 8 Aug 2012 17:00:52 +0000 (10:00 -0700)]
[perl #114018] Let eval close over stale vars in active sub

See also commit cae5dbbe30.

These two lines should never produce different values:

    print $x, "\n";
    print eval '$x', "\n";

But they were producing different values if $x happened to have the
tale flag set.  Even if my in false conditional is not supported (this
was the cause of the bug report), it should still work; and it is
not the only way to get a stale lexical in an active sub (just the
easiest way).

As long as the sub containing the eval is active, the eval should be
able to see the same variables, stale or not.

However, this does get a bit tricky in cases like this, which legiti-
mately warn (from t/lib/warnings/pad):

    my $x = 1;
    $y = \$x; # force abandonment rather than clear-in-place at scope exit
    sub f2 { eval '$x' }

In this case the f2 sub does not explicitly close over the $x, so by
the time the eval is reached the ‘right’ $x is gone.

It is only in those cases where the sub containing the eval has
the stale variable in its own pad that we can safely ignore the
stale flag.

10 years agoB::Concise: Document formats
Father Chrysostomos [Wed, 8 Aug 2012 13:15:24 +0000 (06:15 -0700)]
B::Concise: Document formats

10 years agoDon’t let format arguments ‘leak out’ of formline
Father Chrysostomos [Wed, 8 Aug 2012 07:36:57 +0000 (00:36 -0700)]
Don’t let format arguments ‘leak out’ of formline

When parsing formats, the lexer invents tokens to feed to the parser.

So when the lexer dissects this:

format =
@<<<< @>>>>
$foo, $bar, $baz

The parser actually sees this (the parser knows that = . is like { }):

format =
; formline "@<<<< @>>>>\n", $foo, $bar, $baz;

The lexer makes no effort to make sure that the argument line is con-
tained within formline’s arguments.  To make

{ do_stuff; $foo, bar }

work, the lexer supplies a ‘do’ before the block, if it is
inside a format.

This means that

$a, $b; $c, $d

feeds ($a, $b) to formline, wheras

{ $a, $b; $c, $d }

feeds ($c, $d) to formline.  It also has various other
strange effects:

This script prints "# 0" as I would expect:

print "# ";
format =
(0 and die)

This one, locking parentheses, dies because ‘and’ has low precedence:

print "# ";
format =
0 and die

This does not work:

my $day = "Wed";
format =
({qw[ Sun 0 Mon 1 Tue 2 Wed 3 Thu 4 Fri 5 Sat 6 ]}->{$day})

You have to do this:

my $day = "Wed";
format =
({my %d = qw[ Sun 0 Mon 1 Tue 2 Wed 3 Thu 4 Fri 5 Sat 6 ]; \%d}->{$day})

which is very strange and shouldn’t even be valid syntax.

This does not work, because ‘no’ is not allowed in an expression:

use strict;
$::foo = "bar"
format =
no strict; $foo

Putting a block around it makes it work.  Putting a semicolon before
‘no’ stop it from being a syntax error, but it silently does the
wrong thing.

I thought I could fix all these by putting an implicit do { ... }
around the argument line and removing the special-casing for an open-
ing brace, allowing anonymous hashrefs to work in formats, such
that this:

format =
@<<<< @>>>>
$foo, $bar, $baz

would turn into this:

format =
; formline "@<<<< @>>>>\n", do { $foo, $bar, $baz; };

But that will lead to madness like this ‘working’:

format =

It would also stop lexicals declared in one format line from being
visible in another.

So instead this commit starts being honest with the parser.  We still
have some ‘invented’ tokens, to indicate the start and end of a format
line, but now it is the parser itself that understands a sequence of
format lines, instead of being fed generated code.

So the example above is now presented to the parser like this:

format = ; FORMRBRACK
"@<<<< @>>>>\n" FORMLBRACK $foo, $bar, $baz ; FORMRBRACK
; .

Note about the semicolons:  The parser expects to see a semicolon at
the end of each statement.  So the lexer has to supply one before
FORMRBRACK.  The final dot goes through the same code that handles
closing braces, which generates a semicolon for the same reason.  It’s
easier to make the parser expect a semicolon before the final dot than
to change the } code in the lexer.  We use the } code for . because it
handles the internal variables that keep track of how many nested lev-
els there, what kind, etc.

The extra ;FORMRBRACK after the = is there also to keep the lexer sim-
ple (ahem).  When a newline is encountered during ‘normal’ (as opposed
to format picture) parsing inside a format, that’s when the semicolon
and FORMRBRACK are emitted.  (There was already a semicolon there
before this commit.  I have just added FORMRBRACK in the same spot.)

10 years agoB::Concise: Dump formats upon request
Father Chrysostomos [Wed, 8 Aug 2012 06:16:46 +0000 (23:16 -0700)]
B::Concise: Dump formats upon request

10 years agoB::Concise: Fix -nobanner
Father Chrysostomos [Wed, 8 Aug 2012 05:50:19 +0000 (22:50 -0700)]
B::Concise: Fix -nobanner

It was only working when B::Concise was passed a code ref.

10 years agoIncrease $B::Concise::VERSION to 0.92
Father Chrysostomos [Wed, 8 Aug 2012 05:45:08 +0000 (22:45 -0700)]
Increase $B::Concise::VERSION to 0.92

10 years agotoke.c: Remove unnecessary assignment
Father Chrysostomos [Tue, 7 Aug 2012 20:34:45 +0000 (13:34 -0700)]
toke.c: Remove unnecessary assignment

This was made unnecessary in commit 64a408986cf3d, which changed the
enclosing if block’s protasis to PL_expect == XBLOCK (and also made
sure that PL_expect is set to XBLOCK when a format’s special = delim-
iter is expected).

10 years agoPrevent double frees/crashes with format syntax errs
Father Chrysostomos [Tue, 7 Aug 2012 20:25:24 +0000 (13:25 -0700)]
Prevent double frees/crashes with format syntax errs

This was brought up in ticket #43425.

The new slab allocator for ops (8be227ab5e) makes a CV responsible for
cleaning up its ops if it is freed prematurely (before the root is

Certain syntax errors involving formats can cause the parser to free
the CV owning an op when that op is on the PL_nextval stack.

This happens in these cases:

format =
use; format

format =

format foo require bar

In the first two cases it is the line containing ‘strict’ that is
being interpreted as a format picture line and being fed through
force_next by S_scan_formline.

Then the error condition kicks in after the force, causing a
LEAVE_SCOPE in the parser (perly.c) which frees the sub owning the
const op for the format picture.  Then a token with a freed op is fed
to the parser.

To make this clearer, when the second case above is parsed, the tokens
produced are as follows:

format =
[;] [formline] "@\n" [,]
; use [<word>]
[;] [formline] <freed>
[;] .

Notice how there is an implicit semicolon before each (implicit)
formline.  Notice also how there is an implicit semicolon before the
final dot.

The <freed> thing represents the "strict\n" constant after it has been
freed.  (-DT displays it as THING(opval=op_freed).)

When the implicit semicolon is emitted before a formline, the next two
tokens (formline and the string constant for this format picture line)
are put on to the PL_nextval stack via force_next.

It is when the implicit semicolon before "strict\n" is emitted that
the parser sees the error (there is only one path through the gram-
mar that uses the USE token, and it must have two WORDs following it;
therefore a semicolon after one WORD is an immediate error), calling
LEAVE_SCOPE, which frees the sub created by ‘use’, which owns the
const op on the PL_nextval stack containing the word "strict" and con-
sequently frees it.

I thought I could fix this by putting an implicit do { ... } around
the argument line.  (This would fix another bug, whereby the argument
line in a format can ‘leak out’ of the formline(...).)  But this does
not solve anything, as we end up with four tokens ( } ; formline
const ) on the PL_nextval stack when we emit the implicit semicolon
after ‘use’, instead of two.


will turn into

format =
[;] [formline] "@\n" [,]
[do] [{] ; use [<word>] [;] [}]
[;] [formline] "strict\n"/<freed>
[;] .

It is when the lexer reaches "strict" that it will emit the semicolon
after the use.  So we will be in the same situation as before.

So fixing the fact that the argument line can ‘leak out’ of the
formline and start a new statement won’t solve this particu-
lar problem.

I tried eliminating the LEAVE_SCOPE.  (See
where Dave Mitchell explains that the LEAVE_SCOPE is not strictly nec-
essary, but it is ‘still good to ensure that the savestack gets cor-
rectly popped during error recovery’.)  That does not help, because
the lexer itself does ENTER/LEAVE to make sure form_lex_state and
lex_formbrack get restored properly after the lexer exits the format
(see 583c9d5cccf and 64a408986cf).

So when the final dot is reached, the ‘use’ CV is freed.  Then an op
tree that includes the now-freed "strict\n" const op is passed to
newFORM, which tries to do op_free(block) (as of 3 commits ago; before
that the errors were more catastrophic), and ends up freeing an op
belonging to a freed slab.

Removing LEAVE_SCOPE did actually fix ‘format foo require bar’,
because there is no ENTER/LEAVE involved there, as the = (ENTER) has
not been reached yet.  It was failing because ‘require bar’ would call
force_next for "bar", and then feed a REQUIRE token to the parser,
which would immediately see the error and call LEAVE_SCOPE (free-
ing the format), with the "bar" (belonging to the format’s slab)
still pending.

The final solution I came up with was to reuse an mechanism I came up
with earlier.  Since the savestack may cause ops to outlive their CVs
due to SAVEFREEOP, opslab_force_free (called when an incomplete CV is
freed prematurely) will skip any op with o->op_savestack set.  The
nextval stack can use the same flag.  To make sure nothing goes awry
(we don’t want the same op on the nextval stack and the savestack at
the same time), I added a few assertions.

10 years agotoke.c: Remove TOKENTYPE_GVVAL
Father Chrysostomos [Tue, 7 Aug 2012 12:51:35 +0000 (05:51 -0700)]
toke.c: Remove TOKENTYPE_GVVAL

It has been unused since it was added in bbf60fe6.

10 years agotoke.c: Add missing debug tokens
Father Chrysostomos [Tue, 7 Aug 2012 06:20:14 +0000 (23:20 -0700)]
toke.c: Add missing debug tokens

10 years agoDon’t create formats after compilation errors
Father Chrysostomos [Tue, 7 Aug 2012 04:59:17 +0000 (21:59 -0700)]
Don’t create formats after compilation errors

Otherwise you can end up with a format that has nonsensical op tree,
but it gets attached and you can call it anyway.

10 years agoAdd freed ops to PL_op_(name|desc)
Father Chrysostomos [Tue, 7 Aug 2012 00:52:10 +0000 (17:52 -0700)]
Add freed ops to PL_op_(name|desc)

This is useful for debugging, especially with -DT.

10 years agotoke.c: Fix confused interp-in-format parsing
Father Chrysostomos [Mon, 6 Aug 2012 21:34:25 +0000 (14:34 -0700)]
toke.c: Fix confused interp-in-format parsing

The lexer keeps track of how many levels of brackets it is currently
in (including the = and . delimiting formats, which count as brackets)
in PL_lex_brackets.

When parsing a format, the lexer sets lex_formbrack to the form’s
bracket number.  Whitespace parsing takes note of this, and avoids
reading beyond the end of the current line inside a format, unless it
is in an inner bracketed construct.  So this:

format =
 + $b

treats ‘ + $b’ as a literal string, which becomes the second line
of output.

But this:

format =
{ $a
   + $b }

treats the whole {...} block as the argument for the first format pic-
ture line.

For interpolating (i.e., quoted) constructs, the lexer temporarily
resets the bracket count.  This is so that when it reaches the final
brace in "${...}foo()" it can parse the rest (foo()) as a constant,
rather than a sub call.

When the bracket count was reset, lex_formbrack was left as it was,
resulting in confusion:

# ok
format =
${; use

# also ok
format =
"${; {use
      strict} }"

# syntax error (or crash)
format =
"${; use
     strict }"

# crash
format =
"${ use
    strict }"

When the bracket count is localised and reset at the start of a quoted
construct, we now do the same with lex_formbrack.

10 years agoUpgrade IO-Compress to 2.055
Steve Hay [Wed, 8 Aug 2012 13:15:41 +0000 (14:15 +0100)]
Upgrade IO-Compress to 2.055

10 years agoUpgrade Compress-Raw-Bzip2 and Compress-Raw-Zlib to 2.055
Steve Hay [Wed, 8 Aug 2012 13:09:53 +0000 (14:09 +0100)]
Upgrade Compress-Raw-Bzip2 and Compress-Raw-Zlib to 2.055

10 years agoMAgic for Zlib & Bzip2
Paul [Sat, 4 Aug 2012 15:53:10 +0000 (16:53 +0100)]
MAgic for Zlib & Bzip2

10 years agoignore PERL_XMLDUMP when tainting
Tony Cook [Wed, 8 Aug 2012 11:29:29 +0000 (13:29 +0200)]
ignore PERL_XMLDUMP when tainting

In theory this is a security issue, but from discussion on the
security list that the system perl (or the perl used for anything
critical) is wildly unlikely to have been built with -Dmad.

10 years agoDon't try to set perms in makerel on files which no longer exist
Steve Hay [Wed, 8 Aug 2012 08:22:40 +0000 (09:22 +0100)]
Don't try to set perms in makerel on files which no longer exist

10 years agoAdd /Module/CoreList/ to lib/.gitignore
Steve Hay [Wed, 8 Aug 2012 08:12:00 +0000 (09:12 +0100)]
Add /Module/CoreList/ to lib/.gitignore

10 years agoAllow .tgz as a recognized suffix in core-cpan-diff
Steve Hay [Wed, 8 Aug 2012 07:47:51 +0000 (08:47 +0100)]
Allow .tgz as a recognized suffix in core-cpan-diff
otherwise Memoize-1.03.tgz gets skipped.

10 years agoNote that core-cpan-diff always requires diff(1), even without --diff
Steve Hay [Wed, 8 Aug 2012 07:44:59 +0000 (08:44 +0100)]
Note that core-cpan-diff always requires diff(1), even without --diff

10 years agoUse _strtoi64, _strtoui64 and _atoi64 for WIN64 VC++ builds
Steve Hay [Tue, 7 Aug 2012 07:53:42 +0000 (08:53 +0100)]
Use _strtoi64, _strtoui64 and _atoi64 for WIN64 VC++ builds

VC++ has QUADKIND == QUAD_IS___INT64 so the "secret handshakes" were only
getting used for WIN64 GCC builds (where QUADKIND == QUAD_IS_LONG_LONG).

10 years agoVC++ has QUADKIND == QUAD_IS___INT64 so we might as well make use of it
Steve Hay [Tue, 7 Aug 2012 07:49:09 +0000 (08:49 +0100)]
VC++ has QUADKIND == QUAD_IS___INT64 so we might as well make use of it

- Use I64/UI64 suffixes rather than I64TYPE/U64TYPE casts for
  INT64_C/UINT64_C, not just when _WIN64 is defined
- Use UI64 suffix rather than UL for U64_CONST

10 years agoData::Dumper: Updated changelog
Steffen Mueller [Tue, 7 Aug 2012 06:48:08 +0000 (08:48 +0200)]
Data::Dumper: Updated changelog

10 years agoData::Dumper: Fix tests for pure-Perl implementation
Steffen Mueller [Tue, 7 Aug 2012 06:45:56 +0000 (08:45 +0200)]
Data::Dumper: Fix tests for pure-Perl implementation

Father Chrysostomos fixed vstring handling in both XS and pure-Perl
implementations of Data::Dumper in

He also updated the tests for the default XS implementation, but it seems
that he missed the test changes necessary for the pure-Perl implementation
which now also does the right thing.

10 years agoDelta entry for Data::Dumper optimization
Steffen Mueller [Mon, 6 Aug 2012 18:14:47 +0000 (20:14 +0200)]
Delta entry for Data::Dumper optimization

10 years agoData::Dumper: Fix to use with earlier Perls
Karl Williamson [Mon, 6 Aug 2012 17:27:53 +0000 (11:27 -0600)]
Data::Dumper: Fix to use with earlier Perls

Commit 4b88fb76efce8c436e63b907c9842345d4fa77c7 broke Data::Dumper when
it is used on Perl versions earlier than v5.16.

10 years agocv.h: macro parentheses
Father Chrysostomos [Mon, 6 Aug 2012 21:03:31 +0000 (14:03 -0700)]
cv.h: macro parentheses

I forgot about -- having higher precedence than unary *.  And then
I forgot to test it, convincing myself I had. :-(

10 years agoNested formats
Father Chrysostomos [Mon, 6 Aug 2012 16:48:07 +0000 (09:48 -0700)]
Nested formats

Are nested formats a good idea?  Probably not.  But the only rea-
son they don’t work is that the parser becomes confused and loses
track of where it is.

And it would be nice to have some consistency.  I can put sub defini-
tions inside a format:

format =
;sub foo {


format =
    sub foo {

so why not these?

format foo =
;format bar =

format foo =
    format bar =

In perl 5.17.2 and earlier, you can nest formats, but, due to the
parser being confused, the outer format must be terminated with }
instead of a dot.  That stopped working with commit 7c70caa5333.

format =
"Just another"; format STDERR =
"Perl hacker"
write; select STDERR;

10 years agotoke.c: move leftbracket label
Father Chrysostomos [Mon, 6 Aug 2012 15:41:07 +0000 (08:41 -0700)]
toke.c: move leftbracket label

The only code path that goesto leftbracket was precede by s--.
The first thing leftbracket did was s++.

We can simplify the code slighty by moving the label down one
statement and not s--ing before goingto leftbracket.

10 years ago[perl #114040] Parse formats in interpolating constructs
Father Chrysostomos [Mon, 6 Aug 2012 15:38:28 +0000 (08:38 -0700)]
[perl #114040] Parse formats in interpolating constructs

For re-evals, this is something that broke recently, post-5.16 (the
jumbo fix).  For other interpolating constructs, this has never
worked, as far as I can tell.

The lexer was losing track of PL_lex_state (aka PL_parser->lex_state)
when parsing formats.  Usually, the state alternates between
LEX_FORMLINE (a picture line) and LEX_NORMAL (an argument line), but
the LEX_NORMAL should actually be whatever the state was before the
format started.

This commit adds a new parser member to track the ‘normal’ state when
parsing a format.

It also tweaks S_scan_formline to handle multi-line buffers outside of
string eval (such as happens in interpolating constructs).

That bufend assignment that is removed as a result is not necessary as
of a0d0e21ea6ea (perl 5.000).  That very commit added a bufend assign-
ment after the sv_gets (later filter_gets; later lex_next_chunk) fur-
ther down in the loop in scan_formline.

10 years agoUpdate notes on which Cygwin tools are needed to make a release on Windows
Steve Hay [Mon, 6 Aug 2012 17:10:37 +0000 (18:10 +0100)]
Update notes on which Cygwin tools are needed to make a release on Windows

( no longer uses curl, diffstat is no longer required to produce
the list of acknowledgements and 7z should be used to create smaller
tarballs. Also, core-cpan-diff no longer uses wget.)

10 years agoRestore parts of config_H.gc lost by regen_config_h
Steve Hay [Mon, 6 Aug 2012 08:02:50 +0000 (09:02 +0100)]
Restore parts of config_H.gc lost by regen_config_h

10 years agoRun regen_config_h for GCC
Steve Hay [Mon, 6 Aug 2012 07:58:07 +0000 (08:58 +0100)]
Run regen_config_h for GCC

A few new symbols are added but no existing ones are changed.

10 years agoRun regen_config_h for VC++
Steve Hay [Mon, 6 Aug 2012 07:57:44 +0000 (08:57 +0100)]
Run regen_config_h for VC++

A few new symbols are added but no existing ones are changed.

10 years agoData::Dumper: Import more change history
Steffen Mueller [Fri, 3 Aug 2012 05:52:21 +0000 (07:52 +0200)]
Data::Dumper: Import more change history

10 years agoForbid braces as format delimiters
Father Chrysostomos [Mon, 6 Aug 2012 05:24:09 +0000 (22:24 -0700)]
Forbid braces as format delimiters

As long the argument line is not missing, braces can be used
for a format:

# valid
format foo {

but if the argument line is missing, you get a syntax error:

# invalid
format foo {

and also if the name is missing:

# invalid
format {

If you use = then you can use a closing brace to terminate the format,
but only if the argument line is missing:

# valid, but useless
format =

# invalid
format =

In commit 79072805 (perl 5.0 alpha 20), the lexer was changed to lie
to the parser about formats’ = and . delimiters, pretending they are
actually { and }, because the bracket-handling code takes care of all
the scoping issues (well, most of them).

Unfortunately, this implementation detail can leak through, but it is
far from consistent, as shown above.

Fixing this makes it easier to fix other bugs.

We do this by recording the fact that we are dealing with a format
token before jumping to the bracket code.  And we feed format-specific
tokens to the parser in that case, so it can’t get fake brackets and
real brackets mixed up.

10 years agoassert_(...)
Father Chrysostomos [Mon, 6 Aug 2012 00:22:29 +0000 (17:22 -0700)]

This new macro expands to ‘assert(...),’ (with a trailing comma) under
debugging builds; the empty string otherwise.

It allows for the removal of some #ifdef DEBUGGINGs, which could not be
avoided otherwise.

10 years agoFix a typo in perlootut
Dave Rolsky [Mon, 6 Aug 2012 02:00:49 +0000 (21:00 -0500)]
Fix a typo in perlootut

10 years agoDon’t crash when undefining handle of active format
Father Chrysostomos [Sun, 5 Aug 2012 20:13:12 +0000 (13:13 -0700)]
Don’t crash when undefining handle of active format

format FOO =
undef *STDOUT
$~ = FOO;

Commit 7ef822cddfe9 began the work by putting in a null check and a
goto (to bypass the top format), but the goto wentto some code that
lacked the null check.  (It did actually fix the case of a IO with no
ofp, but not the case of a GV with no IO.)  Interestingly, it added a
bad_ofp label, but did not add the code to goto it (an oversight?).

The unused bad_ofp label was commented out in commit 9cbac4c72b52.

There was already a check before 7ef822cddfe9 to see whether there was
an ofp, but only after the format scope has been popped.

This commit extends that check by making sure there is an io first.

It removes the commented-out bad_ofp label.

10 years agoMake glob.t more resilient
Father Chrysostomos [Sun, 5 Aug 2012 19:41:48 +0000 (12:41 -0700)]
Make glob.t more resilient

It was not tolerating editor temp files with spaces in their
names.  It was testing the output of <op/*> by comparing it with
split /\s/, `echo op/*` on non-Windows non-VMS systems (Unix).
`ls op/* | cat` produces more machine-friendly output, so use that.

10 years agoparser.t: Move tests above ‘Add tests here’
Father Chrysostomos [Sun, 5 Aug 2012 19:28:51 +0000 (12:28 -0700)]
parser.t: Move tests above ‘Add tests here’

10 years agoDon’t let active formats be freed
Father Chrysostomos [Sun, 5 Aug 2012 19:15:18 +0000 (12:15 -0700)]
Don’t let active formats be freed

This crashes:

format FOO =
undef *FOO
$~ = FOO;

The context stack needs to hold a reference count for formats, just as
it does for subs.

10 years agoFix Devel::Peek’s tests for format changes
Father Chrysostomos [Sun, 5 Aug 2012 18:24:26 +0000 (11:24 -0700)]
Fix Devel::Peek’s tests for format changes

10 years agoRecursive formats and closures in formats.
Father Chrysostomos [Sun, 5 Aug 2012 08:05:45 +0000 (01:05 -0700)]
Recursive formats and closures in formats.

Formats called recursively were using the same set of lexicals, so the
inner call would stomp on the outer calls vars, usually clearing them
when exiting.

Previous commits prepared a CvDEPTH field for formats.  This commit
sets it in P(USH|OP)FORMAT and pushes a new pad in enterwrite.

This also allows closures to work properly in formats.  Formerly they
caused assertion failures in cv_clone.  Now cv_clone’s assumptions
about CvDEPTH on CvOUTSIDE and find_runcv are met when subs are embed-
ded in formats.

10 years agoAdd a depth field to formats
Father Chrysostomos [Sun, 5 Aug 2012 07:48:00 +0000 (00:48 -0700)]
Add a depth field to formats

Instead of lengthening the struct, we can reuse SvCUR, which is cur-
rently unused.

10 years agoDisallow setting SvPV on formats
Father Chrysostomos [Sun, 5 Aug 2012 07:34:11 +0000 (00:34 -0700)]
Disallow setting SvPV on formats

Setting a the PV on a format is meaningless, as of the previ-
ous commit.

This frees up SvCUR for other uses.

10 years agoMake PL_(top|body|form)target PVIVs
Father Chrysostomos [Sun, 5 Aug 2012 07:15:52 +0000 (00:15 -0700)]
Make PL_(top|body|form)target PVIVs

These are only used for storing a string and an IV.

Making them into full-blown SVt_PVFMs is overkill.

FmLINES was only being used on these three scalars.  So make it use
the SvIVX field.  struct xpvfm no longer needs an xfm_lines member,
because SVt_PVFMs no longer use it.

This also causes a TODO test in taint.t to start passing, but I do
not fully understand why.  But at least that’s progress. :-)

10 years ago[perl #78550] Fix bad assertion in toke.c:start_subparse
Father Chrysostomos [Sun, 5 Aug 2012 01:01:01 +0000 (18:01 -0700)]
[perl #78550] Fix bad assertion in toke.c:start_subparse

The outer ‘sub’ might actually be a format

10 years agopad.c:cv_clone: Rmv irrelevent part of comment
Father Chrysostomos [Sun, 5 Aug 2012 00:57:21 +0000 (17:57 -0700)]
pad.c:cv_clone: Rmv irrelevent part of comment

10 years agopad.c:cv_clone: add assertions
Father Chrysostomos [Sun, 5 Aug 2012 00:54:32 +0000 (17:54 -0700)]
pad.c:cv_clone: add assertions

The outer sub should always be active and have a pad if it is
a sub that is being cloned.  Only formats can have an inactive or
padless outside.  Add assertions to that effect.

10 years agoClose over stale vars in active subs
Father Chrysostomos [Sat, 4 Aug 2012 21:42:47 +0000 (14:42 -0700)]
Close over stale vars in active subs

\$x and sub { $x }->() should never produce different values.  But
this used to be possible because sub cloning (which happens with
sub{...}) was written to avoid closing over variables that are not
active.  Not closing over inactive variables makes sense in cases like
this (because the variable doesn’t really exist yet):

sub {
    my $x;
    sub foo {

but the logic breaks down in cases like this (which was printing 3
only on the first print):

sub foo {
    my $x;
    sub bar {
        $x = 3;
        print $x, "\n";
        sub { print $x, "\n" }->()

If bar can see a scalar named $x (even if it is questionable),
sub { $x }->() should jolly well see the same scalar as the immedi-
ately enclosing sub.

The only case where a run-time cloning of a CV should refuse to close
over the same scalar that the outer sub sees is when the outer sub is
not running.  That only happens with formats:

sub f {
    my $x;
    format =
write STDOUT;

As of this commit, it does only happen with formats.

The actual cases of subs refusing to close over stale variables in
active parents have changed twice since 5.10.0.  See the comments in
the tests.

10 years agosv.c:varname: Fix bad assertion added by c6fb3f6e
Father Chrysostomos [Sat, 4 Aug 2012 17:16:01 +0000 (10:16 -0700)]
sv.c:varname: Fix bad assertion added by c6fb3f6e

#!perl -w
my $x;
format =
Assertion failed: (!cv || SvTYPE(cv) == SVt_PVCV), function Perl_varname, file sv.c, line 13924.
Abort trap

10 years agoRemove CR characters from raw input in op/magic.t on Windows
Steve Hay [Sat, 4 Aug 2012 13:01:27 +0000 (14:01 +0100)]
Remove CR characters from raw input in op/magic.t on Windows

The :raw input added by e2e1d5ce8b broke tests on Windows by introducing
unexpeted CR characters.

Two tests (154 and 157) currently still fail on Windows if the (DOS)
command prompt is using a different code page to perl's native (Windows)
character set.

10 years agoModule::CoreList: Automatically add aliases for releases
David Leadbeater [Sun, 29 Jul 2012 12:12:03 +0000 (13:12 +0100)]
Module::CoreList: Automatically add aliases for releases

When the release in numeric and conventional written form differ add an
alias for the formatted variant automatically.

10 years agoStore version information as a delta in Module::CoreList
David Leadbeater [Sun, 29 Jul 2012 00:39:05 +0000 (01:39 +0100)]
Store version information as a delta in Module::CoreList

This reduces the size of the file by storing the difference
between the versions of perl rather than a full list for each version.

In order to achieve this without changing the interface each key in the
%version hash is tied to a special tied hash that inflates the stored
difference data to the full list of modules and versions.

As part of the upgrade I ran a comparison with the
%version hash in the current Module::CoreList -- there are no

10 years agoavoid decoding on input in the new tests added in 613c63b4
Tony Cook [Sat, 4 Aug 2012 03:53:38 +0000 (13:53 +1000)]
avoid decoding on input in the new tests added in 613c63b4

This fixes these tests when run in a unicode environment, eg:

  PERL_UNICODE= LC_ALL=en_AU.utf8 ./perl op/magic.t

This does fix tha code page related issue on Win32.

10 years ago[perl #114222] Make ‘use’ parse arguments in term context
Father Chrysostomos [Sat, 4 Aug 2012 01:35:26 +0000 (18:35 -0700)]
[perl #114222] Make ‘use’ parse arguments in term context

(lexing context, that is)

use constant { () }

was a syntax error, because the lexer was guessing when { should be
a statement or hash.

It should not be doing that where a term is expected.

It was actually getting itself confused, and trying to parse the
argument list as a statement.

Setting PL_expect after force_next is ineffectual, as force_next
records the current value of PL_expect, arranging to have it

OPERATOR(USE) was setting PL_expect, but too late.  So no we set
PL_expect explicitly in S_tokenize_use, before any forced tokens,
and use TOKEN(USE), which does not set PL_expect (as setting it
there has no effect).

10 years agoperlexperiment.pod clarifications
Reini Urban [Sun, 15 Jul 2012 17:15:45 +0000 (12:15 -0500)]
perlexperiment.pod clarifications

Removed in Perl is misleading. Those modules just moved to CPAN and are not deprecated.
threads are now ithreads since multiplicity.

10 years agoPod-Functions requires that Pod-Escapes be built to build
Tony Cook [Fri, 3 Aug 2012 13:33:10 +0000 (23:33 +1000)]
Pod-Functions requires that Pod-Escapes be built to build

Discovered doing a parallel build on OpenBSD, reproducible elsewhere

  ./Configure ... && make ext/Pod-Functions/pm_to_blib

While Pod-Escapes is a dependency of Pod-Simple, the Pod-Simple build
process doesn't require that Pod-Escapes already be built, while the
Pod-Functions build process does.

10 years agoFix RT [perl #72156] Re: Perl 5.12.0 RC 0 - Pager detection
Andy Dougherty [Thu, 2 Aug 2012 18:59:55 +0000 (14:59 -0400)]
Fix RT [perl #72156] Re: Perl 5.12.0 RC 0 - Pager detection

Instruct ./getfile to trust the default pager value.  It might not begin
with a slash, or it might include some options, such as
"/usr/bin/less -R".
This is based on commit 53ddb3ba3e23ab80444c30b4deefa64114408438 in
the metaconfig repository.

10 years agoData::Dumper: Comment on previous optimization
Steffen Mueller [Thu, 2 Aug 2012 18:24:40 +0000 (20:24 +0200)]
Data::Dumper: Comment on previous optimization

The optimization in the previous commit to Data::Dumper (sparse seen
hash) is not complete: It is so far only applied to non-RV SVs. This
also means that it's safe not to check for weak-refs. Applying the
optimization to RVs should be possible, but is not as easy (I think).

10 years agoData::Dumper: Option to avoid building much of the seen hash
Steffen Mueller [Thu, 2 Aug 2012 16:51:19 +0000 (18:51 +0200)]
Data::Dumper: Option to avoid building much of the seen hash

If the "$Sparseseen" option is set by the user, Data::Dumper eschews
building the seen-this-scalar hash for ALL SCALARS but instead just adds
those that have a refcount > 1. Since the seen hash is exposed
to the user in the OO interface (rats!), this needs to be opt-in in if
OO is used.

If the DD constructor is called from Dumpxs (because the user used the
functional interface as customary), then this option could be
implicitly enabled in those cases as the seen hash is never visible to
the user.

In my real-world-data benchmark, setting this option speeds up
serialization by about 50%!

This is really Yves Orton's idea. I'm just the code monkey on this one.

10 years agoperldelta for unterminated here-docs
Father Chrysostomos [Thu, 2 Aug 2012 17:01:43 +0000 (10:01 -0700)]
perldelta for unterminated here-docs

10 years ago[perl #114104] Better error for unterminated heredoc delim
Father Chrysostomos [Thu, 2 Aug 2012 16:52:27 +0000 (09:52 -0700)]
[perl #114104] Better error for unterminated heredoc delim

10 years agoperldelta for #114340
Father Chrysostomos [Thu, 2 Aug 2012 05:36:48 +0000 (22:36 -0700)]
perldelta for #114340

10 years agoperldelta for Storable and vstrings
Father Chrysostomos [Thu, 2 Aug 2012 05:31:15 +0000 (22:31 -0700)]
perldelta for Storable and vstrings

10 years agoperldelta for given aliasing $_
Father Chrysostomos [Thu, 2 Aug 2012 05:03:34 +0000 (22:03 -0700)]
perldelta for given aliasing $_

10 years agoregcomp.c: Remove unnecessary variable
Karl Williamson [Thu, 2 Aug 2012 00:28:59 +0000 (18:28 -0600)]
regcomp.c: Remove unnecessary variable

This variable was used because another was declared 'register'.  But
that declaration was removed by commit
e1d1eefb8c88e0dcaf2bb9e6c04d7f6192be966f in 2007, making the temporary
variable redundant.

10 years agoregcomp.c: inline trivial static function
Karl Williamson [Wed, 1 Aug 2012 23:04:13 +0000 (17:04 -0600)]
regcomp.c: inline trivial static function

10 years agoregcomp.c: Fix \N{} multi-char fold buffer boundary bug
Karl Williamson [Wed, 1 Aug 2012 21:12:23 +0000 (15:12 -0600)]
regcomp.c: Fix \N{} multi-char fold buffer boundary bug

An earlier commit in this topic branch fixed the bug (for non-\N{})
cases where a multi-character fold could try to span two EXACTFish
nodes, where they are split because the first one would otherwise
contain too long a string.

This commit extends that fix to include characters entered via \N{...}.
It does this by causing \N handling to be split, so that if the \N
resolves to a single code point, it goes through the normal processing,
so that it no longer bypasses the code that was added in the earlier

10 years agoregcomp.c: Revise API for static function
Karl Williamson [Wed, 1 Aug 2012 20:49:39 +0000 (14:49 -0600)]
regcomp.c: Revise API for static function

This is to allow future changes.   The function now returns success or
failure, and the created regnode (if any) is set via a parameter

I removed the 'register' declaration to get this to work, because
such declarations are considered bad form these days, e.g.,

10 years agoregcomp.c: Fix multi-char fold bug
Karl Williamson [Mon, 18 Jun 2012 19:09:38 +0000 (13:09 -0600)]
regcomp.c: Fix multi-char fold bug

Input text to be matched under /i is placed in EXACTFish nodes.  The
current limit on such text is 255 bytes per node.  Even if we raised
that limit, it will always be finite.  If the input text is longer than
this, it is split across 2 or more nodes.  A problem occurs when that
split occurs within a potential multi-character fold.  For example, if
the final character that fits in a node is 'f', and the next character
is 'i', it should be matchable by LATIN SMALL LIGATURE FI, but because
Perl isn't structured to find multi-char folds that cross node
boundaries, we will miss this it.

The solution presented here isn't optimum.  What we do is try to prevent
all EXACTFish nodes from ending in a character that could be at the
beginning or middle of a multi-char fold.  That prevents the problem.
But in actuality, the problem only occurs if the input text is actually
a multi-char fold, which happens much less frequently.  For example,
we try to not end a full node with an 'f', but the problem doesn't
actually occur unless the adjacent following node begins with an 'i' (or
one of the other characters that 'f' participates in).  That is, this
patch splits when it doesn't need to.

At the point of execution for this patch, we only know that the final
character that fits in the node is that 'f'.  The next character remains
unparsed, and could be in any number of forms, a literal 'i', or a hex,
octal, or named character constant, or it may need to be decoded (from
'use encoding').  So look-ahead is not really viable.

So finding if a real multi-character fold is involved would have to be
done later in the process, when we have full knowledge of the nodes, at
the places where join_exact() is now called, and would require inserting
a new node(s) in the middle of existing ones.

This solution seems reasonable instead.

It does not yet address named character constants (\N{}) which currently
bypass the code added here.

10 years agomktables: Generate tables for chars that aren't in final fold pos
Karl Williamson [Mon, 18 Jun 2012 18:55:42 +0000 (12:55 -0600)]
mktables: Generate tables for chars that aren't in final fold pos

This starts with the existing table that mktables generates that lists
all the characters in Unicode that occur in multi-character folds, and
aren't in the final positions of any such fold.

It generates data structures with this information to make it quickly
available to code that wants to use it.  Future commits will use these

10 years agoregen/mk_invlists: Add mode to generate above-Latin1 only
Karl Williamson [Mon, 18 Jun 2012 18:44:55 +0000 (12:44 -0600)]
regen/mk_invlists: Add mode to generate above-Latin1 only

This change adds the ability to specify that an output inversion list is
to contain only those code points that are above Latin-1.  Typically,
the Latin-1 ones will be accessed from some other means.

10 years agoUnicode::UCD::prop_invlist() Allow to return internal property
Karl Williamson [Mon, 18 Jun 2012 18:38:41 +0000 (12:38 -0600)]
Unicode::UCD::prop_invlist() Allow to return internal property

This creates an optional undocumented parameter to this function to
allow it to return the inversion list of an internal-only Perl property.
This will be used by other functions in Perl, but should not be
documented, as we don't want to encourage the use of internal-only
properties, which are subject to change or removal without notice.

10 years agomktables: Add comment to gen'd data file
Karl Williamson [Mon, 18 Jun 2012 18:37:52 +0000 (12:37 -0600)]
mktables: Add comment to gen'd data file

10 years agomktables: grammar in comments
Karl Williamson [Mon, 18 Jun 2012 18:22:41 +0000 (12:22 -0600)]
mktables: grammar in comments

10 years agoregen/ Remove obsolete code
Karl Williamson [Mon, 18 Jun 2012 18:20:42 +0000 (12:20 -0600)]
regen/ Remove obsolete code

Octals are no longer checked via this mechanism.

10 years agoregcomp.c: Make invlist_search() usable from re_comp.c
Karl Williamson [Mon, 18 Jun 2012 17:51:43 +0000 (11:51 -0600)]
regcomp.c: Make invlist_search() usable from re_comp.c

This was a static function which I couldn't get to be callable from the
debugging version of regcomp.c.  This makes it public, but known only
in the regcomp.c source file.  It changes the name to begin with an
underscore so that if someone cheats by adding preprocessor #defines,
they still have to call it with the name that convention indicates is a
private function.

10 years agoperlop:clarify wording
Karl Williamson [Mon, 18 Jun 2012 17:41:18 +0000 (11:41 -0600)]
perlop:clarify wording

10 years agoregcomp.c: Rename static fcn to better reflect its purpose
Karl Williamson [Sun, 17 Jun 2012 02:02:07 +0000 (20:02 -0600)]
regcomp.c: Rename static fcn to better reflect its purpose

This function handles \N of any ilk, not just named sequences.

10 years agoregcomp.c: Make comment more accurate
Karl Williamson [Sun, 17 Jun 2012 01:55:15 +0000 (19:55 -0600)]
regcomp.c: Make comment more accurate

10 years agoregcomp.c: Can now do /u instead of forcing to utf8
Karl Williamson [Sun, 17 Jun 2012 01:52:12 +0000 (19:52 -0600)]
regcomp.c: Can now do /u instead of forcing to utf8

Now that there is a /u modifier, a regex doesn't have to be in UTF-8 in
order to force Unicode semantics.  Change this relict from the past.

10 years agoregcomp.c: Comments update
Karl Williamson [Wed, 6 Jun 2012 21:02:43 +0000 (15:02 -0600)]
regcomp.c: Comments update

This adds some comments and white-space lines, and updates other
comments to account for the fact that trie handling has changed since
they were written.

10 years agoregcomp.c: Remove variable whose value needed just once
Karl Williamson [Mon, 28 May 2012 16:49:37 +0000 (10:49 -0600)]
regcomp.c: Remove variable whose value needed just once

Previous commits have removed all but one instance of using this
variable, so just use the expression it equates to.

10 years agoregcomp.c: White-space only
Karl Williamson [Mon, 28 May 2012 16:42:03 +0000 (10:42 -0600)]
regcomp.c: White-space only

This indents and outdents to compensate for newly formed and orphan
blocks, respectively; and reflows comments to fit in 80 columns

10 years agoregcomp.c: Trade stack space for time
Karl Williamson [Sun, 27 May 2012 07:08:46 +0000 (01:08 -0600)]
regcomp.c: Trade stack space for time

Pass 1 of regular expression compilation merely calculates the size it
will need. (Note that Yves and I both think this is very suboptimal
behavior.)  Nothing is written out during this pass, but sizes are
just incremented.  The code in regcomp.c all knows this, and skips
writing things in pass 1.  However, when folding, code in other files is
called which doesn't have this size-only mode, and always writes its
results out.  Currently, regcomp handles this by passing to that code a
temporary buffer allocated for the purpose.  In pass1, the result is
simply ignored; in pass2, the results are copied to the correct final

We can avoid that copy by making the temporary buffer large enough to
hold the whole node, and in pass1, use it instead of the node.  The
non-regcomp code writes to the same relative spot in the buffer that it
will use for the real node.  In pass2 the real destination is used, and
the fold gets written directly to the correct spot.

Note that this increases the size pushed onto the stack, but code is
ripped out as well.

However, the main reason I'm doing this is not this speed-up; it is
because it is needed by future commits to fix a bug.

10 years agoregcomp.c: Use mnemonic not numeric constant
Karl Williamson [Sun, 27 May 2012 07:04:39 +0000 (01:04 -0600)]
regcomp.c: Use mnemonic not numeric constant

Future commits will add other uses of this number.

10 years agoregcomp.c: Resolve EBCDIC inconsistency towards simpler
Karl Williamson [Sun, 27 May 2012 04:19:22 +0000 (22:19 -0600)]
regcomp.c: Resolve EBCDIC inconsistency towards simpler

This code has assumed that to_uni_fold() returns its folds in Unicode
(i.e.  Latin1) rather than native EBCDIC.  Other code in the core
assumes the opposite.  One has to change.  I'm changing this one, as the
issues should be dealt with at the lowest level possible, which is in
to_uni_fold().  Since we don't currently have an EBCDIC platform to test
on, making sure that it all hangs together will have to be deferred
until such time as we do.

By doing this we make this code simpler and faster.  The fold has
already been calculated, we just need to copy it to the final place
(done in pass2).

10 years agoregcomp.c: Use function instead of repeating its code
Karl Williamson [Sun, 27 May 2012 03:39:32 +0000 (21:39 -0600)]
regcomp.c: Use function instead of repeating its code

A new flag to to_uni_fold() causes it to do the same work that this code
does, so just call it.

10 years agoregcomp.c: Remove (almost) duplicate code
Karl Williamson [Sat, 26 May 2012 20:19:18 +0000 (14:19 -0600)]
regcomp.c: Remove (almost) duplicate code

A previous commit opened the way to refactor this so that the two
fairly lengthy code blocks that are identical (except for changing the
variable <len>) can have one of them removed.