view release on metacpan or search on metacpan
$enhanced{+caller}++;
goto &Class::Std::import;
}
sub ID ($) {
my ($package, undef, undef, $sub) = caller 1;
if ($sub eq 'Class::Std::new' && $_[0]->isa('SCALAR')
&& ($all || $enhanced{ref $_[0]})) {
# Strangely, it seems that one can dup an unopened file handle without
# warnings.
eval "open $count, '<&dead'";
view release on metacpan or search on metacpan
lib/Acme/Claude/Shell/Hooks.pm view on Meta::CPAN
hooks => [sub {
my ($input, $tool_use_id, $context) = @_;
# Stop the execution spinner
if ($session->_spinner) {
stop_spinner($session->_spinner);
$session->_spinner(undef);
}
# Track tool usage
$session->{_tool_count}++;
return Claude::Agent::Hook::Result->proceed();
}],
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# releases once we can make sure it won't clash with custom
# Module::Install extensions.
$VERSION = '1.06';
# Storage for the pseudo-singleton
$MAIN = undef;
*inc::Module::Install::VERSION = *VERSION;
@inc::Module::Install::ISA = __PACKAGE__;
}
inc/Module/Install.pm view on Meta::CPAN
defined $_[0]
and
! ref $_[0]
and
$_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s
) ? $_[0] : undef;
}
1;
# Copyright 2008 - 2012 Adam Kennedy.
view release on metacpan or search on metacpan
t/00_diag.t view on Meta::CPAN
my $pm = "$module.pm";
$pm =~ s{::}{/}g;
if(eval { require $pm; 1 })
{
my $ver = eval { $module->VERSION };
$ver = 'undef' unless defined $ver;
diag sprintf $format, $module, $ver;
}
else
{
diag sprintf $format, $module, '-';
view release on metacpan or search on metacpan
examples/show_approximations.pl view on Meta::CPAN
my $res = [ $fuzzy->colour_approximations( $r, $g, $b ) ];
my $name = $fuzzy->colour_name( $r, $g, $b );
( my $pp_pack = $pack ) =~ s/^Color::Similarity:://;
my $app = Wx::SimpleApp->new;
my $frame = Wx::Frame->new( undef, -1, "($r, $g, $b) $pp_pack",
[-1, -1], [300, 440] );
my $y = 0;
for my $row ( { distance => 0,
name => 'ORIGINAL: ' . $name,
rgb => [ $r, $g, $b],
view release on metacpan or search on metacpan
inc/Test/Builder.pm view on Meta::CPAN
share($self->{Curr_Test});
$self->{Curr_Test} = 0;
$self->{Test_Results} = &share([]);
$self->{Exported_To} = undef;
$self->{Expected_Tests} = 0;
$self->{Skip_All} = 0;
$self->{Use_Nums} = 1;
inc/Test/Builder.pm view on Meta::CPAN
$self->{No_Header} = 0;
$self->{No_Ending} = 0;
$self->_dup_stdhandles unless $^C;
return undef;
}
#line 221
sub exported_to {
inc/Test/Builder.pm view on Meta::CPAN
if( $arg ) {
local $Level = $Level + 1;
return $self->expected_tests($arg);
}
elsif( !defined $arg ) {
$self->croak("Got an undefined number of tests");
}
elsif( !$arg ) {
$self->croak("You said to run 0 tests");
}
}
inc/Test/Builder.pm view on Meta::CPAN
sub has_plan {
my $self = shift;
return($self->{Expected_Tests}) if $self->{Expected_Tests};
return('no_plan') if $self->{No_Plan};
return(undef);
};
#line 348
inc/Test/Builder.pm view on Meta::CPAN
local $Level = $Level + 1;
$self->_unoverload_str(\$got, \$expect);
if( !defined $got || !defined $expect ) {
# undef only matches undef and nothing else
my $test = !defined $got && !defined $expect;
$self->ok($test, $name);
$self->_is_diag($got, 'eq', $expect) unless $test;
return $test;
inc/Test/Builder.pm view on Meta::CPAN
local $Level = $Level + 1;
$self->_unoverload_num(\$got, \$expect);
if( !defined $got || !defined $expect ) {
# undef only matches undef and nothing else
my $test = !defined $got && !defined $expect;
$self->ok($test, $name);
$self->_is_diag($got, '==', $expect) unless $test;
return $test;
inc/Test/Builder.pm view on Meta::CPAN
# force numeric context
$self->_unoverload_num($val);
}
}
else {
$$val = 'undef';
}
}
return $self->diag(sprintf <<DIAGNOSTIC, $got, $expect);
got: %s
inc/Test/Builder.pm view on Meta::CPAN
sub isnt_eq {
my($self, $got, $dont_expect, $name) = @_;
local $Level = $Level + 1;
if( !defined $got || !defined $dont_expect ) {
# undef only matches undef and nothing else
my $test = defined $got || defined $dont_expect;
$self->ok($test, $name);
$self->_cmp_diag($got, 'ne', $dont_expect) unless $test;
return $test;
inc/Test/Builder.pm view on Meta::CPAN
sub isnt_num {
my($self, $got, $dont_expect, $name) = @_;
local $Level = $Level + 1;
if( !defined $got || !defined $dont_expect ) {
# undef only matches undef and nothing else
my $test = defined $got || defined $dont_expect;
$self->ok($test, $name);
$self->_cmp_diag($got, '!=', $dont_expect) unless $test;
return $test;
inc/Test/Builder.pm view on Meta::CPAN
}
sub _cmp_diag {
my($self, $got, $type, $expect) = @_;
$got = defined $got ? "'$got'" : 'undef';
$expect = defined $expect ? "'$expect'" : 'undef';
return $self->diag(sprintf <<DIAGNOSTIC, $got, $type, $expect);
%s
%s
%s
DIAGNOSTIC
inc/Test/Builder.pm view on Meta::CPAN
#line 916
sub maybe_regex {
my ($self, $regex) = @_;
my $usable_regex = undef;
return $usable_regex unless defined $regex;
my($re, $opts);
inc/Test/Builder.pm view on Meta::CPAN
if( ref $regex eq 'Regexp' ) {
$usable_regex = $regex;
}
# Check for '/foo/' or 'm,foo,'
elsif( ($re, $opts) = $regex =~ m{^ /(.*)/ (\w*) $ }sx or
(undef, $re, $opts) = $regex =~ m,^ m([^\w\s]) (.+) \1 (\w*) $,sx
)
{
$usable_regex = length $opts ? "(?$opts)$re" : $re;
}
inc/Test/Builder.pm view on Meta::CPAN
local $Level = $Level + 1;
$ok = $self->ok( $test, $name );
}
unless( $ok ) {
$this = defined $this ? "'$this'" : 'undef';
my $match = $cmp eq '=~' ? "doesn't match" : "matches";
$self->diag(sprintf <<DIAGNOSTIC, $this, $match, $regex);
%s
%13s '%s'
DIAGNOSTIC
inc/Test/Builder.pm view on Meta::CPAN
return 1 if ref $maybe_fh eq 'GLOB'; # its a glob
return 1 if ref \$maybe_fh eq 'GLOB'; # its a glob ref
return eval { $maybe_fh->isa("IO::Handle") } ||
# 5.5.4's tied() and can() doesn't like getting undef
eval { (tied($maybe_fh) || '')->can('TIEHANDLE') };
}
#line 1067
inc/Test/Builder.pm view on Meta::CPAN
# Prevent printing headers when compiling (i.e. -c)
return if $^C;
# Smash args together like print does.
# Convert undef to 'undef' so its readable.
my $msg = join '', map { defined($_) ? $_ : 'undef' } @msgs;
# Escape each line with a #.
$msg =~ s/^/# /gm;
# Stick a newline on the end if it needs it.
inc/Test/Builder.pm view on Meta::CPAN
# tests are deparsed with B::Deparse
return if $^C;
my $msg = join '', @msgs;
local($\, $", $,) = (undef, ' ', '');
my $fh = $self->output;
# Escape each line after the first with a # so we don't
# confuse Test::Harness.
$msg =~ s/\n(.)/\n# $1/sg;
inc/Test/Builder.pm view on Meta::CPAN
#line 1259
sub _print_diag {
my $self = shift;
local($\, $", $,) = (undef, ' ', '');
my $fh = $self->todo ? $self->todo_output : $self->failure_output;
print $fh @_;
}
#line 1296
inc/Test/Builder.pm view on Meta::CPAN
if( $num > @$test_results ) {
my $start = @$test_results ? @$test_results : 0;
for ($start..$num-1) {
$test_results->[$_] = &share({
'ok' => 1,
actual_ok => undef,
reason => 'incrementing test number',
type => 'unknown',
name => undef
});
}
}
# If backward, wipe history. Its their funeral.
elsif( $num < @$test_results ) {
view release on metacpan or search on metacpan
t/03subname.t view on Meta::CPAN
# Catch exception
my $e = do {
local $@;
#line 45 "03subname.t"
eval { Foo(); 1 } ? undef : $@;
};
like(
$e,
qr{\ADIED at 03subname.t line 4[456]}, # allow a small margin of error
view release on metacpan or search on metacpan
inc/IO/Scalar.pm view on Meta::CPAN
#line 287
sub getc {
my $self = shift;
### Return undef right away if at EOF; else, move pos forward:
return undef if $self->eof;
substr(${*$self->{SR}}, *$self->{Pos}++, 1);
}
#------------------------------
#line 306
sub getline {
my $self = shift;
### Return undef right away if at EOF:
return undef if $self->eof;
### Get next line:
my $sr = *$self->{SR};
my $i = *$self->{Pos}; ### Start matching at this point.
### Minimal impact implementation!
### We do the fast fast thing (no regexps) if using the
### classic input record separator.
### Case 1: $/ is undef: slurp all...
if (!defined($/)) {
*$self->{Pos} = length $$sr;
return substr($$sr, $i);
}
view release on metacpan or search on metacpan
bin/text2cow.pl view on Meta::CPAN
## This is where the real action begins.
################################################################################
die "$PROGNAME: Too many input arguments" if @ARGV > 1;
local $/ = undef; # file slurp mode
my $text = <>; # get input text string
die "$PROGNAME: No input" unless defined $text;
my $n = length $text; # get the number of characters in the string
view release on metacpan or search on metacpan
my $self = {
wrap => 40,
mode => 'say',
fill => 1,
over => 0,
text => undef,
el => 'o',
er => 'o',
U => ' ',
%args,
};
sub _slurp_file
{
my $filename = shift;
my $fh = new IO::File($filename);
local $/ = undef;
my $text = $fh->getline();
return $text;
}
1;
view release on metacpan or search on metacpan
lib/Acme/CreatingCPANModules.pm view on Meta::CPAN
}
sub set {
my $self = shift;
my $newfoo = shift;
defined $newfoo or return undef;
$$self = $newfoo;
return $self->get();
}
sub get {
lib/Acme/CreatingCPANModules.pm view on Meta::CPAN
=cut
sub set {
my $self = shift;
my $newfoo = shift;
defined $newfoo or return undef;
$$self = $newfoo;
return $self->get();
}
=head2 get
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
# the contents of the Makefile that is written.
WriteMakefile(
NAME => 'Acme::Curses::Marquee::Extensions',
VERSION_FROM => 'lib/Acme/Curses/Marquee/Extensions.pm',
PREREQ_PM => {
Acme::Curses::Marquee => undef,
Curses => undef,
Every => undef,
Term::ANSIColor => undef,
Text::FIGlet => 2.00,
},
($] >= 5.005 ? ## Add these new keywords supported since 5.005
(ABSTRACT_FROM => 'lib/Acme/Curses/Marquee/Extensions.pm') : ()),
);
view release on metacpan or search on metacpan
lib/Acme/Curses/Marquee.pm view on Meta::CPAN
my $self = bless { win => $args{window},
height => $args{height},
width => $args{width},
font => $args{font} || 'standard',
srctxt => $args{text} || undef,
figtxt => '',
txtlen => 0,
offset => 0,
active => 0,
}, $class;
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
$file =~ s|::|/|g;
$file .= '.pm';
local $@;
return eval { require $file; $mod->VERSION } || ( $@ ? undef: 0 );
}
# Load CPAN.pm and it's configuration
sub _load_cpan {
return if $CPAN::VERSION;
inc/Module/AutoInstall.pm view on Meta::CPAN
version->can('new')
) {
# 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 {}; }
view release on metacpan or search on metacpan
# check the unknown symbols to ensure they are 'safe'
my @bad = grep { /\W/o } @_;
if ( @bad ) {
# throw an error message informing the user where the problem is
my ( undef, $file , $line ) = caller 0;
die sprintf( "Bad choice of symbol name%s %s for import at %s line %s\n"
, ( @bad == 1 ) ? '' : 's'
, join( ', ' , map { qq|'$_'| } @bad ) , $file , $line );
}
# remove duplicates from the list of aliases, as well as those symbol
# names listed in @EXPORT
# - we keep @EXPORT_OK in a separate list since they are optionally
# requested at use() time
my @aliases = do { local %_;
@_{ @_ } = undef;
delete @_{ @EXPORT };
keys %_
};
# 'import' the symbols into the host package
# otherwise, create an alias for 'damn'
no strict 'refs';
*{ $pkg . '::' . $alias } = sub {
my $ref = shift;
my ( undef , $file , $line ) = caller 1;
# call damn() with the location of where this method was
# originally called
&{ __PACKAGE__ . '::damn' }( $ref , $alias , $file , $line );
=item B<bless> I<reference>
=item B<bless> I<reference> [ , I<package> ]
=item B<bless> I<reference> [ , undef ]
Optionally, B<Acme::Damn> will modify the behaviour of C<bless> to
allow the passing of an explicit C<undef> as the target package to invoke
B<damn()>:
use Acme::Damn qw( bless );
my $obj = ... some blessed reference ...;
# the following statements are equivalent
my $ref = bless $obj , undef;
my $ref = damn $obj;
B<NOTE:> The modification of C<bless> is lexically scoped to the current
package, and is I<not> global.
view release on metacpan or search on metacpan
maint/mkmanifest view on Meta::CPAN
for my $file ( split qq/\0/, qx/git ls-files -z/ ) {
next if exists $manifest{$file};
next if $file eq q[README.pod];
warn "Adding to $MANIFEST: $file\n";
$manifest{$file} = undef;
}
rename $MANIFEST, "$MANIFEST.bak" if -f $MANIFEST;
open my $manifh, '>', $MANIFEST or die "Can't open $MANIFEST: $!";
binmode $manifh, ':raw';
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
sub paired_arguments { () }
# get a unique id for any node
sub id {
if (not ref $_[0]) {
return 'undef' if not defined $_[0];
\$_[0] =~ /\((\w+)\)$/o or die;
return "$1-S";
}
require overload;
overload::StrVal($_[0]) =~ /\((\w+)\)$/o or die;
view release on metacpan or search on metacpan
t/00-report-prereqs.t view on Meta::CPAN
use ExtUtils::MakeMaker;
use File::Spec;
# from $version::LAX
my $lax_version_re =
qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )?
|
(?:\.[0-9]+) (?:_[0-9]+)?
) | (?:
v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )?
|
t/00-report-prereqs.t view on Meta::CPAN
$file =~ s{::}{/}g;
$file .= ".pm";
my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC;
my $want = $req_hash->{$phase}{$type}{$mod};
$want = "undef" unless defined $want;
$want = "any" if !$want && $want == 0;
my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required";
if ($prefix) {
my $have = MM->parse_version( File::Spec->catfile($prefix, $file) );
$have = "undef" unless defined $have;
push @reports, [$mod, $want, $have];
if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) {
if ( $have !~ /\A$lax_version_re\z/ ) {
push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)";
view release on metacpan or search on metacpan
lib/Acme/Dice.pm view on Meta::CPAN
}
sub roll_craps {
my $raw_args = @_ == 1 ? shift : {@_};
croak "param present but undefined: bias"
if exists( $raw_args->{bias} ) && !defined( $raw_args->{bias} );
my $bias = delete( $raw_args->{bias} ) || 0;
croak "Illegal value for 'bias': $bias" if $bias < 0 || $bias > 100;
lib/Acme/Dice.pm view on Meta::CPAN
my $args = {};
my @errors;
# put put defaults in place for missing params
# and detect incoming undefined params
for ( keys( %{$defaults} ) ) {
$raw_args->{$_} = $defaults->{$_} if !exists( $raw_args->{$_} );
push( @errors, "param present but undefined: $_" )
unless defined $raw_args->{$_};
$args->{$_} = delete( $raw_args->{$_} );
push( @errors, "$_ must be a non-negative integer: $args->{$_}" )
if defined( $args->{$_} ) && $args->{$_} !~ m/^\d+$/;
}
view release on metacpan or search on metacpan
t/00-report-prereqs.t view on Meta::CPAN
use ExtUtils::MakeMaker;
use File::Spec;
# from $version::LAX
my $lax_version_re =
qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )?
|
(?:\.[0-9]+) (?:_[0-9]+)?
) | (?:
v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )?
|
t/00-report-prereqs.t view on Meta::CPAN
$file =~ s{::}{/}g;
$file .= ".pm";
my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC;
my $want = $req_hash->{$phase}{$type}{$mod};
$want = "undef" unless defined $want;
$want = "any" if !$want && $want == 0;
my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required";
if ($prefix) {
my $have = MM->parse_version( File::Spec->catfile($prefix, $file) );
$have = "undef" unless defined $have;
push @reports, [$mod, $want, $have];
if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) {
if ( $have !~ /\A$lax_version_re\z/ ) {
push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)";
view release on metacpan or search on metacpan
lib/Acme/DoOrDie.pm view on Meta::CPAN
{
my($name) = @_;
my($want, @result, $result, $syntax);
if (!defined($name) || $name eq "") {
croak("Missing or undefined argument to require");
}
$want = wantarray();
if ($want) {
@result = do($name);
} elsif (defined($want)) {
lib/Acme/DoOrDie.pm view on Meta::CPAN
inconvenient. The main problem is that you need to examine more than
just the return value to distinguish a file-not-found condition from a
successful invocation of a file that ends with these two statements:
$! = ENOENT;
undef;
(The L<autodie> module can't help you since it doesn't support the
C<do> function.)
This module provides the replacement function C<do_or_die> that reports
view release on metacpan or search on metacpan
opposite of Perl's built-in C<do>.
It is used exactly like the C<do BLOCK> function except that,
instead of executing the block it controls, it...well...doesn't.
Regardless of the contents of the block, C<don't> returns C<undef>.
You can even write:
don't {
# code here
view release on metacpan or search on metacpan
DonMartin.pm view on Meta::CPAN
use vars qw/ $thud $thuk $thump $thwa $thwak $thwat $thwip %thwip $thwit $thwock
$thwop %thwop @thwop/; $thwit=length$thwop[length($thwop[$thwat=$thwa=0])-length
($thwop[1])];$thwop=map{$thwat+=length}@thwop[do{$thwop+=length for@thwop[$thwit
..$thwit+length($thwop[6])];$thwop}..do{$thwop&=$thwa;$thwop+=length$_ for@thwop
[3..14.1592645];$thwop}];$thwa=($thwop>>length$thwop[5])<<($thwip=1<<1+1)+1;open
$thwit=undef,"+<$0" or die q=zownt thlip spoosh\n=;$thwa=chr$thwa;while(<$thwit>
){$thump.=$_;last if/^\s*use +@{[__PACKAGE__]}/}$thwak=$thump;$thud=<$thwit>;use
Compress::Zlib;$thud=~s/\s+$//;push @{$thwop{$thwip{$_}=$thwop++%$thwat}},qq{$_}
while $_=shift @thwop;$thuk=do{$thwat=$thwip^4; @thwop=split / /, $thud;!@thwop?
length($thwak):do{exists$thwip{$_}&&++$thwat for@thwop;$thwat!=@thwop}};$thwop=!
$thuk;if($thuk){for(split//,compress($thud.do{@thwop=();local$/=undef,<$thwit>})
){$thwock=$thwop{ord$_}[rand$thwip];if(length join($thwa,@thwop,$thwock)>$thwip{
q{thwak}}-$thwip{thwit}){$thwak.=join($thwa,@thwop).$/;@thwop=( );$thump=''}push
@thwop, $thwock} @thwop and do{seek $thwit, $thwop=$thwip-$thwip, $thwip=$thwop-
$thwop;print$thwit($thwak,$thump,join($thwa,@thwop),$/);seek$thwit,$thwip,$thwop
;}} else {$thwop=$thwip{qq{shpork}}-$thwip{q{shklink}};eval uncompress do{while(
view release on metacpan or search on metacpan
lib/Acme/DotDotGone.pm view on Meta::CPAN
$_[1] = $dots{fromDots}($_[0]);
$_[1], $_[0], $_[1];
}
: ($_[2] =~ m/[a-zA-Z]/)
? sub {
undef
}
: sub {
$_[1] = $dots{fromDots}($_[0]);
$_[1], $_[0];
}
view release on metacpan or search on metacpan
t/00-report-prereqs.t view on Meta::CPAN
use ExtUtils::MakeMaker;
use File::Spec;
# from $version::LAX
my $lax_version_re =
qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )?
|
(?:\.[0-9]+) (?:_[0-9]+)?
) | (?:
v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )?
|
t/00-report-prereqs.t view on Meta::CPAN
$file =~ s{::}{/}g;
$file .= ".pm";
my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC;
my $want = $req_hash->{$phase}{$type}{$mod};
$want = "undef" unless defined $want;
$want = "any" if !$want && $want == 0;
my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required";
if ($prefix) {
my $have = MM->parse_version( File::Spec->catfile($prefix, $file) );
$have = "undef" unless defined $have;
push @reports, [$mod, $want, $have];
if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) {
if ( $have !~ /\A$lax_version_re\z/ ) {
push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)";
view release on metacpan or search on metacpan
lib/Acme/ELLEDNERA/Utils.pm view on Meta::CPAN
=head1 SUBROUTINES
=head2 sum( LIST )
Obtains the sum of a list of numbers. If no numbers are passed in, it will return C<undef>.
A mixture of numbers and non-numerics will work too. However, complex and scientific
numbers are not supported.
The C<sum> subroutine in version 0.03 is broken
view release on metacpan or search on metacpan
eval{%$_||1}?(!%$_?():( $i= $_, join ". ", map
"$_: $$i{$_}", map substr("m;V",0,length) ^ $_, sort map
$_ ^ substr("m;V",0,length), keys %$i ) . "." ) :
eval{1+@$_}?(!@$_?(): join( "; ", @$_ ) ) : $_
} @_;
my( $thought )= !@_ ? undef : join " ... ", @_;
return bless \$thought, 'Acme::ESP::Scanner';
}
sub O'o { [ shift,oO( @_ ) ]->[!$[] }
my $thought= $$scanner;
if( defined $thought ) {
# It is surprising how hard it can be to clear your mind.
# It'd be nice to do this less destructively.
my $surface= "$$mind";
$$mind= undef;
$$mind= $thought . $surface;
substr( $$mind, 0, length($thought), "" );
}
return $secret;
}
view release on metacpan or search on metacpan
lib/Acme/Echo.pm view on Meta::CPAN
our $fh = *STDOUT;
sub import {
my $pkg = shift;
while ( $_ = shift @_ ){
if( /^before|after|lines$/ ){
$modes{ lc $_ } = undef;
}elsif( $_ eq 'line_fmt' ){
$line_fmt = shift;
}elsif( $_ eq 'src_fmt' ){
$src_fmt = shift;
}elsif( $_ eq 'fh' ){
view release on metacpan or search on metacpan
lib/Acme/Ehoh.pm view on Meta::CPAN
$arg =~ /^(-?\d+)$/;
my $year = $1;
if(!defined $year || $year <= 0){
return undef;
}
return $dir[$year % 5];
}
lib/Acme/Ehoh.pm view on Meta::CPAN
=item direction($year)
Return ehoh direction of specified year (value 0 means north, 90 means east,
and so on).
On error, return undef.
=back
=head1 LICENSE
view release on metacpan or search on metacpan
sub buypants { my $st = defined $_[0] ? $_[0] : 0;my $bl = defined $_[1] ? $_[1] : 'Acme::Enc';return($st,$bl)}
sub button {Crypt::OpenPGP->new->encrypt(Data=>shift(),Passphrase=>$belt,Armour=>$stitch)}
sub unbutton {my $pants = shift;$pants =~ s{\# \s* DanMuey \s* \n}{}xms;Crypt::OpenPGP->new->decrypt(Data=>$pants,Passphrase=>$belt)}
sub zipperstuck { $_[0] !~ /DanMuey/ }sub buypants { my $st = defined $_[0] ? $_[0] : 0;
my $bl = defined $_[1] ? $_[1] : 'Acme::Enc';return($st,$bl)}sub import {
(undef,$belt,$stitch)=@_;$belt=$belt->($0) if ref $belt eq 'CODE';($stitch,$belt)=buypants($stitch,$belt);
my $beltloop = $belt;if($belt =~ m{\&}) {my $x;eval qq{package main;\$x = $belt;};$belt = $x->($0);}
open 0 or croak qq{Can't take off pants '$0': $!};
(my $pants = join '', <0>) =~ m{ (.*) use \s+ Acme::Enc }xms; my $hem = $1 || '';$pants =~ s{ .* use \s+ Acme::Enc [^\n]* \n}{}xms;
local $SIG{__WARN__} = \&zipperstuck;do {eval unbutton $pants; exit;} unless zipperstuck $pants;
open 0, ">$0" or croak qq{Cannot put on pants '$0': $!};