perl.git
6 years agoMerge branch 'khw/invlist' into blead
Karl Williamson [Wed, 25 Jul 2012 03:14:46 +0000 (21:14 -0600)] 
Merge branch 'khw/invlist' into blead

This topic branch deals mostly with bracketed character classes in
regular expressions.  It has several main thrusts:

1) The character class macros in handy.h are tied to the class numbers
   in regcomp.h, and a new set of regnode types, POSIX, are introduced.
   This will allow more table driven code in regular expression
   compilation and matching, so that the same regnode type can be used
   for any of the Posix-like character classes, such as \w as well as
   [:upper:].  This will allow removal of nearly-duplicate (and
   triplicate, etc) code.

2) The optimizations for bracketed character classes are extended to
   work off not just the first 256 characters, but all code points.
   This extends some char class optimizations to Unicode, and will
   allow future work to change the regular expression optimizer to work
   off all Unicode characters, instead of its current behavior of mostly
   giving up on these.

3) Several new character class optimizations are introduced, with the
   groundwork laid for more.  A character class containing a single
   character is the same as the single character without the class,
   except that most metacharacters are treated as literals.  Thus,
   /a[.]b/ produces identical results to /a\.b/.  Prior to this merge,
   the first form's compiled version would require quite a bit more
   space than the second.  Now they are identical.

Inversion lists of the whole class are used for optimization
   calculations.

6 years agoregcomp.c: Revise bracketed char class optimizations
Karl Williamson [Mon, 23 Jul 2012 04:37:21 +0000 (22:37 -0600)] 
regcomp.c: Revise bracketed char class optimizations

This commit uses the inversion list instead of the bit map constructed
during compilation of [bracketed classes] for determining the
optimizations that are done at the very end of processing the class.
This provides optimizations for things that can't be seen by just
looking at the bitmap.

There are optimizations done earlier in the code for things
that can be easily caught in Pass 1, but now we have complete
information.  At this time, I'm not repeating checking for most
optimizations that are checked for earlier, though this could be added.
The earlier optimizations could overlook cases where someone specified a
class in a suboptimal way.  For example the earlier code looks for a
class with a single range [0-9], but those 10 code points could instead
have been specified via [0123456789], and the code doesn't catch that
currently; here we could, but I'm not doing so at this time.

The code does do some duplicate checking.  For example, some Unicode
properties match only a single code point, such as lb=cr, and these
aren't known at the earlier point where single code point classes are
checked for.

6 years agoregcomp.c: Fix <if> condition
Karl Williamson [Mon, 23 Jul 2012 04:09:21 +0000 (22:09 -0600)] 
regcomp.c: Fix <if> condition

The else clause is expecting that the regex is compiled under /d, when
in fact, until this commit, it could also be under /l.  I could not come
up with a case currently where this distinction matters, but it's best
to not tempt fate.

6 years agoregcomp.c: Add _invlist_contains_cp
Karl Williamson [Mon, 23 Jul 2012 04:00:46 +0000 (22:00 -0600)] 
regcomp.c: Add _invlist_contains_cp

This simply searches an inversion list without going through a swash.
It will be used in a future commit.

6 years agoutf8.c: Add a get_() method to hide internal details
Karl Williamson [Wed, 25 Jul 2012 02:53:41 +0000 (20:53 -0600)] 
utf8.c: Add a get_() method to hide internal details

This should have been written this way to begin with (I'm the culprit).
But we should have a method so another routine doesn't have to know the
internal details.

6 years agoregcomp.c: Optimize /[[:blank:]]/u into \h
Karl Williamson [Fri, 20 Jul 2012 17:39:09 +0000 (11:39 -0600)] 
regcomp.c: Optimize /[[:blank:]]/u into \h

These two are equivalent.

6 years agoregcomp.c: Properly count elements in [] for false ranges
Karl Williamson [Fri, 20 Jul 2012 17:35:07 +0000 (11:35 -0600)] 
regcomp.c: Properly count elements in [] for false ranges

When something that looks like a range turns out not to be, the hyphen
is matched literally, and so is a separate element in the character
class.  It needs to be accounted as such.

6 years agoregcomp.c: Use POSIXA, NPOSIXA
Karl Williamson [Fri, 20 Jul 2012 16:23:14 +0000 (10:23 -0600)] 
regcomp.c: Use POSIXA, NPOSIXA

This commit optimizes character classes which are matched under /a or
/aa and consist of a single Posix class, into POSIXA or NPOSIXA regop
types.  For example /[[:word:]]/a.  Since [:ascii:] is always
ascii-restricted no matter what the charset modifier is, it is always
optimized.

These nodes should execute somewhat faster than a generic ANYOF node,
and are significantly smaller, taking 2 bytes instead of 12.

The flags field of the node structure is used to hold an enum indicating
which of the 15 Posix classes is being matched.

6 years agoregcomp.sym: Add new node types POSIXA and NPOSIXA
Karl Williamson [Fri, 20 Jul 2012 16:02:23 +0000 (10:02 -0600)] 
regcomp.sym: Add new node types POSIXA and NPOSIXA

These will be used to handle things like /[[:word:]]/a.  This patch
doesn't add the code to actually use these.  That will be done in a
future patch.

Also, placeholders POSIXD, POSIXL, and POSIXU are also added for future
use.

6 years agoregcomp.h: Use handy.h constants
Karl Williamson [Mon, 9 Jul 2012 21:17:28 +0000 (15:17 -0600)] 
regcomp.h: Use handy.h constants

This synchronizes the ANYOF_FOO usages to the isFOO() usages.  Future
commits will take advantage of this relationship.

6 years agohandy.h: Free up bits in PL_charclass[]
Karl Williamson [Fri, 20 Jul 2012 03:53:06 +0000 (21:53 -0600)] 
handy.h: Free up bits in PL_charclass[]

This array is a bit map containing the Posix and similar character
classes for the first 256 code points.  Prior to this commit many
character classes were represented by two bits, one for characters that
are in it over the full Latin-1 range, and one for just the ASCII
characters that are in it.  The number of bits in use was approaching
the 32-bit limit available without playing games.

This commit takes advantage of a recent commit that adds a bit to the
table for all the ASCII characters, and the fact that the ASCII
characters in a character class are a subset of the full Latin1
range.  So, iff both the full-range character class bit and the ASCII
bit is set is that character an ASCII-range character with the given
character class.

A new internal macro is created to generate code to determine if a
character is an ASCII range character with the given class.  It's not
clear if the generated code is faster or slower than the full range
version.

The result is that nearly half the bits are freed up, as the ones for
the ASCII-range are now redundant.

6 years agohandy.h: Add intermediate internal macro
Karl Williamson [Fri, 20 Jul 2012 03:47:48 +0000 (21:47 -0600)] 
handy.h: Add intermediate internal macro

This macro abstracts an operation, and will make future commits cleaner.

6 years agoregcomp.c: Relax some restrictions on optimizations for locale
Karl Williamson [Tue, 10 Jul 2012 04:00:16 +0000 (22:00 -0600)] 
regcomp.c: Relax some restrictions on optimizations for locale

Prior to this commit, we didn't do any inversions for bracketed
character classes running under locale.  However, this is more strict
than necessary.  If there is no folding, and everything else is known at
compile time, then what is matched when the result is complemented is
well-defined, and can be done now.  (Also clarifies one of the affected
comments)

6 years agoregcomp.c: Add func to test 2 inversion lists for equality
Karl Williamson [Tue, 10 Jul 2012 00:44:46 +0000 (18:44 -0600)] 
regcomp.c: Add func to test 2 inversion lists for equality

This adds _invlistEQ which for now is commented out

6 years agoutf8.c: Add info to commented-out -DU lines
Karl Williamson [Mon, 9 Jul 2012 22:35:11 +0000 (16:35 -0600)] 
utf8.c: Add info to commented-out -DU lines

This proved useful when I recently needed to use these for debugging

6 years agoregcomp.c: Reverse order of setting, for speed
Karl Williamson [Mon, 9 Jul 2012 22:17:40 +0000 (16:17 -0600)] 
regcomp.c: Reverse order of setting, for speed

It's faster to append to an inversion list than to insert into the
middle.  The previous order of doing things guaranteed that the 2nd
thing done would be an insertion, hence slower than an append.  Now we
add the lowest ordinal character first, so there is a chance that both
will be appends

6 years agoperllocale: Mention that \n doesn't change for locales
Karl Williamson [Mon, 9 Jul 2012 21:12:36 +0000 (15:12 -0600)] 
perllocale: Mention that \n doesn't change for locales

6 years agohandy.h: Remove duplicated test
Karl Williamson [Mon, 9 Jul 2012 20:30:29 +0000 (14:30 -0600)] 
handy.h: Remove duplicated test

This test is duplicated in the called macro

6 years agohandy.h: White space only
Karl Williamson [Mon, 9 Jul 2012 20:28:11 +0000 (14:28 -0600)] 
handy.h: White space only

This moves a #define next to similar ones, and removes some white space

6 years agoregcomp.c: Move table to wider scope
Karl Williamson [Mon, 9 Jul 2012 20:25:03 +0000 (14:25 -0600)] 
regcomp.c: Move table to wider scope

This table will be used in future commits outside this block's scope

6 years agoregcomp.c: Silence compiler warning
Karl Williamson [Mon, 9 Jul 2012 19:59:09 +0000 (13:59 -0600)] 
regcomp.c: Silence compiler warning

I suspect this being an IV stemmed from an earlier version.  It always
contains unsigneds

6 years agoregcomp.c: Change macro name to better indicate its purpose
Karl Williamson [Mon, 9 Jul 2012 19:54:13 +0000 (13:54 -0600)] 
regcomp.c: Change macro name to better indicate its purpose

6 years agoOptimize a single character [class] into EXACTish
Karl Williamson [Sat, 7 Jul 2012 16:10:30 +0000 (10:10 -0600)] 
Optimize a single character [class] into EXACTish

Things like /[s]/ or /[s]/i can be optimized as if they did not have the
brackets, /s/ or /s/i.

6 years agoregcomp.c: Extract some code into an inline function
Karl Williamson [Mon, 9 Jul 2012 19:10:00 +0000 (13:10 -0600)] 
regcomp.c: Extract some code into an inline function

This code will be used in future commits in multiple places

6 years agoregcomp.c: shrink some optimized [class] nodes
Karl Williamson [Sat, 7 Jul 2012 17:46:40 +0000 (11:46 -0600)] 
regcomp.c: shrink some optimized [class] nodes

Various bracketed character class specifications don't need the full
generality, and can be optimized into smaller, faster nodes.  Recent
commits, such as 3a64b5154fffec75126d34d25954f0aef30d9f8a have
introduced some such optimizations.  However, their commit messages are
wrong, in that they don't end taking up any less space than the original
ANYOF node, as there is no provision for giving it back, once reserved.

This commit corrects that for non-locale nodes.  Restructuring of the
code, more than I care to do now, would be required to extend this to
locale nodes.

Only optimizations that are determined in pass1 of the regex compilation
are eligible for this, as once the space is calculated, it is reserved
before pass2 begins.  There are now two sections where optimization is
done in this routine.  The final section is after all the data is
examined and processed, and we know exactly what is to be in the ANYOF
node.  Currently, most of this calculation processing is skipped in pass
1.  We could do everything in both passes, greatly slowing down the
first, in order to figure out the exact space requirements.

But instead, I've chosen to add a separate optimization section that
looks at only the optimizations that are easily computable in the
current first pass, and to apply those early, in time for the shrinking
to occur.  This commit adds that shrinking.

Locale nodes can't be shrunk because the code currently writes into
their larger buffer before this decision to optimize is made.  To
illustrate, say that the node is at the end of the regex, and the data
is written at x+20, within a generic locale ANYOF node's space.  Pass 1
doesn't write anything, but calculates the space needed.  At the point
that this commit addresses, we would shrink the amount of space to be
allocated to be allocated.  Then we carve out space for the regex from
the heap.  That x+20 could be pointing to something entirely different,
which Pass 2 would destroy.  This can be avoided by storing the stuff
that would be written into a temporary until the optimization decision
has been made.  But there is extra work involved in doing this, that I
don't think is worth it at this time.

The same problem doesn't occur in non-locale situations, even though the
flags field of the node is written before the optimization decision.
This is because every node has the space for a flags field, so it just
gets overwritten as necessary when the optimization is done.

6 years agoregcomp.c: Delay some initialization until needed
Karl Williamson [Sat, 7 Jul 2012 17:42:30 +0000 (11:42 -0600)] 
regcomp.c: Delay some initialization until needed

This delays the initialization of the bitmap in ANYOF nodes until just
before it is needed, and to after where we make a decision to optimize
that node to a node which takes less space.  Currently, the space is
not given up, once reserved in pass 1, so the write is harmless.  This
will allow a future commit to shrink the space.

6 years agoregcomp.c: Remove duplicate assignments
Karl Williamson [Sat, 7 Jul 2012 14:15:56 +0000 (08:15 -0600)] 
regcomp.c: Remove duplicate assignments

These variables are already set to the same values a few lines up.

6 years agohandy.h: Move bit shifting into base macro
Karl Williamson [Tue, 3 Jul 2012 04:18:47 +0000 (22:18 -0600)] 
handy.h: Move bit shifting into base macro

This changes the #defines to be just the shift number, while doing
the shifting in the macro that the number is passed to.  This will prove
useful in future commits

6 years agohandy.h: Renumber character class bits
Karl Williamson [Tue, 3 Jul 2012 03:39:56 +0000 (21:39 -0600)] 
handy.h: Renumber character class bits

These are renumbered so that the ones that correspond to character
classes in regcomp.h are related numerically as well.  This will prove
useful in future commits.

6 years agohandy.h: Reorder some #defines
Karl Williamson [Tue, 3 Jul 2012 03:31:31 +0000 (21:31 -0600)] 
handy.h: Reorder some #defines

They are now ordered in the same order as the similar #defines in
regcomp.h.  This will be useful in later commits

6 years agohandy.h: l1_charclass.h: Add bit for matching ASCII
Karl Williamson [Tue, 3 Jul 2012 03:09:18 +0000 (21:09 -0600)] 
handy.h: l1_charclass.h: Add bit for matching ASCII

This does not replace the isASCII macro definition, as I think the
current one is more efficient than this one provides.  But future
commits will rely on all the named character classes (e.g.,
/[[:ascii:]]/) having a bit, and this is the only one missing.

6 years agohandy.h: refactor some macros to use a new one in common.
Karl Williamson [Tue, 3 Jul 2012 03:04:16 +0000 (21:04 -0600)] 
handy.h: refactor some macros to use a new one in common.

This creates a new, unpublished, macro to implement most of the other
macros.  This macro will be useful in future commits.

6 years agoregcomp.c: Extract code to inline function
Karl Williamson [Sat, 7 Jul 2012 03:41:07 +0000 (21:41 -0600)] 
regcomp.c: Extract code to inline function

Future commits will use this paradigm in additional places, so extract
it to a function, so they all do things right.  This isn't a great API,
but it works for the few places this will be called.

6 years agoregcomp.sym: Correct and add comments
Karl Williamson [Fri, 6 Jul 2012 21:14:19 +0000 (15:14 -0600)] 
regcomp.sym: Correct and add comments

6 years agoregen/regcomp.pl: Allow ';' in comments
Karl Williamson [Fri, 6 Jul 2012 17:31:11 +0000 (11:31 -0600)] 
regen/regcomp.pl: Allow ';' in comments

If a comment contained a semi-colon, the regular expression's greedy
quantifier would think the portion of the comment before it was part of
the data to be processed

6 years agoregcomp.c: Optimize [^\n] into \N
Karl Williamson [Wed, 4 Jul 2012 21:22:59 +0000 (15:22 -0600)] 
regcomp.c: Optimize [^\n] into \N

This optimization is a big win, as it takes less space, and completely
avoids any swash hash creation, and use.

6 years agoregcomp.c: White-space, comments only
Karl Williamson [Wed, 4 Jul 2012 20:49:22 +0000 (14:49 -0600)] 
regcomp.c: White-space, comments only

This fixes some nits in a some comments, adds some comments, but mostly
just indents and outdents to reflect a new outer block, and to fit
within 80 columns

6 years agoregcomp.c: Refactor new charclass optimizations
Karl Williamson [Wed, 4 Jul 2012 20:16:29 +0000 (14:16 -0600)] 
regcomp.c: Refactor new charclass optimizations

Commits 3a64b5154fffec75126d34d25954f0aef30d9f8a and
3172e3fd885a9c54105d3b6156f18dc761fe29e5 introduced some optimizations
into the handling of bracketed character classes with just a single
element.

In working on other optimizations, I realized that it would be better to
put these all in one spot, instead of doing things partially and setting
flags to pass to other areas of the routine.

This commit moves all the processing to a single spot, which gets called
only after we know that there will be just one element in the character
class.

I also realized that the [0-9] optimization should strictly not be done
under locale.  There is no test for this, as actually this would only be
a problem if a locale was in violation of the C standard.  But (most) of
the rest of Perl doesn't assume that locales are well-behaved in this
regard, so now this code doesn't either.

6 years agoregcomp.c: Use data structure properties to remove tests
Karl Williamson [Tue, 3 Jul 2012 02:50:33 +0000 (20:50 -0600)] 
regcomp.c: Use data structure properties to remove tests

The ANYOF_foo character class #defines really form an enum, with the
property that the regular one is n, and its complement is n+1.  So
we can replace the tests in each case: of the switch, with a single test
afterwards.

6 years agoregcomp.c: Use macro for clarity
Karl Williamson [Sun, 1 Jul 2012 18:37:04 +0000 (12:37 -0600)] 
regcomp.c: Use macro for clarity

It's kind of obscure what this test is doing, so change it into a macro
to clarify things

6 years agoregcomp.c: Only try to fold foldable chars
Karl Williamson [Thu, 28 Jun 2012 23:13:18 +0000 (17:13 -0600)] 
regcomp.c: Only try to fold foldable chars

This uses the new table that a previous commit caused mktables to
generate which more precisely determines which Unicode characters
participate in folds.  This avoids trying to calculate a fold that we
can know beforehand doesn't have a fold.

6 years agomktables: Generate new table for foldable chars
Karl Williamson [Thu, 28 Jun 2012 19:32:17 +0000 (13:32 -0600)] 
mktables: Generate new table for foldable chars

This table consists of all characters that participate in any way in a
fold in the current Unicode version.  regcomp.c currently uses the Cased
property as a proxy for these.  This information is used to limit the
number of characters whose folds have to be dealt with in compiling
bracketed regex character classess.   It turns out that Cased contains
more than 1300 more code points than actually do appear in folds, which
means potential extra work for compiling.  Hence this patch allows that
work to be avoided.

There are a few characters in this new table that aren't in Cased, which
are potential bugs in the old way of doing things.  In Unicode 6.1,
these are:  U+02BC MODIFIER LETTER APOSTROPHE, U+0308 COMBINING
DIAERESIS, U+0313 COMBINING COMMA ABOVE, and U+0342 COMBINING GREEK
PERISPOMENI.  I can't figure out how these might be currently causing a
bug, but this patch fixes any such.

6 years agoregcomp.c: Correct outdated comment
Karl Williamson [Wed, 27 Jun 2012 23:18:20 +0000 (17:18 -0600)] 
regcomp.c: Correct outdated comment

6 years agoregcomp.c: Change and comment a problematic #define
Karl Williamson [Wed, 27 Jun 2012 22:57:25 +0000 (16:57 -0600)] 
regcomp.c: Change and comment a problematic #define

As noted in the new comments, there is no out-of-bounds code point, so
this should not be used as such; and it turns out, it really isn't.
But this is a fall-back in case code is changed to not set the variable
that this initializes, and the comment will prevent someone else from
wasting their time trying to figure out why this is like this.

6 years agoembed.fnc: Remove duplicate entry
Karl Williamson [Wed, 27 Jun 2012 22:37:56 +0000 (16:37 -0600)] 
embed.fnc: Remove duplicate entry

6 years agoutf8.h, regcomp.c: Use mnemonics for Unicode chars
Karl Williamson [Wed, 27 Jun 2012 22:31:36 +0000 (16:31 -0600)] 
utf8.h, regcomp.c: Use mnemonics for Unicode chars

Add a mnemonic definition for these three code points.  They are
currently used in only one place, but future commits will use them
elsewhere.

6 years agoembed.fnc: Add const to remove compiler warning
Karl Williamson [Wed, 25 Jul 2012 00:35:40 +0000 (18:35 -0600)] 
embed.fnc: Add const to remove compiler warning

This should have been declared const.

6 years agolex_grow_linestr(): update re_eval_start
David Mitchell [Tue, 24 Jul 2012 14:11:29 +0000 (15:11 +0100)] 
lex_grow_linestr(): update re_eval_start

As seen in [perl #114242], the TryCatch test suite triggers this bug.
lex_grow_linestr() was reallocing the PL_linestr buffer and updating all
pointers within it, but was failing to update
PL_sublex_info.re_eval_start.

Unfortunately, lex_grow_linestr() doesn't seem to be used in core outside
of hereto docs, and due to a separate parser bug, hereto docs can't
currently be used within /(?{})/, so I can't add tests for it yet.

6 years agoUpdate core to Time::Local 1.2300 from CPAN
Dave Rolsky [Fri, 20 Jul 2012 16:28:07 +0000 (11:28 -0500)] 
Update core to Time::Local 1.2300 from CPAN

6 years ago[perl #114248] Newxz? doc wrong in perlclib.pod
David Mitchell [Tue, 24 Jul 2012 10:21:25 +0000 (11:21 +0100)] 
[perl #114248] Newxz? doc wrong in perlclib.pod

Commit 9f653bb54868b8547466924d4ce483acb8987efb changed the docs from
New/Newz to the newer Newx/Newxz, but forgot to remove the
no-longer-present 'id' arg.

6 years agoMerge B 1.37 to blead (more SV flag constants exposed).
Nicholas Clark [Tue, 24 Jul 2012 08:39:08 +0000 (10:39 +0200)] 
Merge B 1.37 to blead (more SV flag constants exposed).

6 years agoBump B's VERSION and note the changes in perldelta.pod.
Nicholas Clark [Mon, 23 Jul 2012 11:39:05 +0000 (13:39 +0200)] 
Bump B's VERSION and note the changes in perldelta.pod.

6 years agoExpose all GV flags matching qr/GVf_/ as constants in B.
Nicholas Clark [Mon, 23 Jul 2012 11:27:32 +0000 (13:27 +0200)] 
Expose all GV flags matching qr/GVf_/ as constants in B.

Previously only those matching qr/GVf_IMPORTED/ were exposed.

6 years agoExpose all CV flags matching qr/CVf_/ as constants in B.
Nicholas Clark [Mon, 23 Jul 2012 11:15:51 +0000 (13:15 +0200)] 
Expose all CV flags matching qr/CVf_/ as constants in B.

Previously most were exposed as constants, but often B was not taught about
flags added to cv.h. Determining the flags by parsing cv.h also permits the
removal of various version-specific logic from the Makefile.PL

6 years agoExpose all SV flags matching qr/SV(?:[fps]|pad)_/ as constants in B.
Nicholas Clark [Mon, 23 Jul 2012 09:30:17 +0000 (11:30 +0200)] 
Expose all SV flags matching qr/SV(?:[fps]|pad)_/ as constants in B.

Previously only a subset were exposed as constants.

6 years agoIn ext/B/Makefile.PL, order the list of files to scan lexically.
Nicholas Clark [Mon, 23 Jul 2012 10:36:27 +0000 (12:36 +0200)] 
In ext/B/Makefile.PL, order the list of files to scan lexically.

It doesn't actually matter which order the files are scanned for constants,
but it's neater and slightly clearer where to add new files if there is an
obvious order.

6 years agoensure that the env var SV after C<{FOO}='x'> is PV only
Chip Salzenberg [Tue, 24 Jul 2012 07:39:46 +0000 (00:39 -0700)] 
ensure that the env var SV after C<{FOO}='x'> is PV only

6 years agoreduce magic overhead of tainting (maybe other magic later)
Chip Salzenberg [Tue, 24 Jul 2012 05:53:49 +0000 (22:53 -0700)] 
reduce magic overhead of tainting (maybe other magic later)

6 years agoUnify code that initializes constants yes, no, and undef
Chip Salzenberg [Tue, 24 Jul 2012 05:40:46 +0000 (22:40 -0700)] 
Unify code that initializes constants yes, no, and undef

6 years agoSync Module-CoreList version in Maintainers.pl with teh CPAN
Chris 'BinGOs' Williams [Mon, 23 Jul 2012 10:05:39 +0000 (11:05 +0100)] 
Sync Module-CoreList version in Maintainers.pl with teh CPAN

6 years agore_tests: Add tests for [perl #114220]
Karl Williamson [Sat, 21 Jul 2012 19:11:07 +0000 (13:11 -0600)] 
re_tests: Add tests for [perl #114220]

This was fixed as a side effect of other patches, so no tests were
created at the time.

6 years agoin sv_chop(), add use SvPOK_only_UTF8() to clear obsolete NIOK
Chip Salzenberg [Sat, 21 Jul 2012 05:13:12 +0000 (22:13 -0700)] 
in sv_chop(), add use SvPOK_only_UTF8() to clear obsolete NIOK

6 years agomake SvOOK_offset macro safer, with parens and underscores
Chip Salzenberg [Sat, 21 Jul 2012 05:11:23 +0000 (22:11 -0700)] 
make SvOOK_offset macro safer, with parens and underscores

6 years agorewrite a regex in lib/DB.t using \Q
Robin Barker [Thu, 19 Jul 2012 15:25:59 +0000 (16:25 +0100)] 
rewrite a regex in lib/DB.t using \Q

The regexp for the 'eval BLOCK' test should match explicit '...'.
So avoid the \{ issue and put \Q before all the punctuation.

6 years agobump to version 5.17.3
Tony Cook [Fri, 20 Jul 2012 15:34:40 +0000 (17:34 +0200)] 
bump to version 5.17.3

6 years agonew perldelta
Tony Cook [Fri, 20 Jul 2012 15:24:19 +0000 (17:24 +0200)] 
new perldelta

6 years agoupdate epigraphs.pod
Tony Cook [Fri, 20 Jul 2012 15:15:10 +0000 (17:15 +0200)] 
update epigraphs.pod

6 years agoadd releaase 5.17.2 to perlhist v5.17.2
Tony Cook [Fri, 20 Jul 2012 12:35:09 +0000 (14:35 +0200)] 
add releaase 5.17.2 to perlhist

6 years agoupdate Module::CoreList for 5.17.2
Tony Cook [Fri, 20 Jul 2012 12:32:19 +0000 (14:32 +0200)] 
update Module::CoreList for 5.17.2

6 years agoPorting/corelist.pl didn't handle newlines in the pod version list
Tony Cook [Fri, 20 Jul 2012 12:18:45 +0000 (14:18 +0200)] 
Porting/corelist.pl didn't handle newlines in the pod version list

6 years agofinalize perldelta
Tony Cook [Fri, 20 Jul 2012 10:59:25 +0000 (12:59 +0200)] 
finalize perldelta

6 years agoOnly generate above-Uni warning for \p{}, \P{}
Karl Williamson [Wed, 18 Jul 2012 23:22:33 +0000 (17:22 -0600)] 
Only generate above-Uni warning for \p{}, \P{}

This warning was being generated inappropriately during some internal
operations, such as parsing a program; spotted by Tom Christiansen.

The solution is to move the check for this situation out of the common
code, and into the code where just \p{} and \P{} are handled.

As mentioned in the commit's perldelta, there remains a bug
[perl #114148], where no warning gets generated when it should

6 years agoregcomp.c: Refactor code into a function
Karl Williamson [Wed, 18 Jul 2012 21:14:54 +0000 (15:14 -0600)] 
regcomp.c: Refactor code into a function

Future commits will use this functionality in additional places beyond
the single one currently.  It makes sense to abstract it into a
function.

6 years agoregcomp.c: set local flag in pass1 of charclass inversion
Karl Williamson [Wed, 4 Jul 2012 19:42:15 +0000 (13:42 -0600)] 
regcomp.c: set local flag in pass1 of charclass inversion

Previously, this flag was not looked at in pass 1, but future commits
will require it to be.  The regnode is not actually allocated in pass1,
so set a local variable with the value, and set the flag in the regnode
after everything affecting the flag is done.

6 years agoregcomp.c: Keep separate list for [:word:] from \p{Word}
Karl Williamson [Wed, 18 Jul 2012 20:06:31 +0000 (14:06 -0600)] 
regcomp.c: Keep separate list for [:word:] from \p{Word}

This commit separates out the building up of code points that match the
posix properties (including \w, \d, \s) from those that match Unicode
properties.  This will prove useful in future commits

6 years agoregcomp.c: Convert boolean variable from a UV
Karl Williamson [Mon, 16 Jul 2012 04:08:22 +0000 (22:08 -0600)] 
regcomp.c: Convert boolean variable from a UV

It's a little clearer to use boolean for a true/false valued variable

6 years agoutf8.c: Create API so internals can be hidden
Karl Williamson [Mon, 16 Jul 2012 04:01:52 +0000 (22:01 -0600)] 
utf8.c: Create API so internals can be hidden

This creates a function to hide some of the internal details of swashes
from the regex engine, which is the only authorized user, enforced
through #ifdefs in embed.fnc.  These work closely together, but it's
best to have a clean interface.

6 years agoregcomp.h: Free up bit; downside is makes locale ANYOF nodes large
Karl Williamson [Sun, 15 Jul 2012 22:11:45 +0000 (16:11 -0600)] 
regcomp.h: Free up bit; downside is makes locale ANYOF nodes large

There have been two flavors of ANYOF nodes under /l (locale) (for
bracketed character classes).  If a class didn't try to match things
like [:word:], it was smaller by 4 bytes than one that did.

A flag bit was used to indicate which size it was.  By making all such
nodes the larger size, whether needed or not, that bit can be freed to
be used for other purposes.

This only affects ANYOF nodes compiled under locale rules.  The hope is
to eventually git rid of these nodes anyway, by taking the suggestion of
Yves Orton to compile regular expressions using the current locale, and
automatically recompile the next time they are used after the locale
changes.

This commit is somewhat experimental, done early in the development
cycle to see if there are any breakages.  There are other ways to free
up a bit, as explained in the comments.  Best would be to split off
nodes that match everything outside Latin1, freeing up the
ANYOF_UNICODE_ALL bit.  However, there currently would need to be two
flavors of this, one also for ANYOFV.  I'm currently working to
eliminate the need for ANYOFV nodes (which aren't sufficient,
[perl #89774]), so it's easiest to wait for this work to be done before
doing the split, after which we can revert this change in order to gain
back the space, but in the meantime, this will have had the opportunity
to smoke out issues that I would like to know about.

6 years agoregcomp.h: Fix up comment
Karl Williamson [Sun, 15 Jul 2012 22:11:02 +0000 (16:11 -0600)] 
regcomp.h: Fix up comment

6 years agoregcomp.c: Clarify, update comments, white-space reflow
Karl Williamson [Sun, 15 Jul 2012 20:35:52 +0000 (14:35 -0600)] 
regcomp.c: Clarify, update comments, white-space reflow

6 years agoperlapi: Clarify hv_fetch() docs
Karl Williamson [Sun, 15 Jul 2012 23:02:19 +0000 (17:02 -0600)] 
perlapi: Clarify hv_fetch() docs

I was confused by the earlier documentation.  Thanks to Leon Timmermans
for clarifying, and to Vicent Pitt for most of the wording

6 years agoop/join.t: don't use done_testing
David Mitchell [Thu, 19 Jul 2012 10:40:49 +0000 (11:40 +0100)] 
op/join.t: don't use done_testing

since the number of tests is known in advance.

6 years agoFixup indentation
Jan Dubois [Wed, 18 Jul 2012 22:47:44 +0000 (15:47 -0700)] 
Fixup indentation

6 years agoAdding support for Visual C's __declspec(noreturn) function declarations to perl
Daniel Dragan [Mon, 16 Jul 2012 20:02:45 +0000 (16:02 -0400)] 
Adding support for Visual C's __declspec(noreturn) function declarations to perl

This will reduce the machine code size on Visual C Perl, by removing C stack
clean up opcodes and possible jmp opcodes after croak() and similar
functions.  Perl's existing __attribute__noreturn__ macro (and therefore
GCC's __attribute__((noreturn)) ) is fundamentally incompatible with MS's
implementation for noreturn functions. win32.h already has _MSC_VER
aware code blocks, so adding more isn't a problem.

6 years agoperldelta updates
Tony Cook [Wed, 18 Jul 2012 11:34:30 +0000 (21:34 +1000)] 
perldelta updates

6 years agosync() on a read-only file handle doesn't work on cygwin either
Tony Cook [Tue, 17 Jul 2012 05:48:02 +0000 (15:48 +1000)] 
sync() on a read-only file handle doesn't work on cygwin either

Cygwin fsync() is implemented in terms of the Win32 FlushFileBuffers()
API which requires GENERIC_WRITE access.

6 years agoperldelta description of magic flags patch
Chip Salzenberg [Sun, 15 Jul 2012 23:20:14 +0000 (16:20 -0700)] 
perldelta description of magic flags patch

6 years agomark blead-only modifications of Compress::Raw::{Bzip2,Zlib} with version bump
Chip Salzenberg [Sun, 15 Jul 2012 23:19:57 +0000 (16:19 -0700)] 
mark blead-only modifications of Compress::Raw::{Bzip2,Zlib} with version bump

6 years agoMagic flags harmonization.
Chip Salzenberg [Fri, 22 Jun 2012 22:18:18 +0000 (15:18 -0700)] 
Magic flags harmonization.

In restore_magic(), which is called after any magic processing, all of
the public OK flags have been shifted into the private OK flags.  Thus
the lack of an appropriate public OK flags was used to trigger both get
magic and required conversions.  This scheme did not cover ROK, however,
so all properly written code had to make sure mg_get was called the right
number of times anyway.  Meanwhile the private OK flags gained a second
purpose of marking converted but non-authoritative values (e.g. the IV
conversion of an NV), and the inadequate flag shift mechanic broke this
in some cases.

This patch removes the shift mechanic for magic flags, thus exposing (and
fixing) some improper usage of magic SVs in which mg_get() was not called
correctly.  It also has the side effect of making magic get functions
specifically set their SVs to undef if that is desired, as the new behavior
of empty get functions is to leave the value unchanged.  This is a feature,
as now get magic that does not modify its value, e.g. tainting, does not
have to be special cased.

The changes to cpan/ here are only temporary, for development only, to
keep blead working until upstream applies them (or something like them).

Thanks to Rik and Father C for review input.

6 years agoperldelta updates
Father Chrysostomos [Sun, 15 Jul 2012 02:13:18 +0000 (19:13 -0700)] 
perldelta updates

6 years agodump.c: Dump op->op_s(labbed|avefree)
Father Chrysostomos [Sun, 15 Jul 2012 02:00:48 +0000 (19:00 -0700)] 
dump.c: Dump op->op_s(labbed|avefree)

6 years agoRemove op_latefree(d)
Father Chrysostomos [Sun, 15 Jul 2012 02:00:17 +0000 (19:00 -0700)] 
Remove op_latefree(d)

This was an early attempt to fix leaking of ops after syntax errors,
disabled because it was deemed to fragile.  The new slab allocator
(8be227a) has solved this problem another way, so latefree(d) no
longer serves any purpose.

6 years agoperly.y: Remove use of latefree from package foo {}
Father Chrysostomos [Sun, 15 Jul 2012 01:45:41 +0000 (18:45 -0700)] 
perly.y: Remove use of latefree from package foo {}

It is not necessary for the op containing the sv containing the name
of the package to last until the end of the block.  Perl_package can
free the op immediately, as the only information it needs from it it
copies to the sv in PL_curstname.  The version number can be treated
the same way.

6 years agoop.c: ck_grep does not need to call listkids
Father Chrysostomos [Sat, 14 Jul 2012 21:16:42 +0000 (14:16 -0700)] 
op.c: ck_grep does not need to call listkids

It calls ck_fun, which applies list context to all the arguments,
since grepstart and mapstart have an L in regen/opcodes.

6 years agoop.c: ck_fun does not need to call LINKLIST
Father Chrysostomos [Sat, 14 Jul 2012 21:10:44 +0000 (14:10 -0700)] 
op.c: ck_fun does not need to call LINKLIST

The branch in question is only reached when it is called from ck_grep,
which itself calls LINKLIST on exactly the same op.

6 years agoop.c:ck_grep: Remove unnecessary op_next assignments
Father Chrysostomos [Sat, 14 Jul 2012 20:28:57 +0000 (13:28 -0700)] 
op.c:ck_grep: Remove unnecessary op_next assignments

ck_grep is a tangled mess and I am trying to simplify it, but at each
step it is not at all obvious what is happening.

grep/map with a block starts out like this:

    grepstart
      pushmark
      null
        scope/leave
          block contents...
      arg1
      arg2
      ...

The if (o->op_flags & OPf_STACKED) at the top of ck_grep runs for
blocks.  The firstkid var refers to the null above, and gets its
op_next set (this code was in ck_sort until recently [ck_grep used to
call ck_sort], and this particular op_next assignment was specific to
grep and map).

Later, the thing is fed through ck_fun, whose OA_CVREF case transforms
the tree into this:

    grepstart
      pushmark
      null             ← new op
        null           ← original null
          scope/leave
            block contents...
      arg1
      arg2
      ...

Then cUNOPx(cLISTOP->op_first->op_sibling)->op_first gets its op_next
set.  By that point, that expression refers to the original null op,
so setting its op_next pointer to begin with seems pointless.

But it is not actually pointless.  Removing that statement breaks
things.  It turns out, as usual, that everything is more complicated
than it seems.  Setting kid->op_next = (OP*)gwop in the block-specific
if statement after setting the first null op’s op_next pointer results
in op_next pointers like this (the newly-created grepwhile doesn’t
link to the grepstart yet at this point):

  [grepwhile]
    grepstart
      pushmark
      null              -> block contents
        scope/leave     -> grepwhile
          block contents...
      arg1
      arg2
      ...

So ck_fun’s OA_CVREF handling, when it calls LINKLIST, sees that the
original null op already has its op_next set and does nothing.  With-
out it set, it copies it from the first kid, resulting in this (when
LINKLIST copies the op_next pointer out, it makes the kid it was cop-
ied from point to its sibling or its parent):

  [grepwhile]
    grepstart
      pushmark
      null
        null              -> grepwhile
          scope/leave     -> null (prev line)
            block contents...
      arg1
      arg2
      ...

That nonsensical arrangement of op_next pointers basically prevents
the block from running, because the grepwhile’s other pointer, copied
from the first null’s kid, ends up pointing to the grepwhile itself.

If we also remove the kid->op_next = (OP*)gwop assignment from the
if(OPf_STACKED) block, then we end up with this after ck_fun:

  [grepwhile]
    grepstart
      pushmark
      null
        null              -> first op in block
          scope/leave     -> null (prev line)
            block contents...
      arg1
      arg2
      ...

Then the op_next poiner from the first null’s kid is copied to
grepwhile’s op_other pointer, and everything works.

This also means we can remove the now-redundant LINKLIST call from the
if(OPfSTACKED) block, since ck_fun’s OA_CVREF handling also does that.
So now every vestige of the original call to ck_sort is gone.

This also means we no longer have to repeat NewOp(1101, gwop...).

6 years agoop.c: ck_grep does not need to check num of args
Father Chrysostomos [Sat, 14 Jul 2012 19:28:15 +0000 (12:28 -0700)] 
op.c: ck_grep does not need to check num of args

It calls ck_fun first, which does the same check, so it is
unnecessary.

6 years agopp_hot.c: Mention that pp_grepstart calls pp_pushmark
Father Chrysostomos [Sat, 14 Jul 2012 19:28:08 +0000 (12:28 -0700)] 
pp_hot.c: Mention that pp_grepstart calls pp_pushmark

6 years agoSimplify ck_grep
Father Chrysostomos [Sat, 14 Jul 2012 13:58:29 +0000 (06:58 -0700)] 
Simplify ck_grep

Back in perl 5.000, ck_grep would call ck_sort (which was still the
case until 354dd559d99 just recently) and the latter would traverse
its way through the op_next pointers to find an op that tried to
escape the block, setting its op_next pointer to null.  Then ck_grep
would traverse op_next pointers itself to find the place where ck_sort
stopped.  That caused problems for grep which were fixed in 748a93069b
(perl 5.001).  It was fixed by setting op_next to 0 on the first op,
so that the loop in ck_grep would not do anything.  But that loop was
left there.  This commit removes it.

There are also a couple of things I missed when disentangling
ck_grep and ck_sort in commit /354dd559d9.  I accidentally put
if (o->op_flags & OPf_STACKED) inside if (o->op_flags & OPf_STACKED).
And the OPf_SPECIAL flag was only being set for sort’s use, so ck_grep
doesn’t need to copy that.

6 years agoop.c: Further simplify ck_sort
Father Chrysostomos [Sat, 14 Jul 2012 13:41:30 +0000 (06:41 -0700)] 
op.c: Further simplify ck_sort

This code currently chases op_next pointers in the sort block to make
sure there is none that can point outside.  To avoid getting stuck in
loops, it has to check for those explicitly.

Instead of nulling out any op_next pointer that points to the leave
op, we can simply turn the leave into a null op (which we already do)
and have the leave op’s op_next pointer point to nothing.

That produces the same result in the end:  Execution of the sort block
is prevented from running rampant and escaping out of it, but exits
the runloop instead, returning control to pp_sort.