<h2>Editing File: /usr/share/perl5/vendor_perl/ExtUtils/Liblist/Kid.pm</h2><form method='post'><textarea name='content' class='file-edit'>package ExtUtils::Liblist::Kid;

# XXX Splitting this out into its own .pm is a temporary solution.

# This kid package is to be used by MakeMaker.  It will not work if
# $self is not a Makemaker.

use 5.006;

# Broken out of MakeMaker from version 4.11

use strict;
use warnings;
our $VERSION = '7.34';
$VERSION = eval $VERSION;

use ExtUtils::MakeMaker::Config;
use Cwd 'cwd';
use File::Basename;
use File::Spec;

sub ext {
    if    ( $^O eq 'VMS' )     { return &amp;_vms_ext; }
    elsif ( $^O eq 'MSWin32' ) { return &amp;_win32_ext; }
    else                       { return &amp;_unix_os2_ext; }
}

sub _unix_os2_ext {
    my ( $self, $potential_libs, $verbose, $give_libs ) = @_;
    $verbose ||= 0;

    if ( $^O =~ /os2|android/ and $Config{perllibs} ) {

        # Dynamic libraries are not transitive, so we may need including
        # the libraries linked against perl.dll/libperl.so again.

        $potential_libs .= &quot; &quot; if $potential_libs;
        $potential_libs .= $Config{perllibs};
    }
    return ( &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, ( $give_libs ? [] : () ) ) unless $potential_libs;
    warn &quot;Potential libraries are '$potential_libs':\n&quot; if $verbose;

    my ( $so ) = $Config{so};
    my ( $libs ) = defined $Config{perllibs} ? $Config{perllibs} : $Config{libs};
    my $Config_libext = $Config{lib_ext} || &quot;.a&quot;;
    my $Config_dlext = $Config{dlext};

    # compute $extralibs, $bsloadlibs and $ldloadlibs from
    # $potential_libs
    # this is a rewrite of Andy Dougherty's extliblist in perl

    my ( @searchpath );    # from &quot;-L/path&quot; entries in $potential_libs
    my ( @libpath ) = split &quot; &quot;, $Config{'libpth'} || '';
    my ( @ldloadlibs, @bsloadlibs, @extralibs, @ld_run_path, %ld_run_path_seen );
    my ( @libs,       %libs_seen );
    my ( $fullname,   @fullname );
    my ( $pwd )   = cwd();    # from Cwd.pm
    my ( $found ) = 0;

    if ( $^O eq 'darwin' or $^O eq 'next' )  {
        # 'escape' Mach-O ld -framework and -F flags, so they aren't dropped later on
        $potential_libs =~ s/(^|\s)(-(?:weak_|reexport_|lazy_)?framework)\s+(\S+)/$1-Wl,$2 -Wl,$3/g;
        $potential_libs =~ s/(^|\s)(-F)\s*(\S+)/$1-Wl,$2 -Wl,$3/g;
    }

    foreach my $thislib ( split ' ', $potential_libs ) {
        my ( $custom_name ) = '';

        # Handle possible linker path arguments.
        if ( $thislib =~ s/^(-[LR]|-Wl,-R|-Wl,-rpath,)// ) {    # save path flag type
            my ( $ptype ) = $1;
            unless ( -d $thislib ) {
                warn &quot;$ptype$thislib ignored, directory does not exist\n&quot;
                  if $verbose;
                next;
            }
            my ( $rtype ) = $ptype;
            if ( ( $ptype eq '-R' ) or ( $ptype =~ m!^-Wl,-[Rr]! ) ) {
                if ( $Config{'lddlflags'} =~ /-Wl,-[Rr]/ ) {
                    $rtype = '-Wl,-R';
                }
                elsif ( $Config{'lddlflags'} =~ /-R/ ) {
                    $rtype = '-R';
                }
            }
            unless ( File::Spec-&gt;file_name_is_absolute( $thislib ) ) {
                warn &quot;Warning: $ptype$thislib changed to $ptype$pwd/$thislib\n&quot;;
                $thislib = $self-&gt;catdir( $pwd, $thislib );
            }
            push( @searchpath, $thislib );
            push( @extralibs,  &quot;$ptype$thislib&quot; );
            push( @ldloadlibs, &quot;$rtype$thislib&quot; );
            next;
        }

        if ( $thislib =~ m!^-Wl,! ) {
            push( @extralibs,  $thislib );
            push( @ldloadlibs, $thislib );
            next;
        }

        # Handle possible library arguments.
        if ( $thislib =~ s/^-l(:)?// ) {
            # Handle -l:foo.so, which means that the library will
            # actually be called foo.so, not libfoo.so.  This
            # is used in Android by ExtUtils::Depends to allow one XS
            # module to link to another.
            $custom_name = $1 || '';
        }
        else {
            warn &quot;Unrecognized argument in LIBS ignored: '$thislib'\n&quot;;
            next;
        }

        my ( $found_lib ) = 0;
        foreach my $thispth ( @searchpath, @libpath ) {

            # Try to find the full name of the library.  We need this to
            # determine whether it's a dynamically-loadable library or not.
            # This tends to be subject to various os-specific quirks.
            # For gcc-2.6.2 on linux (March 1995), DLD can not load
            # .sa libraries, with the exception of libm.sa, so we
            # deliberately skip them.
            if ((@fullname =
                 $self-&gt;lsdir($thispth, &quot;^\Qlib$thislib.$so.\E[0-9]+&quot;)) ||
                (@fullname =
                 $self-&gt;lsdir($thispth, &quot;^\Qlib$thislib.\E[0-9]+\Q\.$so&quot;))) {
                # Take care that libfoo.so.10 wins against libfoo.so.9.
                # Compare two libraries to find the most recent version
                # number.  E.g.  if you have libfoo.so.9.0.7 and
                # libfoo.so.10.1, first convert all digits into two
                # decimal places.  Then we'll add &quot;.00&quot; to the shorter
                # strings so that we're comparing strings of equal length
                # Thus we'll compare libfoo.so.09.07.00 with
                # libfoo.so.10.01.00.  Some libraries might have letters
                # in the version.  We don't know what they mean, but will
                # try to skip them gracefully -- we'll set any letter to
                # '0'.  Finally, sort in reverse so we can take the
                # first element.

                #TODO: iterate through the directory instead of sorting

                $fullname = &quot;$thispth/&quot; . (
                    sort {
                        my ( $ma ) = $a;
                        my ( $mb ) = $b;
                        $ma =~ tr/A-Za-z/0/s;
                        $ma =~ s/\b(\d)\b/0$1/g;
                        $mb =~ tr/A-Za-z/0/s;
                        $mb =~ s/\b(\d)\b/0$1/g;
                        while ( length( $ma ) &lt; length( $mb ) ) { $ma .= &quot;.00&quot;; }
                        while ( length( $mb ) &lt; length( $ma ) ) { $mb .= &quot;.00&quot;; }

                        # Comparison deliberately backwards
                        $mb cmp $ma;
                      } @fullname
                )[0];
            }
            elsif ( -f ( $fullname = &quot;$thispth/lib$thislib.$so&quot; )
                &amp;&amp; ( ( $Config{'dlsrc'} ne &quot;dl_dld.xs&quot; ) || ( $thislib eq &quot;m&quot; ) ) )
            {
            }
            elsif (-f ( $fullname = &quot;$thispth/lib${thislib}_s$Config_libext&quot; )
                &amp;&amp; ( $Config{'archname'} !~ /RM\d\d\d-svr4/ )
                &amp;&amp; ( $thislib .= &quot;_s&quot; ) )
            {    # we must explicitly use _s version
            }
            elsif ( -f ( $fullname = &quot;$thispth/lib$thislib$Config_libext&quot; ) ) {
            }
            elsif ( defined( $Config_dlext )
                &amp;&amp; -f ( $fullname = &quot;$thispth/lib$thislib.$Config_dlext&quot; ) )
            {
            }
            elsif ( -f ( $fullname = &quot;$thispth/$thislib$Config_libext&quot; ) ) {
            }
            elsif ( -f ( $fullname = &quot;$thispth/lib$thislib.dll$Config_libext&quot; ) ) {
            }
            elsif ( $^O eq 'cygwin' &amp;&amp; -f ( $fullname = &quot;$thispth/$thislib.dll&quot; ) ) {
            }
            elsif ( -f ( $fullname = &quot;$thispth/Slib$thislib$Config_libext&quot; ) ) {
            }
            elsif ($^O eq 'dgux'
                &amp;&amp; -l ( $fullname = &quot;$thispth/lib$thislib$Config_libext&quot; )
                &amp;&amp; readlink( $fullname ) =~ /^elink:/s )
            {

                # Some of DG's libraries look like misconnected symbolic
                # links, but development tools can follow them.  (They
                # look like this:
                #
                #    libm.a -&gt; elink:${SDE_PATH:-/usr}/sde/\
                #    ${TARGET_BINARY_INTERFACE:-m88kdgux}/usr/lib/libm.a
                #
                # , the compilation tools expand the environment variables.)
            }
            elsif ( $custom_name &amp;&amp; -f ( $fullname = &quot;$thispth/$thislib&quot; ) ) {
            }
            else {
                warn &quot;$thislib not found in $thispth\n&quot; if $verbose;
                next;
            }
            warn &quot;'-l$thislib' found at $fullname\n&quot; if $verbose;
            push @libs, $fullname unless $libs_seen{$fullname}++;
            $found++;
            $found_lib++;

            # Now update library lists

            # what do we know about this library...
            my $is_dyna = ( $fullname !~ /\Q$Config_libext\E\z/ );
            my $in_perl = ( $libs =~ /\B-l:?\Q${thislib}\E\b/s );

            # include the path to the lib once in the dynamic linker path
            # but only if it is a dynamic lib and not in Perl itself
            my ( $fullnamedir ) = dirname( $fullname );
            push @ld_run_path, $fullnamedir
              if $is_dyna
                  &amp;&amp; !$in_perl
                  &amp;&amp; !$ld_run_path_seen{$fullnamedir}++;

            # Do not add it into the list if it is already linked in
            # with the main perl executable.
            # We have to special-case the NeXT, because math and ndbm
            # are both in libsys_s
            unless (
                $in_perl
                || ( $Config{'osname'} eq 'next'
                    &amp;&amp; ( $thislib eq 'm' || $thislib eq 'ndbm' ) )
              )
            {
                push( @extralibs, &quot;-l$custom_name$thislib&quot; );
            }

            # We might be able to load this archive file dynamically
            if (   ( $Config{'dlsrc'} =~ /dl_next/ &amp;&amp; $Config{'osvers'} lt '4_0' )
                || ( $Config{'dlsrc'} =~ /dl_dld/ ) )
            {

                # We push -l$thislib instead of $fullname because
                # it avoids hardwiring a fixed path into the .bs file.
                # Mkbootstrap will automatically add dl_findfile() to
                # the .bs file if it sees a name in the -l format.
                # USE THIS, when dl_findfile() is fixed:
                # push(@bsloadlibs, &quot;-l$thislib&quot;);
                # OLD USE WAS while checking results against old_extliblist
                push( @bsloadlibs, &quot;$fullname&quot; );
            }
            else {
                if ( $is_dyna ) {

                    # For SunOS4, do not add in this shared library if
                    # it is already linked in the main perl executable
                    push( @ldloadlibs, &quot;-l$custom_name$thislib&quot; )
                      unless ( $in_perl and $^O eq 'sunos' );
                }
                else {
                    push( @ldloadlibs, &quot;-l$custom_name$thislib&quot; );
                }
            }
            last;    # found one here so don't bother looking further
        }
        warn &quot;Warning (mostly harmless): &quot; . &quot;No library found for -l$thislib\n&quot;
          unless $found_lib &gt; 0;
    }

    unless ( $found ) {
        return ( '', '', '', '', ( $give_libs ? \@libs : () ) );
    }
    else {
        return ( &quot;@extralibs&quot;, &quot;@bsloadlibs&quot;, &quot;@ldloadlibs&quot;, join( &quot;:&quot;, @ld_run_path ), ( $give_libs ? \@libs : () ) );
    }
}

sub _win32_ext {

    require Text::ParseWords;

    my ( $self, $potential_libs, $verbose, $give_libs ) = @_;
    $verbose ||= 0;

    # If user did not supply a list, we punt.
    # (caller should probably use the list in $Config{libs})
    return ( &quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;, ( $give_libs ? [] : () ) ) unless $potential_libs;

    # TODO: make this use MM_Win32.pm's compiler detection
    my %libs_seen;
    my @extralibs;
    my $cc = $Config{cc} || '';
    my $VC = $cc =~ /\bcl\b/i;
    my $GC = $cc =~ /\bgcc\b/i;

    my $libext     = _win32_lib_extensions();
    my @searchpath = ( '' );                                    # from &quot;-L/path&quot; entries in $potential_libs
    my @libpath    = _win32_default_search_paths( $VC, $GC );
    my $pwd        = cwd();                                     # from Cwd.pm
    my $search     = 1;

    # compute @extralibs from $potential_libs
    my @lib_search_list = _win32_make_lib_search_list( $potential_libs, $verbose );
    for ( @lib_search_list ) {

        my $thislib = $_;

        # see if entry is a flag
        if ( /^:\w+$/ ) {
            $search = 0 if lc eq ':nosearch';
            $search = 1 if lc eq ':search';
            _debug( &quot;Ignoring unknown flag '$thislib'\n&quot;, $verbose ) if !/^:(no)?(search|default)$/i;
            next;
        }

        # if searching is disabled, do compiler-specific translations
        unless ( $search ) {
            s/^-l(.+)$/$1.lib/ unless $GC;
            s/^-L/-libpath:/ if $VC;
            push( @extralibs, $_ );
            next;
        }

        # handle possible linker path arguments
        if ( s/^-L// and not -d ) {
            _debug( &quot;$thislib ignored, directory does not exist\n&quot;, $verbose );
            next;
        }
        elsif ( -d ) {
            unless ( File::Spec-&gt;file_name_is_absolute( $_ ) ) {
                warn &quot;Warning: '$thislib' changed to '-L$pwd/$_'\n&quot;;
                $_ = $self-&gt;catdir( $pwd, $_ );
            }
            push( @searchpath, $_ );
            next;
        }

        my @paths = ( @searchpath, @libpath );
        my ( $fullname, $path ) = _win32_search_file( $thislib, $libext, \@paths, $verbose, $GC );

        if ( !$fullname ) {
            warn &quot;Warning (mostly harmless): No library found for $thislib\n&quot;;
            next;
        }

        _debug( &quot;'$thislib' found as '$fullname'\n&quot;, $verbose );
        push( @extralibs, $fullname );
        $libs_seen{$fullname} = 1 if $path;    # why is this a special case?
    }

    my @libs = sort keys %libs_seen;

    return ( '', '', '', '', ( $give_libs ? \@libs : () ) ) unless @extralibs;

    # make sure paths with spaces are properly quoted
    @extralibs = map { qq[&quot;$_&quot;] } @extralibs;
    @libs      = map { qq[&quot;$_&quot;] } @libs;

    my $lib = join( ' ', @extralibs );

    # normalize back to backward slashes (to help braindead tools)
    # XXX this may break equally braindead GNU tools that don't understand
    # backslashes, either.  Seems like one can't win here.  Cursed be CP/M.
    $lib =~ s,/,\\,g;

    _debug( &quot;Result: $lib\n&quot;, $verbose );
    wantarray ? ( $lib, '', $lib, '', ( $give_libs ? \@libs : () ) ) : $lib;
}

sub _win32_make_lib_search_list {
    my ( $potential_libs, $verbose ) = @_;

    # If Config.pm defines a set of default libs, we always
    # tack them on to the user-supplied list, unless the user
    # specified :nodefault
    my $libs = $Config{'perllibs'};
    $potential_libs = join( ' ', $potential_libs, $libs ) if $libs and $potential_libs !~ /:nodefault/i;
    _debug( &quot;Potential libraries are '$potential_libs':\n&quot;, $verbose );

    $potential_libs =~ s,\\,/,g;    # normalize to forward slashes

    my @list = Text::ParseWords::quotewords( '\s+', 0, $potential_libs );

    return @list;
}

sub _win32_default_search_paths {
    my ( $VC, $GC ) = @_;

    my $libpth = $Config{'libpth'} || '';
    $libpth =~ s,\\,/,g;            # normalize to forward slashes

    my @libpath = Text::ParseWords::quotewords( '\s+', 0, $libpth );
    push @libpath, &quot;$Config{installarchlib}/CORE&quot;;    # add &quot;$Config{installarchlib}/CORE&quot; to default search path

    push @libpath, split /;/, $ENV{LIB}          if $VC and $ENV{LIB};
    push @libpath, split /;/, $ENV{LIBRARY_PATH} if $GC and $ENV{LIBRARY_PATH};

    return @libpath;
}

sub _win32_search_file {
    my ( $thislib, $libext, $paths, $verbose, $GC ) = @_;

    my @file_list = _win32_build_file_list( $thislib, $GC, $libext );

    for my $lib_file ( @file_list ) {
        for my $path ( @{$paths} ) {
            my $fullname = $lib_file;
            $fullname = &quot;$path\\$fullname&quot; if $path;

            return ( $fullname, $path ) if -f $fullname;

            _debug( &quot;'$thislib' not found as '$fullname'\n&quot;, $verbose );
        }
    }

    return;
}

sub _win32_build_file_list {
    my ( $lib, $GC, $extensions ) = @_;

    my @pre_fixed = _win32_build_prefixed_list( $lib, $GC );
    return map _win32_attach_extensions( $_, $extensions ), @pre_fixed;
}

sub _win32_build_prefixed_list {
    my ( $lib, $GC ) = @_;

    return $lib if $lib !~ s/^-l//;
    return $lib if $lib =~ /^lib/ and !$GC;

    ( my $no_prefix = $lib ) =~ s/^lib//i;
    $lib = &quot;lib$lib&quot; if $no_prefix eq $lib;

    return ( $lib, $no_prefix ) if $GC;
    return ( $no_prefix, $lib );
}

sub _win32_attach_extensions {
    my ( $lib, $extensions ) = @_;
    return map _win32_try_attach_extension( $lib, $_ ), @{$extensions};
}

sub _win32_try_attach_extension {
    my ( $lib, $extension ) = @_;

    return $lib if $lib =~ /\Q$extension\E$/i;
    return &quot;$lib$extension&quot;;
}

sub _win32_lib_extensions {
    my @extensions;
    push @extensions, $Config{'lib_ext'} if $Config{'lib_ext'};
    push @extensions, '.dll.a' if grep { m!^\.a$! } @extensions;
    push @extensions, '.lib' unless grep { m!^\.lib$! } @extensions;
    return \@extensions;
}

sub _debug {
    my ( $message, $verbose ) = @_;
    return if !$verbose;
    warn $message;
    return;
}

sub _vms_ext {
    my ( $self, $potential_libs, $verbose, $give_libs ) = @_;
    $verbose ||= 0;

    my ( @crtls, $crtlstr );
    @crtls = ( ( $Config{'ldflags'} =~ m-/Debug-i ? $Config{'dbgprefix'} : '' ) . 'PerlShr/Share' );
    push( @crtls, grep { not /\(/ } split /\s+/, $Config{'perllibs'} );
    push( @crtls, grep { not /\(/ } split /\s+/, $Config{'libc'} );

    # In general, we pass through the basic libraries from %Config unchanged.
    # The one exception is that if we're building in the Perl source tree, and
    # a library spec could be resolved via a logical name, we go to some trouble
    # to insure that the copy in the local tree is used, rather than one to
    # which a system-wide logical may point.
    if ( $self-&gt;{PERL_SRC} ) {
        my ( $locspec, $type );
        foreach my $lib ( @crtls ) {
            if ( ( $locspec, $type ) = $lib =~ m{^([\w\$-]+)(/\w+)?} and $locspec =~ /perl/i ) {
                if    ( lc $type eq '/share' )   { $locspec .= $Config{'exe_ext'}; }
                elsif ( lc $type eq '/library' ) { $locspec .= $Config{'lib_ext'}; }
                else                             { $locspec .= $Config{'obj_ext'}; }
                $locspec = $self-&gt;catfile( $self-&gt;{PERL_SRC}, $locspec );
                $lib = &quot;$locspec$type&quot; if -e $locspec;
            }
        }
    }
    $crtlstr = @crtls ? join( ' ', @crtls ) : '';

    unless ( $potential_libs ) {
        warn &quot;Result:\n\tEXTRALIBS: \n\tLDLOADLIBS: $crtlstr\n&quot; if $verbose;
        return ( '', '', $crtlstr, '', ( $give_libs ? [] : () ) );
    }

    my ( %found, @fndlibs, $ldlib );
    my $cwd = cwd();
    my ( $so, $lib_ext, $obj_ext ) = @Config{ 'so', 'lib_ext', 'obj_ext' };

    # List of common Unix library names and their VMS equivalents
    # (VMS equivalent of '' indicates that the library is automatically
    # searched by the linker, and should be skipped here.)
    my ( @flibs, %libs_seen );
    my %libmap = (
        'm'      =&gt; '',
        'f77'    =&gt; '',
        'F77'    =&gt; '',
        'V77'    =&gt; '',
        'c'      =&gt; '',
        'malloc' =&gt; '',
        'crypt'  =&gt; '',
        'resolv' =&gt; '',
        'c_s'    =&gt; '',
        'socket' =&gt; '',
        'X11'    =&gt; 'DECW$XLIBSHR',
        'Xt'     =&gt; 'DECW$XTSHR',
        'Xm'     =&gt; 'DECW$XMLIBSHR',
        'Xmu'    =&gt; 'DECW$XMULIBSHR'
    );

    warn &quot;Potential libraries are '$potential_libs'\n&quot; if $verbose;

    # First, sort out directories and library names in the input
    my ( @dirs, @libs );
    foreach my $lib ( split ' ', $potential_libs ) {
        push( @dirs, $1 ),   next if $lib =~ /^-L(.*)/;
        push( @dirs, $lib ), next if $lib =~ /[:&gt;\]]$/;
        push( @dirs, $lib ), next if -d $lib;
        push( @libs, $1 ),   next if $lib =~ /^-l(.*)/;
        push( @libs, $lib );
    }
    push( @dirs, split( ' ', $Config{'libpth'} ) );

    # Now make sure we've got VMS-syntax absolute directory specs
    # (We don't, however, check whether someone's hidden a relative
    # path in a logical name.)
    foreach my $dir ( @dirs ) {
        unless ( -d $dir ) {
            warn &quot;Skipping nonexistent Directory $dir\n&quot; if $verbose &gt; 1;
            $dir = '';
            next;
        }
        warn &quot;Resolving directory $dir\n&quot; if $verbose;
        if ( File::Spec-&gt;file_name_is_absolute( $dir ) ) {
            $dir = VMS::Filespec::vmspath( $dir );
        }
        else {
            $dir = $self-&gt;catdir( $cwd, $dir );
        }
    }
    @dirs = grep { length( $_ ) } @dirs;
    unshift( @dirs, '' );    # Check each $lib without additions first

  LIB: foreach my $lib ( @libs ) {
        if ( exists $libmap{$lib} ) {
            next unless length $libmap{$lib};
            $lib = $libmap{$lib};
        }

        my ( @variants, $cand );
        my ( $ctype ) = '';

        # If we don't have a file type, consider it a possibly abbreviated name and
        # check for common variants.  We try these first to grab libraries before
        # a like-named executable image (e.g. -lperl resolves to perlshr.exe
        # before perl.exe).
        if ( $lib !~ /\.[^:&gt;\]]*$/ ) {
            push( @variants, &quot;${lib}shr&quot;, &quot;${lib}rtl&quot;, &quot;${lib}lib&quot; );
            push( @variants, &quot;lib$lib&quot; ) if $lib !~ /[:&gt;\]]/;
        }
        push( @variants, $lib );
        warn &quot;Looking for $lib\n&quot; if $verbose;
        foreach my $variant ( @variants ) {
            my ( $fullname, $name );

            foreach my $dir ( @dirs ) {
                my ( $type );

                $name = &quot;$dir$variant&quot;;
                warn &quot;\tChecking $name\n&quot; if $verbose &gt; 2;
                $fullname = VMS::Filespec::rmsexpand( $name );
                if ( defined $fullname and -f $fullname ) {

                    # It's got its own suffix, so we'll have to figure out the type
                    if    ( $fullname =~ /(?:$so|exe)$/i )      { $type = 'SHR'; }
                    elsif ( $fullname =~ /(?:$lib_ext|olb)$/i ) { $type = 'OLB'; }
                    elsif ( $fullname =~ /(?:$obj_ext|obj)$/i ) {
                        warn &quot;Warning (mostly harmless): &quot; . &quot;Plain object file $fullname found in library list\n&quot;;
                        $type = 'OBJ';
                    }
                    else {
                        warn &quot;Warning (mostly harmless): &quot; . &quot;Unknown library type for $fullname; assuming shared\n&quot;;
                        $type = 'SHR';
                    }
                }
                elsif (-f ( $fullname = VMS::Filespec::rmsexpand( $name, $so ) )
                    or -f ( $fullname = VMS::Filespec::rmsexpand( $name, '.exe' ) ) )
                {
                    $type = 'SHR';
                    $name = $fullname unless $fullname =~ /exe;?\d*$/i;
                }
                elsif (
                    not length( $ctype ) and    # If we've got a lib already,
                                                # don't bother
                    ( -f ( $fullname = VMS::Filespec::rmsexpand( $name, $lib_ext ) ) or -f ( $fullname = VMS::Filespec::rmsexpand( $name, '.olb' ) ) )
                  )
                {
                    $type = 'OLB';
                    $name = $fullname unless $fullname =~ /olb;?\d*$/i;
                }
                elsif (
                    not length( $ctype ) and    # If we've got a lib already,
                                                # don't bother
                    ( -f ( $fullname = VMS::Filespec::rmsexpand( $name, $obj_ext ) ) or -f ( $fullname = VMS::Filespec::rmsexpand( $name, '.obj' ) ) )
                  )
                {
                    warn &quot;Warning (mostly harmless): &quot; . &quot;Plain object file $fullname found in library list\n&quot;;
                    $type = 'OBJ';
                    $name = $fullname unless $fullname =~ /obj;?\d*$/i;
                }
                if ( defined $type ) {
                    $ctype = $type;
                    $cand  = $name;
                    last if $ctype eq 'SHR';
                }
            }
            if ( $ctype ) {

                push @{ $found{$ctype} }, $cand;
                warn &quot;\tFound as $cand (really $fullname), type $ctype\n&quot;
                  if $verbose &gt; 1;
                push @flibs, $name unless $libs_seen{$fullname}++;
                next LIB;
            }
        }
        warn &quot;Warning (mostly harmless): &quot; . &quot;No library found for $lib\n&quot;;
    }

    push @fndlibs, @{ $found{OBJ} } if exists $found{OBJ};
    push @fndlibs, map { &quot;$_/Library&quot; } @{ $found{OLB} } if exists $found{OLB};
    push @fndlibs, map { &quot;$_/Share&quot; } @{ $found{SHR} }   if exists $found{SHR};
    my $lib = join( ' ', @fndlibs );

    $ldlib = $crtlstr ? &quot;$lib $crtlstr&quot; : $lib;
    $ldlib =~ s/^\s+|\s+$//g;
    warn &quot;Result:\n\tEXTRALIBS: $lib\n\tLDLOADLIBS: $ldlib\n&quot; if $verbose;
    wantarray ? ( $lib, '', $ldlib, '', ( $give_libs ? \@flibs : () ) ) : $lib;
}

1;
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fperl5%2Fvendor_perl%2FExtUtils%2FLiblist'>Back to Directory</a>