Working with a legable config file

[phoenix9]

I have a friend who is writing a text based game, but as yet it had no save capabilities. I told him I'd right a save and load sub-routine for him because while im still new to it i know how to use filehandelers alot better than him.

Due to the simplicity of the game all that I need it to due is store variables in a text file from one running of the game until the next. The problem is I wanted the text file to be understandable instead of just a list of numbers so say the file (named test1.usr in a subfolder of the current directory named configs) is like this:

$a = 1
$b = 2

I am trying to figure out a way so that were I to run code like this:

print "enter username:";
chomp($uname=<STDIN>);
 $USERFILE='configs/'.$uname.'.usr';
open(USERFILE);
# Whatever the solution to my problem is
print $a + $b;

It would show up as:

enter usename:test1
3

the only thing I can figure out to do is make the .usr file:

1
2

with the perl:

chomp($a = <USERFILE>);
chomp($b = <USERFILE>);

the only thing I can do with the current config (.usr) file is print it to STDOUT or another file. How can I keep the current formatting (and therfore legability) but still have the disired outcome.

~Phoenix9

P.S. this is a test version of the code. In the final it will be keeping track of actual information and will not just print 3. However, I bilieve the solution to this problem will work in the final version.

[bbfu]

Config::*

Alternatively, you can use data serialization/persistance modules, such as YAML, Data::Denter, Storable, or Data::Dumper.

[Zaxo]

Take a look at do FILENAME.

For extra redability, have the config file return a hash reference, like this:

{
    foo => 1,
    bar => "frolicsome",
}

Data::Dumper will help with that.

[bart]

Perhaps you could be using a hash instead of a set of global variables, to hold all the data. Hashes require far less code to store and retrieve, than individual scalars, which you'd have to enumerate — heck, Storable can do save and load in one single line of code, each. On the other hand, the saved file wouldn't quite be "legible".

OTOH, hash items are almost as easy to handle than individual variables are. For example, if your hash is %v, then $v{'a'} (or even $v{a}) does the same as your $a would have done.

In that perspective, virtually any Config::* module might do. Or YAML. Even a simple CSV or tab delimited textfile would work.

The next code saves and loads a hash to and from a tab delimited text file — provided the data contains neither a tab or a newline:

sub save {
    my($file, $data) = @_;
    local *FH;
    open FH, ">$file" or die "Can't open file $file: $!";
    local($\, $,) = ("\n", "\t");
    foreach my $key (sort keys %$data){
        print FH $key, $data->{$key};
    }
}

sub load {
    my($file) = @_;
    local *FH;
    my %hash;
    open FH, "<$file" or die "Can't open file $file: $!";
    local $/ = "\n";
    while(<FH>) {
        chomp;
        my($key, $value) = split /\t/;
        $hash{$key} = $value;
    }
    return wantarray ? %hash : \%hash;
}

Example use:
Read more... (801 Bytes)

[Vautrin]

Whenever I need my program to read and save settings to a file, I like to use XML::Simple. Basically, you can dump a hashref / array ref or any combination thereof into a file. Then, you can read it back into an array / hash as well. Plus, with all the XML modules / packages out there (and for languages other then Perl) it becomes very easy to interface with your config files.

For instance, by using the XML out function, you could change:

my $data = {
             things => [
                         { foo => 'bar' },
                         { foo => 'baz' },
                         { foo => 'bam' },
                       ]
           };

Into XML like:

<things>
  <foo>bar</foo>
  <foo>baz</foo>
  <foo>bam</foo>                  
</things>

And then after calling the function to read XML you can access it right from the hash ref! And, again, I can't stop stressing to you how portable XML is. If, in the future, you want to do something with that data, expand the project, or create a new program to work with the data, it's very simple to do. Of course, using a Perl module for another type of config file will do this for you, but it won't be portable across platforms. (I wish everything were coded in perl, but let's be realistic. Sometimes you need to work with Java/C/ASP/Whatever)