Lexical scoping exists to make your life easier. You don't need to reset variables if you use lexical scoping to your advantage. Here's a very concise example:

use strict;
use warnings;
my $i = 0;
while( $i++ < 10 ) {
    no warnings qw/uninitialized/;
    my $scoped;
    print "\$scoped contains $scoped\n";
    $scoped = 100;
}
[download]

This snippet uses strict and warnings, but for the purposes of this particular demonstration turns off the "uninitialized value" warning. Next, it loops ten times. Each time, it creates a lexically scoped (my) variable called $scope. It prints that variable's contents (which are essentially empty, or undefined). It then assigns the number 100 to $scoped, and loops. If you weren't using lexical scoping, on the second loop iteration, $scoped would still contain 100, and that would print. But as you see if you run this, on each iteration $scoped is still empty. Why? Because at the end of each while block iteration, the lexical variable named $scoped "falls out of scope" (it disappears, forever gone). And on the next iteration, a new one is created (via 'my').

What you need to do is write your script in such a way that when the player decides to play again, all the variables that need to be reset simply fall out of scope. The ones whos values should be kept would need to have been defined at a broader scope.

This sort of thing is described in perlintro, perlsub and perlsyn, for starters. Therein you'll also read about properly passing parameters to subroutines rather than absorbing values through global osmosis. Welcome to a new way of thinking.

I'll reply to all of you that told me to use strict and warnings. I am doing that, and my code runs without errors or warnings the first pass. I also have lots of lexical scoping throughout my code, but I couldn't think of a better way to keep the variables I needed so I could use them in all the various subs and such. I tried passing paramaters and other things like that, but I kept getting 'unitialized' errors, so I went back to the global way. I have read perlintro about 50 times, and lots and lots of other documentation, but I'm still learning and making a lot of dumb mistakes. BTW, this game is not finished, and I haven't added in most of the data that I want the game to keep track of between runs (ex. a word list and related logic).

Obviously this is a case of not enough code, so here is my entire script:

Read more... (5 kB)

The particular bug that's causing the error message you're referring to is in the reset_game() sub.

The problem is that you're assigning a single scalar value '0' to a list. That means that $all_occurrences becomes undefined. Use an undefined value within a character class in a regexp and you get an error message. Try the followng:

perl -e "my $var; 'string'=~/[$var]/"
[download]

And here's the error...

Unmatched [ in regex; marked by <-- HERE in m/[ <-- HERE ]/ at -e line
+ 1.
[download]

If you're getting warnings when running under warnings and strictures, the goal is to understand why. The warnings are telling you something. In this case, you mentioned getting uninitialized value warnings. Instead of fixing the problem, you subverted the warnings, and that allowed bugs to creep in. If you had dug into why you were getting those undefined value warnings, you would have tracked the problem down to your reset sub.




Dave

It is very hard to see how a hard coded regex would suddenly become invalid on a second pass. Indeed, it can't. At least not without something very, very unusual happening.

I think you need to post the complete script that demostrates the problem, because your description of the problem does not make great deal of sense, and without being able to run the same code you are running and thereby reproduce the same errors you are encountering, there is no real way to help you.

• use strict; and use warnings;
• Use globals only where necessary, to prevent scary action-at-a-distance and simplify debugging.

use strict;
use warnings;
[download]

The error you describe strikes me as very quirky. You might get around it by tacking the "o" (compile once) option onto the regex:

/[[:alpha:]]/o
[download]

Sadly you have not posted enough of your code to compile. Perhaps you can try to reduce the problem to the minimum set that still runs and exhibits the problem.

If you scope each session of the game and its variables so that when one cycle is complete they go out of scope you will not have to call a reset_game routine

use warnings;
use strict;
# variable we want to keep between runs
my $high_score=0;
my $play_it_again=1;

while ($play_it_again) {
    my $last_score = play_game;
    $high_score = $last_score if $last_score > $high_score; 
    $play_it_again=ask_user;
}

sub play_game {
    my $game_score=0;
    # game logic
    return $game_score;
}

sub ask_user {
    print "Do you want to play again (y or n)? ";
    my $play_again = <STDIN>;
    chomp($play_again);
    $play_again eq "y" ? 1 : 0
}
[download]

use strict; Don't know if you do as this is obviously a small frag of something bigger and you do appear to use my aplenty

Cheers,
R.

Firstly, although I am not certain, I believe the error message is erroneously pointing to the wrong line $guess !~ m/[[:alpha:]]/ rather the error occurs in the elsif portion, where you have

$guess =~ /[$good_guesses]/
[download]

During the 1st pass, $good_guesses is either undefined, or set to a single letter (or multiple letter? doesn't matter).

On second pass, the $good_guesses is reset to a null string.

$guess =~ /[$good_guesses]/
[download]

$guess =~ /[]/
[download]

For whatever reason, if $good_guesses is undefined, the parser figures it out the way you meant. (UPDATE: Nope, that's not the reason, see update below)

To get your code to work, I re-initialized $good_guesses = undef; in your "reset_game" sub.

PS: I wrote my response after I got your program to work, but I did not actually go and read up on all the particulars of character classes in regular expressions, so I may not be entirely accurate.

Sandy

PS (again) ... That was fun!

UPDATE: Made mistake... the reason the code works when $good_guesses is undefined is that there is a condition in front of the condition...

elsif ((defined($good_guesses))&&($guess =~ /[$good_guesses]/))
[download]

$guess =~ /[]/
[download]

Hmm, I believe I am checking to make sure $good_guesses is defined (unless I don't understand what defined() really does):

} elsif ((defined($good_guesses))&&($guess =~ /[$good_guesses]/)) {
        print "\n***You already guessed that letter!*** (hit any key)\
+n"; <>;
    } else {
        if ($word =~ /[$guess]/) {
            if (defined($good_guesses)) {
                $good_guesses .= "$guess" unless ($guess =~ /[$good_gu
+esses]/);
            } else {
                $good_guesses .= "$guess";
            }
[download]

Simply put...

my $var;     # variable is undefined
if ($var) { ... }  # $var is false because it is undefined
if (defined $var) {...}  # false

$var = "";
if ($var) { ... } # false because $var is null string
if (defined $var) {...} # true because $var has been
                        # defined as having a null string

$var = 0;
if ($var) { ... } # false because $var is zero
if (defined $var) {...} # true because $var has been
                        # defined as zero
[download]

Yes, you appear to be right Sandy! I comment out two chunks that are doing stuff with $good_guesses, and it works (well, not the way I want, but I don't get the error). Now I have to figure out how to fix that, because it is now doing it on every run, not just the second pass. I don't know why though, because I'm defining $good_guesses = "" at the top.

A lot of folks have wagged fingers at me for using global variables, and I know what they mean. I just don't know how else to do it! If I want to have a variable that needs to be accessed/updated by the main loop and by multiple subs...how can you do that without storing the variable outside of all the subs? If I try to put it in the loop it will be zeroed out on every loop, and the same with the subs. Any ideas would be appreciated.

This is what I mean:

Read more... (378 Bytes)

Oops, our posts have crossed in the mail (so to speak).

Try either

if ($goodguesses && ($whatever =~ /[$goodguesses]/) {...}
[download]

or undefine $goodguesses

$goodguesses = undef;
[download]

see previous post (just before your last one, for the differences between 'false' and 'defined'

if ($guess !~ /[[:alpha:]]/) {
        print "\n***Invalid letter*** (hit any key)\n"; <>;
}
[download]