ParseXS: refactor: sort out SCOPE object fields

This commit renames the ExtUtils::ParseXS class field

    xsub_SCOPE_enabled
to
    file_SCOPE_enabled

and adds a new field in the ExtUtils::ParseXS::Node::xsub class:

    SCOPE_enabled

This is because SCOPE can be used either in file scope:

    SCOPE: ENABLE
    int
    foo(...)

or in XSUB scope,

    int
    foo(...)
        SCOPE: ENABLE

The file_SCOPE_enabled field records whether a SCOPE keyword has been
encountered just before the XSUB, while the Node::xsub  SCOPE_enabled
field is initialised to the current value of file_SCOPE_enabled when
XSUB parsing starts, and is updated if the SCOPE keyword is encountered
within the XSUB.

Author: iabyn

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

@@ -235,7 +235,9 @@ BEGIN {
 
   'cur_xbody',                 # The Node::xbody currently being parsed
 
-  'xsub_SCOPE_enabled',        # Bool: SCOPE ENABLEd
+  'file_SCOPE_enabled',        # Bool: the current state of the file-scope
+                               # (as opposed to
+                               # XSUB-scope) SCOPE keyword
   );
 
   # do 'use fields', except: fields needs Hash::Util which is XS, which
@@ -563,9 +565,17 @@ EOM
         ." followed by a statement on column one?)")
       if $self->{line}->[0] =~ /^\s/;
 
-    # Initialize some per-XSUB instance variables:
-
-    $self->{xsub_SCOPE_enabled}        = 0;
+    # The SCOPE keyword can appear both in file scope (just before an
+    # XSUB) and as an XSUB keyword. This field maintains the state of the
+    # former: reset it at the start of processing any file-scoped
+    # keywords just before the XSUB (i.e. without any blank lines, e.g.
+    #     SCOPE: ENABLE
+    #     int
+    #     foo(...)
+    # These semantics may not be particularly sensible, but they maintain
+    # backwards compatibility for now.
+
+    $self->{file_SCOPE_enabled} = 0;
 
     # Process next line
 

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

@@ -265,6 +265,9 @@ BEGIN { $build_subclass->('', # parent
                                #    "2": empty prototype
                                #    other: a specific prototype.
 
+    'SCOPE_enabled',           # "SCOPE: ENABLE" seen, in either the
+                               # file or XSUB part of the XS file
+
 )};
 
 
@@ -278,6 +281,10 @@ sub parse {
     # global PROTOTYPES default
     $self->{prototype} = $pxs->{PROTOTYPES_value};
 
+    # inherit any SCOPE: value that immediately preceded the XSUB
+    # declaration
+    $self->{SCOPE_enabled} = $pxs->{file_SCOPE_enabled};
+
     # Parse the XSUB's declaration (return type, name, parameters)
 
     my $decl = ExtUtils::ParseXS::Node::xsub_decl->new();
@@ -1115,7 +1122,9 @@ sub as_code {
         }
 
         if ($expr =~ m#/\*.*scope.*\*/#i) {  # "scope" in C comments
-            $pxs->{xsub_SCOPE_enabled} = 1;
+            # XXX this really aught to be determined during parse rather
+            # than during code emitting.
+            $xsub->{SCOPE_enabled} = 1;
         }
 
         # Specify additional environment for when a template derived from a
@@ -1172,7 +1181,7 @@ sub as_code {
                         $else;
         }
     }
-    elsif ($pxs->{xsub_SCOPE_enabled} or $init_code !~ /^\s*\Q$var\E =/) {
+    elsif ($xsub->{SCOPE_enabled} or $init_code !~ /^\s*\Q$var\E =/) {
         # The template is likely a full block rather than a '$var = ...'
         # expression. Just terminate the variable declaration, and defer the
         # initialisation.
@@ -2352,7 +2361,7 @@ sub as_code {
     # Emit trailers for the body of the XSUB
     # ----------------------------------------------------------------
 
-    if ($pxs->{xsub_SCOPE_enabled}) {
+    if ($xsub->{SCOPE_enabled}) {
         # the matching opens were emitted in input_part->as_code()
         print "      $close_brace\n";
         # PPCODE->as_code emits its own LEAVE and return, so this
@@ -2467,7 +2476,7 @@ sub as_code {
     }
 
     # The matching closes will be emitted in xbody->as_code()
-    print ExtUtils::ParseXS::Q(<<"EOF") if $pxs->{xsub_SCOPE_enabled};
+    print ExtUtils::ParseXS::Q(<<"EOF") if $xsub->{SCOPE_enabled};
         |      ENTER;
         |      $open_brace
 EOF
@@ -3054,7 +3063,12 @@ sub parse {
         if $pxs->{cur_xsub}->{seen_SCOPE};
     $pxs->{cur_xsub}->{seen_SCOPE} = 1;
 
-    $pxs->{xsub_SCOPE_enabled} = $self->{enable};
+    # Note that currently this parse method can be called either while
+    # parsing an XSUB, or while processing file-scoped keywords
+    # just before an XSUB declaration. Sop potentially set both types of
+    # state.
+    $pxs->{cur_xsub}{SCOPE_enabled} = $self->{enable} if $pxs->{cur_xsub};
+    $pxs->{file_SCOPE_enabled}      = $self->{enable};
     1;
 }
 
@@ -3567,7 +3581,7 @@ sub as_code {
 
     $self->SUPER::as_code($pxs, $xsub, $xbody); # emit code block
 
-    print "\tLEAVE;\n" if $pxs->{xsub_SCOPE_enabled};
+    print "\tLEAVE;\n" if $pxs->{cur_xsub}{SCOPE_enabled};
 
     # Suppress "statement is unreachable" warning on HPUX
     print "#if defined(__HP_cc) || defined(__HP_aCC)\n",