"$self=>{ettx} = {};"

Apart from I cannot see that particular line in the code you've posted; if it is there, it should probably be:

$self->{ettx} = {};
.....^
[download]

Update: Ah! You probably mean:  $self=>{ettx} = $xml->XMLin(shift); which should be:

 $self->{ettx} = $xml->XMLin(shift);
......^
[download]

Yes, I apologize. I wrote the post and then deleted lines of code I had inserted for debugging but were not necessary for this. The line you mention was the problem one.

And you were right about the syntax, too!. I thought => was for pointers and -> was for subs. I guess I should google that.

Thanks!

Comma Operator

    The "=>" operator is a synonym for the comma except that it causes its
    left operand to be interpreted as a string if it begins with a letter or
    underscore and is composed only of letters, digits and underscores.

The Arrow Operator
    ""->"" is an infix dereference operator, just as it is in C and C++. If
    the right side is either a "[...]", "{...}", or a "(...)" subscript,
    then the left side must be either a hard or symbolic reference to an
    array, a hash, or a subroutine respectively. (Or technically speaking, a
    location capable of holding a hard reference, if it's an array or hash
    reference being used for assignment.) See perlreftut and perlref.

    Otherwise, the right side is a method name or a simple scalar variable
    containing either the method name or a subroutine reference, and the
    left side must be either an object (a blessed reference) or a class name
    (that is, a package name). See perlobj.

sub loadEttx($){
    ...
    $self=>{ettx} = $xml->XMLin(shift);
}

sub loadTemplate($){
    ...
    $self=>{template} = $xml->XMLin(shift);
}
[download]

The error pointed out by BrowserUk is actually present twice in the posted code (AFAICS).

In addition, there's no point in prototyping all the methods: prototypes are ignored in method calls. (The general monastic wisdom is: Just don't ever bother with prototypes unless you really know what they do and why you need one in a particular case!)

Update: The methods in the OPed code are prototyped to take either zero or one, or else exactly one, scalar arguments – but all three methods take two arguments! Again, it doesn't matter because no prototype checking is ever done.

Apart from the syntax error there is one more possible problem. Are you sure XML::Simple returns the data in a consistent enough way? Without any options? What if some tag that may be repeated occurs just once in a particular file? Or some tag with optional attributes doesn't have them in some cases?

See Simpler than XML::Simple.

I'm not worried about it in this case because an ettx file is wholly predictable and all of my Dump tests have printed exactly what I needed.

These subs seems to be called as methods. When they are, the prototype is not checked. See perlsub's "Prototypes" section.

You might want to remove those prototypes, lest they lull you into thinking they're checking your methods' arguments.

I was wondering why it didn't seem to matter that $self was always in the arguments... Really the reason they were there was to remind me of their usage. What do most people do? Something like this?

sub loadEttx(){#scalar file name

For small projects self-documenting code usually works well enough. Choose good variable names and append descriptors like "_aref" for array references, "_href" for hash references, etc. If you are passing a lot of variables in or you feel like you need to heavily document what is being passed in then you could probably do with so some code code refactoring. An obvious one is if you are passing in a lot of variables then think about putting them into a hash and then just passing in a reference to the hash instead (this also makes it easier to add new variables/hash entries as your code evolves). If you want some additional documentation then put in some POD above the subroutine explaining what is does, what it takes/expects, returns, etc. You might also want to check out Perl Best Practices.
 

Elda Taluta; Sarks Sark; Ark Arks