22 months agoutf8.c: Generalize static fcn return for indeterminate result
Karl Williamson [Sat, 1 Jul 2017 13:21:09 +0000 (07:21 -0600)] 
utf8.c: Generalize static fcn return for indeterminate result

This makes it harder to think that 0 means a definite FALSE.

22 months agoutf8.c: Move a fcn within the file
Karl Williamson [Sat, 1 Jul 2017 12:32:28 +0000 (06:32 -0600)] 
utf8.c: Move a fcn within the file

This simply moves a function to later in the file.  The next commIt will
change it to needing a definition which, until this commit, came after it
in the file, and so was not available to it.

22 months agoutf8.c: Generalize static fcn return for indeterminate result
Karl Williamson [Sat, 1 Jul 2017 12:43:34 +0000 (06:43 -0600)] 
utf8.c: Generalize static fcn return for indeterminate result

This makes it harder to think that 0 means a definite FALSE.

22 months agoutf8.c: Generalize static fcn return for indeterminate result
Karl Williamson [Sat, 1 Jul 2017 12:18:01 +0000 (06:18 -0600)] 
utf8.c: Generalize static fcn return for indeterminate result

Prior to this commit, isFF_OVERLONG() returned a boolean, with 0 also
indicating that there wasn't enough information to make a determination.
I realized that I was forgetting that 0 wasn't necessarily definitive
while coding.  By changing the API to return 3 values, forgetting that
won't likely happen.

This and the next several commits change several other functions that
have the same predicament.

22 months agoutf8.h: Comments only
Karl Williamson [Fri, 30 Jun 2017 19:21:58 +0000 (13:21 -0600)] 
utf8.h: Comments only

An earlier commit had split some comments up.  And this adds clarifying

22 months agoutf8.c: Reorder two 'if' clauses
Karl Williamson [Fri, 30 Jun 2017 19:19:10 +0000 (13:19 -0600)] 
utf8.c: Reorder two 'if' clauses

This is purely to get vertical line up that easier to see of slightly
differently spelled tests

22 months agoutf8.c: Slightly simplify some code
Karl Williamson [Fri, 30 Jun 2017 17:19:59 +0000 (11:19 -0600)] 
utf8.c: Slightly simplify some code

This just does a small refactor, which I think makes things easier to

22 months agoutf8n_to_uvchr(): Properly handle extremely high code points
Karl Williamson [Sat, 8 Jul 2017 20:54:28 +0000 (14:54 -0600)] 
utf8n_to_uvchr(): Properly handle extremely high code points

It turns out that it could incorrectly deem something to be overflowing
or overlong.  This fixes that and changes the test to catch this
possibility.  This fixes a bug, so now on 32-bit systems, it detects
that if you have a start byte of FE, you need  a continuation byte to
determine if the result overflows.

22 months agorm APItest/t/utf8_malformed.t
Karl Williamson [Fri, 7 Jul 2017 18:39:33 +0000 (12:39 -0600)] 
rm APItest/t/utf8_malformed.t

This file no longer contains any tests.  All were either made redundant
with or have been moved to it.

22 months agoMove test to
Karl Williamson [Fri, 7 Jul 2017 18:37:39 +0000 (12:37 -0600)] 
Move test to

This is the final test that was in utf8_malformed.t.  The next commit
will remove the file.

22 months agoAPItest/t/utf8_malformed.t: Remove 2 redundant tests
Karl Williamson [Wed, 5 Jul 2017 16:27:25 +0000 (10:27 -0600)] 
APItest/t/utf8_malformed.t: Remove 2 redundant tests

These tests for the malformation where a UTF-8 sequence is interrupted
by the beginning of another character, already get tested int

22 months agoAPItest/t/ White-space only
Karl Williamson [Fri, 7 Jul 2017 21:20:44 +0000 (15:20 -0600)] 
APItest/t/ White-space only

This indents properly after the previous commit created a block around
this code, and reflows to fit in 79 columns.

22 months agoAPItest/t/ Add a test
Karl Williamson [Tue, 4 Jul 2017 18:57:40 +0000 (12:57 -0600)] 
APItest/t/ Add a test

This verifies that we don't mistake an overlong for overflow

22 months agoAPItest/t/utf8_malformed.t: move tests to
Karl Williamson [Tue, 4 Jul 2017 22:04:26 +0000 (16:04 -0600)] 
APItest/t/utf8_malformed.t: move tests to

This adds infrastructure to to handle the overlong
tests that are now moved to it from utf8_malformed.t

22 months agoAPItest/t/utf8_malformed.t: move test to
Karl Williamson [Tue, 4 Jul 2017 18:22:29 +0000 (12:22 -0600)] 
APItest/t/utf8_malformed.t: move test to

Actually, this test was already in utf8_warn_base, but was executed only
on 64 bit platforms.  It is reasonable to make sure it works on 32 bit
ones, as it is an edge case there as well, in the sense that it is the
first 13 byte code point.

This is the first of a series of commits to remove all the tests in
utf8_malformed, so the entire file can be removed.

utf8_warn_base has been heavily cleaned up, and now has better
infrastructure for more completely testing than utf8_malformed.  The
two files have much the same logic, and rather than trying to maintain
two versions, it's better to combine them.

22 months agoAPItest/t/utf8_malformed.t: Remove redundant test
Karl Williamson [Tue, 4 Jul 2017 19:23:18 +0000 (13:23 -0600)] 
APItest/t/utf8_malformed.t: Remove redundant test

This tests the too short malformation, which is already adequately
tested in

22 months agoAPItest/t/utf8_malformed.t: Remove 2 redundant tests
Karl Williamson [Tue, 4 Jul 2017 19:19:33 +0000 (13:19 -0600)] 
APItest/t/utf8_malformed.t: Remove 2 redundant tests

These test overflowing, which is already adequately tested in

22 months agoAPItest/t/utf8_malformed.t: Remove redundant test
Karl Williamson [Tue, 4 Jul 2017 16:06:37 +0000 (10:06 -0600)] 
APItest/t/utf8_malformed.t: Remove redundant test

This test already is covered in  It tests an overlong
for 2**32.

22 months agoAPItest/t/ Add tests
Karl Williamson [Fri, 7 Jul 2017 16:56:23 +0000 (10:56 -0600)] 
APItest/t/ Add tests

This test takes its various base tests, and intentionally perturbs them to
create malformations to additionally test.  Prior to this commit, only
the function utf8n_to_uvchr_error() was being tested with these
perturbations.  Now, the functions whoe names start with 'is' also get

22 months agoAPItest/t/ Move some tests
Karl Williamson [Wed, 5 Jul 2017 20:58:43 +0000 (14:58 -0600)] 
APItest/t/ Move some tests

This just moves a block and indents and reflows it.  It is moved to
within the loops that set up various malformations in the input.  The
next commit will change these tests to actually use the perturbed

22 months agoAPItest/t/ Move some setup code
Karl Williamson [Wed, 5 Jul 2017 19:09:27 +0000 (13:09 -0600)] 
APItest/t/ Move some setup code

We don't need this code until we've determined we're actually going to
go through with a test.

22 months agoAPItest/t/ Clean up test name
Karl Williamson [Fri, 7 Jul 2017 16:34:01 +0000 (10:34 -0600)] 
APItest/t/ Clean up test name

This name was confusing, as there are two types of things that can be
(dis)allowed, and in the case of an overflow, the first type is not
being tested but has the adjective (dis)allowed present.  Add the term
only when appropriate.

22 months agoAPItest/t/ Skip inappropriate tests
Karl Williamson [Wed, 5 Jul 2017 19:00:03 +0000 (13:00 -0600)] 
APItest/t/ Skip inappropriate tests

If we don't have enough information for the test to be meaningful, don't
bother doing it.

22 months agoAPItest/t/ Use a default value
Karl Williamson [Sat, 1 Jul 2017 04:29:36 +0000 (22:29 -0600)] 
APItest/t/ Use a default value

This adds a default number of bytes needed to detect overflows, like
previous commits have added defaults for other categories.

22 months agoutf8n_to_uvchr() Properly test for extended UTF-8
Karl Williamson [Tue, 27 Jun 2017 20:46:26 +0000 (14:46 -0600)] 
utf8n_to_uvchr() Properly test for extended UTF-8

It somehow dawned on me that the code is incorrect for
warning/disallowing very high code points.  What is really wanted in the
API is to catch UTF-8 that is not necessarily portable.  There are
several classes of this, but I'm referring here to just the code points
that are above the Unicode-defined maximum of 0x10FFFF.  These can be
considered non-portable, and there is a mechanism in the API to
warn/disallow these.

However an earlier standard defined UTF-8 to handle code points up to
2**31-1.  Anything above that is using an extension to UTF-8 that has
never been officially recognized.  Perl does use such an extension, and
the API is supposed to have a different mechanism to warn/disallow on

Thus there are two classes of warning/disallowing for above-Unicode code
points.  One for things that have some non-Unicode official recognition,
and the other for things that have never had official recognition.

UTF-EBCDIC differs somewhat in this, and since Perl 5.24, we have had a
Perl extension that allows it to handle any code point that fits in a
64-bit word.  This kicks in at code points above 2**30-1, a number
different than UTF-8 extended kicks in on ASCII platforms.

Things are also complicated by the fact that the API has provisions for
accepting the overlong UTF-8 malformation.  It is possible to use
extended UTF-8 to represent code points smaller than 31-bit ones.

Until this commit, the extended warning/disallowing was based on the
resultant code point, and only when that code point did not fit into 31

But what is really wanted is if extended UTF-8 was used to represent a
code point, no matter how large the resultant code point is.  This
differs from the previous definition, but only for EBCDIC platforms, or
when the overlong malformation was also present.  So it does not affect
very many real-world cases.

This commit fixes that.  It turns out that it is easier to tell if
something is using extended-UTF8.  One just looks at the first byte of a

The trailing part of the warning message that gets raised is slightly
changed to be clearer.  It's not significant enough to affect perldiag.

22 months agoutf8.h: Add synonyms for flag names
Karl Williamson [Mon, 26 Jun 2017 17:43:21 +0000 (11:43 -0600)] 
utf8.h: Add synonyms for flag names

The next commit will fix the detection of using Perl's extended UTF-8 to
be more accurate.  The current name for various flags in the API is
somewhat misleading.  What is really wanted to know is if extended UTF-8
was used, not the value of the resultant code point.

This commit basically does


It also similarly changes the name of a hash key in APItest/t/utf8.t.

This intermediary step makes the next commit easier to read.

22 months agoAPItest/t/ Generate smaller overlongs
Karl Williamson [Tue, 27 Jun 2017 04:22:32 +0000 (22:22 -0600)] 
APItest/t/ Generate smaller overlongs

This file generates overlongs for testing that that malformation is
handled properly.  This commit changes it to avoid generating an
overlong that uses Perl's extended UTF-8.  This will come in handy a
couple of commits from now, when a bug dealing with that gets fixed.

It also moves setting a variable to outside the loop

22 months agoAPItest/t/ Data::Dumper isn't needed
Karl Williamson [Fri, 30 Jun 2017 18:57:49 +0000 (12:57 -0600)] 
APItest/t/ Data::Dumper isn't needed

22 months agoAPItest/t/ Move some tests from loop
Karl Williamson [Fri, 30 Jun 2017 19:14:57 +0000 (13:14 -0600)] 
APItest/t/ Move some tests from loop

These test if any warnings are generated.  None are ever likely to be
given the way things work.  We can test after the loop that none of the
iterations generated warnings, as any would accumulate.

22 months agoAPItest/t/ Extract code into a fcn
Karl Williamson [Mon, 26 Jun 2017 03:35:05 +0000 (21:35 -0600)] 
APItest/t/ Extract code into a fcn

This uses a function to test for a common paradigm.  The next couple of
commits will change that paradigm, and now the code will only have to
change in one place.

22 months agoutf8.c: Fix bugs with overlongs combined with other malformations.
Karl Williamson [Mon, 19 Jun 2017 18:58:19 +0000 (12:58 -0600)] 
utf8.c: Fix bugs with overlongs combined with other malformations.

The code handling the UTF-8 overlong malformation must come after
handling all the other malformations.  This is because it may change the
code point represented to the REPLACEMENT CHARACTER.  The other
malformation code is expecting the code point to be the original one.
This may cause failure to catch and report other malformations, or
report the wrong value of the erroneous code point.

What was needed was simply to move the 'if else' branch for overlongs to
after the branches for the other formations.

22 months agoAPItest/t/ Add some tests
Karl Williamson [Sun, 25 Jun 2017 04:55:10 +0000 (22:55 -0600)] 
APItest/t/ Add some tests

This adds testing for having some malformations allowed.  These had not
been checked for, and there were some bugs.  It's easiest to TODO all
ones that might fail, creating many passing TODOs.  The TODO will be
removed in the next commit.

22 months agoAPItest/t/ Move things out of inner loop
Karl Williamson [Sun, 25 Jun 2017 04:42:25 +0000 (22:42 -0600)] 
APItest/t/ Move things out of inner loop

The most expensive stuff in this set of nested loops can actually be
done several nests up (even higher for some things, but it's not worth
the trouble).  Given that this test file has been too-long runnning, I
moved things to an outer loop context.

22 months agoAPItest/t/ Reorder loop nesting
Karl Williamson [Sun, 25 Jun 2017 03:32:41 +0000 (21:32 -0600)] 
APItest/t/ Reorder loop nesting

This is in preparation for the next commit.  It also changes some of the
loop variables to 1 to indicate truth, rather than a string.  This will
make some things easier later.

22 months agoAPItest/t/ Revamp testing isFOO
Karl Williamson [Wed, 21 Jun 2017 19:38:55 +0000 (13:38 -0600)] 
APItest/t/ Revamp testing isFOO

Several commits ago, the loop that handles testing the functions that
convert from/to UTF-8 was revampled.  This commit does a similar thing
for the portion of the code that handles the isFOO functions, and
partial character recognition.

It reorders the nesting of loops so that more tests can be done than
previously in the outer loop.  Among these, it now doesn't skip overflow
and deals with using Perl's extended UTF-8 better.

22 months agoutf8n_to_uvchr: U+ should be for only Unicode code points
Karl Williamson [Mon, 19 Jun 2017 18:56:38 +0000 (12:56 -0600)] 
utf8n_to_uvchr: U+ should be for only Unicode code points

For above-Unicode, we should use 0xDEADBEEF instead of U+DEADBEEF.
                                 ^^                    ^^
This is because U+ only applies to Unicode.  This only affects a warning
message for overlongs.

22 months agoAPItest/t/ Add some tests
Karl Williamson [Mon, 19 Jun 2017 17:52:34 +0000 (11:52 -0600)] 
APItest/t/ Add some tests

This adds the edges between overflowing and not on 64-bit platforms

22 months agoAPItest/t/ Do test on all platforms
Karl Williamson [Mon, 19 Jun 2017 17:47:54 +0000 (11:47 -0600)] 
APItest/t/ Do test on all platforms

This modifies and moves a test so it gets done on all platforms, not
just 32-bit ASCII.  It is an edge case on all platforms, but gives
differing results, overflowing on 32-bit ones.

22 months agoAPItest/t/ Rename and modify test
Karl Williamson [Mon, 19 Jun 2017 17:01:54 +0000 (11:01 -0600)] 
APItest/t/ Rename and modify test

This test is testing the first code point that requires 13 UTF-8 bytes
to represent on ASCII platforms.  Change the name from its previous
vague one to one that indicates this.  And don't test for it on EBCDIC
platforms, as it isn't an edge case there.

22 months agoAPItest/t/ Remove obsolete test
Karl Williamson [Mon, 19 Jun 2017 04:55:38 +0000 (22:55 -0600)] 
APItest/t/ Remove obsolete test

This was an attempt to test the fact that very high code points are
controlled both by regular above-Unicode warnings, and special,
non-portable warnings.  This test is now done better in the loop in the

22 months agoAPItest/t/ Rename a test
Karl Williamson [Mon, 19 Jun 2017 04:52:06 +0000 (22:52 -0600)] 
APItest/t/ Rename a test

The names are now more uniform.

22 months agoAPItest/t/ Move some tests in the file
Karl Williamson [Mon, 19 Jun 2017 04:50:12 +0000 (22:50 -0600)] 
APItest/t/ Move some tests in the file

The order had been to mostly test in increasing code point order.  This
sorts the two exceptions to comply.

22 months agoAPItest/t/ Split test into 64 vs 32 bit versions
Karl Williamson [Mon, 19 Jun 2017 04:36:21 +0000 (22:36 -0600)] 
APItest/t/ Split test into 64 vs 32 bit versions

It's cleaner to have this test which differs on 32 vs 64 bit platforms
in the appropriate sections that have other tests specific to their

The tests for EBCDIC were arbitrary, just placeholders really, since
these particular tests were added for situations found only on ASCII
platforms.  Therefore, the EBCDIC tests were removed.

22 months agoAPItest/t/ Create block for warnings control
Karl Williamson [Mon, 19 Jun 2017 04:25:39 +0000 (22:25 -0600)] 
APItest/t/ Create block for warnings control

This adds a block that turns off warnings in the whole thing, so that
tests can be more easily be modified in future commits, and the interior
warnings control statments can be removed.

22 months agoAPItest/t/ White-space, comments only
Karl Williamson [Sun, 18 Jun 2017 04:31:58 +0000 (22:31 -0600)] 
APItest/t/ White-space, comments only

This reflows things after the changes in the previous commits

22 months agoAPItest/t/ Remove hash element
Karl Williamson [Sun, 18 Jun 2017 00:58:54 +0000 (18:58 -0600)] 
APItest/t/ Remove hash element

The previous commit has enabled this one to remove another of the hash
elements from the tests data structure.  The value can now be calculated
from the code point.  The element gave the warnings category to used.
But now we use the category based on the code point, with special
handling of the ones that can be true for regular above-Unicode, and
those that are so far above Unicode that they must use Perl's extended

22 months agoAPItest/t/ Remove most tests
Karl Williamson [Sat, 17 Jun 2017 12:43:03 +0000 (06:43 -0600)] 
APItest/t/ Remove most tests

In order to test that the various flags passed to utf8n_to_uvchr()
work independently of each other, previously this file tried all
possible combinations.  But, as explained in the comments added in this
commit, by appropriate use of all the flags that don't apply to
something being tested, we can verify that those flags are independent
of that thing, and cut down the combinatorial complexity significantly.

22 months agoutf8n_to_uvchr() Use correct warnings category
Karl Williamson [Thu, 15 Jun 2017 18:06:57 +0000 (12:06 -0600)] 
utf8n_to_uvchr() Use correct warnings category

The warning about too large a code point should be under the
'non_unicode' warnings category.

22 months agoAPItest/t/ Revamp loop to/from utf8
Karl Williamson [Sun, 2 Jul 2017 15:11:17 +0000 (09:11 -0600)] 
APItest/t/ Revamp loop to/from utf8

This test file had gotten kinda messy as new tasks were shoe horned into
it.  This cleans it up, and positions it to be easier maintain going
forward.  I tried to minimize the number of changes shown per commit,
but this is the minimal I could get, and since it is a revamp, there are
lots of differences.

Some combinatorial explosion has been removed.

A new subroutine is created which compares the expected vs actually
gotten warnings, and is called in two places, removing duplicated code.

This exposed a bug in very large, hence rare, code points.  It will be
fixed in the next commit.  It was far easier to just make all similar
tests TODO here, removing that in the next commit.  This means this
commit has many passing TODOs

22 months agoAPItest/t/ Tighten up tests
Karl Williamson [Fri, 16 Jun 2017 00:53:43 +0000 (18:53 -0600)] 
APItest/t/ Tighten up tests

This commit causes the tests to check that messages containing a code
point have the correct exact wording, including the code point.  The
tests are tightened up somewhat for other messages, but more is coming
in a later commit.

22 months agoAPItest/t/ Skip most tests
Karl Williamson [Fri, 16 Jun 2017 00:27:54 +0000 (18:27 -0600)] 
APItest/t/ Skip most tests

This test file tests every end-of-Unicode-plane noncharacter, and a
middling surrogate, and a nonchar in the interior of the consecutive
range of them.  But, we don't really have to do more than basic testing
for these  middling cases.  We should test that they are detected as
being in their respective categories, but testing that all combinations
of warning and disallowed flags and return flags shouldn't be necessary.
It's sufficient to test for those for the real edge cases.

This cuts the number of tests in this file to somewhat less than 1/3 of
the original.

22 months agoAPItest/t/ Store warnings sans \n
Karl Williamson [Sat, 17 Jun 2017 12:27:59 +0000 (06:27 -0600)] 
APItest/t/ Store warnings sans \n

This will make the output more legible that future commits will create

22 months agoAPItest/t/ Change some test names
Karl Williamson [Thu, 15 Jun 2017 23:35:54 +0000 (17:35 -0600)] 
APItest/t/ Change some test names

This omits distracting detail from subsidiary tests, indenting them from
the major one.

22 months agoAPItest/t/ Simplify some calculations
Karl Williamson [Thu, 15 Jun 2017 22:13:12 +0000 (16:13 -0600)] 
APItest/t/ Simplify some calculations

This commit pulls some variable setting outside an inner loop.  It's
easily settable there, instead of being calculated.  It allows for
removal of another hash element.

22 months agoAPItest/t/ Do formatting outside loop
Karl Williamson [Thu, 15 Jun 2017 21:45:14 +0000 (15:45 -0600)] 
APItest/t/ Do formatting outside loop

To save extra effort

22 months agoAPItest/t/ Improve some more diagnostics
Karl Williamson [Thu, 15 Jun 2017 21:00:08 +0000 (15:00 -0600)] 
APItest/t/ Improve some more diagnostics

This changes the diagnostics when testing utf8n_to_uvchr() so they are
more human readable, and aren't generated until failure.

It also corrects things to display $@ on eval failure (previously it
displayed $!)

22 months agoAPItest/t/ Improve some diagnostics
Karl Williamson [Thu, 15 Jun 2017 20:24:05 +0000 (14:24 -0600)] 
APItest/t/ Improve some diagnostics

This creates a function that will display in more human-readable form
the eval string used for testing uvchr_to_utf8().  And it calls that
function should there be a failure.  Thus the calculations aren't done
unless necessary.

It also corrects a diagnostic to show $@ after an eval failure instead
of $!

22 months agoAPItest/t/ Display mnemonics on error
Karl Williamson [Thu, 15 Jun 2017 18:49:10 +0000 (12:49 -0600)] 
APItest/t/ Display mnemonics on error

Part of the testing for this is that the returned flags for problematic
conditions are correct.  This commit adds a routine that will convert
numeric values of the flags into a mnemonic string like FOO|BAR|BAZ.
This makes debugging easier.  The names are not computed unless there is
an error.

22 months agoAPItest/t/ Rename some variables
Karl Williamson [Wed, 14 Jun 2017 04:48:36 +0000 (22:48 -0600)] 
APItest/t/ Rename some variables

The new names more closely indicate the variables' purposes.

22 months agoAPItest/t/ Make hash element optional
Karl Williamson [Fri, 30 Jun 2017 17:55:18 +0000 (11:55 -0600)] 
APItest/t/ Make hash element optional

This element of the hash gives how many bytes are needed in an
incomplete sequence in order to classify the full sequence.  In some
cases every code point in the category has this be the same number, and
it can be cleaner to not manually specify the number.

22 months agoAPItest/t/ Remove hash elements
Karl Williamson [Fri, 26 May 2017 03:16:29 +0000 (21:16 -0600)] 
APItest/t/ Remove hash elements

These two elements can be calculated from the others

22 months agoAPItest/t/ Remove element from hash
Karl Williamson [Fri, 26 May 2017 03:04:09 +0000 (21:04 -0600)] 
APItest/t/ Remove element from hash

The warning message can be figured out from other elements.

22 months agoAPItest/t/ Eliminate hash element
Karl Williamson [Fri, 26 May 2017 02:09:07 +0000 (20:09 -0600)] 
APItest/t/ Eliminate hash element

This is leftover from an earlier version of the tests, and can be
calculated instead of having to manually specify it.

22 months agoAPItest/t/ Standardize overflow test detection
Karl Williamson [Wed, 14 Jun 2017 21:24:29 +0000 (15:24 -0600)] 
APItest/t/ Standardize overflow test detection

There are two methods currently for detecting if a test is for overflow.
This standardizes on the one where the expected code point is 0, and
uses the already existing variable instead of qr//

22 months agoAPItest/t/utf8.t: Don't test above IV_MAX
Karl Williamson [Mon, 15 May 2017 15:54:40 +0000 (09:54 -0600)] 
APItest/t/utf8.t: Don't test above IV_MAX

For 32-bit platforms, this means moving  the tests to the 64-bit only portion of
the file.  And it comments out the tests that are above 64-bit IV_MAX.

This is in preparation for IV_MAX being the upper legal limit for code

22 months agoAPItest/t/utf8.t: Add a test
Karl Williamson [Wed, 5 Jul 2017 17:31:12 +0000 (11:31 -0600)] 
APItest/t/utf8.t: Add a test

This test will be important when we convert to limiting code points to
at most IV_MAX.

22 months agoAPItest/t/utf8.t: Comments, white-space only
Karl Williamson [Sun, 14 May 2017 04:58:00 +0000 (22:58 -0600)] 
APItest/t/utf8.t: Comments, white-space only

22 months agoAPItest/t/utf8.t: Better handle some platforms
Karl Williamson [Sun, 14 May 2017 04:53:47 +0000 (22:53 -0600)] 
APItest/t/utf8.t: Better handle some platforms

A future commit will cause some expected errors to not actually be
errors on some platforms.  This detects and handles these.

22 months agoAPItest/t/utf8.t: Remove unnecessary hash initializations
Karl Williamson [Sun, 14 May 2017 04:51:43 +0000 (22:51 -0600)] 
APItest/t/utf8.t: Remove unnecessary hash initializations

22 months agoAPItest/t/utf8.t: Fix some convoluted code
Karl Williamson [Sun, 14 May 2017 04:50:26 +0000 (22:50 -0600)] 
APItest/t/utf8.t: Fix some convoluted code

This code got overly complex as time went by, and can be cleaned up.

22 months agoAPItest/t/utf8.t: Rmv useless line
Karl Williamson [Mon, 8 May 2017 15:47:41 +0000 (09:47 -0600)] 
APItest/t/utf8.t: Rmv useless line

This entry is overwritten by the next line.

22 months agoAPItest/t: Change some variable names
Karl Williamson [Tue, 27 Jun 2017 04:27:23 +0000 (22:27 -0600)] 
APItest/t: Change some variable names

One of these is used in multiple test files in this directory.

The names are ambiguous for the contexts they occur in.  'first' can
mean earliest in the string, but here it means the lowest ordinal value.

22 months agoAPItest/t/ Make sure diagnostics are on separate lines
Karl Williamson [Thu, 15 Jun 2017 18:01:15 +0000 (12:01 -0600)] 
APItest/t/ Make sure diagnostics are on separate lines

This changes diagnostic output to guarantee each element of the array
starts on a new line, for easier readability.  The array may or may not
already have terminating \n characters in the elements.

22 months agoAPItest/t/ Split function into two
Karl Williamson [Tue, 30 May 2017 02:58:32 +0000 (20:58 -0600)] 
APItest/t/ Split function into two

This function outputs a byte string as hex bytes.  A future commit will
want that output without surrounding quotes, so create a version that
doesn't have them.

22 months agoutf8n_to_uvchr(): Avoid some work
Karl Williamson [Tue, 27 Jun 2017 04:08:01 +0000 (22:08 -0600)] 
utf8n_to_uvchr(): Avoid some work

By adding a single mask, we can avoid some unnecessary work, as that
work is not necessary if just the one bit is set.

22 months agoutf8.c: Comments, white-space only
Karl Williamson [Fri, 30 Jun 2017 18:37:15 +0000 (12:37 -0600)] 
utf8.c: Comments, white-space only

22 months agoutf8.c: Consolidate duplicated string constants
Karl Williamson [Fri, 30 Jun 2017 18:35:53 +0000 (12:35 -0600)] 
utf8.c: Consolidate duplicated string constants

This reduces maintenance costs if they have to be updated.

22 months agoutf8.c: Don't calc code point from overflowing UTF8
Karl Williamson [Wed, 10 May 2017 02:16:13 +0000 (20:16 -0600)] 
utf8.c: Don't calc code point from overflowing UTF8

This avoids calculating a code point from UTF-8 that is known to
overflow.  This could give incorrect results (used only in warning
messages), but is done only when there are 3 (or more) malformations:
overflow, overlong, UTF-8 terminated early, so it's unlikely to actually
happen in the field.

I am not adding any tests, as I don't know of any existing failures, and
soon there will be a commit that limits code points to be at most
IV_MAX.  That commit will cause cause existing tests to fail without
this fix, so that is good enough to test it.  I imagine a brute force
generator of UTF-8 would find some string that showed this problem up,
absent the other coming changes, but it's not worth it.

22 months agot/uni/parser.t: Skip some tests on 32-bit platforms
Karl Williamson [Tue, 4 Jul 2017 00:59:50 +0000 (18:59 -0600)] 
t/uni/parser.t: Skip some tests on 32-bit platforms

These tests require code points that are too large for 32-bit platforms,
so skip there.

22 months agoMove test from t/opbasic to t/uni
Karl Williamson [Wed, 10 May 2017 02:27:40 +0000 (20:27 -0600)] 
Move test from t/opbasic to t/uni

This test is really not very basic, so it doesn't belong in opbasic.  It
is for having a string delimiter be a very large code point, well above
the legal strict Unicode max.  The code point is 2**32 - 1, which is
UV_MAX on 32-bit platforms.

Use of UV_MAX for a delimiter is about to become illegal, and so this
test needs to be skipped on these.  Since this is compile time, there
are a few complications in getting the script to compile on such
systems, even though it is skipped at run time.

The opbasic test file is so basic that it doesn't even use t/,
whereas the one in t/uni does use that, and that has better
infrastructure for handling this issue, including getting it to work on
EBCDIC platforms.

22 months agot/comp/parser.t: Skip test on 32-bit builds
Karl Williamson [Mon, 3 Jul 2017 17:30:52 +0000 (11:30 -0600)] 
t/comp/parser.t: Skip test on 32-bit builds

This code point is no longer legal on such builds.  We need to use this
code point to trigger the bug, so can't lower it to work on those

22 months agot/op/index.t: Skip now illegal code points on 32 bit builds
Karl Williamson [Mon, 3 Jul 2017 19:52:31 +0000 (13:52 -0600)] 
t/op/index.t: Skip now illegal code points on 32 bit builds

These tests use code points that are now illegal on 32-bit platforms, so
skip them there.  The failures these tests were added for did not happen
except on these now-illegal code points.

22 months agot/op/chop.t: Don't use too large code points
Karl Williamson [Mon, 3 Jul 2017 15:33:09 +0000 (09:33 -0600)] 
t/op/chop.t: Don't use too large code points

The bug this was testing for requires a code point that will no longer
be legal on 32-bit machines.  So skip unless we're on a 64-bit platform,
and revise to use chr() in the skipped code instead of "\x{}".  The
latter would try to be compiled even if execution gets skipped, so would
cause it to die, whereas chr() is runtime, so get skipped if
inappropriate.  This also tested the very highest legal code point on
64-bit machines, which is now illegal, so test the new very highest one.

22 months agot/re/pat_advanced.t: Revise some tests
Karl Williamson [Sun, 2 Jul 2017 16:34:12 +0000 (10:34 -0600)] 
t/re/pat_advanced.t: Revise some tests

These tests used the highest available code points, but those will soon
be made illegal.  The tests don't need to be for these particular code
points, but there do need to be tests of user-defined properties of high
code points, so this commit changes to use the highest ones that will be
legal after that change.

22 months agoRestore a portion of reverted commits
Karl Williamson [Mon, 3 Jul 2017 19:46:42 +0000 (13:46 -0600)] 
Restore a portion of reverted commits

See the previous commit for details.

22 months agoRevert: Restrict code points to <= IV_MAX
Karl Williamson [Mon, 3 Jul 2017 18:26:34 +0000 (12:26 -0600)] 
Revert: Restrict code points to <= IV_MAX

This reverts the two related commits
51099b64db323d0e1d871837f619d72bea8ca2f9  (partially)
13f4dd346e6f3b61534a20f246de3a80b3feb743  (entirely)

I was in the middle of a long branch dealing with this and related
issues when these were pushed to blead.  It was far easier for me to
revert these at the beginning of my branch than to try to rebase
unreverted.  And there are changes needed to the approaches taken in the
reverted commits.  A third related commit,
113b8661ce6d987db4dd217e2f90cbb983ce5d00, doesn't cause problems so
isn't reverted.

I reverted the second commit, then the first one, and squashed them
together into this one.  No other changes were done in this commit.
The reason for the squashing is to avoid problems when bisecting on a
32-bit machine.  If the bisect landed between the commits, it could show
failures.  The portion of the first commit that wasn't reverted was the
part that was rendered moot because of the changes in the meantime that
forbid bitwise operations on strings containing code points above

The next commit in this series will reinstate portions of these commits.
I reverted as much as possible here to make this reversion commit

The biggest problem with these commits, is that some Perl applications
are made vulnerable to Denial of Service attacks.  I do believe it is ok
to croak when a program tries, for example, to do chr() of too large a
number, which is what the reverted commit does (and what this branch
will eventually reinstate doing).  But when parsing UTF-8, you can't
just die if you find something too large.  That would be an easy DOS on
any program, such as a web server, that gets its UTF-8 from the public.
Perl already has a means to deal with too-large code points (before
5.26, this was those code points that overflow the word size), and web
servers should have already been written in such a way as to deal with
these.  This branch just adapts the code so that anything above IV_MAX
is considered to be overflowing.  Web servers should not have to change
as a result.

A second issue is that one of the reasons we did the original
deprecation is so that we can use the forbidden code points internally
ourselves, such as Perl 6 does to store Grapheme Normal Form.  The
implementation should not burn bridges, but allow that use to easily
happen when the time comes.  For that reason, some tests should not be
deleted, but commented out, so they can be quickly adapted.

While working on this branch, I found several unlikely-to-occur bugs in
the existing code.  These should be fixed now in the code that handles
up to UV_MAX code points, so that when we do allow internal use of such,
the bugs are already gone.

I also had researched the tests that fail as a result of the IV_MAX
restriction.  Some of the test changes in these reverted commits were

For example, some tests that got changed were for bugs that happen only
on code points that are now illegal on 32-bit builds.  Lowering the code
point in the test to a legal value, as was done in some instances,  no
longer tests for the original bug.  Instead, where I found this, I just
skip the test on 32-bit platforms.

Other tests were simply deleted, where a lower code point would have
worked, and the test is useful with a lower code point.  I retain such
tests, using a lower code point.  In some cases, it was probably ok to
delete the tests on 32-bit platforms, as something was retained for a
64-bit one, but since I had already done the adaptive work, I retain

And still other tests were from files that I extensively revamp, so I
went with the revamp.

The following few commits fix those as far as possible now.  This is so
that the reversion of the tests and my changes are close together in the
final commit series.  Some changes have to wait to later, as for those
where the entire test files are revamped, or when the deprecation
messages finally go away in the final commit of this series.

In cases where the message wording I was contemplating using conflicts
with the reverted commits, I change mine to use that of the reverted

22 months agot/re/pat_advanced.t: Fix test to work on EBCDIC
Karl Williamson [Tue, 11 Jul 2017 02:11:09 +0000 (20:11 -0600)] 
t/re/pat_advanced.t: Fix test to work on EBCDIC

22 months agot/op/sprintf2.t: Generalize test to work on EBCDIC
Karl Williamson [Tue, 11 Jul 2017 02:09:25 +0000 (20:09 -0600)] 
t/op/sprintf2.t: Generalize test to work on EBCDIC

22 months agoperldelta for 6091bd4ca4a4
Tony Cook [Mon, 10 Jul 2017 06:51:18 +0000 (16:51 +1000)] 
perldelta for 6091bd4ca4a4

22 months ago(perl #131597) ensure the GV slot is filled for our [%$@]foo: attr
Tony Cook [Mon, 19 Jun 2017 04:59:53 +0000 (14:59 +1000)] 
(perl #131597) ensure the GV slot is filled for our [%$@]foo: attr

22 months agoTest that ref works in tainted statements
Father Chrysostomos [Mon, 10 Jul 2017 05:53:52 +0000 (22:53 -0700)] 
Test that ref works in tainted statements

This commit broke Module::Runtime in debugging builds:

commit ba75e9a42bd919d317a4f5deb1e487c13586929d
Author: David Mitchell <>
Date:   Fri Jan 6 14:59:54 2017 +0000

    make OP_REF support boolean context

This commit restored the previous, behaviour:

commit a10e04b588b6b10ac6d059efacd8dec25d14bdb3
Author: David Mitchell <>
Date:   Thu Jun 15 14:29:56 2017 +0100

    pp_ref: do SvSETMAGIC(TARG)

But no test was added to make sure it stays fixed.  Here is a test.

22 months agoperldelta for 67c3640a57440a
Tony Cook [Mon, 10 Jul 2017 05:41:52 +0000 (15:41 +1000)] 
perldelta for 67c3640a57440a

22 months ago(perl #131570) don't skip the temps stack entry we just allocated
Tony Cook [Wed, 21 Jun 2017 05:00:56 +0000 (15:00 +1000)] 
(perl #131570) don't skip the temps stack entry we just allocated

22 months agoAdd test descriptions for some tests in t/base/translate.t.
Vitali Peil [Mon, 26 Jun 2017 23:03:01 +0000 (19:03 -0400)] 
Add test descriptions for some tests in t/base/translate.t.

This partially resolves RT # 131655.

Vitali Peil is now a Perl author.

22 months agoRevert "use symbolic constants for substrs[] indices"
David Mitchell [Wed, 5 Jul 2017 13:02:24 +0000 (14:02 +0100)] 
Revert "use symbolic constants for substrs[] indices"

This reverts commit 2ac902efe11ee156653eb2ca1369f0e5f4546c31.

See thread at Message-ID: <>

22 months agoregcomp.c: use symbolic constants for substrs[] indices
Dagfinn Ilmari MannsÃ¥ker [Wed, 5 Jul 2017 10:51:29 +0000 (11:51 +0100)] 
regcomp.c: use symbolic constants for substrs[] indices

22 months agoperldebug: cross reference to perldebguts
Ricardo Signes [Tue, 4 Jul 2017 18:50:31 +0000 (14:50 -0400)] 
perldebug: cross reference to perldebguts

22 months agobump $PerlIO::scalar::VERSION
Tony Cook [Wed, 21 Jun 2017 07:07:17 +0000 (17:07 +1000)] 
bump $PerlIO::scalar::VERSION

22 months ago(perl #131546) return a reasonable error code opening a read-only scalar
Tony Cook [Wed, 21 Jun 2017 07:07:02 +0000 (17:07 +1000)] 
(perl #131546) return a reasonable error code opening a read-only scalar

22 months ago(perl #131546) some notes on in-memory files for open()
Tony Cook [Mon, 12 Jun 2017 01:03:35 +0000 (11:03 +1000)] 
(perl #131546) some notes on in-memory files for open()