Perl - Multi-line Regex & Appending Based on Capture Group

On the face of it, you are asking for the range operator.

while (<$fh>)
{   
    if (/^\s*VALUE LABELS/ .. /\.$/) {
        # a line between the two identified above (including them)
        # process as below
    }
}

Your specification "to the period" is a little simple, but I trust that you know your data.

However, since your files have been "cleaned up" so that they have only blocks of the shown format, you don't really need to identify the range. The rest of the code is fairly straightforward.

Based on the data I take 7 or 9 to be the last in a group of numbers which is first on the line, followed by spaces and those phrases. Please clarify if this isn't correct.

my (%res, $label_name);    
while (<$fh>) 
{
    next if /^\s*$/;

    if (/^\s*VALUE LABELS\s*(.*)/) {
        $label_name = $1;
        next;
    }

    if (/^\d*7\s*'(Not Applicable)'/i or /^\d*9\s*'(Don't Know)'/i)  # '
    {
        # $1 has either "Not Applicable" or "Don't Know"
        push @{$res{uc $1}}, $label_name;
    } 
}
print "$_: @{$res{$_}}\n" for keys %res;

This prints the desired output.

We reset the $label_name once that line is encountered. Empty lines are skipped as well.

The data winds up in the hash %res with keys which are those two captured phrases. The value for each key is an anonymous array, and $label_name for that block is added each time a phrase is detected. This is done by pushing it to the dereferenced array for that key, @{ $res{$1} }.

For references and complex data structures see tutorial perlreftut and cookbook perldsc.

The uc is used to change to upper case, per desired output format. This is a little wasteful since uc runs every single time. You can instead omit it and post-process the obtained hash. That does involve copying the hash into a new one, which may or may not be more efficient. Or, you can use uc only when printing out the results.

In order to append content to a file open it in the append mode, with '>>'. See below.

What remains is to connect this with the processing you show, that cleans up the data. I don't know why you need to process the file as a string. There may well be good reasons for that, but I would not recommend it for what the question asks, after the data has been cleaned up. A regex on a multi-line text in place of the above simple processing is much harder and brittle to changes.

One change in your code is necessary, with how record separators are used. Normally you want to localize their changes, not set them in the BEGIN block. Like so

my $file_content;
CLEAN_UP_DATA: {
    local $/;  # slurp the file ($/ is now undef)
    open my $fh, '<', $file or die "Can't open $file: $!";
    $file_content = <$fh>;    
    # process file content, for example like with code in the question
};

# Here $/ is whatever it was before the block, likely the good old default

I named the block (CLEAN_UP_DATA:) just so, that isn't necessary. The semicolon at the end }; is. Note, once we unset $/ the whole file is read into a string at once. (Your while (<$infile>) has one iteration. You can see this by printing $. inside the loop.)

Then you can continue. One way is to break the string with cleaned up content into lines

foreach my $line (split /\n/, $file_content) {
    # process line by line
}

and use the code in this answer as it stands (or other line-by-line approaches).

Another way is to simply write out the cleaned-up file and open that afresh.

CLEAN_UP_DATA: {
    local $/;  # slurp the file ($/ is now undef)
    open my $fh, '<', $file or die "Can't open $file: $!";
    my $file_content = <$fh>;    
    # process file content
    my $fh_out, '>', $outfile  or die "Can't open $outfile: $!";
    # write it out
}; 

open my $fh, '<', $outfile  or die "Can't open $outfile: $!";
# Process line by line, obtaining %res
close $fh;

open my $fh_app, '>>', $outfile  or die "Can't open $outfile to append: $!";
# Now append results as needed, for example
print $fh_app "$_: @{$res{$_}}\n" for keys %res;

Here you can also use code in this answer as is, or other line-by-line solutions.