my $sv_name = $specialsv_name[$sv_index];
Certain SV types are considered 'special'. They're represented by
-B::SPECIAL and are refered to by a number from the specialsv_list.
+B::SPECIAL and are referred to by a number from the specialsv_list.
This array maps that number back to the name of the SV (like 'Nullsv'
or '&PL_sv_undef').
my $sv_name = $specialsv_name[$sv_index];
Certain SV types are considered 'special'. They're represented by
-B::SPECIAL and are refered to by a number from the specialsv_list.
+B::SPECIAL and are referred to by a number from the specialsv_list.
This array maps that number back to the name of the SV (like 'Nullsv'
or '&PL_sv_undef').
This module is used by the B::CC back end. It walks "basic blocks".
A basic block is a series of operations which is known to execute from
-start to finish, with no possiblity of branching or halting.
+start to finish, with no possibility of branching or halting.
It can be used either stand alone or from inside another program.
=head2 Arithmetic
-Compiled Perl programs use native C arithemtic much more frequently
+Compiled Perl programs use native C arithmetic much more frequently
than standard perl. Operations on large numbers or on boundary
cases may produce different behaviour.
the inner workings of perl or other compiler backends. It can print OPs in
the order they appear in the OP tree, in the order they will execute, or
in a text approximation to their tree structure, and the format of the
-information displyed is customizable. Its function is similar to that of
+information displayed is customizable. Its function is similar to that of
perl's B<-Dx> debugging flag or the B<B::Terse> module, but it is more
sophisticated and flexible.
# give bareword warnings in that case. Therefore if context
# requires, we'll put parens around the outside "(sort f 1, 2,
# 3)". Unfortunately, we'll currently think the parens are
- # neccessary more often that they really are, because we don't
+ # necessary more often that they really are, because we don't
# distinguish which side of an assignment we're on.
if ($cx >= 5) {
return "($name2 $args)";
with the B<-terse> option. It is provided for compatibility with old scripts
(and habits) but using B::Concise directly is now recommended instead.
-For compatiblilty with the old B::Terse, this module also adds a
+For compatibility with the old B::Terse, this module also adds a
method named C<terse> to B::OP and B::SV objects. The B::SV method is
largely compatible with the old one, though authors of new software
might be advised to choose a more user-friendly output format. The
=head2 bcopts => $bcopts || [ @bcopts ]
When getRendering() runs, it passes bcopts into B::Concise::compile().
-The bcopts arg can be a singls string, or an array of strings.
+The bcopts arg can be a single string, or an array of strings.
=head2 errs => $err_str_regex || [ @err_str_regexs ]
thats easier to achieve when matching against 1 input than 2.
Opcode arguments (text within braces) are disregarded for matching
-purposes. This loses some info in 'add[t5]', but greatly simplifys
+purposes. This loses some info in 'add[t5]', but greatly simplifies
matching 'nextstate(main 22 (eval 10):1)'. Besides, we are testing
for regressions, not for complete accuracy.
1. native reference data allows closer/easier matching by regex.
2. samples can be eyeballed to grok T-nT differences.
3. data can help to validate mkCheckRex() operation.
- 4. can develop regexes which accomodate T-nT differences.
+ 4. can develop regexes which accommodate T-nT differences.
5. can test with both native and cross-converted regexes.
Cross-testing (expect_nt on threaded, expect on non-threaded) exposes
The source buffer can either be a scalar or a scalar reference.
-The B<$level> paramter defines the compression level. Valid values are
+The B<$level> parameter defines the compression level. Valid values are
0 through 9, C<Z_NO_COMPRESSION>, C<Z_BEST_SPEED>,
C<Z_BEST_COMPRESSION>, and C<Z_DEFAULT_COMPRESSION>.
If B<$level> is not specified C<Z_DEFAULT_COMPRESSION> will be used.
a DBM database it always writes the key and value as strings. So when
you use this:
- $hash{12345} = "soemthing" ;
+ $hash{12345} = "something" ;
the key 12345 will get stored in the DBM database as the 5 byte string
"12345". If you actually want the key to be stored in the DBM database
read-once operation. Once it has been performed, the C<Digest::MD5>
object is automatically C<reset> and can be used to calculate another
digest value. Call $md5->clone->digest if you want to calculate the
-digest without reseting the digest state.
+digest without resetting the digest state.
=item $md5->hexdigest
=over 2
-=item B<NOTE:> Not all encoding suppport this feature
+=item B<NOTE:> Not all encoding support this feature
Some encodings ignore I<CHECK> argument. For example,
L<Encode::Unicode> ignores I<CHECK> and it always croaks on error.
In any other Encoding ON
---------------------------------------------
-As you see, there is one exception, In ASCII. That way you can assue
+As you see, there is one exception, In ASCII. That way you can assume
Goal #1. And with Encode Goal #2 is assumed but you still have to be
careful in such cases mentioned in B<CAVEAT> paragraphs.
The multiple use of this pragma is discouraged.
By the same reason, the use this pragma inside modules is also
-discouraged (though not as strongly discouranged as the case above.
+discouraged (though not as strongly discouraged as the case above.
See below).
If you still have to write a module with this pragma, be very careful
hebrew|arabic|baltic|vietnamese)$/ix =>
'"cp" . $Encode::Alias::Winlatin2cp{lc($1)}' );
- # Common names for non-latin prefered MIME names
+ # Common names for non-latin preferred MIME names
define_alias( 'ascii' => 'US-ascii',
'cyrillic' => 'iso-8859-5',
'arabic' => 'iso-8859-6',
=head2 Alias overloading
You can override predefined aliases by simply applying define_alias().
-The new alias is always evaluated first, and when neccessary,
+The new alias is always evaluated first, and when necessary,
define_alias() flushes the internal cache to make the new definition
available.
=item new ( [ DIRNAME ] )
-C<new> is the constuctor for C<IO::Dir> objects. It accepts one optional
+C<new> is the constructor for C<IO::Dir> objects. It accepts one optional
argument which, if given, C<new> will pass to C<open>
=back
=item events ( IO )
-Returns the event mask which represents the events that happend on IO
+Returns the event mask which represents the events that happened on IO
during the last call to C<poll>.
=item remove ( IO )
ReusePort Set SO_REUSEPORT before binding
Broadcast Set SO_BROADCAST before binding
Timeout Timeout value for various operations
- MultiHomed Try all adresses for multi-homed hosts
+ MultiHomed Try all addresses for multi-homed hosts
Blocking Determine if connection will be blocking mode
If C<Listen> is defined then a listen socket is created, else if the
=head2 C<ndbm store returned -1, errno 22, key "..." at ...>
-This warning is emmitted when you try to store a key or a value that
+This warning is emitted when you try to store a key or a value that
is too long. It means that the change was not recorded in the
database. See BUGS AND WARNINGS below.
=head2 C<odbm store returned -1, errno 22, key "..." at ...>
-This warning is emmitted when you try to store a key or a value that
+This warning is emitted when you try to store a key or a value that
is too long. It means that the change was not recorded in the
database. See BUGS AND WARNINGS below.
anonlist anonhash
-Note that despite the existance of this optag a memory resource attack
+Note that despite the existence of this optag a memory resource attack
may still be possible using only :base_core ops.
Disabling these ops is a I<very> heavy handed way to attempt to prevent
=item :dangerous
This tag is simply a bucket for opcodes that are unlikely to be used via
-a tag name but need to be tagged for completness and documentation.
+a tag name but need to be tagged for completeness and documentation.
syscall dump chroot
sub import {
shift;
- # Not that unimport is the prefered form since import's don't
+ # Not that unimport is the preferred form since import's don't
# accumulate well owing to the 'only ever add opmask' rule.
# E.g., perl -Mops=:set1 -Mops=:setb is unlikely to do as expected.
opmask_add(invert_opset opset(@_)) if @_;
=head2 C<sdbm store returned -1, errno 22, key "..." at ...>
-This warning is emmitted when you try to store a key or a value that
+This warning is emitted when you try to store a key or a value that
is too long. It means that the change was not recorded in the
database. See BUGS AND WARNINGS below.
Since Storable version 2.05, CODE references may be serialized with
the help of L<B::Deparse>. To enable this feature, set
-C<$Storable::Deparse> to a true value. To enable deserializazion,
+C<$Storable::Deparse> to a true value. To enable deserialization,
C<$Storable::Eval> should be set to a true value. Be aware that
deserialization is done through C<eval>, which is dangerous if the
Storable file contains malicious data. You can set C<$Storable::Eval>
=item C<STORABLE_attach> I<class>, I<cloning>, I<serialized>
While C<STORABLE_freeze> and C<STORABLE_thaw> are useful for classes where
-each instance is independant, this mechanism has difficulty (or is
+each instance is independent, this mechanism has difficulty (or is
incompatible) with objects that exist as common process-level or
system-level resources, such as singleton objects, database pools, caches
or memoized objects.
Prior to Storable 2.01, no distinction was made between signed and
unsigned integers on storing. By default Storable prefers to store a
scalars string representation (if it has one) so this would only cause
-problems when storing large unsigned integers that had never been coverted
+problems when storing large unsigned integers that had never been converted
to string or floating point. In other words values that had been generated
by integer operations such as logic ops and then not used in any string or
arithmetic context before storing.
=item B<eval_sv>
-Evalulates the passed SV. Result handling is done the same as for
+Evaluates the passed SV. Result handling is done the same as for
C<call_sv()> etc.
=item B<eval_pv>
-Excercises the C function of the same name in scalar context. Returns the
+Exercises the C function of the same name in scalar context. Returns the
same SV that the C function returns.
=item B<require_pv>
-Excercises the C function of the same name. Returns nothing.
+Exercises the C function of the same name. Returns nothing.
=back
variable interpolation. That is normally disallowed, since it is a
potential security risk. Note that this pragma is ignored when the regular
expression is obtained from tainted data, i.e. evaluation is always
-disallowed with tainted regular expresssions. See L<perlre/(?{ code })>.
+disallowed with tainted regular expressions. See L<perlre/(?{ code })>.
For the purpose of this pragma, interpolation of precompiled regular
expressions (i.e., the result of C<qr//>) is I<not> considered variable
Returns true if we currently have C<IO::String> support loaded.
Either C<IO::String> or C<perlio> support is needed to support writing
-stringified archives. Currently, C<perlio> is the preffered method, if
+stringified archives. Currently, C<perlio> is the preferred method, if
available.
See the C<GLOBAL VARIABLES> section to see how to change this preference.
This requires C<perl-5.8> or higher, compiled with C<perlio>
Either C<IO::String> or C<perlio> support is needed to support writing
-stringified archives. Currently, C<perlio> is the preffered method, if
+stringified archives. Currently, C<perlio> is the preferred method, if
available.
See the C<GLOBAL VARIABLES> section to see how to change this preference.
use constant WRITE_ONLY => sub { $_[0] ? 'wb' . shift : 'w' };
use constant MODE_READ => sub { $_[0] =~ /^r/ ? 1 : 0 };
-# Pointless assigment to make -w shut up
+# Pointless assignment to make -w shut up
my $getpwuid; $getpwuid = 'unknown' unless eval { my $f = getpwuid (0); };
my $getgrgid; $getgrgid = 'unknown' unless eval { my $f = getgrgid (0); };
use constant UNAME => sub { $getpwuid || scalar getpwuid( shift() ) };
Autoties are most commonly used in the module to which they actually tie,
and need to export their attributes to any module that calls them. To
-facilitiate this, Attribute::Handlers recognizes a special "pseudo-class" --
+facilitate this, Attribute::Handlers recognizes a special "pseudo-class" --
C<__CALLER__>, which may be specified as the qualifier of an attribute:
package Tie::Me::Kangaroo:Down::Sport;
=item 5.
An optional fifth parameter (-novals) can be set to a true value and
-indicates to suppress the val attribut in each option element within
+indicates to suppress the val attribute in each option element within
the optgroup.
See the discussion on optgroup at W3C
called JavaScript. Internet Explorer, 3.0 and higher, supports a
closely-related dialect called JScript. JavaScript isn't the same as
Java, and certainly isn't at all the same as Perl, which is a great
-pity. JavaScript allows you to programatically change the contents of
+pity. JavaScript allows you to programmatically change the contents of
fill-out forms, create new windows, and pop up dialog box from within
Netscape itself. From the point of view of CGI scripting, JavaScript
is quite useful for validating fill-out forms prior to submitting
fatalsToBrowser() output.
1.23 ineval() now checks both $^S and inspects the message for the "eval" pattern
- (hack alert!) in order to accomodate various combinations of Perl and
+ (hack alert!) in order to accommodate various combinations of Perl and
mod_perl.
1.24 Patch from Scott Gifford (sgifford@suspectclass.com): Add support
package CPAN::LWP::UserAgent;
use vars qw(@ISA $USER $PASSWD $SETUPDONE);
-# we delay requiring LWP::UserAgent and setting up inheritence until we need it
+# we delay requiring LWP::UserAgent and setting up inheritance until we need it
package CPAN::Complete;
@CPAN::Complete::ISA = qw(CPAN::Debug);
require() statements.
The configuration dialog can be started any time later again by
-issueing the command C< o conf init > in the CPAN shell.
+issuing the command C< o conf init > in the CPAN shell.
Currently the following keys in the hash reference $CPAN::Config are
defined:
Thanks to Graham Barr for contributing the following paragraphs about
the interaction between perl, and various firewall configurations. For
-further informations on firewalls, it is recommended to consult the
+further information on firewalls, it is recommended to consult the
documentation that comes with the ncftp program. If you are unable to
go through the firewall with a simple Perl setup, it is very likely
that you can configure ncftp so that it works for your firewall.
read-once operation. Once it has been performed, the $ctx object is
automatically C<reset> and can be used to calculate another digest
value. Call $ctx->clone->digest if you want to calculate the digest
-without reseting the digest state.
+without resetting the digest state.
=item $ctx->hexdigest
=begin comment
The packages below implement functions for generating properly
-formated commandlines for the compiler being used. Each package
+formatted commandlines for the compiler being used. Each package
defines two primary functions 'format_linker_cmd()' &
'format_compiler_cmd()' that accepts a list of named arguments (a
-hash) and returns a list of formated options suitable for invoking the
+hash) and returns a list of formatted options suitable for invoking the
compiler. By default, if the compiler supports scripting of its
operation then a script file is built containing the options while
those options are removed from the commandline, and a reference to the
file
UMASK_NULL Nullify umask
- DEV_NULL Supress all command output
+ DEV_NULL Suppress all command output
=head3 init_DIRFILESEP I<Abstract>
print "Executing $abs\n" if ($trace >= 2);
my $version_check = qq{$abs -le "require $ver; print qq{VER_OK}"};
- # To avoid using the unportable 2>&1 to supress STDERR,
+ # To avoid using the unportable 2>&1 to suppress STDERR,
# we close it before running the command.
# However, thanks to a thread library bug in many BSDs
# ( http://www.freebsd.org/cgi/query-pr.cgi?pr=51535 )
=item pasthru (override)
VMS has $(MMSQUALIFIERS) which is a listing of all the original command line
-options. This is used in every invokation of make in the VMS Makefile so
+options. This is used in every invocation of make in the VMS Makefile so
PASTHRU should not be necessary. Using PASTHRU tends to blow commands past
the 256 character limit.
{'PM_FILTER' => 'grep -v \\"^\\#\\"'}
-to remove all the leading coments on the fly during the build. The
+to remove all the leading comments on the fly during the build. The
extra \\ are necessary, unfortunately, because this variable is interpolated
within the context of a Perl program built on the command line, and double
quotes are what is used with the -e switch to build that command line. The
=item depend
- {ANY_TARGET => ANY_DEPENDECY, ...}
+ {ANY_TARGET => ANY_DEPENDENCY, ...}
(ANY_TARGET must not be given a double-colon rule by MakeMaker.)
=item C<< MAN3PODS => ' ' >>
-This is commonly used to supress the creation of man pages. MAN3PODS
+This is commonly used to suppress the creation of man pages. MAN3PODS
takes a hash ref not a string, but the above worked by accident in old
versions of MakeMaker.
}
sub UNTIE {
- # This sub does nothing, but is neccessary for references to be released.
+ # This sub does nothing, but is necessary for references to be released.
}
sub end_marker {
=item B<hiertype>
-Retains C<::> in type names so that C++ hierachical types can be
+Retains C<::> in type names so that C++ hierarchical types can be
mapped. Default is false.
=item B<except>
B<NOTE>: C<dirname()> and C<basename()> emulate the behaviours, and
quirks, of the shell and C functions of the same name. See each
-function's documention for details. If your concern is just parsing
+function's documentation for details. If your concern is just parsing
paths it is safer to use L<File::Spec>'s C<splitpath()> and
C<splitdir()> methods.
directory path.
B<IMPORTANT NOTE:> Beginning with version 1.3 of this module, the resulting
-path is relative by default and I<not> absolute. This descision was made due
+path is relative by default and I<not> absolute. This decision was made due
to portability reasons. Since C<File::Spec-E<gt>catdir()> returns relative paths
on all other operating systems, it will now also follow this convention on Mac
OS. Note that this may break some existing scripts.
B<IMPORTANT NOTE:> Beginning with version 1.3 of this module, the
resulting path is relative by default and I<not> absolute. This
-descision was made due to portability reasons. Since
+decision was made due to portability reasons. Since
C<File::Spec-E<gt>catfile()> returns relative paths on all other
operating systems, it will now also follow this convention on Mac OS.
Note that this may break some existing scripts.
Returns false if the stat information differs or if the link count is
greater than 1.
-On certain platofms, eg Windows, not all the fields returned by stat()
+On certain platforms, e.g. Windows, not all the fields returned by stat()
can be compared. For example, the C<dev> and C<rdev> fields seem to be
different in Windows. Also, it seems that the size of the file
returned by stat() does not always agree, with C<stat(FH)> being more
changed when the placeholders are removed from C<$_> after the filter
is complete.
-For example, the following filter detects concatentated pairs of
+For example, the following filter detects concatenated pairs of
strings/quotelikes and reverses the order in which they are
concatenated:
Used with the example above, C<@libfiles> (or C<@$libfiles>) would
contain two strings upon completion: C<"lib/srdlib"> and
C<"lib/extlib">, in that order. It is also possible to specify that
-only integer or floating point numbers are acceptible values.
+only integer or floating point numbers are acceptable values.
Often it is useful to allow comma-separated lists of values as well as
multiple occurrences of the options. This is easy using Perl's split()
the hash C<%defines> (or C<%$defines>) will contain two keys, C<"os">
with value C<"linux> and C<"vendor"> with value C<"redhat">. It is
also possible to specify that only integer or floating point numbers
-are acceptible values. The keys are always taken to be strings.
+are acceptable values. The keys are always taken to be strings.
=head2 User-defined subroutines to handle options
die(), issue the error message, and record that an error result must
be returned upon completion.
-If the text of the error message starts with an exclamantion mark C<!>
+If the text of the error message starts with an exclamation mark C<!>
it is interpreted specially by GetOptions(). There is currently one
special command implemented: C<die("!FINISH")> will cause GetOptions()
to stop processing options, as if it encountered a double dash C<-->.
=head1 DESCRIPTION
- B<This program> will read the given input file(s) and do someting
+ B<This program> will read the given input file(s) and do something
useful with the contents thereof.
=cut
Configured this way, single-character options can be bundled but long
options B<must> always start with a double dash C<--> to avoid
-abiguity. For example, when C<vax>, C<a>, C<v> and C<x> are all valid
+ambiguity. For example, when C<vax>, C<a>, C<v> and C<x> are all valid
options,
-vax
--foo --bar arg1 arg2 arg3
If an argument callback routine is specified, C<@ARGV> will always be
-empty upon succesful return of GetOptions() since all options have been
+empty upon successful return of GetOptions() since all options have been
processed. The only exception is when C<--> is used:
--foo arg1 --bar arg2 -- arg3
-al, -la, -ala, -all,... a, l
--al, --all all
-The suprising part is that C<--a> sets option C<a> (due to auto
+The surprising part is that C<--a> sets option C<a> (due to auto
completion), not C<all>.
Note: disabling C<bundling> also disables C<bundling_override>.
You could instead do lookups on $wanted with:
use I18N::LangTags qw(same_language_tag);
- my $repsonse = '';
+ my $response = '';
foreach my $l2 (keys %greetings) {
if(same_language_tag($wanted, $l2)) {
$response = $greetings{$l2};
syntactically invalid and for tags, like "aus", that are listed in
brackets below. This function is not exported.
-The map of tags-to-names that it uses is accessable as
+The map of tags-to-names that it uses is accessible as
%I18N::LangTags::List::Name, and it's the same as the list
that follows in this documentation, which should be useful
to you even if you don't use this module.
$self->{sign} = $$mis;
# for something like 0Ey, set y to 1, and -0 => +0
- # Check $$miv for beeing '0' and $$mfv eq '', because otherwise _m could not
+ # Check $$miv for being '0' and $$mfv eq '', because otherwise _m could not
# have become 0. That's faster than to call $MBI->_is_zero().
$self->{sign} = '+', $self->{_e} = $MBI->_one()
if $$miv eq '0' and $$mfv eq '';
# The following all modify their first argument. If you want to preserve
# $x, use $z = $x->copy()->bXXX($y); See under L<CAVEATS> for why this is
- # neccessary when mixing $a = $b assigments with non-overloaded math.
+ # necessary when mixing $a = $b assignments with non-overloaded math.
# set
$x->bzero(); # set $i to 0
=head1 DESCRIPTION
-All operators (inlcuding basic math operations) are overloaded if you
+All operators (including basic math operations) are overloaded if you
declare your big floating point numbers as
$i = new Math::BigFloat '12_3.456_789_123_456_789E-2';
=back
-all with optional leading and trailing zeros and/or spaces. Additonally,
+all with optional leading and trailing zeros and/or spaces. Additionally,
numbers are allowed to have an underscore between any two digits.
Empty strings as well as other illegal numbers results in 'NaN'.
Note that C<< Math::BigFloat->accuracy() >> and C<< Math::BigFloat->precision() >>
set the global variables, and thus B<any> newly created number will be subject
-to the global rounding B<immidiately>. This means that in the examples above, the
+to the global rounding B<immediately>. This means that in the examples above, the
C<3> as argument to C<bdiv()> will also get an accuracy of B<5>.
It is less confusing to either calculate the result fully, and afterwards
-round it explicitely, or use the additional parameters to the math
+round it explicitly, or use the additional parameters to the math
functions like so:
use Math::BigFloat;
influence of C<< CLASS->accuracy($A) >>, all results from math operations with
that number will also be rounded.
-In most cases, you should probably round the results explicitely using one of
+In most cases, you should probably round the results explicitly using one of
L<round()>, L<bround()> or L<bfround()> or by passing the desired accuracy
to the math operation as additional parameter:
use Math::BigFloat lib => 'Foo,Math::BigInt::Bar';
Calc.pm uses as internal format an array of elements of some decimal base
-(usually 1e7, but this might be differen for some systems) with the least
+(usually 1e7, but this might be different for some systems) with the least
significant digit first, while BitVect.pm uses a bit vector of base 2, most
significant bit first. Other modules might use even different means of
representing the numbers. See the respective module documentation for further
require Math::BigFloat;
-This will load the neccessary things (like BigInt) when they are needed, and
+This will load the necessary things (like BigInt) when they are needed, and
automatically.
Use the lib, Luke! And see L<Using Math::BigInt::Lite> for more details than
don't specify it onem but if you specify one, it will try to load them.
Actually, the lib loading order would be "Bar,Baz,Calc", and then
-"Foo,Bar,Baz,Calc", but independend of which lib exists, the result is the
+"Foo,Bar,Baz,Calc", but independent of which lib exists, the result is the
same as trying the latter load alone, except for the fact that one of Bar or
-Baz might be loaded needlessly in an intermidiate step (and thus hang around
+Baz might be loaded needlessly in an intermediate step (and thus hang around
and waste memory). If neither Bar nor Baz exist (or don't work/compile), they
will still be tried to be loaded, but this is not as time/memory consuming as
actually loading one of them. Still, this type of usage is not recommended due
print $c->bdiv(123.456),"\n";
It prints both quotient and reminder since print works in list context. Also,
-bdiv() will modify $c, so be carefull. You probably want to use
+bdiv() will modify $c, so be careful. You probably want to use
print $c / 123.456,"\n";
print scalar $c->bdiv(123.456),"\n"; # or if you want to modify $c
use Math::BigFloat;
Math::BigFloat->accuracy(4); # enables global rounding:
- my $x = Math::BigFloat->new(123456); # rounded immidiately to "12350"
+ my $x = Math::BigFloat->new(123456); # rounded immediately to "12350"
print "$x\n"; # print "123500"
my $y = Math::BigFloat->new(3); # rounded to "3
print "$y\n"; # print "3"
sub bone
{
# create a bigint '+1' (or -1 if given sign '-'),
- # if given a BigInt, set it to +1 or -1, respecively
+ # if given a BigInt, set it to +1 or -1, respectively
my $self = shift;
my $sign = shift; $sign = '+' if !defined $sign || $sign ne '-';
$self = $class if !defined $self;
# the first argument is number of args objectify() should look at it will
# return $count+1 elements, the first will be a classname. This is because
# overloaded '""' calls bstr($object,undef,undef) and this would result in
- # useless objects beeing created and thrown away. So we cannot simple loop
+ # useless objects being created and thrown away. So we cannot simple loop
# over @_. If the given count is 0, all arguments will be used.
# If the second arg is a ref, use it as class.
$x->is_inf($sign); # if $x is +inf, or -inf (sign is default '+')
$x->is_int(); # if $x is an integer (not a float)
- # comparing and digit/sign extration
+ # comparing and digit/sign extraction
$x->bcmp($y); # compare numbers (undef,<0,=0,>0)
$x->bacmp($y); # compare absolutely (undef,<0,=0,>0)
$x->sign(); # return the sign, either +,- or NaN
# The following all modify their first argument. If you want to preserve
# $x, use $z = $x->copy()->bXXX($y); See under L<CAVEATS> for why this is
- # neccessary when mixing $a = $b assigments with non-overloaded math.
+ # necessary when mixing $a = $b assignments with non-overloaded math.
$x->bzero(); # set $x to 0
$x->bnan(); # set $x to NaN
=head1 DESCRIPTION
-All operators (inlcuding basic math operations) are overloaded if you
+All operators (including basic math operations) are overloaded if you
declare your big integers as
$i = new Math::BigInt '123_456_789_123_456_789';
even
version version number of the class you used
1.61
- div_scale Fallback acccuracy for div
+ div_scale Fallback accuracy for div
40
trap_nan If true, traps creation of NaN via croak()
1
influence of C<< CLASS->accuracy($A) >>, all results from math operations with
that number will also be rounded.
-In most cases, you should probably round the results explicitely using one of
+In most cases, you should probably round the results explicitly using one of
L<round()>, L<bround()> or L<bfround()> or by passing the desired accuracy
to the math operation as additional parameter:
$x->is_inf(); # true if +inf
$x->is_inf('-'); # true if -inf (sign is default '+')
-These methods all test the BigInt for beeing one specific value and return
+These methods all test the BigInt for being one specific value and return
true or false depending on the input. These are faster than doing something
like:
These methods are only testing the sign, and not the value.
-C<is_positive()> and C<is_negative()> are aliase to C<is_pos()> and
+C<is_positive()> and C<is_negative()> are aliases to C<is_pos()> and
C<is_neg()>, respectively. C<is_positive()> and C<is_negative()> were
introduced in v1.36, while C<is_pos()> and C<is_neg()> were only introduced
in v1.68.
$x->bstr();
-Returns a normalized string represantation of C<$x>.
+Returns a normalized string representation of C<$x>.
=head2 bsstr
result has at most max(scale, length(dividend), length(divisor)) digits
Actual code:
scale = max(scale, length(dividend)-1,length(divisor)-1);
- scale += length(divisior) - length(dividend);
+ scale += length(divisor) - length(dividend);
So for lx = 3, ly = 9, scale = 10, scale will actually be 16 (10+9-3).
Actually, the 'difference' added to the scale is calculated from the
number of "significant digits" in dividend and divisor, which is derived
* to find out the current global P, use C<< Math::SomeClass->precision() >>
* use C<< $x->accuracy() >> respective C<< $x->precision() >> for the local
setting of C<< $x >>.
- * Please note that C<< $x->accuracy() >> respecive C<< $x->precision() >>
+ * Please note that C<< $x->accuracy() >> respective C<< $x->precision() >>
return eventually defined global A or P, when C<< $x >>'s A or P is not
set.
be automatically cleared.
* If two objects are involved in an operation, and one of them has A in
effect, and the other P, this results in an error (NaN).
- * A takes precendence over P (Hint: A comes before P).
+ * A takes precedence over P (Hint: A comes before P).
If neither of them is defined, nothing is used, i.e. the result will have
as many digits as it can (with an exception for fdiv/fsqrt) and will not
be rounded.
+ never round (this is the default):
This is done by setting A and P to undef. No math operation
will round the result, with fdiv() and fsqrt() as exceptions to guard
- against overflows. You must explicitely call bround(), bfround() or
+ against overflows. You must explicitly call bround(), bfround() or
round() (the latter with parameters).
Note: Once you have rounded a number, the settings will 'stick' on it
and 'infect' all other numbers engaged in math operations with it, since
=item ==, !=, <, >, <=, >= with NaNs
BigInt's bcmp() routine currently returns undef to signal that a NaN was
-involved in a comparisation. However, the overload code turns that into
+involved in a comparison. However, the overload code turns that into
either 1 or '' and thus operations like C<< NaN != NaN >> might return
wrong values.
With a technique called copy-on-write, the cost of copying with overload could
be minimized or even completely avoided. A test implementation of COW did show
performance gains for overloaded math, but introduced a performance loss due
-to a constant overhead for all other operatons. So Math::BigInt does currently
+to a constant overhead for all other operations. So Math::BigInt does currently
not COW.
The rewritten version of this module (vs. v0.01) is slower on certain
There is now a C<bsstr()> method to get the string in scientific notation aka
C<1e+2> instead of C<100>. Be advised that overloaded 'eq' always uses bstr()
-for comparisation, but Perl will represent some numbers as 100 and others
+for comparison, but Perl will represent some numbers as 100 and others
as 1e+308. If in doubt, convert both arguments to Math::BigInt before
comparing them as strings:
$y = Math::BigInt->new($y);
ok ($x,$y); # okay
-Alternatively, simple use C<< <=> >> for comparisations, this will get it
+Alternatively, simple use C<< <=> >> for comparisons, this will get it
always right. There is not yet a way to get a number automatically represented
as a string that matches exactly the way Perl represents it.
This also works for other subclasses, like Math::String.
-It is yet unlcear whether overloaded int() should return a scalar or a BigInt.
+It is yet unclear whether overloaded int() should return a scalar or a BigInt.
If you want a real Perl scalar, use C<numify()>:
print $c->bdiv(10000),"\n";
It prints both quotient and remainder since print calls C<bdiv()> in list
-context. Also, C<bdiv()> will modify $c, so be carefull. You probably want
+context. Also, C<bdiv()> will modify $c, so be careful. You probably want
to use
print $c / 10000,"\n";
holds true for any $x and $y, which justifies calling the two return
values of bdiv() the quotient and remainder. The only exception to this rule
are when $y == 0 and $x is negative, then the remainder will also be
-negative. See below under "infinity handling" for the reasoning behing this.
+negative. See below under "infinity handling" for the reasoning behind this.
Perl's 'use integer;' changes the behaviour of % and / for scalars, but will
not change BigInt's way to do things. This is because under 'use integer' Perl
and still at it in 2005.
Many people contributed in one or more ways to the final beast, see the file
-CREDITS for an (uncomplete) list. If you miss your name, please drop me a
+CREDITS for an (incomplete) list. If you miss your name, please drop me a
mail. Thank you!
=cut
_num(obj) returns a Perl integer/floating point number
NOTE: because of Perl numeric notation defaults,
the _num'ified obj may lose accuracy due to
- machine-dependend floating point size limitations
+ machine-dependent floating point size limitations
_add(obj,obj) Simple addition of two objects
_mul(obj,obj) Multiplication of two objects
are swapped. In this case, the first param needs to
be preserved, while you can destroy the second.
sub (x,y,1) => return x - y and keep x intact!
- _dec(obj) decrement object by one (input is garant. to be > 0)
+ _dec(obj) decrement object by one (input is guaranteed to be > 0)
_inc(obj) increment object by one
The first parameter can be modified, that includes the possibility that you
return a reference to a completely different object instead. Although keeping
-the reference and just changing it's contents is prefered over creating and
+the reference and just changing it's contents is preferred over creating and
returning a different reference.
Return values are always references to objects, strings, or true/false for
-comparisation routines.
+comparison routines.
=head1 WRAP YOUR OWN
=head1 METHODS
-Any methods not listed here are dervied from Math::BigFloat (or
+Any methods not listed here are derived from Math::BigFloat (or
Math::BigInt), so make sure you check these two modules for further
information.
undef
round_mode RW Global round mode
even
- div_scale RW Fallback acccuracy for div
+ div_scale RW Fallback accuracy for div
40
trap_nan RW Trap creation of NaN (undef = no)
undef
By default, if a redispatch attempt fails to find another method
elsewhere in the objects class hierarchy, it quietly gives up and does
-nothing (but see L<"Enforcing redispatch">). This gracious acquiesence
+nothing (but see L<"Enforcing redispatch">). This gracious acquiescence
is also unlike the (generally annoying) behaviour of C<SUPER>, which
throws an exception if it cannot redispatch.
That means that the inheritance tree of the object is traversed breadth-first
and the resulting order of classes is used as the sequence in which methods
are called. However, that sequence is modified by imposing a rule that the
-appropritae method of a derived class must be called before the same method of
+appropriate method of a derived class must be called before the same method of
any ancestral class. That's why, in the above example, C<X::foo> is called
before C<D::foo>, even though C<D> comes before C<X> in C<@B::ISA>.
command, you may read from this filehandle using read() or <>. The
filehandle will return EOF when the final dot is encountered.
Similarly, you may write to the filehandle in order to send data to
-the server after issuing a commmand that expects data to be written.
+the server after issuing a command that expects data to be written.
See the Net::POP3 and Net::SMTP modules for examples of this.
=head1 DESCRIPTION
C<Net::Config> holds configuration data for the modules in the libnet
-distribuion. During installation you will be asked for these values.
+distribution. During installation you will be asked for these values.
The configuration data is held globally in a file in the perl installation
tree, but a user may override any of these values by providing their own. This
# .libnetrc
{
- nntp_hosts => [ "my_prefered_host" ],
+ nntp_hosts => [ "my_preferred_host" ],
ph_hosts => [ "my_ph_server" ],
}
__END__
=item ftp_ext_passive
-=item ftp_int_pasive
+=item ftp_int_passive
FTP servers normally work on a non-passive mode. That is when you want to
transfer data you have to tell the server the address and port to
overridden by an environment variable C<FTP_FIREWALL>. If specified, and the
given host cannot be directly connected to, then the
connection is made to the firewall machine and the string C<@hostname> is
-appended to the login identifier. This kind of setup is also refered to
+appended to the login identifier. This kind of setup is also referred to
as an ftp proxy.
B<FirewallType> - The type of firewall running on the machine indicated by
=item alloc ( SIZE [, RECORD_SIZE] )
The alloc command allows you to give the ftp server a hint about the size
-of the file about to be transfered using the ALLO ftp command. Some storage
+of the file about to be transferred using the ALLO ftp command. Some storage
systems use this to make intelligent decisions about how to store the file.
The C<SIZE> argument represents the size of the file in bytes. The
C<RECORD_SIZE> argument indicates a mazimum record or page size for files
The size of the file will be determined, and sent to the server
automatically for normal files so that this method need only be called if
-you are transfering data from a socket, named pipe, or other stream not
+you are transferring data from a socket, named pipe, or other stream not
associated with a normal file.
=item ls ( [ DIR ] )
the current directory with the same leafname as the remote file.
If C<WHERE> is given then the first C<WHERE> bytes of the file will
-not be transfered, and the remaining bytes will be appended to
+not be transferred, and the remaining bytes will be appended to
the local file if it already exists.
Returns C<LOCAL_FILE>, or the generated local file name if C<LOCAL_FILE>
is not given.
B<NOTE>: If for some reason the transfer does not complete and an error is
-returned then the contents that had been transfered will not be remove
+returned then the contents that had been transferred will not be remove
automatically.
=item put_unique ( LOCAL_FILE [, REMOTE_FILE ] )
Returns the size in bytes for the given file as stored on the remote server.
B<NOTE>: The size reported is the size of the stored file on the remote server.
-If the file is subsequently transfered from the server in ASCII mode
+If the file is subsequently transferred from the server in ASCII mode
and the remote server and local machine have different ideas about
"End Of Line" then the size of file on the local machine after transfer
may be different.
If C<FH> is specified then it is expected to be a valid filehandle
and the result will be printed to it, on success a true value will be
returned. If C<FH> is not specified then the return value, on success,
-will be a reference to an array containg the article requested, each
+will be a reference to an array containing the article requested, each
entry in the array will contain one line of the article.
If no arguments are passed then the current article in the currently
=item capa ()
-Return a reference to a hash of the capabilties of the server. APOP
+Return a reference to a hash of the capabilities of the server. APOP
is added as a pseudo capability. Note that I've been unable to
find a list of the standard capability values, and some appear to
be multi-word and some are not. We make an attempt at intelligently
=item reset ()
-Reset the status of the remote POP3 server. This includes reseting the
+Reset the status of the remote POP3 server. This includes resetting the
status of all messages to not be deleted.
=item quit ()
}
}
-# Description: Allow UDP source endpoint comparision to be
+# Description: Allow UDP source endpoint comparison to be
# skipped for those remote interfaces that do
# not response from the same endpoint.
the return value does NOT determine if the remote host is alive or
not since the full TCP three-way handshake may not have completed
yet. The remote host is only considered reachable if it receives
-a TCP ACK within the timeout specifed. To begin waiting for the
+a TCP ACK within the timeout specified. To begin waiting for the
ACK packets, use the ack() method as explained below. Use the
"syn" protocol instead the "tcp" protocol to determine reachability
of multiple destinations simultaneously by sending parallel TCP
1024.
If $device is given, this device is used to bind the source endpoint
-before sending the ping packet. I beleive this only works with
+before sending the ping packet. I believe this only works with
superuser privileges and with udp and icmp protocols at this time.
-If $tos is given, this ToS is configured into the soscket.
+If $tos is given, this ToS is configured into the socket.
=item $p->ping($host [, $timeout]);
=item $p->tcp_service_check( { 0 | 1 } );
-Depricated method, but does the same as service_check() method.
+Deprecated method, but does the same as service_check() method.
=item $p->hires( { 0 | 1 } );
undef. In list context, the host, the ack time, and the
dotted ip string will be returned instead of just the host.
If the optional $host argument is specified, the return
-value will be partaining to that host only.
+value will be pertaining to that host only.
This call simply does nothing if you are using any protocol
other than syn.
Net::SMTP attempts to DWIM with addresses that are passed. For
example an application might extract The From: line from an email
-and pass that to mail(). While this may work, it is not reccomended.
+and pass that to mail(). While this may work, it is not recommended.
The application should really use a module like L<Mail::Address>
to extract the mail address and pass that.
-If C<ExactAddresses> is passed to the contructor, then addresses
+If C<ExactAddresses> is passed to the constructor, then addresses
should be a valid rfc2821-quoted address, although Net::SMTP will
accept accept the address surrounded by angle brackets.
...
binmode($fh,":encoding(...)"); # next chunk is encoded
...
- binmode($fh,":pop"); # back to un-encocded
+ binmode($fh,":pop"); # back to un-encoded
A more elegant (and safer) interface is needed.
=item * unresolved internal link I<NAME>
The given link to I<NAME> does not have a matching node in the current
-POD. This also happend when a single word node name is not enclosed in
+POD. This also happens when a single word node name is not enclosed in
C<"">.
=item * Unknown command "I<CMD>"
=item * =item type mismatch (I<one> vs. I<two>)
-A list started with e.g. a bulletted C<=item> and continued with a
+A list started with e.g. a bulleted C<=item> and continued with a
numbered one. This is obviously inconsistent. For most translators the
type of the I<first> C<=item> determines the type of the list.
=item %Kinds
-This holds a hash-of-lists. Each list contains the functions in the catagory
+This holds a hash-of-lists. Each list contains the functions in the category
the key denotes.
=item %Type
-In this hash each key represents a function and the value is the catagory.
-The catagory can be a comma separated list.
+In this hash each key represents a function and the value is the category.
+The category can be a comma separated list.
=item %Flavor
=item %Type_Description
-In this hash each key represents a catagory of functions and the value is
-a short description of that catagory.
+In this hash each key represents a category of functions and the value is
+a short description of that category.
=item @Type_Order
-This list of catagories is used to produce the same order as the
+This list of categories is used to produce the same order as the
L<perlfunc/"Perl Functions by Category"> section.
=back
pods (empty by default).
--podroot - filesystem base directory from which all relative paths
in podpath stem (default is .).
- --[no]quiet - supress some benign warning messages (default is off).
+ --[no]quiet - suppress some benign warning messages (default is off).
--[no]recurse - recurse on those subdirectories listed in podpath
(default behaviour).
--title - title that will appear in resulting html file.
my $handle = $pod_input->handle();
Returns a reference to the handle object from which input is read (the
-one used to contructed this input source object).
+one used to construct this input source object).
=end __PRIVATE__
be written that could be immediately processed by C<latex>.
For some pod escapes it may be necessary to include the amsmath
-package. This is not yet added to the preamble automaatically.
+package. This is not yet added to the preamble automatically.
=cut
methods for your subclass (to perform any needed per-file and/or
per-document initialization or cleanup).
-If you need to perform any preprocesssing of input before it is parsed
+If you need to perform any preprocessing of input before it is parsed
you may want to override one or more of B<preprocess_line()> and/or
B<preprocess_paragraph()>.
For the most part, the B<Pod::Parser> base class should be able to
do most of the input parsing for you and leave you free to worry about
-how to intepret the commands and translate the result.
+how to interpret the commands and translate the result.
Note that all we have described here in this quick overview is the
simplest most straightforward use of B<Pod::Parser> to do stream-based
The parameter C<$text> is a string or block of text to be parsed
for interior sequences; and the parameter C<$line_num> is the
-line number curresponding to the beginning of C<$text>.
+line number corresponding to the beginning of C<$text>.
B<parse_text()> will parse the given text into a parse-tree of "nodes."
and interior-sequences. Each "node" in the parse tree is either a
Returns a value of true if the given section and subsection heading
titles match any of the currently selected section specifications in
effect from prior calls to B<select()> and B<add_selection()> (or if
-there are no explictly selected/deselected sections).
+there are no explicitly selected/deselected sections).
The arguments C<$heading1>, C<$heading2>, etc. are the heading titles of
the corresponding sections, subsections, etc. to try and match. If
All other arguments should correspond to the names of input files
containing POD sections. A file name of "-" or "<&STDIN" will
-be interpeted to mean standard input (which is the default if no
+be interpreted to mean standard input (which is the default if no
filenames are given).
=cut
=item *
If program usage has been explicitly requested by the user, it is often
-desireable to exit with a status of 1 (as opposed to 0) after issuing
-the user-requested usage message. It is also desireable to give a
+desirable to exit with a status of 1 (as opposed to 0) after issuing
+the user-requested usage message. It is also desirable to give a
more verbose description of program usage in this case.
=back
is usually a Bad Idea in a switch statement. However, this
is Perl, not a police state, so there I<is> a way to do it, if you must.
-If a C<case> block executes an untargetted C<next>, control is
+If a C<case> block executes an untargeted C<next>, control is
immediately transferred to the statement I<after> the C<case> statement
(i.e. usually another case), rather than out of the surrounding
C<switch> block.
case /\d/ { handle_dig_any(); }
}
-If an untargetted C<last> statement is executed in a case block, this
+If an untargeted C<last> statement is executed in a case block, this
immediately transfers control out of the enclosing C<switch> block
(in other words, there is an implicit C<last> at the end of each
normal C<case> block). Thus the previous example could also have been
interface has the advantage of better compile time error checking, since
misspelled names of colors or attributes in calls to color() and colored()
won't be caught until runtime whereas misspelled names of constants will be
-caught at compile time. So, polute your namespace with almost two dozen
+caught at compile time. So, pollute your namespace with almost two dozen
subroutines that you may not even use that often, or risk a silly bug by
mistyping an attribute. Your choice, TMTOWTDI after all.
constants aren't required, in which case you may feel free to insert commas
unless you're using $Term::ANSIColor::AUTORESET.)
-For easier debuging, you may prefer to always use the commas when not
+For easier debugging, you may prefer to always use the commas when not
setting $Term::ANSIColor::AUTORESET so that you'll get a fatal compile error
rather than a warning.
++ $ntest;
return 1;
} else {
- # backwards compatiblity (I think). skip() used to be
+ # backwards compatibility (I think). skip() used to be
# called like ok(), which is weird. I haven't decided what to do with
# this yet.
# warn <<WARN if $^W;
L<Test::More> and L<Test::Unit>.
Some earlier versions of this module had docs with some confusing
-typoes in the description of C<skip(...)>.
+typos in the description of C<skip(...)>.
=head1 SEE ALSO
diag(@diagnostic_message);
Prints a diagnostic message which is guaranteed not to interfere with
-test output. Like C<print> @diagnostic_message is simply concatinated
+test output. Like C<print> @diagnostic_message is simply concatenated
together.
Handy for this sort of thing:
is_deeply( [sort @this], [sort @that] );
-B<NOTE> By historical accident, this is not a true set comparision.
+B<NOTE> By historical accident, this is not a true set comparison.
While the order of elements does not matter, duplicate elements do.
Test::Deep contains much better set comparison functions.
current C<pos> location of the string's variable
(or at index zero, if no C<pos> position is defined).
In other words, the C<extract_...> subroutines I<don't>
-extract the first occurance of a substring anywhere
+extract the first occurrence of a substring anywhere
in a string (like an unanchored regex would). Rather,
-they extract an occurance of the substring appearing
+they extract an occurrence of the substring appearing
immediately at the current matching position in the
string (like a C<\G>-anchored regex would).
C<extract_variable> extracts any valid Perl variable or
variable-involved expression, including scalars, arrays, hashes, array
-accesses, hash look-ups, method calls through objects, subroutine calles
+accesses, hash look-ups, method calls through objects, subroutine calls
through subroutine references, etc.
The subroutine takes up to two optional arguments:
character is extracted from the start of the text and the extraction
subroutines reapplied. Characters which are thus removed are accumulated and
eventually become the next field (unless the fourth argument is true, in which
-case they are disgarded).
+case they are discarded).
For example, the following extracts substrings that are valid Perl variables:
=head1 DESCRIPTION
C<Text::Wrap::wrap()> is a very simple paragraph formatter. It formats a
-single paragraph at a time by breaking lines at word boundries.
+single paragraph at a time by breaking lines at word boundaries.
Indentation is controlled for the first line (C<$initial_tab>) and
all subsequent lines (C<$subsequent_tab>) independently. Please note:
C<$initial_tab> and C<$subsequent_tab> are the literal strings that will
-be used: it is unlikley you would want to pass in a number.
+be used: it is unlikely you would want to pass in a number.
Text::Wrap::fill() is a simple multi-paragraph formatter. It formats
each paragraph separately and then joins them together when it's done. It
if (@_) {
$unwritten = $self->_downcopy($data, $end, $_[1] - $end);
} else {
- # Make the file longer to accomodate the last segment that doesn'
+ # Make the file longer to accommodate the last segment that doesn'
$unwritten = $self->_downcopy($data, $end);
}
}
The methods C<UNTIE> and C<DESTROY> are not defined in B<Tie::Hash>,
B<Tie::StdHash>, or B<Tie::ExtraHash>. Tied hashes do not require
-presense of these methods, but if defined, the methods will be called in
+presence of these methods, but if defined, the methods will be called in
proper time, see L<perltie>.
C<SCALAR> is only defined in B<Tie::StdHash> and B<Tie::ExtraHash>.
return value is a I<range>: an anonymous list of lists that contain
I<start-of-range>, I<end-of-range> code point pairs. You can test whether
a code point is in a range using the L</charinrange> function. If the
-argument is not a known charater block, C<undef> is returned.
+argument is not a known character block, C<undef> is returned.
=cut
return value is a I<range>: an anonymous list of lists that contain
I<start-of-range>, I<end-of-range> code point pairs. You can test whether a
code point is in a range using the L</charinrange> function. If the
-argument is not a known charater script, C<undef> is returned.
+argument is not a known character script, C<undef> is returned.
=cut
push @{"$inheritor\::ISA"}, $base;
if ( has_fields($base) || has_attr($base) ) {
- # No multiple fields inheritence *suck*
+ # No multiple fields inheritance *suck*
if ($fields_base) {
require Carp;
Carp::croak("Can't multiply inherit %FIELDS");
C<-1, set by base.pm>.
Will also initialize the fields if one of the base classes has it.
-Multiple inheritence of fields is B<NOT> supported, if two or more
+Multiple inheritance of fields is B<NOT> supported, if two or more
base classes each have inheritable fields the 'base' pragma will
croak. See L<fields>, L<public> and L<protected> for a description of
this feature.
print $x + 1, " ", $y,"\n"; # prints 10 9
but calling any method that modifies the number directly will result in
-B<both> the original and the copy beeing destroyed:
+B<both> the original and the copy being destroyed:
$x = 9; $y = $x;
print $x->badd(1), " ", $y,"\n"; # prints 10 10
Don't worry if it says Math::BigInt::Lite, bignum and friends will use Lite
if it is installed since it is faster for some operations. It will be
-automatically upgraded to BigInt whenever neccessary:
+automatically upgraded to BigInt whenever necessary:
perl -Mbignum -le 'print ref(2**255)'
This also means it is a bad idea to check for some specific package, since
the actual contents of $x might be something unexpected. Due to the
-transparent way of bignum C<ref()> should not be neccessary, anyway.
+transparent way of bignum C<ref()> should not be necessary, anyway.
Since Math::BigInt and BigFloat also overload the normal math operations,
the following line will still work:
print $x + 1, " ", $y,"\n"; # prints 10 9
but calling any method that modifies the number directly will result in
-B<both> the original and the copy beeing destroyed:
+B<both> the original and the copy being destroyed:
$x = 9; $y = $x;
print $x->badd(1), " ", $y,"\n"; # prints 10 10
=item inf()
-A shortcut to return Math::BigInt->binf(). Usefull because Perl does not always
+A shortcut to return Math::BigInt->binf(). Useful because Perl does not always
handle bareword C<inf> properly.
=item NaN()
-A shortcut to return Math::BigInt->bnan(). Usefull because Perl does not always
+A shortcut to return Math::BigInt->bnan(). Useful because Perl does not always
handle bareword C<NaN> properly.
=item upgrade()
=head1 DESCRIPTION
-All operators (inlcuding basic math operations) are overloaded. Integer and
+All operators (including basic math operations) are overloaded. Integer and
floating-point constants are created as proper BigInts or BigFloats,
respectively.
the fxxx() notation, though. This makes you independed on the fact that the
underlying object might morph into a different class than BigFloat.
-=head2 Cavaet
+=head2 Caveat
But a warning is in order. When using the following to make a copy of a number,
only a shallow copy will be made.
print $x + 1, " ", $y,"\n"; # prints 10 9
but calling any method that modifies the number directly will result in
-B<both> the original and the copy beeing destroyed:
+B<both> the original and the copy being destroyed:
$x = 9; $y = $x;
print $x->badd(1), " ", $y,"\n"; # prints 10 10
I<dir> (or current directory) and working back up to five levels of '..'.
Intended for use on command line with B<-M> option as a way of testing
-arbitary scripts against an uninstalled version of a package.
+arbitrary scripts against an uninstalled version of a package.
However it is possible to :
This module also adds a stack trace to the error message when perl dies.
This is useful for pinpointing what caused the death. The B<-traceonly> (or
-just B<-t>) flag turns off the explantions of warning messages leaving just
+just B<-t>) flag turns off the explanations of warning messages leaving just
the stack traces. So if your script is dieing, run it again with
perl -Mdiagnostics=-traceonly my_bad_script
# + Fix a side-effect of bug #24674 in the perl debugger ("odd taint bug")
# Changes: 1.24: Mar 03, 2004 Richard Foley <richard.foley@rfi.net>
# + Added command to save all debugger commands for sourcing later.
-# + Added command to display parent inheritence tree of given class.
+# + Added command to display parent inheritance tree of given class.
# + Fixed minor newline in history bug.
# Changes: 1.25: Apr 17, 2004 Richard Foley <richard.foley@rfi.net>
# + Fixed option bug (setting invalid options + not recognising valid short forms)
# sure that the line specified really is breakable.
#
# On the other hand, if there was a subname supplied, the
- # preceeding block has moved us to the proper file and
+ # preceding block has moved us to the proper file and
# location within that file, and then scanned forward
# looking for the next executable line. We have to make
# sure that one was found.
The C<catch()> subroutine is the essence of fast and low-impact. We simply
set an already-existing global scalar variable to a constant value. This
avoids allocating any memory possibly in the middle of something that will
-get all confused if we do, particularily under I<unsafe signals>.
+get all confused if we do, particularly under I<unsafe signals>.
=cut
=item *
-Add C<postpone>, C<load>, and C<compile> as possibles (we may be completing the keyword itself
+Add C<postpone>, C<load>, and C<compile> as possibles (we may be completing the keyword itself)
=item *
$v = version->new( 1.002_03); # 1.2.30 See "Quoting"
$v = version->new( 1.002003); # 1.2.3
-All of the preceeding examples except the second to last are true
+All of the preceding examples except the second to last are true
whether or not the input value is quoted. The important feature is that
the input value contains only a single decimal.
B<may> only support numeric comparisons. See also L<"Quoting">.
WARNING: Comparing version with unequal numbers of decimal places (whether
-explicitely or implicitely initialized), may yield unexpected results at
+explicitly or implicitly initialized), may yield unexpected results at
first glance. For example, the following inequalities hold:
version->new(0.96) > version->new(0.95); # 0.960.0 > 0.950.0
Alpha versions with a single decimal place will be treated exactly as if
they were L<Numeric Versions>, for parsing purposes. The stringification for
-alpha versions with a single decimal place may seem suprising, since any
+alpha versions with a single decimal place may seem surprising, since any
trailing zeros will visible. For example, the above $alphaver will print as
12.03_0100
This suppresses printing of VMS status messages to SYS$OUTPUT and
SYS$ERROR if Perl terminates with an error status. and allows
programs that are expecting "unix-style" Perl to avoid having to parse
-VMS error messages. It does not supress any messages from Perl
+VMS error messages. It does not suppress any messages from Perl
itself, just the messages generated by DCL after Perl exits. The DCL
symbol $STATUS will still have the termination status, but with a
high-order bit set:
vmsish" is not un-hushed by calling vmsish::hushed(0) at runtime.
The messages from error exits from inside the Perl core are generally
-more serious, and are not supressed.
+more serious, and are not suppressed.
=back
=head1 DESCRIPTION
-The extention provides both high-level and low-level access to .ini
+The extension provides both high-level and low-level access to .ini
files.
=head2 High level access
file_type() may croak with one of the strings C<"Invalid EXE
signature"> or C<"EXE marked invalid"> to indicate typical error
conditions. If given non-absolute path, will look on C<PATH>, will
-add extention F<.exe> if no extension is present (add extension F<.>
+add extension F<.exe> if no extension is present (add extension F<.>
to suppress).
=item C<@list = process_codepages()>
=item C<screen_set($buffer)>
restores the screen given the result of screen(). E.g., if the file
-C<$file> contains the sceen contents, then
+C<$file> contains the screen contents, then
open IN, $file or die;
binmode IN;
Set window visibility state flag for the window for subsequent drawing.
No actual drawing is done at this moment. Use C<ShowWindow($hwnd, $state)>
when redrawing is needed. While update is disabled, changes to the "window
-state" do not change the appearence of the window. Default: $update is TRUE.
+state" do not change the appearance of the window. Default: $update is TRUE.
(What is manipulated is the bit C<WS_VISIBLE> of the window style.)
PostMsg $hwnd, WM_CLOSE;
PostMsg $hwnd, WM_QUIT;
-In fact, MPFROMSHORT() may be omited above.
+In fact, MPFROMSHORT() may be omitted above.
For messages to other processes, messages which take/return a pointer are
not supported.
while (<>) {
s/(\012|\015\012|\015)$//;
if (/^=(\S+)/ && $directive{$1} && $last_unempty) {
- printf "%s: line %5d, no blank line preceeding directive =%s\n",
+ printf "%s: line %5d, no blank line preceding directive =%s\n",
$ARGV, $., $1;
$exit = 1;
}
B<pod2usage> will read the given input file looking for pod
documentation and will print the corresponding usage message.
-If no input file is specifed than standard input is read.
+If no input file is specified than standard input is read.
B<pod2usage> invokes the B<pod2usage()> function in the B<Pod::Usage>
module. Please see L<Pod::Usage/pod2usage()>.
Suppose that you have some C files implementing some functionality,
and the corresponding header files. How to create an extension which
-makes this functionality accessable in Perl? The example below
+makes this functionality accessible in Perl? The example below
assumes that the header files are F<interface_simple.h> and
I<interface_hairy.h>, and you want the perl module be named as
C<Ext::Ension>. If you need some preprocessor directives and/or
The generated batch file is initially processed as a batch file each
time it is run. This means that, to use it from within another batch
-file you should preceed it with C<call> or else the calling batch
+file you should precede it with C<call> or else the calling batch
file will not run any commands after the script:
call script [args]
The generated batch file is initially processed as a batch file each
time it is run. This means that, to use it from within another batch
-file you should preceed it with C<call> or else the calling batch
+file you should precede it with C<call> or else the calling batch
file will not run any commands after the script:
call script [args]
perl comp.pl --do cecopy pc:..\lib\Exporter.pm ce:[p]\lib
--copy copies file to CE device
- here also [p] will be expanded to corrent PerlCE path, and additionally
+ here also [p] will be expanded to current PerlCE path, and additionally
when --copy=compact specified then, if filename looks like perl module,
then POD will be stripped away from that file
modules
projects / p5sagit/p5-mst-13.2.git / commitdiff