Release cperl-5.27.0

Highlights:
* study HASH CODE ARRAY with hash shrink.
* much faster HASH split (10^8x faster, which is measurable even
  if not often used)
* strict hashpairs
* on BOM set utf8 and unicode_strings
* Safer perl -c:s cmdline flag
* Faster glob
* dtraces probes for hash and globs
* Initial pgcc compiler support
* Support long paths (>4096)
* Many mingw and cygwin fixes.

Changes:
* Add strict hashpairs to perlfunc.pod MAP and perldata.pod List value constructors.
* Simplify MSVC deploy, no powershell smoke
* Adjust cygwin/mingw install+pkg deploy

Author: rurban

appveyor.yml

@@ -73,14 +73,14 @@ build_script:
   - if "%CYGWIN%"=="1" sh ./Configure -des -Dusedevel & make
 
 test_script:
-  - ps: if ($env:MSVC_VERSION -gt 0) {
-      $A = Start-Process -FilePath .\t\appveyor-smoke.bat -Wait -passthru;$a.ExitCode }
+  - ps: if ($env:MSVC_VERSION -gt 0) { $env:MSVC = 1 }
+  - if "%MSVC%"=="1"   t\appveyor-smoke.bat
   - if "%CYGWIN%"=="1" make -s test
   - if "%MINGW%"=="1"  make -s -C win32 %MKOPT% test
 
 before_deploy:  
-  - if "%CYGWIN%"=="1" %CYGR%\bin\sh -lc "cd $APPVEYOR_BUILD_FOLDER; make install DESTDIR=/cygdrive/c/projects/cperl/inst && tar cvfj ${APPVEYOR_REPO_TAG_NAME}-cygwin-${platform}.tar.bz2 -C /cygdrive/c/projects/cperl/inst"
-  - if "%MINGW%"=="1" sh -lc "cd $APPVEYOR_BUILD_FOLDER; make install DESTDIR=/c/projects/cperl/inst && tar cvfj ${APPVEYOR_REPO_TAG_NAME}-mingw-${platform}.tar.bz2 -C /c/projects/cperl/inst"
+  - if "%CYGWIN%"=="1" %CYGR%\bin\sh -lc "cd $APPVEYOR_BUILD_FOLDER; make install DESTDIR=/cygdrive/c/projects/cperl/inst && cd /cygdrive/c/projects/cperl/inst && tar Jcvf ${APPVEYOR_REPO_TAG_NAME}-cygwin-${platform}.tar.xz *"
+  - if "%MINGW%"=="1" sh -lc "cd $APPVEYOR_BUILD_FOLDER; make install DESTDIR=/c/projects/cperl/inst && cd /c/projects/cperl/inst && tar Jcvf ${APPVEYOR_REPO_TAG_NAME}-mingw-${platform}.tar.xz *"
 
 # appveyor cannot glob * in names
 artifacts:
@@ -96,16 +96,16 @@ artifacts:
   - path: $(APPVEYOR_REPO_TAG_NAME)-win64.exe
     name: tagged-64
     type: exe
-  - path: $(APPVEYOR_REPO_TAG_NAME)-cygwin-x86.tar.bz2
+  - path: $(APPVEYOR_REPO_TAG_NAME)-cygwin-x86.tar.xz
     name: cygwin-32
     type: tar
-  - path: $(APPVEYOR_REPO_TAG_NAME)-cygwin-x64.tar.bz2
+  - path: $(APPVEYOR_REPO_TAG_NAME)-cygwin-x64.tar.xz
     name: cygwin-64
     type: tar
-  - path: $(APPVEYOR_REPO_TAG_NAME)-mingw-x86.tar.bz2
+  - path: $(APPVEYOR_REPO_TAG_NAME)-mingw-x86.tar.xz
     name: mingw-32
     type: tar
-  - path: $(APPVEYOR_REPO_TAG_NAME)-mingw-x64.tar.bz2
+  - path: $(APPVEYOR_REPO_TAG_NAME)-mingw-x64.tar.xz
     name: mingw-64
     type: tar
 
@@ -121,13 +121,13 @@ deploy:
   force_update: true
   on:
     branch: /(master|relprep|cperl-tag-deploy-test)/
-    MSVC_VERSION: 12
 - provider: GitHub
   tag: $(APPVEYOR_REPO_TAG_NAME)-win
   description: 'cperl windows sfx tagged (msvcr120.dll)'
   auth_token:
     secure: AsIAOIgCJX0QhrUKal2V00aaB5nRWtmtFTFeDVsGnbJLeEQpv9avUp0HT1cA8bNs
-  artifact: tagged-32,tagged-64,cygwin-32,cygwin-64,mingw-32,mingw-64
+  artifact: tagged-32,tagged-64,cygwin-32,cygwin-64
+  #artifact: tagged-32,tagged-64,cygwin-32,cygwin-64,mingw-32,mingw-64
   draft: true
   force_update: true
   on:

pod/perlcdelta.pod

@@ -189,6 +189,17 @@ L<perldtrace/"glob/gv call statistics"> sections.
 
 =back
 
+=head3 L<perldata>, L<perlfunc>
+
+=over 4
+
+=item *
+
+Added new pairwise hash contruction limitations to L<perldata/"List
+value constructors"> and L<perlfunc/"map EXPR,LIST">.
+
+=back
+
 =head1 Diagnostics
 
 The following additions or changes have been made to diagnostic output,

pod/perldata.pod

@@ -1018,12 +1018,30 @@ This can be used to provide overridable configuration defaults:
     # values in %args take priority over %config_defaults
     %config = (%config_defaults, %args);
 
+
+Hashes need to be assigned from list pairs. Under C<use warnings 'misc'>
+an odd number of list elements is warned with "Odd number of elements
+in hash assignment". Since cperl 5.27 under C<use strict> hash assignment
+from lists must be from pairs, and from map even from an empty or
+single pair only.
+
+    {
+      no strict;
+      my %h = (0..2); # warning
+      my %h = map {$_} (0..1); # warning
+    }
+    {
+      use strict;
+      my %h = (0..2);          # error
+      my %h = map {$_} (0..1); # error
+      my %h = map {$_=>1, $_+1=>1} (0..1); # error
+    }
+
 =head2 Subscripts
 
-An array can be accessed one scalar at a
-time by specifying a dollar sign (C<$>), then the
-name of the array (without the leading C<@>), then the subscript inside
-square brackets.  For example:
+An array can be accessed one scalar at a time by specifying a dollar
+sign (C<$>), then the name of the array (without the leading C<@>),
+then the subscript inside square brackets.  For example:
 
     @myarray = (5, 50, 500, 5000);
     print "The Third Element is", $myarray[2], "\n";

pod/perlfunc.pod

@@ -3427,9 +3427,9 @@ relatives.  In particular, it is not limited to using regular expressions.
 
 Evaluates the BLOCK or EXPR for each element of LIST (locally setting
 L<C<$_>|perlvar/$_> to each element) and returns the list value
-consisting of those
-elements for which the expression evaluated to true.  In scalar
-context, returns the number of times the expression was true.
+consisting of those elements for which the expression evaluated to
+true.  In scalar context, returns the number of times the expression
+was true.
 
     my @foo = grep(!/^#/, @bar);    # weed out comments
 
@@ -3438,15 +3438,14 @@ or equivalently,
     my @foo = grep {!/^#/} @bar;    # weed out comments
 
 Note that L<C<$_>|perlvar/$_> is an alias to the list value, so it can
-be used to
-modify the elements of the LIST.  While this is useful and supported,
-it can cause bizarre results if the elements of LIST are not variables.
-Similarly, grep returns aliases into the original list, much as a for
-loop's index variable aliases the list elements.  That is, modifying an
-element of a list returned by grep (for example, in a C<foreach>,
-L<C<map>|/map BLOCK LIST> or another L<C<grep>|/grep BLOCK LIST>)
-actually modifies the element in the original list.
-This is usually something to be avoided when writing clear code.
+be used to modify the elements of the LIST.  While this is useful and
+supported, it can cause bizarre results if the elements of LIST are
+not variables.  Similarly, grep returns aliases into the original
+list, much as a for loop's index variable aliases the list elements.
+That is, modifying an element of a list returned by grep (for example,
+in a C<foreach>, L<C<map>|/map BLOCK LIST> or another L<C<grep>|/grep
+BLOCK LIST>) actually modifies the element in the original list.  This
+is usually something to be avoided when writing clear code.
 
 If C<$_> is lexical in the scope where the C<grep> appears, because it has
 been declared with C<my $_>, then, in addition to being locally aliased to
@@ -4076,12 +4075,11 @@ X<map>
 =for Pod::Functions apply a change to a list to get back a new list with the changes
 
 Evaluates the BLOCK or EXPR for each element of LIST (locally setting
-L<C<$_>|perlvar/$_> to each element) and returns the list value composed
-of the
-results of each such evaluation.  In scalar context, returns the
-total number of elements so generated.  Evaluates BLOCK or EXPR in
-list context, so each element of LIST may produce zero, one, or
-more elements in the returned value.
+L<C<$_>|perlvar/$_> to each element) and returns the list value
+composed of the results of each such evaluation.  In scalar context,
+returns the total number of elements so generated.  Evaluates BLOCK or
+EXPR in list context, so each element of LIST may produce zero, one,
+or more elements in the returned value.
 
     my @chars = map(chr, @numbers);
 
@@ -4122,21 +4120,21 @@ clearer in most cases.  See also L<C<grep>|/grep BLOCK LIST> for a
 list composed of those items of the original list for which the BLOCK
 or EXPR evaluates to true.
 
-If C<$_> is lexical in the scope where the C<map> appears (because it has
-been declared with the deprecated C<my $_> construct),
-then, in addition to being locally aliased to
-the list elements, C<$_> keeps being lexical inside the block; that is, it
-can't be seen from the outside, avoiding any potential side-effects.
-
-C<{> starts both hash references and blocks, so C<map { ...> could be either
-the start of map BLOCK LIST or map EXPR, LIST.  Because Perl doesn't look
-ahead for the closing C<}> it has to take a guess at which it's dealing with
-based on what it finds just after the
-C<{>.  Usually it gets it right, but if it
-doesn't it won't realize something is wrong until it gets to the C<}> and
-encounters the missing (or unexpected) comma.  The syntax error will be
-reported close to the C<}>, but you'll need to change something near the C<{>
-such as using a unary C<+> or semicolon to give Perl some help:
+If C<$_> is lexical in the scope where the C<map> appears (because it
+has been declared with the deprecated C<my $_> construct), then, in
+addition to being locally aliased to the list elements, C<$_> keeps
+being lexical inside the block; that is, it can't be seen from the
+outside, avoiding any potential side-effects.
+
+C<{> starts both hash references and blocks, so C<map { ...> could be
+either the start of map BLOCK LIST or map EXPR, LIST.  Because Perl
+doesn't look ahead for the closing C<}> it has to take a guess at
+which it's dealing with based on what it finds just after the C<{>.
+Usually it gets it right, but if it doesn't it won't realize something
+is wrong until it gets to the C<}> and encounters the missing (or
+unexpected) comma.  The syntax error will be reported close to the
+C<}>, but you'll need to change something near the C<{> such as using
+a unary C<+> or semicolon to give Perl some help:
 
  my %hash = map {  "\L$_" => 1  } @array # perl guesses EXPR. wrong
  my %hash = map { +"\L$_" => 1  } @array # perl guesses BLOCK. right
@@ -4154,6 +4152,24 @@ or to force an anon hash constructor use C<+{>:
 
 to get a list of anonymous hashes each with only one entry apiece.
 
+Assignment to hashes is stricter under use L<strict> with the default
+C<'hashpairs'> in cperl. Without strict hashpairs the list elements
+constructed in the block can be of arbitrary size, only under C<use
+warnings 'misc'> an odd number of elements is warned about.  With
+strict hashpairs the list elements constructed in the block can only
+be an empty pair or a single pair, but not an odd number and not
+multiple pairs. I<cperl only>
+
+    use strict; my %h = map{ $_ } @_;
+
+    => Error: Only pair in map hash assignment allowed while "strict
+              hashpairs", got 1 elements
+
+    use strict; my %h = map{$_ => 1, $_+1 => 2} (0..1);
+
+    => Error: Only pair in map hash assignment allowed while "strict
+              hashpairs", got 4 elements
+
 =item mkdir FILENAME,MASK
 X<mkdir> X<md> X<directory, create>
 

t/appveyor-smoke.bat

@@ -32,6 +32,7 @@ nmake test CCTYPE=MSVC120 USE_NO_REGISTRY=define || exit /b
 
 rem install on master/relprep/tag
 if "%APPVEYOR_REPO_TAG%" == "true" goto tag
+echo branch %APPVEYOR_REPO_BRANCH%
 if "%APPVEYOR_REPO_BRANCH%" == "master" goto nightly
 if "%APPVEYOR_REPO_BRANCH%" == "smoke/relprep" goto nightly
 if "%APPVEYOR_REPO_BRANCH%" == "cperl-tag-deploy-test" goto nightly