libperlio-via-symlink-perl-0.05.orig/0000750000175000017500000000000010232005161020624 5ustar bastianbastian00000000000000libperlio-via-symlink-perl-0.05.orig/t/0000750000175000017500000000000010232005161021067 5ustar bastianbastian00000000000000libperlio-via-symlink-perl-0.05.orig/t/1use.t0000640000175000017500000000013410105662566022151 0ustar bastianbastian00000000000000#!/usr/bin/perl use Test; BEGIN { plan tests => 1 }; use PerlIO::via::symlink; ok(1); exit; libperlio-via-symlink-perl-0.05.orig/t/2basic.t0000640000175000017500000000206310232004724022425 0ustar bastianbastian00000000000000#!/usr/bin/perl use Config; use Test::More ( $Config{d_symlink} ? (tests => 9) : (skip_all => "symlink not available") ); use PerlIO::via::symlink; use strict; use POSIX qw(setlocale LC_ALL); setlocale (LC_ALL, 'C'); my $fname = 'symlink-test'; unlink ($fname); open my $fh, '+>:via(symlink)', $fname; ok ($! =~ m'Invalid argument'); open $fh, '>:via(symlink)', $fname or die $!; print $fh "link foobar"; close $fh; ok (-l $fname); is (readlink $fname, 'foobar'); open $fh, '<:via(symlink)', $fname or die $!; is (<$fh>, 'link foobar', 'read'); seek $fh, 0, 0; is (<$fh>, 'link foobar', 'read'); unlink ($fname); eval { open my $fh, '>:via(symlink)', $fname or die $!; print $fh "foobar"; close $fh or die $!; }; ok ($@ =~ m'Invalid argument'); open $fh, '<:via(symlink)', $fname; ok ($! =~ m'Bad file (number|descriptor)'); eval { open my $fh, '>:via(symlink)', $fname or die $!; `touch $fname`; print $fh "link foobar"; close $fh or die $!; }; ok ($@ =~ m'File exists'); open $fh, '<:via(symlink)', $fname; ok ($! =~ m'Bad file (number|descriptor)'); libperlio-via-symlink-perl-0.05.orig/inc/0000750000175000017500000000000010232005161021375 5ustar bastianbastian00000000000000libperlio-via-symlink-perl-0.05.orig/inc/ExtUtils/0000750000175000017500000000000010232005161023156 5ustar bastianbastian00000000000000libperlio-via-symlink-perl-0.05.orig/inc/ExtUtils/AutoInstall.pm0000640000175000017500000004365010200702143025763 0ustar bastianbastian00000000000000#line 1 "inc/ExtUtils/AutoInstall.pm - /usr/local/lib/perl5/site_perl/5.8.5/ExtUtils/AutoInstall.pm" # $File: //member/autrijus/ExtUtils-AutoInstall/lib/ExtUtils/AutoInstall.pm $ # $Revision: #14 $ $Change: 10538 $ $DateTime: 2004/04/29 17:55:36 $ vim: expandtab shiftwidth=4 package ExtUtils::AutoInstall; $ExtUtils::AutoInstall::VERSION = '0.61'; use strict; use Cwd (); use ExtUtils::MakeMaker (); #line 308 # special map on pre-defined feature sets my %FeatureMap = ( '' => 'Core Features', # XXX: deprecated '-core' => 'Core Features', ); # various lexical flags my (@Missing, @Existing, %DisabledTests, $UnderCPAN, $HasCPANPLUS); my ($Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly); my ($PostambleActions, $PostambleUsed); _accept_default(!-t STDIN); # see if it's a non-interactive session _init(); sub _accept_default { $AcceptDefault = shift; } sub missing_modules { return @Missing; } sub do_install { __PACKAGE__->install( [ UNIVERSAL::isa($Config, 'HASH') ? %{$Config} : @{$Config}], @Missing, ); } # initialize various flags, and/or perform install sub _init { foreach my $arg (@ARGV, split(/[\s\t]+/, $ENV{PERL_EXTUTILS_AUTOINSTALL} || '')) { if ($arg =~ /^--config=(.*)$/) { $Config = [ split(',', $1) ]; } elsif ($arg =~ /^--installdeps=(.*)$/) { __PACKAGE__->install($Config, @Missing = split(/,/, $1)); exit 0; } elsif ($arg =~ /^--default(?:deps)?$/) { $AcceptDefault = 1; } elsif ($arg =~ /^--check(?:deps)?$/) { $CheckOnly = 1; } elsif ($arg =~ /^--skip(?:deps)?$/) { $SkipInstall = 1; } elsif ($arg =~ /^--test(?:only)?$/) { $TestOnly = 1; } } } # overrides MakeMaker's prompt() to automatically accept the default choice sub _prompt { goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault; my ($prompt, $default) = @_; my $y = ($default =~ /^[Yy]/); print $prompt, ' [', ($y ? 'Y' : 'y'), '/', ($y ? 'n' : 'N'), '] '; print "$default\n"; return $default; } # the workhorse sub import { my $class = shift; my @args = @_ or return; my $core_all; print "*** $class version ".$class->VERSION."\n"; print "*** Checking for dependencies...\n"; my $cwd = Cwd::cwd(); $Config = []; my $maxlen = length((sort { length($b) <=> length($a) } grep { /^[^\-]/ } map { ref($_) ? keys %{ref($_) eq 'HASH' ? $_ : +{@{$_}}} : '' } map { +{@args}->{$_} } grep { /^[^\-]/ or /^-core$/i } keys %{+{@args}})[0]); while (my ($feature, $modules) = splice(@args, 0, 2)) { my (@required, @tests, @skiptests); my $default = 1; my $conflict = 0; if ($feature =~ m/^-(\w+)$/) { my $option = lc($1); # check for a newer version of myself _update_to($modules, @_) and return if $option eq 'version'; # sets CPAN configuration options $Config = $modules if $option eq 'config'; # promote every features to core status $core_all = ($modules =~ /^all$/i) and next if $option eq 'core'; next unless $option eq 'core'; } print "[".($FeatureMap{lc($feature)} || $feature)."]\n"; $modules = [ %{$modules} ] if UNIVERSAL::isa($modules, 'HASH'); unshift @$modules, -default => &{shift(@$modules)} if (ref($modules->[0]) eq 'CODE'); # XXX: bugward combatability while (my ($mod, $arg) = splice(@$modules, 0, 2)) { if ($mod =~ m/^-(\w+)$/) { my $option = lc($1); $default = $arg if ($option eq 'default'); $conflict = $arg if ($option eq 'conflict'); @tests = @{$arg} if ($option eq 'tests'); @skiptests = @{$arg} if ($option eq 'skiptests'); next; } printf("- %-${maxlen}s ...", $mod); # XXX: check for conflicts and uninstalls(!) them. if (defined(my $cur = _version_check(_load($mod), $arg ||= 0))) { print "loaded. ($cur".($arg ? " >= $arg" : '').")\n"; push @Existing, $mod => $arg; $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { print "missing." . ($arg ? " (would need $arg)" : '') . "\n"; push @required, $mod => $arg; } } next unless @required; my $mandatory = ($feature eq '-core' or $core_all); if (!$SkipInstall and ($CheckOnly or _prompt( qq{==> Auto-install the }. (@required / 2). ($mandatory ? ' mandatory' : ' optional'). qq{ module(s) from CPAN?}, $default ? 'y' : 'n', ) =~ /^[Yy]/)) { push (@Missing, @required); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } elsif (!$SkipInstall and $default and $mandatory and _prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', ) =~ /^[Nn]/) { push (@Missing, @required); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { $DisabledTests{$_} = 1 for map { glob($_) } @tests; } } _check_lock(); # check for $UnderCPAN if (@Missing and not ($CheckOnly or $UnderCPAN)) { require Config; print "*** Dependencies will be installed the next time you type '$Config::Config{make}'.\n"; # make an educated guess of whether we'll need root permission. print " (You may need to do that as the 'root' user.)\n" if eval '$>'; } print "*** $class configuration finished.\n"; chdir $cwd; # import to main:: no strict 'refs'; *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main'; } # CPAN.pm is non-reentrant, so check if we're under it and have no CPANPLUS sub _check_lock { return unless @Missing; return if _has_cpanplus(); require CPAN; CPAN::Config->load; my $lock = MM->catfile($CPAN::Config->{cpan_home}, ".lock"); if (-f $lock and open(LOCK, $lock) and ($^O eq 'MSWin32' ? _under_cpan() : == getppid()) and ($CPAN::Config->{prerequisites_policy} || '') ne 'ignore' ) { print << '.'; *** Since we're running under CPAN, I'll just let it take care of the dependency's installation later. . $UnderCPAN = 1; } close LOCK; } sub install { my $class = shift; my $i; # used below to strip leading '-' from config keys my @config = (map { s/^-// if ++$i; $_ } @{+shift}); my (@modules, @installed); while (my ($pkg, $ver) = splice(@_, 0, 2)) { # grep out those already installed if (defined(_version_check(_load($pkg), $ver))) { push @installed, $pkg; } else { push @modules, $pkg, $ver; } } return @installed unless @modules; # nothing to do print "*** Installing dependencies...\n"; return unless _connected_to('cpan.org'); my %args = @config; my %failed; local *FAILED; if ($args{do_once} and open(FAILED, '.#autoinstall.failed')) { while () { chomp; $failed{$_}++ } close FAILED; my @newmod; while (my ($k, $v) = splice(@modules, 0, 2)) { push @newmod, ($k => $v) unless $failed{$k}; } @modules = @newmod; } if (_has_cpanplus()) { _install_cpanplus(\@modules, \@config); } else { _install_cpan(\@modules, \@config); } print "*** $class installation finished.\n"; # see if we have successfully installed them while (my ($pkg, $ver) = splice(@modules, 0, 2)) { if (defined(_version_check(_load($pkg), $ver))) { push @installed, $pkg; } elsif ($args{do_once} and open(FAILED, '>> .#autoinstall.failed')) { print FAILED "$pkg\n"; } } close FAILED if $args{do_once}; return @installed; } sub _install_cpanplus { my @modules = @{+shift}; my @config = @{+shift}; my $installed = 0; require CPANPLUS::Backend; my $cp = CPANPLUS::Backend->new; my $conf = $cp->configure_object; return unless _can_write( $conf->can('conf') ? $conf->get_conf('base') # 0.05x+ : $conf->_get_build('base') # 0.04x ); # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $conf->get_conf('makeflags') || ''; if (UNIVERSAL::isa($makeflags, 'HASH')) { # 0.03+ uses a hashref here $makeflags->{UNINST} = 1 unless exists $makeflags->{UNINST}; } else { # 0.02 and below uses a scalar $makeflags = join(' ', split(' ', $makeflags), 'UNINST=1') if ($makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' }); } $conf->set_conf(makeflags => $makeflags); $conf->set_conf(prereqs => 1); while (my ($key, $val) = splice(@config, 0, 2)) { eval { $conf->set_conf($key, $val) }; } my $modtree = $cp->module_tree; while (my ($pkg, $ver) = splice(@modules, 0, 2)) { print "*** Installing $pkg...\n"; MY::preinstall($pkg, $ver) or next if defined &MY::preinstall; my $success; my $obj = $modtree->{$pkg}; if ($obj and defined(_version_check($obj->{version}, $ver))) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc (grep { m/$pathname.pm/i } keys(%INC)) { delete $INC{$inc}; } my $rv = $cp->install( modules => [ $obj->{module} ]); if ($rv and ($rv->{$obj->{module}} or $rv->{ok})) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation cancelled.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall($pkg, $ver, $success) if defined &MY::postinstall; } return $installed; } sub _install_cpan { my @modules = @{+shift}; my @config = @{+shift}; my $installed = 0; my %args; require CPAN; CPAN::Config->load; return unless _can_write(MM->catfile($CPAN::Config->{cpan_home}, 'sources')); # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $CPAN::Config->{make_install_arg} || ''; $CPAN::Config->{make_install_arg} = join(' ', split(' ', $makeflags), 'UNINST=1') if ($makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' }); # don't show start-up info $CPAN::Config->{inhibit_startup_message} = 1; # set additional options while (my ($opt, $arg) = splice(@config, 0, 2)) { ($args{$opt} = $arg, next) if $opt =~ /^force$/; # pseudo-option $CPAN::Config->{$opt} = $arg; } local $CPAN::Config->{prerequisites_policy} = 'follow'; while (my ($pkg, $ver) = splice(@modules, 0, 2)) { MY::preinstall($pkg, $ver) or next if defined &MY::preinstall; print "*** Installing $pkg...\n"; my $obj = CPAN::Shell->expand(Module => $pkg); my $success = 0; if ($obj and defined(_version_check($obj->cpan_version, $ver))) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc (grep { m/$pathname.pm/i } keys(%INC)) { delete $INC{$inc}; } $obj->force('install') if $args{force}; my $rv = $obj->install || eval { $CPAN::META->instance( 'CPAN::Distribution', $obj->cpan_file, )->{install} if $CPAN::META }; if ($rv eq 'YES') { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation failed.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall($pkg, $ver, $success) if defined &MY::postinstall; } return $installed; } sub _has_cpanplus { return ( $HasCPANPLUS = ( $INC{'CPANPLUS/Config.pm'} or _load('CPANPLUS::Shell::Default') ) ); } # make guesses on whether we're under the CPAN installation directory sub _under_cpan { require Cwd; require File::Spec; my $cwd = File::Spec->canonpath(Cwd::cwd()); my $cpan = File::Spec->canonpath($CPAN::Config->{cpan_home}); return (index($cwd, $cpan) > -1); } sub _update_to { my $class = __PACKAGE__; my $ver = shift; return if defined(_version_check(_load($class), $ver)); # no need to upgrade if (_prompt( "==> A newer version of $class ($ver) is required. Install?", 'y' ) =~ /^[Nn]/) { die "*** Please install $class $ver manually.\n"; } print << "."; *** Trying to fetch it from CPAN... . # install ourselves _load($class) and return $class->import(@_) if $class->install([], $class, $ver); print << '.'; exit 1; *** Cannot bootstrap myself. :-( Installation terminated. . } # check if we're connected to some host, using inet_aton sub _connected_to { my $site = shift; return ( ( _load('Socket') and Socket::inet_aton($site) ) or _prompt(qq( *** Your host cannot resolve the domain name '$site', which probably means the Internet connections are unavailable. ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ ); } # check if a directory is writable; may create it on demand sub _can_write { my $path = shift; mkdir ($path, 0755) unless -e $path; require Config; return 1 if -w $path and -w $Config::Config{sitelib}; print << "."; *** You are not allowed to write to the directory '$path'; the installation may fail due to insufficient permissions. . if (eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt(qq( ==> Should we try to re-execute the autoinstall process with 'sudo'?), 'y' ) =~ /^[Yy]/) { # try to bootstrap ourselves from sudo print << "."; *** Trying to re-execute the autoinstall process with 'sudo'... . my $missing = join(',', @Missing); my $config = join(',', UNIVERSAL::isa($Config, 'HASH') ? %{$Config} : @{$Config} ) if $Config; return unless system('sudo', $^X, $0, "--config=$config", "--installdeps=$missing"); print << "."; *** The 'sudo' command exited with error! Resuming... . } return _prompt(qq( ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ } # load a module and return the version it reports sub _load { my $mod = pop; # class/instance doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; local $@; return eval { require $file; $mod->VERSION } || ($@ ? undef : 0); } # compare two versions, either use Sort::Versions or plain comparison sub _version_check { my ($cur, $min) = @_; return unless defined $cur; $cur =~ s/\s+$//; # check for version numbers that are not in decimal format if (ref($cur) or ref($min) or $cur =~ /v|\..*\./ or $min =~ /v|\..*\./) { if ($version::VERSION or defined(_load('version'))) { # use version.pm if it is installed. return ((version->new($cur) >= version->new($min)) ? $cur : undef); } elsif ($Sort::Versions::VERSION or defined(_load('Sort::Versions'))) { # use Sort::Versions as the sorting algorithm for a.b.c versions return ((Sort::Versions::versioncmp($cur, $min) != -1) ? $cur : undef); } warn "Cannot reliably compare non-decimal formatted versions.\n". "Please install version.pm or Sort::Versions.\n"; } # plain comparison local $^W = 0; # shuts off 'not numeric' bugs return ($cur >= $min ? $cur : undef); } # nothing; this usage is deprecated. sub main::PREREQ_PM { return {}; } sub _make_args { my %args = @_; $args{PREREQ_PM} = { %{$args{PREREQ_PM} || {} }, @Existing, @Missing } if $UnderCPAN or $TestOnly; if ($args{EXE_FILES}) { require ExtUtils::Manifest; my $manifest = ExtUtils::Manifest::maniread('MANIFEST'); $args{EXE_FILES} = [ grep { exists $manifest->{$_} } @{$args{EXE_FILES}} ]; } $args{test}{TESTS} ||= 't/*.t'; $args{test}{TESTS} = join(' ', grep { !exists($DisabledTests{$_}) } map { glob($_) } split(/\s+/, $args{test}{TESTS})); my $missing = join(',', @Missing); my $config = join(',', UNIVERSAL::isa($Config, 'HASH') ? %{$Config} : @{$Config} ) if $Config; $PostambleActions = ( $missing ? "\$(PERL) $0 --config=$config --installdeps=$missing" : "\@\$(NOOP)" ); return %args; } # a wrapper to ExtUtils::MakeMaker::WriteMakefile sub Write { require Carp; Carp::croak "WriteMakefile: Need even number of args" if @_ % 2; if ($CheckOnly) { print << "."; *** Makefile not written in check-only mode. . return; } my %args = _make_args(@_); no strict 'refs'; $PostambleUsed = 0; local *MY::postamble = \&postamble unless defined &MY::postamble; ExtUtils::MakeMaker::WriteMakefile(%args); print << "." unless $PostambleUsed; *** WARNING: Makefile written with customized MY::postamble() without including contents from ExtUtils::AutoInstall::postamble() -- auto installation features disabled. Please contact the author. . return 1; } sub postamble { $PostambleUsed = 1; return << "."; config :: installdeps \t\@\$(NOOP) checkdeps :: \t\$(PERL) $0 --checkdeps installdeps :: \t$PostambleActions . } 1; __END__ #line 973 libperlio-via-symlink-perl-0.05.orig/inc/Module/0000750000175000017500000000000010232005161022622 5ustar bastianbastian00000000000000libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/0000750000175000017500000000000010232005161024230 5ustar bastianbastian00000000000000libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Makefile.pm0000640000175000017500000000724010200702143026306 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Makefile.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Makefile.pm" package Module::Install::Makefile; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.01'; use strict 'vars'; use vars '$VERSION'; use ExtUtils::MakeMaker (); sub Makefile { $_[0] } sub prompt { shift; goto &ExtUtils::MakeMaker::prompt; } sub makemaker_args { my $self = shift; my $args = ($self->{makemaker_args} ||= {}); %$args = ( %$args, @_ ) if @_; $args; } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join(" ", grep length, $clean->{FILES}, @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [shift]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name || $self->determine_NAME($args); $args->{VERSION} = $self->version || $self->determine_VERSION($args); $args->{NAME} =~ s/-/::/g; if ($] >= 5.005) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = $self->author; } if ( eval($ExtUtils::MakeMaker::VERSION) >= 6.10 ) { $args->{NO_META} = 1; } if ( eval($ExtUtils::MakeMaker::VERSION) > 6.17 ) { $args->{SIGN} = 1 if $self->sign; } delete $args->{SIGN} unless $self->is_admin; # merge both kinds of requires into prereq_pm my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } map { @$_ } grep $_, ($self->build_requires, $self->requires) ); # merge both kinds of requires into prereq_pm my $dir = ($args->{DIR} ||= []); if ($self->bundles) { push @$dir, map "$_->[1]", @{$self->bundles}; delete $prereq->{$_->[0]} for @{$self->bundles}; } if (my $perl_version = $self->perl_version) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, ". "but we need version >= $perl_version"; } my %args = map {($_ => $args->{$_})} grep {defined($args->{$_})} keys %$args; if ($self->admin->preop) { $args{dist} = $self->admin->preop; } ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile(); } sub fix_up_makefile { my $self = shift; my $top_class = ref($self->_top) || ''; my $top_version = $self->_top->VERSION || ''; my $preamble = $self->preamble ? "# Preamble by $top_class $top_version\n" . $self->preamble : ''; my $postamble = "# Postamble by $top_class $top_version\n" . ($self->postamble || ''); open MAKEFILE, '< Makefile' or die $!; my $makefile = do { local $/; }; close MAKEFILE; $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /; $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g; $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g; $makefile =~ s/^(FULLPERL = .*)/$1 -Iinc/m; $makefile =~ s/^(PERL = .*)/$1 -Iinc/m; open MAKEFILE, '> Makefile' or die $!; print MAKEFILE "$preamble$makefile$postamble"; close MAKEFILE; } sub preamble { my ($self, $text) = @_; $self->{preamble} = $text . $self->{preamble} if defined $text; $self->{preamble}; } sub postamble { my ($self, $text) = @_; $self->{postamble} ||= $self->admin->postamble; $self->{postamble} .= $text if defined $text; $self->{postamble} } 1; __END__ #line 273 libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Fetch.pm0000640000175000017500000000462710200702143025630 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Fetch.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Fetch.pm" package Module::Install::Fetch; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.01'; sub get_file { my ($self, %args) = @_; my ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; if ($scheme eq 'http' and !eval { require LWP::Simple; 1 }) { $args{url} = $args{ftp_url} or (warn("LWP support unavailable!\n"), return); ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; } $|++; print "Fetching '$file' from $host... "; unless (eval { require Socket; Socket::inet_aton($host) }) { warn "'$host' resolve failed!\n"; return; } return unless $scheme eq 'ftp' or $scheme eq 'http'; require Cwd; my $dir = Cwd::getcwd(); chdir $args{local_dir} or return if exists $args{local_dir}; if (eval { require LWP::Simple; 1 }) { LWP::Simple::mirror($args{url}, $file); } elsif (eval { require Net::FTP; 1 }) { eval { # use Net::FTP to get past firewall my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600); $ftp->login("anonymous", 'anonymous@example.com'); $ftp->cwd($path); $ftp->binary; $ftp->get($file) or (warn("$!\n"), return); $ftp->quit; } } elsif (my $ftp = $self->can_run('ftp')) { eval { # no Net::FTP, fallback to ftp.exe require FileHandle; my $fh = FileHandle->new; local $SIG{CHLD} = 'IGNORE'; unless ($fh->open("|$ftp -n")) { warn "Couldn't open ftp: $!\n"; chdir $dir; return; } my @dialog = split(/\n/, << "."); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit . foreach (@dialog) { $fh->print("$_\n") } $fh->close; } } else { warn "No working 'ftp' program available!\n"; chdir $dir; return; } unless (-f $file) { warn "Fetching failed: $@\n"; chdir $dir; return; } return if exists $args{size} and -s $file != $args{size}; system($args{run}) if exists $args{run}; unlink($file) if $args{remove}; print(((!exists $args{check_for} or -e $args{check_for}) ? "done!" : "failed! ($!)"), "\n"); chdir $dir; return !$?; } 1; libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Base.pm0000640000175000017500000000152410200702143025442 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Base.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Base.pm" package Module::Install::Base; #line 28 sub new { my ($class, %args) = @_; foreach my $method (qw(call load)) { *{"$class\::$method"} = sub { +shift->_top->$method(@_); } unless defined &{"$class\::$method"}; } bless(\%args, $class); } #line 46 sub AUTOLOAD { my $self = shift; goto &{$self->_top->autoload}; } #line 57 sub _top { $_[0]->{_top} } #line 68 sub admin { my $self = shift; $self->_top->{admin} or Module::Install::Base::FakeAdmin->new; } sub is_admin { my $self = shift; $self->admin->VERSION; } sub DESTROY {} package Module::Install::Base::FakeAdmin; my $Fake; sub new { $Fake ||= bless(\@_, $_[0]) } sub AUTOLOAD {} sub DESTROY {} 1; __END__ #line 112 libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/AutoInstall.pm0000640000175000017500000000361410200702143027031 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/AutoInstall.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/AutoInstall.pm" package Module::Install::AutoInstall; use Module::Install::Base; @ISA = qw(Module::Install::Base); sub AutoInstall { $_[0] } sub run { my $self = shift; $self->auto_install_now(@_); } sub write { my $self = shift; $self->auto_install(@_); } sub auto_install { my $self = shift; return if $self->{done}++; # ExtUtils::AutoInstall Bootstrap Code, version 7. AUTO:{my$p='ExtUtils::AutoInstall';my$v=0.49;$p->VERSION||0>=$v or+eval"use $p $v;1"or+do{my$e=$ENV{PERL_EXTUTILS_AUTOINSTALL}; (!defined($e)||$e!~m/--(?:default|skip|testonly)/and-t STDIN or eval"use ExtUtils::MakeMaker;WriteMakefile(PREREQ_PM=>{'$p',$v} );1"and exit)and print"==> $p $v required. Install it from CP". "AN? [Y/n] "and!~/^n/i and print"*** Installing $p\n"and do{if (eval '$>' and lc(`sudo -V`) =~ /version/){system('sudo', $^X,"-MCPANPLUS","-e","CPANPLUS::install $p");eval"use $p $v;1" ||system('sudo', $^X, "-MCPAN", "-e", "CPAN::install $p")}eval{ require CPANPLUS;CPANPLUS::install$p};eval"use $p $v;1"or eval{ require CPAN;CPAN::install$p};eval"use $p $v;1"||die"*** Please manually install $p $v from cpan.org first...\n"}}} # Flatten array of arrays into a single array my @core = map @$_, map @$_, grep ref, $self->build_requires, $self->requires; while ( @core and @_ > 1 and $_[0] =~ /^-\w+$/ ) { push @core, splice(@_, 0, 2); } ExtUtils::AutoInstall->import( (@core ? (-core => \@core) : ()), @_, $self->features ); $self->makemaker_args( ExtUtils::AutoInstall::_make_args() ); my $class = ref($self); $self->postamble( "# --- $class section:\n" . ExtUtils::AutoInstall::postamble() ); } sub auto_install_now { my $self = shift; $self->auto_install; ExtUtils::AutoInstall::do_install(); } 1; libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Metadata.pm0000640000175000017500000001153310200702143026311 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Metadata.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Metadata.pm" package Module::Install::Metadata; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.04'; use strict 'vars'; use vars qw($VERSION); sub Meta { shift } my @scalar_keys = qw( name module_name version abstract author license distribution_type sign perl_version ); my @tuple_keys = qw(build_requires requires recommends bundles); foreach my $key (@scalar_keys) { *$key = sub { my $self = shift; return $self->{'values'}{$key} unless @_; $self->{'values'}{$key} = shift; return $self; }; } foreach my $key (@tuple_keys) { *$key = sub { my $self = shift; return $self->{'values'}{$key} unless @_; my @rv; while (@_) { my $module = shift or last; my $version = shift || 0; if ($module eq 'perl') { $version =~ s{^(\d+)\.(\d+)\.(\d+)} {$1 + $2/1_000 + $3/1_000_000}e; $self->perl_version($version); next; } my $rv = [$module, $version]; push @{$self->{'values'}{$key}}, $rv; push @rv, $rv; } return @rv; }; } sub features { my $self = shift; while (my ($name, $mods) = splice(@_, 0, 2)) { my $count = 0; push @{$self->{'values'}{'features'}}, ($name => [ map { (++$count % 2 and ref($_) and ($count += $#$_)) ? @$_ : $_ } @$mods ] ); } return @{$self->{'values'}{'features'}}; } sub no_index { my $self = shift; my $type = shift; push @{$self->{'values'}{'no_index'}{$type}}, @_ if $type; return $self->{'values'}{'no_index'}; } sub _dump { my $self = shift; my $package = ref($self->_top); my $version = $self->_top->VERSION; my %values = %{$self->{'values'}}; delete $values{sign}; if (my $perl_version = delete $values{perl_version}) { # Always canonical to three-dot version $perl_version =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2), int($3))}e if $perl_version >= 5.006; $values{requires} = [ [perl => $perl_version], @{$values{requires}||[]}, ]; } warn "No license specified, setting license = 'unknown'\n" unless $values{license}; $values{license} ||= 'unknown'; $values{distribution_type} ||= 'module'; $values{name} ||= do { my $name = $values{module_name}; $name =~ s/::/-/g; $name; } if $values{module_name}; if ($values{name} =~ /::/) { my $name = $values{name}; $name =~ s/::/-/g; die "Error in name(): '$values{name}' should be '$name'!\n"; } my $dump = ''; foreach my $key (@scalar_keys) { $dump .= "$key: $values{$key}\n" if exists $values{$key}; } foreach my $key (@tuple_keys) { next unless exists $values{$key}; $dump .= "$key:\n"; foreach (@{$values{$key}}) { $dump .= " $_->[0]: $_->[1]\n"; } } if (my $no_index = $values{no_index}) { push @{$no_index->{'directory'}}, 'inc'; require YAML; local $YAML::UseHeader = 0; $dump .= YAML::Dump({ no_index => $no_index}); } else { $dump .= << "META"; no_index: directory: - inc META } $dump .= "generated_by: $package version $version\n"; return $dump; } sub read { my $self = shift; $self->include_deps( 'YAML', 0 ); require YAML; my $data = YAML::LoadFile( 'META.yml' ); # Call methods explicitly in case user has already set some values. while ( my ($key, $value) = each %$data ) { next unless $self->can( $key ); if (ref $value eq 'HASH') { while (my ($module, $version) = each %$value) { $self->$key( $module => $version ); } } else { $self->$key( $value ); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; META_NOT_OURS: { local *FH; if (open FH, "META.yml") { while () { last META_NOT_OURS if /^generated_by: Module::Install\b/; } return $self if -s FH; } } warn "Writing META.yml\n"; open META, "> META.yml" or warn "Cannot write to META.yml: $!"; print META $self->_dump; close META; return $self; } sub version_from { my ($self, $version_from) = @_; require ExtUtils::MM_Unix; $self->version(ExtUtils::MM_Unix->parse_version($version_from)); } sub abstract_from { my ($self, $abstract_from) = @_; require ExtUtils::MM_Unix; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix') ->parse_abstract($abstract_from) ); } 1; libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Can.pm0000640000175000017500000000165710200702143025300 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Can.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Can.pm" package Module::Install::Can; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.01'; use strict; use Config (); use File::Spec (); use ExtUtils::MakeMaker (); # check if we can run some command sub can_run { my ($self, $cmd) = @_; my $_cmd = $cmd; return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { my $abs = File::Spec->catfile($dir, $_[1]); return $abs if (-x $abs or $abs = MM->maybe_command($abs)); } return; } sub can_cc { my $self = shift; my @chunks = split(/ /, $Config::Config{cc}) or return; # $Config{cc} may contain args; try to find out the program part while (@chunks) { return $self->can_run("@chunks") || (pop(@chunks), next); } return; } 1; libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Win32.pm0000640000175000017500000000363210200702143025474 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Win32.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Win32.pm" package Module::Install::Win32; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.02'; use strict; # determine if the user needs nmake, and download it if needed sub check_nmake { my $self = shift; $self->load('can_run'); $self->load('get_file'); require Config; return unless ( $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and $^O eq 'MSWin32' and !$self->can_run('nmake') ); print "The required 'nmake' executable not found, fetching it...\n"; require File::Basename; my $rv = $self->get_file( url => 'http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe', ftp_url => 'ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe', local_dir => File::Basename::dirname($^X), size => 51928, run => 'Nmake15.exe /o > nul', check_for => 'Nmake.exe', remove => 1, ); if (!$rv) { die << '.'; ------------------------------------------------------------------------------- Since you are using Microsoft Windows, you will need the 'nmake' utility before installation. It's available at: http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe or ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe Please download the file manually, save it to a directory in %PATH% (e.g. C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to that directory, and run "Nmake15.exe" from there; that will create the 'nmake.exe' file needed by this module. You may then resume the installation process described in README. ------------------------------------------------------------------------------- . } } 1; __END__ libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/Include.pm0000640000175000017500000000064510200702143026156 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/Include.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/Include.pm" package Module::Install::Include; use Module::Install::Base; @ISA = qw(Module::Install::Base); sub include { +shift->admin->include(@_) }; sub include_deps { +shift->admin->include_deps(@_) }; sub auto_include { +shift->admin->auto_include(@_) }; sub auto_include_deps { +shift->admin->auto_include_deps(@_) }; 1; libperlio-via-symlink-perl-0.05.orig/inc/Module/Install/WriteAll.pm0000640000175000017500000000152610200702143026315 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install/WriteAll.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install/WriteAll.pm" package Module::Install::WriteAll; use Module::Install::Base; @ISA = qw(Module::Install::Base); sub WriteAll { my $self = shift; my %args = ( meta => 1, sign => 0, inline => 0, check_nmake => 1, @_ ); $self->sign(1) if $args{sign}; $self->Meta->write if $args{meta}; $self->admin->WriteAll(%args) if $self->is_admin; if ($0 =~ /Build.PL$/i) { $self->Build->write; } else { $self->check_nmake if $args{check_nmake}; $self->makemaker_args( PL_FILES => {} ) unless $self->makemaker_args->{'PL_FILES'}; if ($args{inline}) { $self->Inline->write; } else { $self->Makefile->write; } } } 1; libperlio-via-symlink-perl-0.05.orig/inc/Module/Install.pm0000640000175000017500000000732710200702143024577 0ustar bastianbastian00000000000000#line 1 "inc/Module/Install.pm - /usr/local/lib/perl5/site_perl/5.8.5/Module/Install.pm" package Module::Install; $VERSION = '0.36'; die << "." unless $INC{join('/', inc => split(/::/, __PACKAGE__)).'.pm'}; Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; . use strict 'vars'; use Cwd (); use File::Find (); use File::Path (); @inc::Module::Install::ISA = 'Module::Install'; *inc::Module::Install::VERSION = *VERSION; #line 129 sub import { my $class = shift; my $self = $class->new(@_); if (not -f $self->{file}) { require "$self->{path}/$self->{dispatch}.pm"; File::Path::mkpath("$self->{prefix}/$self->{author}"); $self->{admin} = "$self->{name}::$self->{dispatch}"->new(_top => $self); $self->{admin}->init; @_ = ($class, _self => $self); goto &{"$self->{name}::import"}; } *{caller(0) . "::AUTOLOAD"} = $self->autoload; # Unregister loader and worker packages so subdirs can use them again delete $INC{"$self->{file}"}; delete $INC{"$self->{path}.pm"}; } #line 156 sub autoload { my $self = shift; my $caller = caller; my $cwd = Cwd::cwd(); my $sym = "$caller\::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::cwd(); if (my $code = $sym->{$pwd}) { goto &$code unless $cwd eq $pwd; # delegate back to parent dirs } $$sym =~ /([^:]+)$/ or die "Cannot autoload $caller"; unshift @_, ($self, $1); goto &{$self->can('call')} unless uc($1) eq $1; }; } #line 181 sub new { my ($class, %args) = @_; return $args{_self} if $args{_self}; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= '.author'; $args{bundle} ||= 'inc/BUNDLES'; $class =~ s/^\Q$args{prefix}\E:://; $args{name} ||= $class; $args{version} ||= $class->VERSION; unless ($args{path}) { $args{path} = $args{name}; $args{path} =~ s!::!/!g; } $args{file} ||= "$args{prefix}/$args{path}.pm"; bless(\%args, $class); } #line 210 sub call { my $self = shift; my $method = shift; my $obj = $self->load($method) or return; unshift @_, $obj; goto &{$obj->can($method)}; } #line 225 sub load { my ($self, $method) = @_; $self->load_extensions( "$self->{prefix}/$self->{path}", $self ) unless $self->{extensions}; foreach my $obj (@{$self->{extensions}}) { return $obj if $obj->can($method); } my $admin = $self->{admin} or die << "END"; The '$method' method does not exist in the '$self->{prefix}' path! Please remove the '$self->{prefix}' directory and run $0 again to load it. END my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } #line 255 sub load_extensions { my ($self, $path, $top_obj) = @_; unshift @INC, $self->{prefix} unless grep { $_ eq $self->{prefix} } @INC; local @INC = ($path, @INC); foreach my $rv ($self->find_extensions($path)) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; eval { require $file; 1 } or (warn($@), next); $self->{pathnames}{$pkg} = delete $INC{$file}; push @{$self->{extensions}}, $pkg->new( _top => $top_obj ); } } #line 279 sub find_extensions { my ($self, $path) = @_; my @found; File::Find::find(sub { my $file = $File::Find::name; return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is; return if $1 eq $self->{dispatch}; $file = "$self->{path}/$1.pm"; my $pkg = "$self->{name}::$1"; $pkg =~ s!/!::!g; push @found, [$file, $pkg]; }, $path) if -d $path; @found; } 1; __END__ #line 617 libperlio-via-symlink-perl-0.05.orig/SIGNATURE0000640000175000017500000000370310232004724022120 0ustar bastianbastian00000000000000This file contains message digests of all files listed in MANIFEST, signed via the Module::Signature module, version 0.44. To verify the content in this distribution, first make sure you have Module::Signature installed, then type: % cpansign -v It will check each file's integrity, as well as the signature's validity. If "==> Signature verified OK! <==" is not displayed, the distribution may already have been compromised, and you should not run its Makefile.PL or Build.PL. -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 SHA1 7432e29018289a6dc75163f17df2a26fd2742d2b CHANGES SHA1 1776e7a5f7bb41b83d26d9093d1ddb08d2d7124f MANIFEST SHA1 42d50a5c7162574b66a24d6fbd3980410ac2ccd9 META.yml SHA1 3eaf6ff28e9f88959c455a03079faa2a8953e85a Makefile.PL SHA1 4533ed9057c0ebe3e9a6b0f1818446f79d7e3a86 README SHA1 7338f67a9d2ef18cfa49a86cc1cdd9b8e1bf2ea4 inc/ExtUtils/AutoInstall.pm SHA1 06d883487127fa0026311904e7c4867e850c505c inc/Module/Install.pm SHA1 25c1920fccb1077b2e11ed0f18df50089d2beb5d inc/Module/Install/AutoInstall.pm SHA1 2771d5c5033e94c4789c66a0aad4e21c62985ce9 inc/Module/Install/Base.pm SHA1 b5e2d5fc07b92d042c97631d2b00f61f974fc164 inc/Module/Install/Can.pm SHA1 c3747aa4bd8faa530c974b78f729c67f15c6f928 inc/Module/Install/Fetch.pm SHA1 c6d2a330e2a8cb3a1db7bfc4236fea9a8aafe297 inc/Module/Install/Include.pm SHA1 d8bc0d6e0a82d2b7533bdd3de467593094cc8b2c inc/Module/Install/Makefile.pm SHA1 6fca1d05c6b9a8f10865de5be4fefb9bfa7a52e9 inc/Module/Install/Metadata.pm SHA1 6b051a6d3ed824df40343a7ff09b66282e1783c3 inc/Module/Install/Win32.pm SHA1 77f82ce7c623e05304ac9aae05bcd1a5558fadbb inc/Module/Install/WriteAll.pm SHA1 848a89d779274614252ffc90c354508b99b162d2 symlink.pm SHA1 43e4b27eb350b710c5ff892d11d28f210871603a t/1use.t SHA1 92429b9fdade53ace07772e9e6a8535e0c53ed48 t/2basic.t -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.0 (FreeBSD) iD8DBQFCJGu2k1XldlEkA5YRAoiMAJsHQdIAkbvAwZFPts7Yxe1JaATL2gCbBWOu Uy4sLkCTsjrqMnp9UJBJH+A= =G8Cw -----END PGP SIGNATURE----- libperlio-via-symlink-perl-0.05.orig/symlink.pm0000640000175000017500000000434610232004724022664 0ustar bastianbastian00000000000000package PerlIO::via::symlink; use 5.008; use warnings; use strict; our $VERSION = '0.05'; =head1 NAME PerlIO::via::symlink - PerlIO layers for create symlinks =head1 SYNOPSIS open $fh, '>:via(symlink)', $fname; print $fh "link foobar"; close $fh; =head1 DESCRIPTION The PerlIO layer C allows you to create a symbolic link by writing to the file handle. You need to write C"link $name" to the file handle. If the format does not match, C will fail with EINVAL. =cut use Errno qw(EINVAL ENOENT); use Symbol qw(gensym); sub PUSHED { $! = EINVAL, return -1 unless $_[1] eq 'w' || $_[1] eq 'r'; my $self = bless gensym(), $_[0]; *$self->{mode} = $_[1]; return $self; } sub OPEN { my ($self, $fname) = @_; *$self->{fname} = $fname; return 1 if *$self->{mode} eq 'w'; lstat ($fname) or return -1; $! = EINVAL, return -1 unless -l $fname; *$self->{content} = 'link '.readlink ($fname); return 1; } sub WRITE { my ($self, $buf) = @_; *$self->{content} .= $buf; return length($buf); } sub FILL { my ($self) = @_; return if *$self->{filled}; ++*$self->{filled}; return *$self->{content}; } sub SEEK { my ($self) = @_; delete *$self->{filled}; } sub CLOSE { my ($link, $fname, $mode) = @{*{$_[0]}}{qw/content fname mode/}; return 0 if $mode eq 'r'; $link =~ s/^link // or $! = EINVAL, return -1; symlink $link, $fname or return -1; return 0; } =head1 TEST COVERAGE ----------------------------------- ------ ------ ------ ------ ------ ------ File stmt branch cond sub time total ----------------------------------- ------ ------ ------ ------ ------ ------ blib/lib/PerlIO/via/symlink.pm 100.0 100.0 n/a 100.0 100.0 100.0 Total 100.0 100.0 n/a 100.0 100.0 100.0 ----------------------------------- ------ ------ ------ ------ ------ ------ =head1 AUTHORS Chia-liang Kao Eclkao@clkao.orgE =head1 COPYRIGHT Copyright 2004-2005 by Chia-liang Kao Eclkao@clkao.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See L =cut 1; libperlio-via-symlink-perl-0.05.orig/Makefile.PL0000640000175000017500000000050410105662566022617 0ustar bastianbastian00000000000000#!/usr/bin/perl use inc::Module::Install; name ('PerlIO-via-symlink'); author ('Chia-liang Kao '); abstract ('PerlIO layer for symlinks'); license ('perl'); version_from ('symlink.pm'); clean_files ('symlink-test'); # from test include('ExtUtils::AutoInstall'); auto_install(); WriteAll( sign => 1 ); libperlio-via-symlink-perl-0.05.orig/META.yml0000640000175000017500000000035010232004724022100 0ustar bastianbastian00000000000000name: PerlIO-via-symlink version: 0.05 abstract: PerlIO layer for symlinks author: Chia-liang Kao license: perl distribution_type: module no_index: directory: - inc generated_by: Module::Install version 0.36 libperlio-via-symlink-perl-0.05.orig/MANIFEST0000640000175000017500000000067210105662566022004 0ustar bastianbastian00000000000000CHANGES inc/ExtUtils/AutoInstall.pm inc/Module/Install.pm inc/Module/Install/AutoInstall.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Include.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm Makefile.PL MANIFEST META.yml Module meta-data (added by MakeMaker) README SIGNATURE symlink.pm t/1use.t t/2basic.t libperlio-via-symlink-perl-0.05.orig/CHANGES0000640000175000017500000000044310232004724021625 0ustar bastianbastian00000000000000[Changes for 0.04 - 1 Mar, 2005] Fix tests for non-C locales. [Changes for 0.04 - 31 Jan, 2005] Fix tests on Solaris. [Changes for 0.03 - 10 Nov, 2004] Skip tests on win32. [Changes for 0.02 - 9 Aug, 2004] Support reading symlink. [Changes for 0.01 - 20 Jul, 2004] Initial release. libperlio-via-symlink-perl-0.05.orig/README0000640000175000017500000000114110232004724021506 0ustar bastianbastian00000000000000This is the README file for PerlIO::via::symlink, a module that helps creating symlink from IO handle. * Installation PerlIO::via::symlink uses the stanard perl module install process: % perl Makefile.PL % make # make install * Latest version The latest PerlIO::via::symlink could be found on cpan or at: http://svn.clkao.org/svnweb/member/browse/clkao/PerlIO-via-symlink/ * Copyright Copyright 2004-2005 by Chia-liang Kao clkao@clkao.org. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See .