Consider using a different storage format. I would choose JSON:

See also Re^4: The safety of string eval and block eval. and Re^2: Storing state of execution

Updates:

"Arbitary structures" was not meant as arbitary as I wrote, thanks tobyink++. It should read something like "any mix of scalars, arrays, and hashes, without circular references, handles, code references, globs".

"Memory usage attack" means that either the parsed file uses significantly more memory (several orders of magnitute) than the file size, or parsing the file may execute code that allocates much memory.

"Unexpected network access" means either that parsing the file completely and correctly may require reading additional data from the internet, or parsing the file may execute code that accesses the network.

"8 bit clean" means that any binary data may be stored and fetched.

Added comments column

Added Data::Dumper

Alexander

JSON cannot store "arbitrary structures". Not unless your definition of "arbitrary" is extremely limited. It can't contain cyclic references for example. Something like this can be represented in Perl code, Storable, YAML, and (using IDREF) probably in XML, but not JSON…

use strict;
use warnings;
use Data::Dumper qw(Dumper);
use YAML::XS qw(Dump);

my $data = do {
   my $child  = {};
   my $parent = { child => $child };
   $child->{parent} = $parent;
};

print "#### Perl ####\n";
print Dumper($data), "\n";

print "#### YAML ####\n";
print Dump($data), "\n";
[download]

JSON cannot store "arbitrary structures". Not unless your definition of "arbitrary" is extremely limited. It can't contain cyclic references for example.

You are right.

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)

Hello victorz22,

I tried using eval...

Actually, this is a job for the do EXPR syntax (see do). With data file dir/hash_file.txt under the script’s directory and its contents corrected as per kevbot’s answer, the following script:

use strict;
use warnings;
use Data::Dumper;

our %hash;

cycleUsesForLibs('./dir', 'Scope', 'hash_file.txt', 'model');

sub cycleUsesForLibs
{
    my ($fileDirectory, $scopeName, $fileName, $modelName) = @_;

    chdir  $fileDirectory;
    do     $fileName;
    my     @hashData = $hash{$scopeName}{$modelName};
    my     @dereferencedData;
    push   @dereferencedData, @$_ for @hashData;
    print "Data: \n", Dumper(@dereferencedData);
}
[download]

gives this output:

14:35 >perl 1777_SoPW.pl
Data:
$VAR1 = 'data I need';
$VAR2 = 'another row of needed data';
$VAR3 = 'more data I need';

14:36 >
[download]

Note:

1. With use strict in place (as it always should be!), it’s necessary to declare our %hash before referencing it in $hash{$scopeName}{$modelName}.
2. You want @dereferencedData to contain all the lines of data, not just the last one, so you need to push these onto the array. The code you show just overwrites the array on each iteration of the foreach loop.

Hope that helps,

Thank you however the code didn't work, i get an error saying i cant use an undefined value as an array reference on the line with the push statement. Also because my function will be called multiple times will the global %hash variable be overwritten? Im not sure how the global will work for multpile different hashes all using one global.

i get an error saying i cant use an undefined value as an array reference on the line with the push statement.

Then the hash wasn’t correctly read-in from the data file. Have you fixed the format of the data as kevbot showed? Without further details (see The SSCCE), it’s impossible to know where the problem lies.

<Update>
Add the error handling code shown at the end of the do documentation to determine whether the do statement (1) failed to read the file, (2) read the file but failed to parse (compile) it, or (3) successfully read and parsed the file. Then print out the contents of %hash to see exactly what data was read in.
</Update>

Also because my function will be called multiple times will the global %hash variable be overwritten?

Yes, of course, each time the subroutine is called the do $fileName; statement will overwrite %hash with the data in the indicated file.

Hope that helps,

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

%hash = ( 
      #scope changes
      Scope => {
            model => [
                  'data I need',
                  'another row of needed data',
                  'more data I need'
            ]
      },
      IrreleventScope => {
          #don't need this stuff
      }       
);
[download]

Thanks for catching my error but that isn't my actual hash it was only an example. I can't post the actual one but it does have a semicolon as well as the 1 at the end of the file.

As kevbot said your example is flawed.

This works for me

use strict; use warnings; 
use Data::Dumper; 
  my %hash;

  my $loadedFile = join "", <DATA>;
{
    no strict; 
    eval ($loadedFile);
    if ($@) {print 'eval error:'.$@."\n"; } 

} 


    my @hashData  = $hash{Scope}{model};

    my @dereferencedData;
    foreach my $line (@hashData){
        @dereferencedData = @$line;
    }
        
    print "Data: \n";
    print Dumper @dereferencedData;
    print "\n";

__DATA__
%hash = ( 
      #scope changes
      Scope => {
            model => [
                  1,2,3,4,5,6
            ]

      },
      IrreleventScope =>{
                  a=>'b'
            }       

)
;
[download]

Data:
$VAR1 = 1;
$VAR2 = 2;
$VAR3 = 3;
$VAR4 = 4;
$VAR5 = 5;
$VAR6 = 6;
[download]

Thank you but the solution didnt work for me, I still get an uninitialized variable for my @hashData. However i was able to get your code to load in $loadedFile.

If it did not work for you (but you don't explain i which respect it did not work) and worked for huck, then it is likely there's something wrong in the code you did not show, perhaps in the hash initialization you replaced with pseudo-code.

I still get an uninitialized variable for my @hashData.

Then it seems obvious that you're not loading a value with this line:

my @hashData  = $hash{Scope}{model};

Side note: This should probably read more like:

my @hashData  = @$hash{Scope}{model};

Never assume there is data where you expect it to be when it is coming from an outside source. Check it first. For example:

my @hashData  = ();
if (!defined $hash{Scope}{model}) {
    print "Scope and model missing!\n";
} else {
    @hashData = @$hash{Scope}{model};
}
[download]

...or something of that ilk.

use strict; use warnings; 
use Data::Dumper; 
my %hash;

my $loadedFile = do {local $/=undef; <DATA>};
{
    no strict; 
    eval ($loadedFile);
    if ($@) {print 'eval error:'.$@."\n"; } 

} 

my $hashData  = $hash{Scope}{model};

my @dereferencedData = @$hashData;
print "Data: \n", Dumper (\@dereferencedData), "\n";

__DATA__
%hash = ( 
      #scope changes
      Scope => {
            model => [
                  'data I need',
                  'another row of needed data',
                  'more data I need'
            ]

      },
      IrreleventScope =>{
                  a=>'b'
            }       

);
[download]

Data: 
$VAR1 = [
          'data I need',
          'another row of needed data',
          'more data I need'
        ];
[download]

Thanks for the tip on using a scalar instead of an array. I still can't get the code to work, the error i get is that $hashData doesn't get initialized so there is something wrong with that call, however $loadedFile does get loaded in properly, thank you.

Show us the offending line(s) of code, and the data you are working with, and, most importantly, the error message!

                Once it hits the fan, the only rational choice is to sweep it up, package it, and sell it as fertilizer.

G'day victorz22,

[Although you've only been here a while, you've made quite a few posts and should be aware of both "How do I post a question effectively?" and "SSCCE". Even when you can't post real data, you can post dummy data that's representative of what you're working with. Posting the type of thing you have here helps no one.]

You can do what you want ("without eval") by using require.

Instead of repeatedly doing I/O every time you want to access some value from your data, I recommend you read the file and capture the data once; it can then be used as many times as you want (without further I/O).

Furthermore, rather than changing directory and then accessing a file, I'd suggest accessing a path directly. You can use File::Spec to do this.

I dummied up this data for you:

$ cat pm_1190415/external/external_hash
%hash = (
    scopeX => {
        modelA => [qw{XA XA XA}],
        modelB => [qw{XB XB XB}],
    },
    scopeY => {
        modelA => [qw{YA YA YA}],
        modelB => [qw{YB YB YB}],
    },
    scopeZ => {
        modelA => [qw{ZA ZA ZA}],
        modelB => [qw{ZB ZB ZB}],
    },
);

1;
[download]

This script shows techniques for achieving all of my recommendations:

#!/usr/bin/env perl -l

use strict;
use warnings;

use File::Spec;

my ($dir, $file) = qw{pm_1190415/external external_hash};

my $extern_hash = get_extern_hash($dir, $file);

print "@{$extern_hash->{scopeX}{modelB}}";
print "@{$extern_hash->{scopeZ}{modelA}}";

sub get_extern_hash {
    my $path = File::Spec::->catfile(@_);
    our %hash;
    require $path;
    return \%hash;
}
[download]

Here's the output:

XB XB XB
ZA ZA ZA
[download]

You can do what you want ("without eval") by using require.

That's not strictly "without eval". All of eval STRING, do FILENAME, require FILENAME, require MODULE, use FILENAME, use MODULE, and evalbytes STRING (since v5.16) finally evaluate a string or file contents as perl code and execute it. See Re^4: Storing state of execution.

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)

You should show us the real code. And please try to isolate the problem step by step.

On a side note, you can use "do filepath" instead of all the reading and eval stuff.

Try Re: Perl data notation (PSON/JSON/SafestUndumper), Re: Safe.pm: Which parameter for permit_only? (Safest Undumper of Data::Dumper)