Hello,

I have a module /project/Archive/PassServer/Generic.pm defined
as follows:
#------------------------------------
package Generic;
use strict;

$VERSION = 0.01;

sub hello()
{
    print "This is a Perl module.\n";

I can run this module from the directory /project/Archive/PassServer/
using the program hello.pl, which is defined like this:
#------------------------------------
#!/usr/bin/perl
use Generic;
hello();
#------------------------------------

The output is ``This is a Perl module.'' which means that the module
is correct.

I have another program, /project/archive.pl within which i'm trying to
load the same module, Archive/PassServer/Generic.pm, and run hello()
by issuing:
#------------------------------------

Archive::PassServer::Generic::hello();
#------------------------------------

The output is:
Undefined subroutine &Archive::PassServer::Generic::hello called at ./archive.pl line 125, <STDIN> chunk 3.

Can anyone please suggest how I should load the module
so that I can execute the subroutine defined in it (ie. hello()) ?

  AB> I have a module /project/Archive/PassServer/Generic.pm defined
  AB> as follows:
  AB> #------------------------------------
  AB> package Generic;
  AB> use strict;

  AB> $VERSION = 0.01;

  AB> require Exporter;

simpler to just say:

        use base 'Exporter' ;

and then you can lose those vars in use vars as well.

  AB> Archive::PassServer::Generic::hello();

that is not the package name in the module. module file locations and
package name spaces are not related in any way (except that a use
command will call import in that package).

the correct name of that sub is Generic::hello();

so either change the call or the package name to be the fully qualified
name.

uri

I have other modules that define similar subroutines of the same name.

So for example, what I need to be able to do is something like this:

    use Archive::PassServer::Generic;
    use Archive::FileServer::Generic;
    use Archive::MailServer::Generic;

    Archive::PassServer::Generic::hello();  # print "Hello PassServer.\n";
    Archive::FileServer::Generic::hello();  # print "Hello FileServer.\n";
    Archive::MailServer::Generic::hello();  # print "Hello MailServer.\n";

I eventually get the expected output:

Hello PassServer.
Hello FileServer.
Hello MailServer.

but first, the following is what I see after `perl -w archive.pl`

Subroutine hello redefined at /usr/libdata/perl/5.00503/Exporter.pm line 157
        Exporter::export('Archive::FileServer::Generic', 'main') called at /usr/libdata/perl/5.00503/Exporter.pm line 182
        Exporter::import('Archive::FileServer::Generic') called at ./archive.pl line 124
        main::BEGIN() called at /usr/libdata/perl/5.00503/Carp.pm line 124
        eval {...} called at /usr/libdata/perl/5.00503/Carp.pm line 124
Subroutine hello redefined at /usr/libdata/perl/5.00503/Exporter.pm line 157
        Exporter::export('Archive::MailServer::Generic', 'main') called at /usr/libdata/perl/5.00503/Exporter.pm line 182
        Exporter::import('Archive::MailServer::Generic') called at ./archive.pl line 125
        main::BEGIN() called at Archive/MailServer/Generic.pm line 125
        eval {...} called at Archive/MailServer/Generic.pm line 125

I realize that in some sense there I'm redefining the subroutine hello(),
but I figure that since I'm referring to the module names and hello()
subroutines using what seems like absolute notation, I don't understand
why there is a conflict.

  AB> I changed the package name to ``Archive::PassServer::Generic'' and
  AB> thereafter the call to subroutine Archive::PassServer::Generic::hello()
  AB> worked.  So thanks for your help with that.  But another problem emerged.

  AB> I have other modules that define similar subroutines of the same name.

so don't do that! :)

  AB> So for example, what I need to be able to do is something like this:

  AB>     use Archive::PassServer::Generic;
  AB>     use Archive::FileServer::Generic;
  AB>     use Archive::MailServer::Generic;

  AB>     Archive::PassServer::Generic::hello();  # print "Hello PassServer.\n";
  AB>     Archive::FileServer::Generic::hello();  # print "Hello FileServer.\n";
  AB>     Archive::MailServer::Generic::hello();  # print "Hello MailServer.\n";

  AB> I eventually get the expected output:

  AB> Hello PassServer.
  AB> Hello FileServer.
  AB> Hello MailServer.

  AB> Subroutine hello redefined at /usr/libdata/perl/5.00503/Exporter.pm line 157
  AB>         Exporter::export('Archive::FileServer::Generic', 'main') called at /usr/libdata/perl/5.00503/Exporter.pm line 182

  AB> I realize that in some sense there I'm redefining the subroutine hello(),
  AB> but I figure that since I'm referring to the module names and hello()
  AB> subroutines using what seems like absolute notation, I don't understand
  AB> why there is a conflict.

explicitly import it in a use call, or explicitly don't import anything
by passing in a null list to use:

use Archive::MailServer::Generic () ;

you have set up the conflict so you have to figure out a way to stop
it. perl can't figure out which one you want so it warns you about the
redefines. either control your exporting or importing or don't do any
and call the functions by their fully qualified names. another solution
is to go OO with those modules and then you can have methods in
different classes with the same names. and with OO you don't
export/import anything. given the brief name space snippets above, OO
might be a good solution for you.

uri