ParseXS: handle PROTOTYPES keyword.

See the previous commit for a general discussion on the problems
with ENABLE/DISABLE-valued keywords.

This commit specifically updated how the PROTOTYPES: keyword is handled.

Compared with the previous production release, PROTOTYPES now:

is stricter in validation:

it still accepts ENABLE or DISABLE in a case-insensitive matter, but now
treats any trailing text as an error, apart from possibly a 'D' or
':'. So Anything apart these forms are compile-time errors now:

    ENABLE
    enable
    Enabled
    DISABLE;
    DisablED;
    etc

For backwards compatibility it still treats anything apart from
/^ENABLE/ as false; so all except the first example above are treated
as DISABLE. But now, it warns if the keyword has been accepted but isn't
one of ENABLE/DISABLE.

Author: iabyn

dist/ExtUtils-ParseXS/lib/ExtUtils/ParseXS/Node.pm

@@ -3425,14 +3425,21 @@ sub parse {
     my ($keyword) = ($self =~ /(\w+)=/); # final component of class name
 
     if ($keyword eq 'PROTOTYPES') {
-        # XXX note that for backwards compatibility, parsing the PROTOTYPES
-        # keyword's value is very lax: it is case insensitive, and ignores
-        # any trailing garbage on the line
-        unless ($s =~ /^(ENABLE|DISABLE)\b/i) {
-            my ($keyword) = ($self =~ /(\w+)=/); # final component of class name
+        # For backwards compatibility, parsing the PROTOTYPES
+        # keyword's value is very lax: in particular, anything that
+        # didn't match 'ENABLE' (such as 'Enabled' or 'ENABLED') used to
+        # be treated as valid but false. Continue to use this
+        # interpretation for backcomp, but warn.
+
+        unless ($s =~ /^ ((ENABLE|DISABLE) D? ;?) \s* $ /xi) {
             $pxs->death("Error: $keyword: ENABLE/DISABLE")
         }
-        $self->{enable} = uc($1) eq 'ENABLE' ? 1 : 0;
+        my ($value, $en_dis) = ($1, $2);
+        $self->{enable} = $en_dis eq 'ENABLE' ? 1 : 0;
+        unless ($value =~ /^(ENABLE|DISABLE)$/) {
+            $pxs->Warn("Warning: invalid PROTOTYPES value '$value' interpreted as "
+                . ($self->{enable} ? 'ENABLE' : 'DISABLE'));
+        }
     }
     else {
         # SCOPE / VERSIONCHECK / EXPORT_XSUB_SYMBOLS

dist/ExtUtils-ParseXS/t/001-basic.t

@@ -4307,21 +4307,6 @@ EOF
             [ 1, 0, qr{Error: VERSIONCHECK: ENABLE/DISABLE}, "should die" ],
         ],
 
-        [
-            "PROTOTYPES: long word",
-            [ Q(<<'EOF') ],
-                |PROTOTYPES: ENABLEblah
-EOF
-            [ 1, 0, qr{Error: PROTOTYPES: ENABLE/DISABLE}, "should die" ],
-        ],
-        [
-            "PROTOTYPES: trailing text (stupid but legal)",
-            [ Q(<<'EOF') ],
-                |PROTOTYPES: diSAble blah # bloo +$%
-EOF
-            [ 0, 0, qr{dXSARGS}, "boot fn generated" ],
-        ],
-
         [
             "EXPORT_XSUB_SYMBOLS: long word",
             [ Q(<<'EOF') ],
@@ -4370,7 +4355,125 @@ EOF
 
 
 {
-    # Test per-XSUB ENABLE/DISABLE keywords
+    # Test PROTOTYPES keyword. Note that there is a lot of
+    # backwards-compatibility oddness in the keyword's value
+
+    my $preamble = Q(<<'EOF');
+        |MODULE = Foo PACKAGE = Foo
+        |
+EOF
+
+    my @test_fns = (
+        [
+            "PROTOTYPES: ENABLE",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: ENABLE
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 0, 0, qr{newXSproto_portable.*"\$\$"}, "has proto" ],
+        ],
+        [
+            "PROTOTYPES: ENABLED",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: ENABLED
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 0, 0, qr{newXSproto_portable.*"\$\$"}, "has proto" ],
+            [ 1, 0, qr{Warning: invalid PROTOTYPES value 'ENABLED' interpreted as ENABLE},
+                    "got warning" ],
+        ],
+        [
+            "PROTOTYPES: ENABLE;",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: ENABLE;
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 0, 0, qr{newXSproto_portable.*"\$\$"}, "has proto" ],
+            [ 1, 0, qr{Warning: invalid PROTOTYPES value 'ENABLE;' interpreted as ENABLE},
+                    "got warning" ],
+        ],
+
+        [
+            "PROTOTYPES: DISABLE",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: DISABLE
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 0, 1, qr{"\$\$"}, "doesn't have proto" ],
+        ],
+        [
+            "PROTOTYPES: DISABLED",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: DISABLED
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 0, 1, qr{"\$\$"}, "doesn't have proto" ],
+            [ 1, 0, qr{Warning: invalid PROTOTYPES value 'DISABLED' interpreted as DISABLE},
+                    "got warning" ],
+        ],
+        [
+            "PROTOTYPES: DISABLE;",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: DISABLE;
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 0, 1, qr{"\$\$"}, "doesn't have proto" ],
+            [ 1, 0, qr{Warning: invalid PROTOTYPES value 'DISABLE;' interpreted as DISABLE},
+                    "got warning" ],
+        ],
+
+        [
+            "PROTOTYPES: long word",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: ENABLEblah
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 1, 0, qr{Error: PROTOTYPES: ENABLE/DISABLE}, "should die" ],
+        ],
+        [
+            "PROTOTYPES: trailing text",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: ENABLE blah
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 1, 0, qr{Error: PROTOTYPES: ENABLE/DISABLE}, "should die" ],
+        ],
+        [
+            "PROTOTYPES: trailing text and comment)",
+            [ Q(<<'EOF') ],
+                |PROTOTYPES: DISABLE blah # bloo +$%
+                |
+                |void
+                |foo(int a, int b)
+EOF
+            [ 1, 0, qr{Error: PROTOTYPES: ENABLE/DISABLE}, "should die" ],
+        ],
+
+
+    );
+
+    test_many($preamble, 'boot_Foo', \@test_fns);
+}
+
+
+{
+    # Test per-XSUB ENABLE/DISABLE keywords except PROTOTYPES
 
     my $preamble = Q(<<'EOF');
         |MODULE = Foo PACKAGE = Foo