sub AUTOLOAD {
    my @name_pieces = split /::/, $AUTOLOAD;
    my $function = pop @name_pieces;
    my $package = join "::", @name_pieces;

    no strict 'refs';
    *{"$package\::$function"} = get_sub($package, $function);
    goto &{"$package\::$function"};
}
[download]

for my $package (@packages) {
    for my $function (@functions) {
        no strict 'refs';
        *{"$package\::$function"} = get_sub($package, $function);
    }
}
[download]

Tilly:
Thers is an AUTOLOAD in ABC.pm that loads constants using the constant routine in ABC.xs. ABC.pm exports the direct-call sub names (for those who don't want to use the tied interface) and the constants. Here is the AUTOLOAD routine in ABC.pm:

our $AUTOLOAD;
sub AUTOLOAD {
    # this is used to 'autoload' constants from the constant()
    # XS function.  If a constant is not found then control is passed
    # to the AUTOLOAD in AutoLoader.

    my $constname;
    ($constname = $AUTOLOAD) =~ s/.*:://;
    croak "& not defined" if $constname eq 'constant';
    my $val = constant($constname, @_ ? $_[0] : 0);
    
    if ($! != 0) {
        if ($! =~ /Invalid/ || $!{EINVAL}) {
            $AutoLoader::AUTOLOAD = $AUTOLOAD;
            goto &AutoLoader::AUTOLOAD;
        } else {
            croak "Your vendor has not defined $constname";
    }   }
    eval "sub $AUTOLOAD { $val }";
    goto &$AUTOLOAD;
}
[download]

Your solution is not clear to me. Does it provide autoloading, or is it them same as putting all of the tie routines as preloaded (before the __END__)? Can you please re-cast it for use with the existing AUTOLOAD?

This would be an example of why moving more and more dispatch logic into AUTOLOAD leads to problems.

You have a complex AUTOLOAD that already does two very different things. It defines a series of constants. And you have a set of functions that are only loaded if they are used. Unless you've written out all of the tie methods and AutoSplit them for AutoLoader to find, you haven't implemented a tie interface. So making this do that is not just a question of making a small modification to this AUTOLOAD routine.

Making things worse, ABC is not inherited by the classes that you want to be able to tie to. So if you want to use AUTOLOAD, you have to write a new AUTOLOAD that is in that class, or in a superclass that is loaded from that class. Which lead to your original question that you didn't know how to write said AUTOLOAD.

So show me how to write the AUTOLOAD you want to write, and I'll show you how to convert it. Otherwise look at the template I wrote, and try to write get_sub which will, for instance, take "XYZ::ABC::Array" and "STORE" as arguments, then returns an anonymous subroutine.

What do can I do to keep the inherited naming structure and autoload the tie routines? Can I put multiple package statements/sections in my one ABC.pm file?

Yes, though it can get a little messy. For example, you could call this module

package Foo;
use strict;
use warnings;

package Foo::Bar;
use strict;
use warnings;

sub foo {
    print 'foo';
}

return 1;
[download]

with the script

use Foo;
use strict;
use warnings;

Foo::Bar->foo;
[download]

Note that you cannot use Foo::Bar since the file does not exist. The Foo use statement loads Foo::Bar into the namespace. (-- Not quite true: see below)

52 of them make autoloading seem worthwhile. Although if they are in separate packages, each one containing only the tie routines for one "tie-to" name, maybe autoloading isn't worthwhile?

You can use a base class (i.e. ISA) to define your autoload routines, so no matter how many files you have, the actual code is localized. A good intro (if you need it) on constructing a base class for exactly this is found in perltoot.

Update: As a template for the autoload code, I give you a modified module

package Foo;
use strict;
use warnings;
our $AUTOLOAD;

sub AUTOLOAD {
    my $self = shift;
    my $class = ref($self) || $self;
    my $name = $AUTOLOAD;
    print "$name in $class\n";
}

package Foo::Bar;
use strict;
use warnings;
use Exporter;
our @ISA = qw(Foo);

sub foo {
    print "foo\n";
}

return 1;
[download]

and script

use Foo;
use strict;
use warnings;

Foo::Bar->foo;
Foo->bar;
Foo::Bar->bar;
[download]

Now if you'll excuse me, I have some documentation to read -- ikegami just blew my mind.

Note that you cannot use Foo::Bar since the file does not exist. The Foo use statement loads Foo::Bar into the namespace.

There's a way of using use to load (add a code ref to @INC), and there's a way of using use to import (add the module to %INC).

If appropriate, please update your post when your mind has recovered from Ikegami's inscrutable note :-)

# AUTOLOAD is used to
#  1) 'autoload' constants from the constant() function in ABC.xs
# If the name is not a constant then it's parsed for
#  2) a tie package-name::function-name, which if matched is executed

our $AUTOLOAD;  # implicit argument of AUTOLOAD

sub AUTOLOAD {

    # make the base name (without the "package::")
    (my $constname = $AUTOLOAD) =~ s/.*:://;
    # call the constant lookup routine in ABC.xs
    my $val = constant($constname, 0);
    if ($!) {

        # the name in $AUTOLOAD is not a constant defined by XYZ::ABC
                     # sah = scalar/array/hash
        if (my ($abcx, $sah, $function) =
            $AUTOLOAD =~ /^XYZ::(ABCA?)::(Scalar|Array|Hash|BTree)::([
+A-Z]+)$/) {

            if (($sah = lc $sah) eq 'btree') {$sah = 'hash'}
 
            if ($function eq uc("TIE$sah")) {
                my $self = shift;
                my $base_sah = shift; # sah = scalar/array/hash
                $val = '';
                if (!$base_sah || ($val = ref($base_sah)) ne "abc_${sa
+h}Ptr") {
                    croak "3rd operand of tie should be the return val
+ue from abc_make_$sah: ref was '$val'";
                }
                return bless \$base_sah, $self;

                                   # Scalar or Array or Hash
            } elsif ($function eq 'FETCH'
                  || $function eq 'STORE'
                  || $sah ne 'scalar' # Array or Hash
                  && $function =~ /^(DELETE|EXISTS|CLEAR)$/
                  || $sah eq 'array'
                  && $function =~ /^(FETCHSIZE|STORESIZE|EXTEND|POP|PU
+SH|SHIFT|UNSHIFT|SPLICE)$/
                  || $sah eq 'hash'
                  && $function =~ /^(FIRSTKEY|NEXTKEY|SCALAR)$/) {

                $function =~ s/KEY$/_KEY/;
  
                if ($sah eq 'array'                            #nowrap
                 && $function =~ /^(FETCH$|STORE$|EXI|D|SP)/) {#nowrap
                    $function .= '_nowrap';                    #nowrap
                }
                my $subname = lc($abcx) . "_${sah}_" . lc($function);
                no strict 'refs';
                
                # define the symbol so AUTOLOAD won't be called again 
+for this name
                *$AUTOLOAD = sub {
                    # dereference the base scalar/array/hash
                    my $base_sah_ref = shift;
                    unshift @_, $$base_sah_ref;
                    # go to the constructed sub name in ABC.xs
                    goto &$subname;
                };
                # having defined the symbol, execute the sub in ABC.xs
                goto &$AUTOLOAD;

            } elsif ($function eq 'UNTIE'
                  || $function eq 'DESTROY') {
                return;  # do nothing
        }   }
        croak "$AUTOLOAD is not a defined constant or subroutine for X
+YZ::ABC";
    }
    # the name in $AUTOLOAD is a constant defined by XYZ::ABC: define 
+it for perl
    no strict 'refs';
    # define the symbol so AUTOLOAD won't be called again for this nam
+e
    *$AUTOLOAD = sub{$val};
    # in the general case the following line should be goto &$AUTOLOAD
+;
    return $val;
}
[download]