Personally, I would rather use YAML or one of the config-modules from CPAN, but it seems, other non-Perl programs are also depending on the environment, right?

This imperfect script should do some very basic parsing and interpolation. However, it would fail in situations like Y=`echo fails` or where here-documents are involved. If you need every functionality that you shell provides, stay with it. You might be able to get rid of the wrapper script using exec or system, though.

use strict;
use warnings;
use Shell::Parser;
use Data::Dumper;


sub parse_shellscript_from_fh {
  my ($fh) = @_;
  my %vars;

  my $parser = new Shell::Parser syntax => 'bash',
    handlers => {
         assign => sub {
           my ($self, %args)  = @_;
           my ($name, $value) =
             $args{token} =~ /^\s*(\w+)\s*=\s*\"(.*)\"\s*$/s;

           if ( defined $value ) {
             #-- multi-line/array? $value =~ s/\n//msg;
             $vars{$name} = $value;
           } else {
             warn "No value for variable ", ($name//'?'), "\n";
           }
         }
        };

  #-- parsing
  my $text = join("", <$fh>);
  $parser->parse(  $text );
  $parser->eof;


  #-- rudimentary variable interpolation
  my $max_passes = 5;
  my $not_substituted;
  for (1 .. $max_passes ) {
    $not_substituted = 0;
    foreach my $varname ( keys %vars ) {
      $vars{$varname} =~ s|\$(\w+)| $vars{$1} // do{ "\$$1" } |ge;
      $not_substituted += $vars{$varname} =~ tr/$/$/;
    }
    last unless $not_substituted;
  }

  die "Recursion or too few parses ... " if $not_substituted;

  return \%vars;
}



print "Vars: ", Dumper( parse_shellscript_from_fh( *DATA ) ), "\n";



__DATA__
A="foo"
B="some other data"
C="appending $A"
D="
  some list
  with more data
  and $B
"

X=<<EOF
  does not work there
EOF

Y=`echo fails`
[download]

Result:

No value for variable ?
No value for variable ?
Vars: $VAR1 = {
          'A' => 'foo',
          'D' => '
  some list
  with more data
  and some other data
',
          'C' => 'appending foo',
          'B' => 'some other data'
        };
[download]

That's awesome. Thanks. I don't like that that module was last maintained ~8 years ago, but it works. (I've also got to figure out why $not_substituted is getting set with my data - seems to work when I remove that die)

#!/usr/bin/perl
use warnings;
use strict;

use Data::Dumper;

my $VARNAME = qr/[A-Z_][A-Z_0-9]*/;

my %env;
while (<>) {
    if (/^($VARNAME)="(.*)"$/) {
        $env{$1} = $2;
    } elsif (/^($VARNAME=")$/) {
        my $var = $1;
        my @val;
        my $line;
        until (($line = <>) =~ /"/) {
            chomp $line;
            push @val, $line;
        }
        $line =~ s/".*//s;
        push @val, $line;
        $env{$var} = \@val;
    } else {
        warn "Invalid line $.\n";
    }
}
while (my ($key, $value) = each %env) {
    if (ref $value) {
        s/\$($VARNAME)/$env{$1}/g for @$value;
    } else {
        $value =~ s/\$($VARNAME)/$env{$1}/g;
    }
    $env{$key} = $value;
}
print Dumper \%env;
[download]

G'day ag4ve,

This works with the example foo.conf file you posted; however, I would recommend checking that your example data is representative of your real data.

$ perl -Mstrict -Mwarnings -Mautodie -e '
    my %conf;
    open my $fh, "<", "foo.conf";
    my $data = do { local $/; <$fh> };
    $conf{$1} = $2 while $data =~ /(\w+)="([^"]*)"/g;
    s/\$(\w+)/$conf{$1}/g for values %conf;

    use Data::Dumper;
    print Dumper \%conf;
'
$VAR1 = {
          'A' => 'foo',
          'C' => 'appending foo',
          'B' => 'some other data',
          'D' => '
  some list
  with more data
  and some other data
'
        };
[download]

If I understand correctly, you have a config file on the one hand and a shell script that reads it and source the environment on the other hand. If my comprehension is correct, then simply reading the config file within the Perl program might be easier.