view release on metacpan or search on metacpan
}
elsif ( $arg =~ $ENTITY_PATTERN or $arg =~ $SITELINK_PATTERN ) {
'lookup';
}
else {
my $guess = () = $arg =~ /[a-z]+:[^\s]/gi;
$guess += () = $arg =~ /<[^>]+>/g;
$guess += () = $arg =~ /[?\$][^\s]/g;
if ( $guess > 2 ) {
warning("ignoring additional command line argument")
if $OPT{query} or @ARGV > 1;
'query';
}
else {
=head1 MODES
Request mode C<query> (default), C<lookup>, C<serch>, or C<psearch> can
explicitly be set via first argument or it's guessed from arguments.
=head2 query
Read SPARQL query from STDIN, option C<--query|-q>, or argument. Namespace
definitions and C<SELECT> clause are added if missing.
view release on metacpan or search on metacpan
lib/App/week.pm view on Meta::CPAN
}
sub argv {
my $app = shift;
for (@{$app->ARGV}) {
call \&guess_date,
for => $app,
with => [ qw(year mon mday show_year) ];
}
return $app;
}
view release on metacpan or search on metacpan
lib/App/wmiirc/Backlight.pm view on Meta::CPAN
use App::wmiirc::Plugin;
with 'App::wmiirc::Role::Key';
# So on my vaio the down works here, but up doesn't(?!), I've hacked it into the
# acpi stuff instead -- urgh. Serves me right for buying proprietary Sony stuff
# I guess.
sub key_backlight_down(XF86MonBrightnessDown) {
system qw(xbacklight -steps 1 -time 0 -dec 10);
}
view release on metacpan or search on metacpan
lib/App/wordlist/wordle.pm view on Meta::CPAN
delete $_[0]{'x.doc.faq'};
$_[0]{description} = <<'MARKDOWN';
This is a wrapper to <prog:wordlist> designed to be a convenient helper to solve
Wordle puzzle. By default it greps from the `EN::Wordle` wordlist. It accepts
a series of guesses in a format like the following:
A^R^isE^
Pound
might
blA^ck
PR^ivY^
where lowercase means wrong guess, uppercase means correct letter and position,
while (uppercase) letter followed by a caret (`^`) means the letter exists in
another position. It will convert these guesses to regex patterns and the
`--chars-unordered` option and pass it to `wordlist`.
MARKDOWN
$_[0]{examples} = [
{
argv => ['cR^eEk'],
summary => 'One guess',
test => 0,
'x.doc.show_result' => 0,
},
{
argv => ['A^R^isE^', 'Pound', 'might', 'blA^ck', 'PR^ivY^'],
summary => 'Five guesses',
test => 0,
'x.doc.show_result' => 0,
},
];
},
lib/App/wordlist/wordle.pm view on Meta::CPAN
my @chars = split //, $arg;
my $re = '';
my %letter_exists;
while (@chars) {
my $char = shift @chars;
return [400, "Invalid letter '$char' in guess '$arg'"] unless $char =~ /[A-Za-z]/;
my $caret = @chars && $chars[0] eq '^' ? shift(@chars) : '';
my $uc = $char eq uc $char;
$char = lc $char;
if ($caret) { # letter is in another position
my $letters = $possible_letters;
$letters =~ s/$char//;
$re .= "[$letters]";
$letter_exists{$char}++;
$chars_unordered .= $char unless index($chars_unordered, $char) >= 0;
} elsif ($uc) { # correct guess
$re .= $char;
$letter_exists{$char}++;
$chars_unordered .= $char unless index($chars_unordered, $char) >= 0;
} else { # wrong guess
my $letters = $possible_letters;
$letters =~ s/$char//;
$possible_letters =~ s/$char// unless $letter_exists{$char};
$re .= "[$letters]";
}
lib/App/wordlist/wordle.pm view on Meta::CPAN
Examples:
=over
=item * One guess:
wordlist_wordle(arg => ["cR^eEk"]);
=item * Five guesses:
wordlist_wordle(arg => ["A^R^isE^", "Pound", "might", "blA^ck", "PR^ivY^"]);
=back
This is a wrapper to L<wordlist> designed to be a convenient helper to solve
Wordle puzzle. By default it greps from the C<EN::Wordle> wordlist. It accepts
a series of guesses in a format like the following:
A^R^isE^
Pound
might
blA^ck
PR^ivY^
where lowercase means wrong guess, uppercase means correct letter and position,
while (uppercase) letter followed by a caret (C<^>) means the letter exists in
another position. It will convert these guesses to regex patterns and the
C<--chars-unordered> option and pass it to C<wordlist>.
This function is not exported.
Arguments ('*' denotes required arguments):
view release on metacpan or search on metacpan
lib/App/wordlist.pm view on Meta::CPAN
Included in the distribution is the <prog:wordlist-wordle> script for
convenience. This CLI defaults to grepping the "EN::Wordle" wordlist and you
specify something like `wt_S_` for the pattern (lowercase for letter in
incorrect position, uppercase for letter in correct position, underscore for
unguessed):
% wordlist-wordle 'wt_S_'
_
};
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
else {
print
"*** Dependencies will be installed the next time you type '$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";
inc/Module/AutoInstall.pm view on Meta::CPAN
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() );
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
else {
print
"*** Dependencies will be installed the next time you type '$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";
inc/Module/AutoInstall.pm view on Meta::CPAN
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::getcwd() );
view release on metacpan or search on metacpan
lib/AppleII/Disk.pm view on Meta::CPAN
r Allow reads (this is actually ignored; you can always read)
w Allow writes
d Disk image is in DOS 3.3 order
p Disk image is in ProDOS order
If you don't specify 'd' or 'p', then the format is guessed from the
filename. '.PO' and '.HDV' files are ProDOS order, and anything else
is assumed to be DOS 3.3 order.
If you specify 'w' to allow writes, then the image file is created if
it doesn't already exist.
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
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";
inc/Module/AutoInstall.pm view on Meta::CPAN
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() );
view release on metacpan or search on metacpan
inc/Devel/PPPort.pm view on Meta::CPAN
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
share/files/public/skins/default/jquery-ui-1.9.1.custom/development-bundle/external/jshint.js view on Meta::CPAN
// value is the JSHINT function itself.
var JSHINT = (function () {
"use strict";
var anonname, // The guessed name for anonymous functions.
// These are operators that should not be used with the ! operator.
bang = {
"<" : true,
view release on metacpan or search on metacpan
lib/Arabic.pm view on Meta::CPAN
if ( $condition && ... ) { print "Hello\n" };
There are some cases where Perl can't immediately tell the difference between an
expression and a statement. For instance, the syntax for a block and an anonymous
hash reference constructor look the same unless there's something in the braces that
give Perl a hint. The yada yada is a syntax error if Perl doesn't guess that the
{ ... } is a block. In that case, it doesn't think the ... is the yada yada because
it's expecting an expression instead of a statement:
my @transformed = map { ... } @input; # syntax error
view release on metacpan or search on metacpan
perllib/Arch/Changeset.pm view on Meta::CPAN
if (-f "$self->{dir}/=ancestor") {
$ancestor = load_file("$self->{dir}/=ancestor");
chomp($ancestor);
}
unless ($ancestor) {
# just guess
my $revision = $self->{revision};
$ancestor = adjacent_revision($revision, -1) || $revision;
}
return $self->{ancestor} = $ancestor;
}
perllib/Arch/Changeset.pm view on Meta::CPAN
=item B<ancestor>
Return the ancestor of the changeset. If I<=ancestor> file is found (that is
the case for library changesets) its content is returned, otherwise try to
guess the ancestor of the revision using B<Arch::Util::adjacent_revision>.
=back
=head1 BUGS
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
else {
print
"*** Dependencies will be installed the next time you type '$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";
inc/Module/AutoInstall.pm view on Meta::CPAN
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() );
view release on metacpan or search on metacpan
xs/ppport.h view on Meta::CPAN
print "It may very well be supported all the way back to ",
format_version(5.003_07), ".\n";
}
else {
print "But given the things $f depends on, it's a good",
" guess that it isn't\n",
"supported prior to ", format_version($todo), ".\n";
}
}
}
}
xs/ppport.h view on Meta::CPAN
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
lib/Archive/Extract/ppport.h view on Meta::CPAN
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
lib/Archive/Extract.pm view on Meta::CPAN
} else {
### if we're on solaris we /might/ be using /bin/tar, which has
### a weird output format... we might also be using
### /usr/local/bin/tar, which is gnu tar, which is perfectly
### fine... so we have to do some guessing here =/
my @files = map { chomp; s!\x0D!!g if ON_WIN32;
!ON_SOLARIS ? $_
: (m|^ x \s+ # 'xtract' -- sigh
(.+?), # the actual file name
\s+ [\d,.]+ \s bytes,
view release on metacpan or search on metacpan
lib/Archive/Lha/Header/Base.pm view on Meta::CPAN
# Map OS identifier to the most likely filename encoding used by that platform.
my %_os_charset = (
'a' => 'iso-8859-15', # Amiga
'M' => 'cp1252', # MS-DOS / Windows
'w' => 'cp1252', # WinNT / Win95
'U' => 'guess', # Unix (encoding varies: UTF-8 on modern, latin-1 on older)
'H' => 'cp932', # Human68K (Sharp X68000)
'J' => 'cp932', # Java VM (often used with Japanese archives)
'm' => 'UTF-8', # Macintosh (modern)
);
sub charset_for_os {
my ($self) = @_;
my $os_id = $self->{os} ? $self->{os}[0] : undef;
return $os_id && $os_id ne '?' ? ( $_os_charset{$os_id} // 'guess' ) : 'guess';
}
sub pathname {
my ($self, $from, $to) = @_;
my $path;
lib/Archive/Lha/Header/Base.pm view on Meta::CPAN
# default from-encoding: auto-detect from OS field
$from //= $self->charset_for_os;
$to //= 'UTF-8';
require Encode;
if ( lc $from eq 'guess' ) {
require Encode::Guess;
my $enc = Encode::Guess::guess_encoding(
$path => qw( latin1 latin2 cp932 euc-jp )
);
Encode::from_to( $path, ref($enc) ? $enc->name : 'latin1', $to );
}
elsif ( lc $from ne lc $to ) {
lib/Archive/Lha/Header/Base.pm view on Meta::CPAN
You also can pass encoding options:
# the pathname should have been encoded as 'euc-jp'
$header->pathname('euc-jp' => 'shiftjis');
If you are not sure, you can let it guess:
# original encoding of the path would be guessed
$header->pathname('guess' => 'shiftjis');
=head2 charset_for_os
Returns the most likely filename encoding for this archive entry based on
the OS identifier byte in the header: C<iso-8859-15> for Amiga (C<a>),
C<cp1252> for MS-DOS/Windows (C<M>/C<w>), C<UTF-8> for Unix (C<U>) and
modern Mac (C<m>), C<cp932> for Human68K/Java (C<H>/C<J>). Returns
C<'guess'> when the OS field is absent or unrecognised, which causes
C<pathname()> to invoke L<Encode::Guess>.
=head2 dirname
returns directory part of the pathname. This is mainly used while creating parent directory for the file.
view release on metacpan or search on metacpan
xs/ppport.h view on Meta::CPAN
print "It may very well be supported all the way back to ",
format_version(5.003_07), ".\n";
}
else {
print "But given the things $f depends on, it's a good",
" guess that it isn't\n",
"supported prior to ", format_version($todo), ".\n";
}
}
}
}
xs/ppport.h view on Meta::CPAN
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
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";
inc/Module/AutoInstall.pm view on Meta::CPAN
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() );
view release on metacpan or search on metacpan
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
use strict;
use warnings;
=head1 NAME
ExtUtils::CppGuess - guess C++ compiler and flags
=head1 SYNOPSIS
With L<Extutils::MakeMaker>:
use ExtUtils::CppGuess;
my $guess = ExtUtils::CppGuess->new;
WriteMakefile
( # MakeMaker args,
$guess->makemaker_options,
);
With L<Module::Build>:
my $guess = ExtUtils::CppGuess->new;
my $build = Module::Build->new
( # Module::Build arguments
$guess->module_build_options,
);
$build->create_build_script;
=head1 DESCRIPTION
C<ExtUtils::CppGuess> attempts to guess the system's C++ compiler
that is compatible with the C compiler that your perl was built with.
It can generate the necessary options to the L<Module::Build>
constructor or to L<ExtUtils::MakeMaker>'s C<WriteMakefile>
function.
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
This can be used a bit creatively to be portable in one's XS files,
as the tests for this module need to be:
# in Makefile.PL:
$guess->add_extra_compiler_flags(
'-DINCLUDE_DOT=' .
($guess->iostream_fname =~ /\./ ? 1 : 0)
);
// in your .xs file:
#if INCLUDE_DOT
#include <string.h>
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
Added in 0.15.
=head2 cpp_standard_flag
$guess->cpp_standard_flag( $standard_name )
Given a string C<$standard_name> that is currently one of
=over
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
our %ENV2VAL = (
CXX => 'compiler_command',
);
# This is IBM's "how to compile on" list with lots of compilers:
# https://www.ibm.com/support/knowledgecenter/en/SS4PJT_5.2.0/com.ibm.help.cd52.unix.doc/com.ibm.help.cdunix_user.doc/CDU_Compiling_Custom_Programs.html
sub guess_compiler {
my $self = shift;
return $self->{guess} if $self->{guess};
my $c_compiler = $self->_cc;
# $c_compiler = $Config::Config{cc} if not defined $c_compiler;
my %guess;
if ($self->{os} eq 'freebsd' && $self->{osvers} =~ /^(\d+)/ && $1 >= 10) {
$self->{is_clang} = 1; # special-case override
%guess = (
compiler_command => 'clang++',
extra_lflags => '-lc++',
);
} elsif( $self->_cc_is_sunstudio( $c_compiler ) ) {
%guess = (
compiler_command => 'CC',
extra_cflags => '',
extra_lflags => '',
);
} elsif( $self->_cc_is_clang( $c_compiler ) ) {
%guess = (
compiler_command => 'clang++',
extra_cflags => '-xc++',
extra_lflags => '-lstdc++',
);
} elsif( $self->_cc_is_gcc( $c_compiler ) ) {
%guess = (
compiler_command => 'g++',
extra_cflags => '-xc++',
);
# Don't use -lstdc++ if Perl was linked with -static-libstdc++ (ActivePerl 5.18+ on Windows)
$guess{extra_lflags} = '-lstdc++'
unless ($self->_config->{ldflags} || '') =~ /static-libstdc\+\+/;
} elsif ( $self->_cc_is_msvc( $c_compiler ) ) {
%guess = (
compiler_command => 'cl',
extra_cflags => '-TP -EHsc',
extra_lflags => 'msvcprt.lib',
);
}
$guess{$ENV2VAL{$_}} = $ENV{$_} for grep defined $ENV{$_}, keys %ENV2VAL;
if (!%guess) {
my $v1 = `$c_compiler -v`;
my $v2 = `$c_compiler -V`;
my $v3 = `$c_compiler --version`;
my $os = $self->_os;
die <<EOF;
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
-v: '$v1'
-V: '$v2'
--version: '$v3'
EOF
}
$guess{extra_lflags} .= ' -lgcc_s'
if $self->_os eq 'netbsd' and
$guess{compiler_command} =~ /g\+\+/i and
$guess{extra_lflags} !~ /-lgcc_s/;
$self->{guess} = \%guess;
}
sub _get_cflags {
my ($self, $omit_ccflags) = @_;
$self->guess_compiler or die;
join ' ', '', map _trim_whitespace($_), grep defined && length,
($omit_ccflags ? '' : $self->_config->{ccflags}),
$self->{guess}{extra_cflags},
$self->{extra_compiler_flags},
($self->is_clang ? '-Wno-reserved-user-defined-literal' : ()),
;
}
sub _get_lflags {
my $self = shift;
$self->guess_compiler || die;
join ' ', '', map _trim_whitespace($_), grep defined && length,
$self->{guess}{extra_lflags},
$self->{extra_linker_flags},
;
}
sub makemaker_options {
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
my $cflags = $self->_get_cflags;
return (
CCFLAGS => $cflags,
dynamic_lib => { OTHERLDFLAGS => $lflags },
CC => $self->{guess}{compiler_command},
);
}
sub module_build_options {
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
my $cflags = $self->_get_cflags(1);
return (
extra_compiler_flags => $cflags,
extra_linker_flags => $lflags,
config => { cc => $self->{guess}{compiler_command} },
);
}
# originally from Alien::wxWidgets::Utility
# Why was this hanging around outside of all functions, and without any other
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
return $self->{is_sunstudio};
}
sub is_gcc {
my $self = shift;
$self->guess_compiler || die;
return $self->{is_gcc};
}
sub is_msvc {
my $self = shift;
$self->guess_compiler || die;
return $self->{is_msvc};
}
sub is_clang {
my $self = shift;
$self->guess_compiler || die;
return $self->{is_clang};
}
sub is_sunstudio {
my $self = shift;
$self->guess_compiler || die;
return $self->{is_sunstudio};
}
sub add_extra_compiler_flags {
my( $self, $string ) = @_;
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
$self->{extra_linker_flags}, $string;
}
sub compiler_command {
my( $self ) = @_;
$self->guess_compiler || die;
my $cc = $self->{guess}{compiler_command};
my $cflags = $self->_get_cflags;
join ' ', map _trim_whitespace($_), grep defined && length, $cc, $cflags;
}
sub _trim_whitespace {
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
# returns true if compile succeeded, false if failed
sub _compile_no_h {
my( $self ) = @_;
return $self->{no_h_status} if defined $self->{no_h_status};
$self->guess_compiler || die;
$self->{no_h_status} = $self->_can_compile_code( $test_cpp );
}
sub iostream_fname {
my( $self ) = @_;
fatlib/ExtUtils/CppGuess.pm view on Meta::CPAN
};
sub cpp_standard_flag {
my ($self, $standard_name) = @_;
$self->guess_compiler || die;
my ($detected_compiler) = grep { $self->{$_} } keys %$CPP_STANDARD_FLAGS;
die "Unknown standard '$standard_name' for compiler '$detected_compiler'"
unless exists $CPP_STANDARD_FLAGS->{$detected_compiler}{$standard_name};
view release on metacpan or search on metacpan
src/ppport.h view on Meta::CPAN
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
lib/Archive/Tar/Wrapper.pm view on Meta::CPAN
and returns 1 on success or C<undef> on failure.
The temporary directory holding the tar data gets cleaned up when C<$arch>
goes out of scope.
C<read> handles both compressed and uncompressed files. To find out if
a file is compressed or uncompressed, it tries to guess by extension,
then by checking the first couple of bytes in the tar file.
If only a limited number of files is needed from a tarball, they
can be specified after the tarball name:
view release on metacpan or search on metacpan
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
else {
print
"*** Dependencies will be installed the next time you type '$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";
inc/Module/AutoInstall.pm view on Meta::CPAN
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() );
view release on metacpan or search on metacpan
lib/Archive/Zip.pm view on Meta::CPAN
sub _binmode {
my $fh = shift;
return _CAN($fh, 'binmode') ? $fh->binmode() : binmode($fh);
}
# Attempt to guess whether file handle is seekable.
# Because of problems with Windows, this only returns true when
# the file handle is a real file.
sub _isSeekable {
my $fh = shift;
return 0 unless ref $fh;
lib/Archive/Zip.pm view on Meta::CPAN
names, etc.).
C<Archive::Zip> tries to be consistent with file naming conventions, and will
translate back and forth between native and Zip file names.
However, it can't guess which format names are in. So two rules control what
kind of file name you must pass various routines:
=over 4
=item Names of files are in local format.
view release on metacpan or search on metacpan
print "It may very well be supported all the way back to ",
format_version(5.003_07), ".\n";
}
else {
print "But given the things $f depends on, it's a good",
" guess that it isn't\n",
"supported prior to ", format_version($todo), ".\n";
}
}
}
}
#ifndef IVSIZE
# ifdef LONGSIZE
# define IVSIZE LONGSIZE
# else
# define IVSIZE 4 /* A bold guess, but the best we can make. */
# endif
#endif
#ifndef UVTYPE
# define UVTYPE unsigned IVTYPE
#endif
view release on metacpan or search on metacpan
lib/Arithmetic/PaperAndPencil.pm view on Meta::CPAN
of the first partial remainder and of the second occurrence of the
divider.
Acceptable break from reality: I have not found anywhere an
explanation for this technique. The way it is implemented is just some
guesswork after some reverse engineering attempt on a few examples. A
special point is that it seems to require something similar to the
C<cheating> technique above, because I do not see how we can
"unstrike" the digits that were stricken with the previous digit
candidate.