=item Metaconfig worked for me
-My system at the time was Interactive 2.2, a SVR3.2/386 derivative that
+My system at the time was Interactive 2.2, an SVR3.2/386 derivative that
also had some POSIX support. Metaconfig-generated Configure scripts
worked fine for me on that system. On the other hand, autoconf-generated
scripts usually didn't. (They did come quite close, though, in some
perl foo arg1 arg2 arg3
If you want to specify perl options C<-my_opts> to the perl itself (as
-opposed to to your program), use
+opposed to your program), use
perl -my_opts foo arg1 arg2 arg3
This document is written in pod format hence there are punctuation
-characters in in odd places. Do not worry, you've apparently got the
+characters in odd places. Do not worry, you've apparently got the
ASCII->EBCDIC translation worked out correctly. You can read more
about pod in pod/perlpod.pod or the short summary in the INSTALL file.
First you get the BS2000 commandline prompt ('*'). Here you may enter
your parameters, e.g. C<-e 'print "Hello World!\\n";'> (note the
double backslash!) or C<-w> and the name of your Perl script.
-Filenames starting with C</> are searched in in the Posix filesystem,
+Filenames starting with C</> are searched in the Posix filesystem,
others are searched in the BS2000 filesystem. You may even use
wildcards if you put a C<%> in front of your filename (e.g. C<-w
checkfiles.pl %*.c>). Read your C/C++ manual for additional
See instructions in these packages for building.
In the wince directory, type "nmake -f makefile.ce". This should
-build perl.exe and and perl.dll. For building extension dlls,
+build perl.exe and perl.dll. For building extension dlls,
type "nmake -f makefile.ce dlls"
When building ext dlls, you get lots of macro redefinition
=head1 INTRODUCTION
-EPOC is a OS for palmtops and mobile phones. For more informations look at:
+EPOC is an OS for palmtops and mobile phones. For more informations look at:
http://www.symbian.com/
This is a port of perl to EPOC. It runs on ER5 machines: Psion 5mx,
have to switch back manually to ESHELL. When perl is running, you will
see a task with the name STDOUT in the task list.
-If you have a ER3 machine (i.e. a PSION 5), you may have to supply the
+If you have an ER3 machine (i.e. a PSION 5), you may have to supply the
full path to the perl executable C:\system\programs\perl.exe.
If you need to set the current directory of perl, please use the
An executable compiled on a PA-RISC 2.0 platform will not execute on a
PA-RISC 1.1 platform, even if they are running the same version of
HP-UX. If you are building Perl on a PA-RISC 2.0 platform and want that
-Perl to to also run on a PA-RISC 1.1, the compiler flags +DAportable and
+Perl to also run on a PA-RISC 1.1, the compiler flags +DAportable and
+DS32 should be used.
It is no longer possible to compile PA-RISC 1.0 executables on either
perl foo.pl arg1 arg2 arg3
If you want to specify perl options C<-my_opts> to the perl itself (as
-opposed to to your program), use
+opposed to your program), use
perl -my_opts foo.pl arg1 arg2 arg3
Note also that executable files on OS/2 can have an arbitrary extension,
but F<.exe> will be automatically appended if no dot is present in the name.
-The workaround as as simple as that: since F<blah.> and F<blah> denote the
+The workaround is as simple as that: since F<blah.> and F<blah> denote the
same file, to start an executable residing in file F<n:/bin/blah> (no
extension) give an argument C<n:/bin/blah.> (dot appended) to system().
Returns C<undef> if it was not called yet, otherwise bit 1 is
set if on the previous call do_harderror was enabled, bit
-2 is set if if on previous call do_exception was enabled.
+2 is set if on previous call do_exception was enabled.
This function enables/disables error popups associated with
hardware errors (Disk not ready etc.) and software exceptions.
processes have these sections loaded at same addresses, and no fixup
of internal links inside the F<.EXE> is needed.
-Since DLLs may be loaded at run time, to have the same mechanism for for DLLs
+Since DLLs may be loaded at run time, to have the same mechanism for DLLs
one needs to have the address range of I<any of the loaded> DLLs in the
system to be available I<in all the processes> which did not load a particular
DLL yet. This is why the DLLs are mapped to the shared memory region.
=head2 Testing Anomalies of Perl on VM/ESA
The `make test` step runs a Perl Verification Procedure, usually before
-installation. As the 5.6.1 kit was was being assembled
+installation. As the 5.6.1 kit was being assembled
the following "failures" were known to appear on some machines
during `make test` (mostly due to ASCII vs. EBCDIC conflicts),
your results may differ:
The VOS Standard C Compiler (or the VOS Standard C
Cross-Compiler) and the VOS C Runtime. If you are using
the generally-available version of POSIX support, you may
-instead use the the VOS GNU C/C++ Compiler. These are
+instead use the VOS GNU C/C++ Compiler. These are
standard Stratus products.
=item 2
with all lowercase letters, and every time dmake is invoked
to bring files up to date, it will try to recompile such files again.
For example, Tk distribution has a lot of such files, resulting in
-needless recompiles everytime dmake is invoked. To avoid this, you
+needless recompiles every time dmake is invoked. To avoid this, you
may use the script "sync_ext.pl" after a successful build. It is
available in the win32 subdirectory of the Perl source distribution.
Return an integer from an XSUB immediately. Uses C<XST_mIV>.
=for apidoc Am|void|XSRETURN_NV|NV nv
-Return an double from an XSUB immediately. Uses C<XST_mNV>.
+Return a double from an XSUB immediately. Uses C<XST_mNV>.
=for apidoc Am|void|XSRETURN_PV|char* str
Return a copy of a string from an XSUB immediately. Uses C<XST_mPV>.
* as the first line of a Perl program designed to be executed directly
* by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG
* begins with a character other then #, then Perl will only treat
- * it as a command line if if finds the string "perl" in the first
+ * it as a command line if it finds the string "perl" in the first
* word; otherwise it's treated as the first line of code in the script.
* (IOW, Perl won't hand off to another interpreter via an alternate
* shebang sequence that might be legal Perl code.)
Takes any Perl variable and turns it into an object in the
appropriate B::OP-derived or B::SV-derived class. Apart from functions
such as C<main_root>, this is the primary way to get an initial
-"handle" on a internal perl data structure which can then be followed
+"handle" on an internal perl data structure which can then be followed
with the other access methods.
=item ppname(OPNUM)
}
} else {
# glob() invocations can be translated into calls of
- # CORE::GLOBAL::glob with an second parameter, a number.
+ # CORE::GLOBAL::glob with a second parameter, a number.
# Reverse this.
if ($kid eq "CORE::GLOBAL::glob") {
$kid = "glob";
are encountered subsequently. This is useful especially for properly
dumping subroutine references.
-Expects a anonymous hash of name => value pairs. Same rules apply for names
+Expects an anonymous hash of name => value pairs. Same rules apply for names
as in C<new>. If no argument is supplied, will return the "seen" list of
name => value pairs, in a list context. Otherwise, returns the object
itself.
the state of the MD5 message-digest algorithm. You can add data to
the object and finally ask for the digest.
-If called as a instance method (i.e. $md5->new) it will just reset the
+If called as an instance method (i.e. $md5->new) it will just reset the
state the object to the state of a newly created object. No new
object is created in this case.
EOT
} else { # ASCII
$EXPECT = <<EOT;
-bf8c3c72d071d1c0303fc9e311820708 ext/Digest/MD5/MD5.pm
+665ddc08b12d6b1bf85ac6dc5aae68b3 ext/Digest/MD5/MD5.pm
95444a9c6ad17e443e4606c6c7fd9e28 ext/Digest/MD5/MD5.xs
EOT
}
{
"%s(%d): Object Image Load Failure\n",
"%s(%d): Object Image Load Success\n",
- "%s(%d): Not an recognisable object file\n",
+ "%s(%d): Not a recognisable object file\n",
"%s(%d): No valid architecture\n",
"%s(%d): Object image has an invalid format\n",
"%s(%d): Invalid access (permissions?)\n",
{
"%s(%d): Object Image Load Failure\n",
"%s(%d): Object Image Load Success\n",
- "%s(%d): Not an recognisable object file\n",
+ "%s(%d): Not a recognisable object file\n",
"%s(%d): No valid architecture\n",
"%s(%d): Object image has an invalid format\n",
"%s(%d): Invalid access (permissions?)\n",
=item * The name in the IANA registry.
-=item * The name used by the the organization that defined it.
+=item * The name used by the organization that defined it.
=back
=back
-C<IO::Dir> also provides a interface to reading directories via a tied
+C<IO::Dir> also provides an interface to reading directories via a tied
HASH. The tied HASH extends the interface beyond just the directory
reading routines by the use of C<lstat>, from the C<File::stat> package,
C<unlink>, C<rmdir> and C<utime>.
=item new ( FILENAME [,MODE [,PERMS]] )
-Creates a C<IO::File>. If it receives any parameters, they are passed to
+Creates an C<IO::File>. If it receives any parameters, they are passed to
the method C<open>; if the open fails, the object is destroyed. Otherwise,
it is returned to the caller.
the open mode, optionally followed by a file permission value.
If C<IO::File::open> receives a Perl mode string ("E<gt>", "+E<lt>", etc.)
-or a ANSI C fopen() mode string ("w", "r+", etc.), it uses the basic
+or an ANSI C fopen() mode string ("w", "r+", etc.), it uses the basic
Perl C<open> operator (but protects any special characters).
If C<IO::File::open> is given a numeric mode, it passes that mode
=item new_from_fd ( FD, MODE )
-Creates a C<IO::Handle> like C<new> does.
+Creates an C<IO::Handle> like C<new> does.
It requires two parameters, which are passed to the method C<fdopen>;
if the fdopen fails, the object is destroyed. Otherwise, it is returned
to the caller.
=item $io->fdopen ( FD, MODE )
C<fdopen> is like an ordinary C<open> except that its first parameter
-is not a filename but rather a file handle name, a IO::Handle object,
+is not a filename but rather a file handle name, an IO::Handle object,
or a file descriptor number.
=item $io->opened
=head1 NOTE
-A C<IO::Handle> object is a reference to a symbol/GLOB reference (see
+An C<IO::Handle> object is a reference to a symbol/GLOB reference (see
the C<Symbol> package). Some modules that
inherit from C<IO::Handle> may want to keep object related variables
in the hash table part of the GLOB. In an attempt to prevent modules
=item new ( [READER, WRITER] )
-Creates a C<IO::Pipe>, which is a reference to a newly created symbol
+Creates an C<IO::Pipe>, which is a reference to a newly created symbol
(see the C<Symbol> package). C<IO::Pipe::new> optionally takes two
arguments, which should be objects blessed into C<IO::Handle>, or a
subclass thereof. These two objects will be used for the system call
handle with the same C<fileno> is specified then only the last one is cached.
Each handle can be an C<IO::Handle> object, an integer or an array
-reference where the first element is a C<IO::Handle> or an integer.
+reference where the first element is an C<IO::Handle> or an integer.
=item remove ( HANDLES )
=item sockdomain
Returns the numerical number for the socket domain type. For example, for
-a AF_INET socket the value of &AF_INET will be returned.
+an AF_INET socket the value of &AF_INET will be returned.
=item sockopt(OPT [, VAL])
*/
#define SX_ITEM 'i' /* An array item introducer */
#define SX_IT_UNDEF 'I' /* Undefined array item */
-#define SX_KEY 'k' /* An hash key introducer */
-#define SX_VALUE 'v' /* An hash value introducer */
+#define SX_KEY 'k' /* A hash key introducer */
+#define SX_VALUE 'v' /* A hash value introducer */
#define SX_VL_UNDEF 'V' /* Undefined hash value */
/*
/*
* At store time:
- * An hash table records the objects which have already been stored.
+ * A hash table records the objects which have already been stored.
* Those are referred to as SX_OBJECT in the file, and their "tag" (i.e.
* an arbitrary sequence number) is used to identify them.
*
/*
* store_hash
*
- * Store an hash table.
+ * Store a hash table.
*
* Layout is SX_HASH <size> followed by each key/value pair, in random order.
* Values are stored as <object>.
* stored, before recursing...
*
* In order to avoid creating new SvIVs to hold the tagnum we just
- * cast the tagnum to a SV pointer and store that in the hash. This
+ * cast the tagnum to an SV pointer and store that in the hash. This
* means that we must clean up the hash manually afterwards, but gives
* us a 15% throughput increase.
*
TRACEME(("class name: %s", class));
/*
- * Decode user-frozen string length and read it in a SV.
+ * Decode user-frozen string length and read it in an SV.
*
* For efficiency reasons, we read data directly into the SV buffer.
* To understand that code, read retrieve_scalar()
=item T_HVREF
From the perl level this is a reference to a perl hash.
-From the C level this is a pointer to a HV.
+From the C level this is a pointer to an HV.
=cut
=item T_IV
A signed integer. This is cast to the required integer type when
-passed to C and converted to a IV when passed back to Perl.
+passed to C and converted to an IV when passed back to Perl.
=cut
=item share VARIABLE
-C<share> takes a value and marks it as shared, you can share an scalar, array, hash
+C<share> takes a value and marks it as shared, you can share a scalar, array, hash
scalar ref, array ref and hash ref, C<share> will return the shared value.
C<share> will traverse up references exactly I<one> level.
if(SvROK(value)) {
shared_sv* target = Perl_sharedsv_find(aTHX_ SvRV(value));
if(!target) {
- Perl_croak(aTHX_ "You cannot assign a non shared reference to an shared array");
+ Perl_croak(aTHX_ "You cannot assign a non shared reference to a shared array");
}
value = newRV_noinc(newSViv(PTR2IV(target)));
}
if(SvROK(tmp)) {
shared_sv* target = Perl_sharedsv_find(aTHX_ SvRV(tmp));
if(!target) {
- Perl_croak(aTHX_ "You cannot assign a non shared reference to an shared array");
+ Perl_croak(aTHX_ "You cannot assign a non shared reference to a shared array");
}
tmp = newRV_noinc(newSViv(PTR2IV(target)));
}
if(SvROK(tmp)) {
shared_sv* target = Perl_sharedsv_find(aTHX_ SvRV(tmp));
if(!target) {
- Perl_croak(aTHX_ "You cannot assign a non shared reference to an shared array");
+ Perl_croak(aTHX_ "You cannot assign a non shared reference to a shared array");
}
tmp = newRV_noinc(newSViv(PTR2IV(target)));
}
# The gross features should work with versions going back to 2.nil but
# some tweaking will probably be necessary.
#
-# DGUX is a SVR4 derivative. It ships with gcc as the standard
+# DGUX is an SVR4 derivative. It ships with gcc as the standard
# compiler. Since version 3.0 it has shipped with Perl 4.036
# installed in /usr/bin, which is kind of neat. Be careful when you
# install that you don't overwrite the system version, though (by
Returns the SV which corresponds to the specified key in the hash. The
C<klen> is the length of the key. If C<lval> is set then the fetch will be
part of a store. Check that the return value is non-null before
-dereferencing it to a C<SV*>.
+dereferencing it to an C<SV*>.
See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
information on how to use this function on tied hashes.
return 0;
}
-/* returns a HE * structure with the all fields set */
+/* returns an HE * structure with the all fields set */
/* note that hent_val will be a mortal sv for MAGICAL hashes */
/*
=for apidoc hv_fetch_ent
/*
=for apidoc AmU||HEf_SVKEY
This flag, used in the length slot of hash entries and magic structures,
-specifies the structure contains a C<SV*> pointer where a C<char*> pointer
+specifies the structure contains an C<SV*> pointer where a C<char*> pointer
is to be expected. (For information only--not to be used).
=for apidoc AmU||Nullhv
*/
/* these hash entry flags ride on hent_klen (for use only in magic/tied HVs) */
-#define HEf_SVKEY -2 /* hent_key is a SV* */
+#define HEf_SVKEY -2 /* hent_key is an SV* */
#define Nullhv Null(HV*)
"in phase $phase\n";
}
-This creates an handler for the attribute C<:Loud> in the class LoudDecl.
+This creates a handler for the attribute C<:Loud> in the class LoudDecl.
Thereafter, any subroutine declared with a C<:Loud> attribute in the class
LoudDecl:
the handler get in the way.
You can turn off that eagerness-to-help by declaring
-an attribute handler with the the keyword C<RAWDATA>. For example:
+an attribute handler with the keyword C<RAWDATA>. For example:
sub Raw : ATTR(RAWDATA) {...}
sub Nekkid : ATTR(SCALAR,RAWDATA) {...}
True, so don't scrub this directory.
################################################################
## Name
-Without the the timestamp check make sure that nothing happens
+Without the timestamp check make sure that nothing happens
## Extra
0, 1, 1
## Require
True, so don't scrub this directory.
################################################################
## Name
-With the the timestamp check make sure that things happen (stuff gets deleted)
+With the timestamp check make sure that things happen (stuff gets deleted)
## Extra
0, 1, 0
## Get
session cookies.
The B<-nph> parameter, if set to a true value, will issue the correct
-headers to work with a NPH (no-parse-header) script. This is important
+headers to work with an NPH (no-parse-header) script. This is important
to use with certain servers that expect all their scripts to be NPH.
The B<-charset> parameter can be used to control the character set
-nph=>1);
The B<-nph> parameter, if set to a true value, will issue the correct
-headers to work with a NPH (no-parse-header) script. This is important
+headers to work with an NPH (no-parse-header) script. This is important
to use with certain servers, such as Microsoft Internet Explorer, which
expect all their scripts to be NPH.
<IMG ALIGN="LEFT" SRC="fred.gif">
Sometimes an HTML tag attribute has no argument. For example, ordered
-lists can be marked as COMPACT. The syntax for this is an argument that
+lists can be marked as COMPACT. The syntax for this is an argument
that points to an undef string:
print ol({compact=>undef},li('one'),li('two'),li('three'));
Prior to CGI.pm version 2.41, providing an empty ('') string as an
attribute argument was the same as providing undef. However, this has
-changed in order to accommodate those who want to create tags of the form
+changed in order to accommodate those who want to create tags of the form
<IMG ALT="">. The difference is shown in these two pieces of code:
CODE RESULT
# no-op
}
-# If ENV{FCGI_SOCKET_PATH} is specified, we maintain a FCGI Request handle
+# If ENV{FCGI_SOCKET_PATH} is specified, we maintain an FCGI Request handle
# in this package variable.
use vars qw($Ext_Request);
BEGIN {
=item FCGI_SOCKET_PATH
The address (TCP/IP) or path (UNIX Domain) of the socket the external FastCGI
-script to which bind an listen for incoming connections from the web server.
+script to which bind can listen for incoming connections from the web server.
=item FCGI_LISTEN_QUEUE
# compare it use utility for compare
# print it do nothing
- # Alt2 maintain it as what is is
+ # Alt2 maintain it as what it is
# read index files convert
# compare it use utility because there's still a ">" vs "gt" issue
# print it use CPAN::Version for print
Changes to the directory where the distribution has been unpacked and
runs the external command C<make install> there. If C<make> has not
yet been run, it will be run first. A C<make test> will be issued in
-any case and if this fails, the install will be cancelled. The
+any case and if this fails, the install will be canceled. The
cancellation can be avoided by letting C<force> run the C<install> for
you.
=item CPAN::Module::description()
-Returns a 44 chracter description of this module. Only available for
+Returns a 44 character description of this module. Only available for
modules listed in The Module List (CPAN/modules/00modlist.long.html
or 00modlist.long.txt.gz)
=item CPAN::Module::look()
-Changes to the directory where the distribution assoicated with this
+Changes to the directory where the distribution associated with this
module has been unpacked and opens a subshell there. Exiting the
subshell returns.
"file:" URLs, then you only need a perl better than perl5.003 to run
this module. Otherwise Net::FTP is strongly recommended. LWP may be
required for non-UNIX systems or if your nearest CPAN site is
-associated with an URL that is not C<ftp:>.
+associated with a URL that is not C<ftp:>.
If you have neither Net::FTP nor LWP, there is a fallback mechanism
implemented for an external ftp command or for an external lynx
Most functions in package CPAN are exported per default. The reason
for this is that the primary use is intended for the cpan shell or for
-oneliners.
+one-liners.
=head1 POPULATE AN INSTALLATION WITH LOTS OF MODULES
outside world you must do it via the web server. If you set environment
variables like http_proxy or ftp_proxy to a values beginning with http://
or in your web browser you have to set proxy information then you know
-you are running a http firewall.
+you are running an http firewall.
To access servers outside these types of firewalls with perl (even for
ftp) you will need to use LWP.
=item ftp firewall
-This where the firewall machine runs a ftp server. This kind of
+This where the firewall machine runs an ftp server. This kind of
firewall will only let you access ftp servers outside the firewall.
This is usually done by connecting to the firewall with ftp, then
entering a username like "user@outside.host.com"
=item One way visibility
-I say one way visibility as these firewalls try to make themselve look
+I say one way visibility as these firewalls try to make themselves look
invisible to the users inside the firewall. An FTP data connection is
normally created by sending the remote server your IP address and then
listening for the connection. But the remote server will not be able to
o conf ncftp "/usr/bin/ncftp -f /home/scott/ncftplogin.cfg"
-Your milage may vary...
+Your mileage may vary...
=head1 FAQ
algorithm names which contains letters which are not legal perl
identifiers, e.g. "SHA-1".
-If new() is called as a instance method (i.e. $ctx->new) it will just
+If new() is called as an instance method (i.e. $ctx->new) it will just
reset the state the object to the state of a newly created object. No
new object is created in this case, and the return value is the
reference to the object (i.e. $ctx).
pointer and length) then I<VALUE> should be a reference to an array of
values in the order expected by the type. C<C_constant> will always call
this function with I<MACRO> defined, defaulting to the constant's name.
-I<DEFAULT> if defined is an array reference giving default type and and
+I<DEFAULT> if defined is an array reference giving default type and
value(s) if the clause generated by I<MACRO> doesn't evaluate to true.
The two pairs I<PRE> and I<POST> if defined give C code snippets to proceed
and follow the value, and the default value.
the number of parameters passed to the C function C<constant>]
You can call the perl visible subroutine something other than C<constant> if
-you give the parameter I<SUBNAME>. The C subroutine it calls defaults to the
+you give the parameter I<SUBNAME>. The C subroutine it calls defaults to
the name of the perl visible subroutine, unless you give the parameter
I<C_SUBNAME>.
WriteMakefileSnippet ATTRIBUTE =E<gt> VALUE [, ...]
-An function to generate perl code for Makefile.PL that will regenerate
+A function to generate perl code for Makefile.PL that will regenerate
the constant subroutines. Parameters are named as passed to C<WriteConstants>,
with the addition of C<INDENT> to specify the number of leading spaces
(default 2).
$self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
# The user who requests an installation directory explicitly
- # should not have to tell us a architecture installation directory
+ # should not have to tell us an architecture installation directory
# as well. We look if a directory exists that is named after the
# architecture. If not we take it as a sign that it should be the
# same as the requested installation directory. Otherwise we take
# Split directory into components - assume no file
my ($volume, $directories, undef) = File::Spec->splitpath( $path, 1);
- # Slightly less efficient than having a a function in File::Spec
+ # Slightly less efficient than having a function in File::Spec
# to chop off the end of a directory or even a function that
# can handle ../ in a directory tree
# Sometimes splitdir() returns a blank at the end
Getopt::Long supports two useful variants of simple options:
I<negatable> options and I<incremental> options.
-A negatable option is specified with a exclamation mark C<!> after the
+A negatable option is specified with an exclamation mark C<!> after the
option name:
my $verbose = ''; # option variable with default value (false)
You can redistribute and/or
modify this document under the same terms as Perl itself.
-This document is provided in the the hope that it will be
+This document is provided in the hope that it will be
useful, but without any warranty;
without even the implied warranty of accuracy, authoritativeness,
completeness, merchantability, or fitness for a particular purpose.
my $lh = ThisProject::I18N->get_handle();
# For the moment, assume that things are set up so
# that we load class ThisProject::I18N::en
- # and that that's the class that $lh belongs to.
+ # and that's the class that $lh belongs to.
...
if(-e $filename) {
go_process_file($filename)
Your query matched 10 files in 4 directories.
-So how hard could that be? You look at the code that produces
+So how hard could that be? You look at the code that
produces the first item, and it reads:
printf("I scanned %g directories.",
with I<all other> integer values, since "directory" is an inanimate
noun, when preceded by a number and in the nominative or accusative
cases (as it is here, just your luck!), it does stay plural, but it is
-forced into the genitive case -- yet another another ending... And
+forced into the genitive case -- yet another ending... And
you never hear him get to the part about how you're going to run into
similar (but maybe subtly different) problems with other Slavic
languages like Polish, because the floor comes up to meet you, and you
A I<new> operation possible on a complex number that is
the identity for real numbers is called the I<conjugate>, and is noted
-with an horizontal bar above the number, or C<~z> here.
+with a horizontal bar above the number, or C<~z> here.
z = a + bi
~z = a - bi
I<coth>, I<acosech>, I<acotanh>, have aliases I<rho>, I<theta>, I<ln>,
I<cosec>, I<cotan>, I<acosec>, I<acotan>, I<cosech>, I<cotanh>,
I<acosech>, I<acotanh>, respectively. C<Re>, C<Im>, C<arg>, C<abs>,
-C<rho>, and C<theta> can be used also also mutators. The C<cbrt>
+C<rho>, and C<theta> can be used also as mutators. The C<cbrt>
returns only one of the solutions: if you want all three, use the
C<root> function.
Died at...
For the C<csc>, C<cot>, C<asec>, C<acsc>, C<acot>, C<csch>, C<coth>,
-C<asech>, C<acsch>, the argument cannot be C<0> (zero). For the the
+C<asech>, C<acsch>, the argument cannot be C<0> (zero). For the
logarithmic functions and the C<atanh>, C<acoth>, the argument cannot
be C<1> (one). For the C<atanh>, C<acoth>, the argument cannot be
C<-1> (minus one). For the C<atan>, C<acot>, the argument cannot be
certain day. Memoize will look at the clock and see 12:00:00. Then
9.01 seconds later, at 12:00:10.008 you try to read it back. Memoize
will look at the clock and see 12:00:10 and conclude that the value
-has expired. This will probably not occur if if you have
+has expired. This will probably not occur if you have
C<Time::HiRes> installed.
=head1 AUTHOR
the current class -- to look for a suitable method in other
ancestors of C<$self> -- whereas C<$self->SUPER::m()> cannot.
- An particularly interesting use of redispatch is in
+ A particularly interesting use of redispatch is in
C<AUTOLOAD>'ed methods. If such a method determines that it is
not able to handle a particular call, it may choose to
redispatch that call, in the hope that some other C<AUTOLOAD>
# your internet domain
inet_domain => undef,
- # If you have an ftp proxy firewall (not a http firewall)
+ # If you have an ftp proxy firewall (not an http firewall)
# then set this to the name of the firewall
ftp_firewall => undef,
=item ftp_firewall
-If you have an FTP proxy firewall (B<NOT> a HTTP or SOCKS firewall)
+If you have an FTP proxy firewall (B<NOT> an HTTP or SOCKS firewall)
then this value should be set to the firewall hostname. If your firewall
does not listen to port 21, then this value should be set to
C<"hostname:port"> (eg C<"hostname:99">)
=item new (HOST [,OPTIONS])
This is the constructor for a new Net::FTP object. C<HOST> is the
-name of the remote host to which a FTP connection is required.
+name of the remote host to which an FTP connection is required.
C<OPTIONS> are passed in a hash like fashion, using key and value pairs.
Possible options are:
-B<Firewall> - The name of a machine which acts as a FTP firewall. This can be
+B<Firewall> - The name of a machine which acts as an FTP firewall. This can be
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
-as a ftp proxy.
+as an ftp proxy.
B<FirewallType> - The type of firewall running on the machine indicated by
B<Firewall>. This can be overridden by an environment variable
=item get ( REMOTE_FILE [, LOCAL_FILE [, WHERE]] )
Get C<REMOTE_FILE> from the server and store locally. C<LOCAL_FILE> may be
-a filename or a filehandle. If not specified the the file will be stored in
+a filename or a filehandle. If not specified, the file will be stored in
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
=item nlst ( [ DIR ] )
-Send a C<NLST> command to the server, with an optional parameter.
+Send an C<NLST> command to the server, with an optional parameter.
=item list ( [ DIR ] )
=item port ( [ PORT ] )
Send a C<PORT> command to the server. If C<PORT> is specified then it is sent
-to the server. If not the a listen socket is created and the correct information
+to the server. If not, the a listen socket is created and the correct information
sent to the server.
=item pasv ()
Read C<SIZE> bytes of data from the server and place it into C<BUFFER>, also
performing any <CRLF> translation necessary. C<TIMEOUT> is optional, if not
-given the the timeout value from the command connection will be used.
+given, the timeout value from the command connection will be used.
Returns the number of bytes read before any <CRLF> translation.
Write C<SIZE> bytes of data from C<BUFFER> to the server, also
performing any <CRLF> translation necessary. C<TIMEOUT> is optional, if not
-given the the timeout value from the command connection will be used.
+given, the timeout value from the command connection will be used.
Returns the number of bytes written before any <CRLF> translation.
bracket.
The final operation uses the backslash character to
-invalidate the special meaning of the a open square bracket C<[>,
+invalidate the special meaning of an open square bracket C<[>,
the asterisk, backslash or the question mark. Two backslashes in
sequence will result in the evaluation of the backslash as a
character with no special meaning.
=item login ( [ USER [, PASS ]] )
-Send both the
the USER and PASS commands. If C<PASS> is not given the
+Send both the USER and PASS commands. If C<PASS> is not given the
C<Net::POP3> uses C<Net::Netrc> to lookup the password using the host
and username. If the username is not specified then the current user name
will be used.
Normally when perl Makefile.PL is run it will run Configure which will
ask some questions about your system. The results of these questions
-will be stored in in a file called libnet.cfg which will be installed
+will be stored in a file called libnet.cfg which will be installed
alongside the other perl modules in this distribution. The Makefile.PL
will run Configure in an interactive mode unless these exists a file
called libnet.cfg in the build directory.
=item new Net::SMTP [ HOST, ] [ OPTIONS ]
This is the constructor for a new Net::SMTP object. C<HOST> is the
-name of the remote host to which a SMTP connection is required.
+name of the remote host to which an SMTP connection is required.
If C<HOST> is not given, then the C<SMTP_Host> specified in C<Net::Config>
will be used.
=head2 Where to get this document
-This document is distributed with the libnet disribution, and is also
-avaliable on the libnet web page at
+This document is distributed with the libnet distribution, and is also
+available on the libnet web page at
http://www.pobox.com/~gbarr/libnet/
Copyright (c) 1997-1998 Graham Barr. All rights reserved.
This document is free; you can redistribute it and/or modify it
-under the terms of the Artistic Licence.
+under the terms of the Artistic License.
=head2 Disclaimer
=head2 What is libnet ?
libnet is a collection of perl5 modules which all related to network
-programming. The majority of the modules avaliable provided the
+programming. The majority of the modules available provided the
client side of popular server-client protocols that are used in
the internet community.
=head2 What machines support libnet ?
-libnet itself is an entirly perl-code distribution so it should work
+libnet itself is an entirely perl-code distribution so it should work
on any machine that perl runs on. However IO may not work
with some machines and earlier releases of perl. But this
should not be the case with perl version 5.004 or later.
http://www.cpan.org/modules/by-module/Net/
-The latest release and information is also avaliable on the libnet web page
+The latest release and information is also available on the libnet web page
at
http://www.pobox.com/~gbarr/libnet/
=head1 Using Net::FTP
-=head2 How do I download files from a FTP server ?
+=head2 How do I download files from an FTP server ?
An example taken from an article posted to comp.lang.perl.misc
=head2 Can I do a reget operation like the ftp command ?
-=head2 How do I get a directory listing from a FTP server ?
+=head2 How do I get a directory listing from an FTP server ?
-=head2 Changeing directory to "" does not fail ?
+=head2 Changing directory to "" does not fail ?
Passing an argument of "" to ->cwd() has the same affect of calling ->cwd()
without any arguments. Turn on Debug (I<See below>) and you will see what is
=head2 I am behind a SOCKS firewall, but the Firewall option does not work ?
The Firewall option is only for support of one type of firewall. The type
-supported is a ftp proxy.
+supported is an ftp proxy.
To use Net::FTP, or any other module in the libnet distribution,
through a SOCKS firewall you must create a socks-ified perl executable
by compiling perl with the socks library.
-=head2 I am behind a FTP proxy firewall, but cannot access machines outside ?
+=head2 I am behind an FTP proxy firewall, but cannot access machines outside ?
-Net::FTP implements the most popular ftp proxy firewall approach. The sceme
-implemented is that where you loginin to the firewall with C<user@hostname>
+Net::FTP implements the most popular ftp proxy firewall approach. The scheme
+implemented is that where you log in to the firewall with C<user@hostname>
I have heard of one other type of firewall which requires a login to the
-firewall with an accont, then a second login with C<user@hostname>. You can
+firewall with an account, then a second login with C<user@hostname>. You can
still use Net::FTP to traverse these firewalls, but a more manual approach
must be taken, eg
=head2 My ftp proxy firewall does not listen on port 21
FTP servers usually listen on the same port number, port 21, as any other
-FTP server. But there is no reason why thi has to be the case.
+FTP server. But there is no reason why this has to be the case.
If you pass a port number to Net::FTP then it assumes this is the port
number of the final destination. By default Net::FTP will always try
=head2 I have seen scripts call a method message, but cannot find it documented ?
Net::FTP, like several other packages in libnet, inherits from Net::Cmd, so
-all the methods described in Net::Cmd are also avaliable on Net::FTP
+all the methods described in Net::Cmd are also available on Net::FTP
objects.
=head2 Why does Net::FTP not implement mput and mget methods
=head2 The verify method always returns true ?
-Well it may seem thay way, but it does not. The verify method returns true
-if the command suceeded. If you pass verify an address which the
-server would normally have to forward to another machine the the command
-will suceed with something like
+Well it may seem that way, but it does not. The verify method returns true
+if the command succeeded. If you pass verify an address which the
+server would normally have to forward to another machine, the command
+will succeed with something like
252 Couldn't verify <someone@there> but will attempt delivery anyway
-This command will only fail if you pass it an address in a domain the
+This command will fail only if you pass it an address in a domain
the server directly delivers for, and that address does not exist.
=head1 Debugging scripts
constructor, in most cases one option is called C<Debug>. Passing
this option with a non-zero value will turn on a protocol trace, which
will be sent to STDERR. This trace can be useful to see what commands
-are being sent to the remote server and what responces are being
+are being sent to the remote server and what responses are being
received back.
#!/your/path/to/perl
Net::FTP=GLOB(0x8152974)>>> QUIT
Net::FTP=GLOB(0x8152974)<<< 221 Goodbye.
-The first few lines tell you the modules that Net::FTP uses and thier versions,
-this is usefule data to me when a user reports a bug. The last seven lines
+The first few lines tell you the modules that Net::FTP uses and their versions,
+this is useful data to me when a user reports a bug. The last seven lines
show the communication with the server. Each line has three parts. The first
part is the object itself, this is useful for separating the output
-if you are using mutiple objects. The second part is either C<<<<<> to
+if you are using multiple objects. The second part is either C<<<<<> to
show data coming from the server or C<>>>>> to show data
going to the server. The remainder of the line is the command
-being sent or responce being received.
+being sent or response being received.
=head1 AUTHOR AND COPYRIGHT
=item C<$checker-E<gt>hyperlink()>
Add (if argument specified) and retrieve the hyperlinks (as defined by
-C<LE<lt>E<gt>>) of the current POD. They consist of an 2-item array: line
+C<LE<lt>E<gt>>) of the current POD. They consist of a 2-item array: line
number and C<Pod::Hyperlink> object.
=back
}
#
-# process_pod - process a pod pod tag, thus stop ignoring pod directives
+# process_pod - process a pod tag, thus stop ignoring pod directives
# until we see a corresponding cut.
#
sub process_pod {
warn "$0: $podfile: cannot resolve L<$opar> in paragraph $paragraph.";
}
- # now we have an URL or just plain code
+ # now we have a URL or just plain code
$$rstr = $linktext . '>' . $$rstr;
if( defined( $url ) ){
$res = "<A HREF=\"$url\">" . process_text1( $lev, $rstr ) . '</A>';
}
#
-# page_sect - make an URL from the text of a L<>
+# page_sect - make a URL from the text of a L<>
#
sub page_sect($$) {
my( $page, $section ) = @_;
to the beginning of the interior sequence. If the C<$ptree> argument is
given, it must be the last argument, and it must be either string, or
else an array-ref suitable for passing to B<Pod::ParseTree::new> (or
-it may be a reference to an Pod::ParseTree object).
+it may be a reference to a Pod::ParseTree object).
=cut
\end{document}
-but can be more complicated if a index is required.
+but can be more complicated if an index is required.
Can be used to set or retrieve the current value.
$add = $parser->AddPostamble();
=item release
Set the centered footer. By default, this is the version of Perl you run
-Pod::Man under. Note that some system an macro sets assume that the
+Pod::Man under. Note that some system macro sets assume that the
centered footer will be a modification date and will prepend something like
"Last modified: "; if this is the case, you may want to set C<release> to
the last modified date and C<date> to the version number.
A I<parse-option> is simply a named option of B<Pod::Parser> with a
value that corresponds to a certain specified behavior. These various
-behaviors of B<Pod::Parser> may be enabled/disabled by setting or
+behaviors of B<Pod::Parser> may be enabled/disabled by setting
or unsetting one or more I<parse-options> using the B<parseopts()> method.
The set of currently accepted parse-options is as follows:
This method is useful if you need to perform your own interpolation
of interior sequences and can't rely upon B<interpolate> to expand
-them in simple bottom-up order order.
+them in simple bottom-up order.
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
tree-based approach. Rather than doing everything in one pass and
calling the B<interpolate()> method to expand sequences into text, it
may be desirable to instead create a parse-tree using the B<parse_text()>
-method to return a tree-like structure which may contain an ordered list
+method to return a tree-like structure which may contain an ordered
list of children (each of which may be a text-string, or a similar
tree-like structure).
commands, and I<text-expr> is intended to match the paragraph text for
the command. If a range-regex is supposed to match a POD command, then
the first character of the regex (the one after the initial '/')
-absolutely I<must> be an single '=' character; it may not be anything
+absolutely I<must> be a single '=' character; it may not be anything
else (not even a regex meta-character) if it is supposed to match
against the name of a POD command.
=head2 Test the manual
Simplest way to build up a decent testing suite is to just test what
-the manual says it does. [3] Let's pull something out of of the
+the manual says it does. [3] Let's pull something out of the
Date::ICal SYNOPSIS and test that all it's bits work.
#!/usr/bin/perl -w
is also not specified, the set C</["'`]/> is used. If the text to be processed
is not specified either, C<$_> is used.
-In list context, C<extract_delimited> returns a array of three
+In list context, C<extract_delimited> returns an array of three
elements, the extracted substring (I<including the surrounding
delimiters>), the remainder of the text, and the skipped prefix (if
any). If a suitable delimited substring is not found, the first
If the string is "PARA", C<extract_tagged> returns only the first paragraph
after the tag (up to the first line that is either empty or contains
only whitespace characters).
-If the string is "", the the default behaviour (i.e. failure) is reinstated.
+If the string is "", the default behaviour (i.e. failure) is reinstated.
For example, suppose the start tag "/para" introduces a paragraph, which then
continues until the next "/endpara" tag or until another "/para" tag is
=item [7]
the left delimiter of the second block of the operation
-(that is, if it is a C<s>, C<tr>, or C<y>),
+(that is, if it is an C<s>, C<tr>, or C<y>),
=item [8]
which would cause the earlier " || die;\nexit;" to be skipped in any
sequence of code fragment extractions.
-To avoid this problem, when it encounters a here document whilst
+To avoid this problem, when it encounters a here document while
extracting from a modifiable string, C<extract_quotelike> silently
rearranges the string to an equivalent piece of Perl:
Omitting the fourth argument (outermost delimiter brackets) indicates that the
value of the second argument is to be used for the outermost delimiters.
-Once the prefix an dthe outermost opening delimiter bracket have been
+Once the prefix an the outermost opening delimiter bracket have been
recognized, code blocks are extracted by stepping through the input text and
trying the following alternatives in sequence:
C<extract_multiple> starts at the current C<pos> of the string, and
sets that C<pos> appropriately after it matches.
-Hence, the aim of of a call to C<extract_multiple> in a list context
+Hence, the aim of a call to C<extract_multiple> in a list context
is to split the processed string into as many non-overlapping fields as
possible, by repeatedly applying each of the specified extractors
to the remainder of the string. Thus C<extract_multiple> is
=item 3.
-An number specifying the maximum number of fields to return. If this
+A number specifying the maximum number of fields to return. If this
argument is omitted (or C<undef>), split continues as long as possible.
If the third argument is I<N>, then extraction continues until I<N> fields
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:
If no match is found, a reference to an empty hash is returned.
-The C<block> property is the same as as returned by charinfo(). It is
+The C<block> property is the same as returned by charinfo(). It is
not defined in the Unicode Character Database proper (Chapter 4 of the
Unicode 3.0 Standard, aka TUS3) but instead in an auxiliary database
(Chapter 14 of TUS3). Similarly for the C<script> property.
# '+0' canonical zero value
# ' -123 123 123' canonical value '-123123123'
# '1 23 456 7890' canonical value '+1234567890'
-# Output values always always in canonical form
+# Output values always in canonical form
#
# Actual math is done in an internal format consisting of an array
# whose first element is the sign (/^[+-]$/) and whose remaining
# &ftp'dir( remote LIST options )
# Start a list goin with the given options.
# Presuming that the remote deamon uses the ls command to generate the
-# data to send back then then you can send it some extra options (eg: -lRa)
+# data to send back then you can send it some extra options (eg: -lRa)
# return 1 if sucessful and 0 on a failure
sub ftp'dir_open
{
=back
-B<Warning.> Due to the presense of assignment versions of operations,
+B<Warning.> Due to the presence of assignment versions of operations,
routines which may be called in assignment context may create
self-referential structures. Currently Perl will not free self-referential
structures until cycles are C<explicitly> broken. You may get problems
On the other hand, anyone who has used algebraic notation knows the
expressive power of the arithmetic metaphor. Overloading works hard
to enable this metaphor while preserving the Perlian way as far as
-possible. Since it is not not possible to freely mix two contradicting
+possible. Since it is not possible to freely mix two contradicting
metaphors, overloading allows the arithmetic way to write things I<as
far as all the mutators are called via overloaded access only>. The
way it is done is described in L<Copy Constructor>.
Second, we create a new tied hash each time the hash syntax is used.
This allows us not to worry about a possibility of a reference loop,
-would would lead to a memory leak.
+which would lead to a memory leak.
Both these problems can be cured. Say, if we want to overload hash
dereference on a reference to an object which is I<implemented> as a
and one can inspect the value in debugger using all the possible
methods.
-Something is is still amiss: consider the loop variable $cnt of the
+Something is still amiss: consider the loop variable $cnt of the
script. It was a number, not an object. We cannot make this value of
type C<symbolic>, since then the loop will not terminate.
# I<CreateTTY> bits control attempts to create a new TTY on events:
# 1: on fork() 2: debugger is started inside debugger
# 4: on startup
-# c) Code to auto-create a new TTY window on OS/2 (currently one one
+# c) Code to auto-create a new TTY window on OS/2 (currently one
# extra window per session - need named pipes to have more...);
# d) Simplified interface for custom createTTY functions (with a backward
# compatibility hack); now returns the TTY name to use; return of ''
<li>Corrected error in canonical decomposition for U+1FF4.</li>
<li>Added compatibility decompositions to clarify collation tables. (U+2100,
U+2101, U+2105, U+2106, U+1E9A)</li>
- <li>A series of general category changes to assist the convergence of of
+ <li>A series of general category changes to assist the convergence of
Unicode definition of identifier with ISO TR 10176:
<ul>
<li>So > Lo: U+0950, U+0AD0, U+0F00, U+0F88..U+0F8B</li>
/*
* Strong denial of stdio - make all stdio calls (we can think of) errors
*/
-/* This is an 1st attempt to stop other include files pulling
+/* This is a 1st attempt to stop other include files pulling
in real <stdio.h>.
A more ambitious set of possible symbols can be found in
sfio.h (inside an _cplusplus gard).
and writes the value to I<*result> (or the value is discarded if I<result>
is NULL).
-The hex number may optinally be prefixed with "0b" or "b" unless
+The hex number may optionally be prefixed with "0b" or "b" unless
C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the binary
number may use '_' characters to separate digits.
}
value_nv *= 2.0;
/* If an NV has not enough bits in its mantissa to
- * represent an UV this summing of small low-order numbers
+ * represent a UV this summing of small low-order numbers
* is a waste of time (because the NV cannot preserve
* the low-order bits anyway): we could just remember when
* did we overflow and in the end just multiply value_nv by the
and writes the value to I<*result> (or the value is discarded if I<result>
is NULL).
-The hex number may optinally be prefixed with "0x" or "x" unless
+The hex number may optionally be prefixed with "0x" or "x" unless
C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the hex
number may use '_' characters to separate digits.
}
value_nv *= 16.0;
/* If an NV has not enough bits in its mantissa to
- * represent an UV this summing of small low-order numbers
+ * represent a UV this summing of small low-order numbers
* is a waste of time (because the NV cannot preserve
* the low-order bits anyway): we could just remember when
* did we overflow and in the end just multiply value_nv by the
}
value_nv *= 8.0;
/* If an NV has not enough bits in its mantissa to
- * represent an UV this summing of small low-order numbers
+ * represent a UV this summing of small low-order numbers
* is a waste of time (because the NV cannot preserve
* the low-order bits anyway): we could just remember when
* did we overflow and in the end just multiply value_nv by the
#endif /* DEBUGGING */
-/* These constants should be used in preference to to raw characters
+/* These constants should be used in preference to raw characters
* when using magic. Note that some perl guts still assume
* certain character properties of these constants, namely that
* isUPPER() and toLOWER() may do useful mappings.
int code;
b->ptr++; /* say we have read it as far as
* flush() is concerned */
- b->buf++; /* Leave space an front of buffer */
+ b->buf++; /* Leave space in front of buffer */
b->bufsiz--; /* Buffer is thus smaller */
code = PerlIO_fill(f); /* Fetch some more */
b->bufsiz++; /* Restore size for next time */
and writes the value to I<*result> (or the value is discarded if I<result>
is NULL).
-The hex number may optinally be prefixed with "0b" or "b" unless
+The hex number may optionally be prefixed with "0b" or "b" unless
C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the binary
number may use '_' characters to separate digits.
and writes the value to I<*result> (or the value is discarded if I<result>
is NULL).
-The hex number may optinally be prefixed with "0x" or "x" unless
+The hex number may optionally be prefixed with "0x" or "x" unless
C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the hex
number may use '_' characters to separate digits.
=item SvIVx
Coerces the given SV to an integer and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvIV> otherwise.
+sv only once. Use the more efficient C<SvIV> otherwise.
IV SvIVx(SV* sv)
=item SvNVx
Coerces the given SV to a double and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvNV> otherwise.
+sv only once. Use the more efficient C<SvNV> otherwise.
NV SvNVx(SV* sv)
=item SvPVbytex
Like C<SvPV>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
otherwise.
=item SvPVbytex_force
Like C<SvPV_force>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
otherwise.
char* SvPVbytex_force(SV* sv, STRLEN len)
=item SvPVutf8x
Like C<SvPV>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
otherwise.
char* SvPVutf8x(SV* sv, STRLEN len)
=item SvPVutf8x_force
Like C<SvPV_force>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
otherwise.
char* SvPVutf8x_force(SV* sv, STRLEN len)
=item SvUVx
Coerces the given SV to an unsigned integer and returns it. Guarantees to
-evaluate sv only once. Use the more efficent C<SvUV> otherwise.
+evaluate sv only once. Use the more efficient C<SvUV> otherwise.
UV SvUVx(SV* sv)
and loaded by SWASHGET, using lib/utf8_heavy.pl.
The "special" is a string like "utf8::ToSpecLower", which means
-the hash %utf8::ToSpecLower, which is stored in in the same file,
+the hash %utf8::ToSpecLower, which is stored in the same file,
lib/unicore/To/Lower.pl, and also loaded by SWASHGET. The access
to the hash is by Perl_to_utf8_case().
run. Since version 5.005, Perl has shipped with a module
capable of inspecting the optimized parse tree (C<B>), and this has
been used to write many useful utilities, including a module that lets
-you turn your Perl into C source code that can be compiled into an
+you turn your Perl into C source code that can be compiled into a
native executable.
The C<B> module provides access to the parse tree, and other modules
4 12 24 48 80
With non-C<DEBUGGING> perl, the buckets starting from C<128> have
-a 4-byte overhead, and thus a 8192-long bucket may take up to
+a 4-byte overhead, and thus an 8192-long bucket may take up to
8188-byte allocations.
=item C<Total sbrk(): SBRKed/SBRKs:CONTINUOUS>
=item Can't exec "%s": %s
-(W exec) An system(), exec(), or piped open call could not execute the
+(W exec) A system(), exec(), or piped open call could not execute the
named program for the indicated reason. Typical reasons include: the
permissions were wrong on the file, the file wasn't found in
C<$ENV{PATH}>, the executable in question was compiled for another
=item Illegal octal digit %s
-(F) You used an 8 or 9 in a octal number.
+(F) You used an 8 or 9 in an octal number.
=item Illegal octal digit %s ignored
-(W digit) You may have tried to use an 8 or 9 in a octal number.
+(W digit) You may have tried to use an 8 or 9 in an octal number.
Interpretation of the octal number stopped before the 8 or 9.
=item Illegal switch in PERL5OPT: %s
=item lstat() on filehandle %s
-(W io) You tried to do a lstat on a filehandle. What did you mean
+(W io) You tried to do an lstat on a filehandle. What did you mean
by that? lstat() makes sense only on filenames. (Perl did a fstat()
instead on the filehandle.)
=item perlio: invalid separator character %s in attribute list
(S) When pushing layers onto the Perl I/O system, something other than a
-colon or whitespace was seen between the elements of an layer list.
+colon or whitespace was seen between the elements of a layer list.
If the previous attribute had a parenthesised parameter list, perhaps that
list was terminated too soon.
=item Substitution pattern not terminated
-(F) The lexer couldn't find the interior delimiter of a s/// or s{}{}
+(F) The lexer couldn't find the interior delimiter of an s/// or s{}{}
construct. Remember that bracketing delimiters count nesting level.
Missing the leading C<$> from variable C<$s> may cause this error.
=item Substitution replacement not terminated
-(F) The lexer couldn't find the final delimiter of a s/// or s{}{}
+(F) The lexer couldn't find the final delimiter of an s/// or s{}{}
construct. Remember that bracketing delimiters count nesting level.
Missing the leading C<$> from variable C<$s> may cause this error.
to develop and maintain--to put it mildly.
The 5.0 release of Perl let us have complex data structures. You
-may now write something like this and all of a sudden, you'd have a array
+may now write something like this and all of a sudden, you'd have an array
with three dimensions!
for $x (1 .. 10) {
How do you print it out? Why can't you say just C<print @AoA>? How do
you sort it? How can you pass it to a function or get one of these back
-from a function? Is is an object? Can you save it to disk to read
+from a function? Is it an object? Can you save it to disk to read
back later? How do you access whole rows or columns of that matrix? Do
all the values have to be numeric?
number, or a reference). They cannot directly contain other arrays or
hashes, but instead contain I<references> to other arrays or hashes.
-You can't use a reference to a array or hash in quite the same way that you
+You can't use a reference to an array or hash in quite the same way that you
would a real array or hash. For C or C++ programmers unused to
distinguishing between arrays and pointers to the same, this can be
confusing. If so, just think of it as the difference between a structure
=head1 ARRAYS OF ARRAYS
-=head2 Declaration of a ARRAY OF ARRAYS
+=head2 Declaration of an ARRAY OF ARRAYS
@AoA = (
[ "fred", "barney" ],
[ "homer", "marge", "bart" ],
);
-=head2 Generation of a ARRAY OF ARRAYS
+=head2 Generation of an ARRAY OF ARRAYS
# reading from file
while ( <> ) {
# add to an existing row
push @{ $AoA[0] }, "wilma", "betty";
-=head2 Access and Printing of a ARRAY OF ARRAYS
+=head2 Access and Printing of an ARRAY OF ARRAYS
# one element
$AoA[0][0] = "Fred";
=head1 ARRAYS OF HASHES
-=head2 Declaration of a ARRAY OF HASHES
+=head2 Declaration of an ARRAY OF HASHES
@AoH = (
{
}
);
-=head2 Generation of a ARRAY OF HASHES
+=head2 Generation of an ARRAY OF HASHES
# reading from file
# format: LEAD=fred FRIEND=barney
$AoH[0]{pet} = "dino";
$AoH[2]{pet} = "santa's little helper";
-=head2 Access and Printing of a ARRAY OF HASHES
+=head2 Access and Printing of an ARRAY OF HASHES
# one element
$AoH[0]{lead} = "fred";
% cc -o persistent persistent.c `perl -MExtUtils::Embed -e ccopts -e ldopts`
-Here's a example script file:
+Here's an example script file:
#test.pl
my $string = "hello";
The Perl parser will expand $variable and @variable references in
regular expressions unless the delimiter is a single quote. Remember,
-too, that the right-hand side of a C<s///> substitution is considered
+too, that the right-hand side of an C<s///> substitution is considered
a double-quoted string (see L<perlop> for more details). Remember
also that any regex special characters will be acted on unless you
precede the substitution with \Q. Here's an example:
Once you can identify individual blocks, try allowing them to be
nested. That isn't difficult either.
-Here is a interesting idea that doesn't involve the Debug filter.
+Here is an interesting idea that doesn't involve the Debug filter.
Currently Perl subroutines have fairly limited support for formal
parameter lists. You can specify the number of parameters and their
type, but you still have to manually take them out of the C<@_> array
operations. In general, they do what you want, unless you want
consistency.
-An named array in scalar context is quite different from what would at
+A named array in scalar context is quite different from what would at
first glance appear to be a list in scalar context. You can't get a list
like C<(1,2,3)> into being in scalar context, because the compiler knows
the context at compile time. It would generate the scalar comma operator
on your favorite CPAN mirror for a slew of potentially useful
modules.
-If using crypt() on an Unicode string (which potentially has
+If using crypt() on a Unicode string (which potentially has
characters with codepoints above 255), Perl tries to make sense of
the situation by using only the low eight bits of the characters when
calling crypt().
=item gmtime EXPR
-Converts a time as returned by the time function to a 8-element list
+Converts a time as returned by the time function to an 8-element list
with the time localized for the standard Greenwich time zone.
Typically used as follows:
=item lc
-Returns an lowercased version of EXPR. This is the internal function
+Returns a lowercased version of EXPR. This is the internal function
implementing the C<\L> escape in double-quoted strings. Respects
current LC_CTYPE locale if C<use locale> in force. See L<perllocale>
and L<perlunicode> for more details about locale and Unicode support.
is given, returns an empty list in list context, the undefined value in
scalar context, and (of course) nothing at all in a void context.
-(Note that in the absence of a explicit C<return>, a subroutine, eval,
+(Note that in the absence of an explicit C<return>, a subroutine, eval,
or do FILE will automatically return the value of the last expression
evaluated.)
/* Get the key from an HE structure and also return
the length of the key string */
SV* hv_iterval(HV*, HE* entry);
- /* Return a SV pointer to the value of the HE
+ /* Return an SV pointer to the value of the HE
structure */
SV* hv_iternextsv(HV*, char** key, I32* retlen);
/* This convenience routine combines hv_iternext,
=head2 Reference Counts and Mortality
-Perl uses an reference count-driven garbage collection mechanism. SVs,
+Perl uses a reference count-driven garbage collection mechanism. SVs,
AVs, or HVs (xV for short in the following) start their life with a
reference count of 1. If the reference count of an xV ever drops to 0,
then it will be destroyed and its memory made available for reuse.
=head2 Magic Virtual Tables
-The C<mg_virtual> field in the C<MAGIC> structure is a pointer to a
+The C<mg_virtual> field in the C<MAGIC> structure is a pointer to an
C<MGVTBL>, which is a structure of function pointers and stands for
"Magic Virtual Table" to handle the various operations that might be
applied to that variable.
=item C<SV* save_svref(SV **sptr)>
-Similar to C<save_scalar>, but will reinstate a C<SV *>.
+Similar to C<save_scalar>, but will reinstate an C<SV *>.
=item C<void save_aptr(AV **aptr)>
we're getting just a single value out of the array -- you ask for a scalar,
you get a scalar.
-To get multiple values from a array:
+To get multiple values from an array:
@animals[0,1]; # gives ("camel", "llama");
@animals[0..2]; # gives ("camel", "llama", "owl");
The PerlIO abstraction was introduced in perl5.003_02 but languished as
just an abstraction until perl5.7.0. However during that time a number
-of perl extentions switched to using it, so the API is mostly fixed to
+of perl extensions switched to using it, so the API is mostly fixed to
maintain (source) compatibility.
The aim of the implementation is to provide the PerlIO API in a flexible
IV flags; /* Various flags for state */
};
-A C<PerlIOl *> is a pointer to t
o the struct, and the I<application> level
+A C<PerlIOl *> is a pointer to the struct, and the I<application> level
C<PerlIO *> is a pointer to a C<PerlIOl *> - i.e. a pointer to a pointer to
the struct. This allows the application level C<PerlIO *> to remain
constant while the actual C<PerlIOl *> underneath changes. (Compare perl's
Extra layers can be inserted to process the data as it flows through.
This was the driving need for including the scheme in perl 5.7.0+ - we
-needed a mechanism to allow data to be translated bewteen perl's
+needed a mechanism to allow data to be translated between perl's
internal encoding (conceptually at least Unicode as UTF-8), and the
"native" format used by the system. This is provided by the
":encoding(xxxx)" layer which typically sits above the buffering layer.
=item PERLIO_F_ERROR
-An error has occured (for C<PerlIO_error()>)
+An error has occur
red (for C<PerlIO_error()>)
=item PERLIO_F_TRUNCATE
This instance of this layer supports the "fast C<gets>" interface.
Normally set based on C<PERLIO_K_FASTGETS> for the class and by the
-existance of the function(s) in the table. However a class that
+existence of the function(s) in the table. However a class that
normally provides that interface may need to avoid it on a
particular instance. The "pending" layer needs to do this when
-it is pushed above an layer which does not support the interface.
+it is pushed above a layer which does not support the interface.
(Perl's C<sv_gets()> does not expect the streams fast C<gets> behaviour
to change during one "get".)
=item IV (*Pushed)(PerlIO *f,const char *mode, SV *arg);
-The only absoultely mandatory method. Called when the layer is pushed onto the stack.
+The only absolutely mandatory method. Called when the layer is pushed onto the stack.
The C<mode> argument may be NULL if this occurs post-open. The C<arg> will be non-C<NULL>
if an argument string was passed. In most cases this should call
C<PerlIOBase_pushed()> to convert C<mode> into the appropriate
C<PerlIO_fdopen> calls; the C<'#'> prefix means that this is C<sysopen> and that I<imode> and
I<perm> should be passed to C<PerlLIO_open3>; C<'r'> means B<r>ead, C<'w'> means B<w>rite
and C<'a'> means B<a>ppend. The C<'+'> suffix means that both reading and writing/appending
-are permited. The C<'b'> suffix means file should be binary, and C<'t'> means it
+are permitted. The C<'b'> suffix means file should be binary, and C<'t'> means it
is text. (Binary/Text should be ignored by almost all layers and binary IO done,
with PerlIO. The C<:crlf> layer should be pushed to handle the distinction.)
-If I<old> is not C<NULL> then this is a C<PerlIO_reopen>. Perl iteself does not use
+If I<old> is not C<NULL> then this is a C<PerlIO_reopen>. Perl itself does not use
this (yet?) and semantics are a little vague.
If I<fd> not negative then it is the numeric file descriptor I<fd>, which will
-be open in an manner compatible with the supplied mode string, the call is
+be open in a manner compatible with the supplied mode string, the call is
thus equivalent to C<PerlIO_fdopen>. In this case I<nargs> will be zero.
If I<nargs> is greater than zero then it gives the number of arguments passed
Having said all that translation-only layers do not need to provide C<Open()> at all,
but rather leave the opening to a lower level layer and wait to be "pushed".
-If a layer does provide C<Open()> it should normaly call the C<Open()> method
+If a layer does provide C<Open()> it should normally call the C<Open()> method
of next layer down (if any) and then push itself on top if that succeeds.
=item SV * (*Getarg)(PerlIO *f);
=item IV (*Fileno)(PerlIO *f);
-Returns the Unix/Posix numeric file decriptor for the handle. Normally
+Returns the Unix/Posix numeric file descriptor for the handle. Normally
C<PerlIOBase_fileno()> (which just asks next layer down) will suffice
for this.
Should make stream's state consistent with layers below. That is, any
buffered write data should be written, and file position of lower layers
-adjusted for data read fron below but not actually consumed.
+adjusted for data read from below but not actually consumed.
(Should perhaps C<Unread()> such data to the lower layer.)
=item IV (*Fill)(PerlIO *f);
Once the generic server socket has been created using the parameters
listed above, the server then waits for a new client to connect
-to it. The server blocks in the C<accept> method, which eventually an
-bidirectional connection to the remote client. (Make sure to autoflush
+to it. The server blocks in the C<accept> method, which eventually accepts a
+bidirectional connection from the remote client. (Make sure to autoflush
this handle to circumvent buffering.)
To add to user-friendliness, our server prompts the user for commands.
Extension modules are written in C (or a mix of Perl and C). They
are usually dynamically loaded into Perl if and when you need them,
-but may also be be linked in statically. Supported extension modules
+but may also be linked in statically. Supported extension modules
include Socket, Fcntl, and POSIX.
Many popular C extension modules do not come bundled (at least, not
By default, the C<flock> call will block until a lock is granted.
A request for a shared lock will be granted as soon as there is no
-exclusive locker. A request for a exclusive lock will be granted as
+exclusive locker. A request for an exclusive lock will be granted as
soon as there is no locker of any kind. Locks are on file descriptors,
not file names. You can't lock a file until you open it, and you can't
hold on to a lock once the file has been closed.
Pod parsers, when processing a series of verbatim paragraphs one
after another, should consider them to be one large verbatim
paragraph that happens to contain blank lines. I.e., these two
-lines, which have an blank line between them:
+lines, which have a blank line between them:
use Foo;
programs to aid in the testing, or when (as noted above) the tests
assume certain things about the filesystem and paths. Be careful
not to depend on a specific output style for errors, such as when
-checking C<$!> after an system call. Some platforms expect a certain
+checking C<$!> after a system call. Some platforms expect a certain
output format, and perl on those platforms may have been adjusted
accordingly. Most specifically, don't anchor a regex when testing
an error value.
This is grandfathered for the RHS of a substitute to avoid shocking the
B<sed> addicts, but it's a dirty habit to get into. That's because in
-PerlThink, the righthand side of a C<s///> is a double-quoted string. C<\1> in
+PerlThink, the righthand side of an C<s///> is a double-quoted string. C<\1> in
the usual double-quoted string means a control-A. The customary Unix
meaning of C<\1> is kludged in for C<s///>. However, if you get into the habit
of doing that, you get yourself into trouble if you then add an C</e>
Symbolic references are names of variables or other objects, just as a
symbolic link in a Unix filesystem contains merely the name of a file.
-The C<*glob> notation is something of a of symbolic reference. (Symbolic
+The C<*glob> notation is something of a symbolic reference. (Symbolic
references are sometimes called "soft references", but please don't call
them that; references are confusing enough without useless synonyms.)
$dna = "ATCGTTGAATGCAAATGACATGAC";
$dna =~ /TGA/;
-doesn't work; it may match an C<TGA>, but there is no guarantee that
+doesn't work; it may match a C<TGA>, but there is no guarantee that
the match is aligned with codon boundaries, e.g., the substring
S<C<GTT GAA> > gives a match. A better solution is
=item Encoding Names
The MIME name as defined in IETF RFC-XXXX, The name in the IANA registry,
-The name used by the the organization that defined it
+The name used by the organization that defined it
=back
=head2 DLL Versioning
-Windows needs a way to know what version of a XS or C<libperl> DLL it's
+Windows needs a way to know what version of an XS or C<libperl> DLL it's
loading.
=head2 Introduce @( and @)
for each and every constructor you ever write is to speak Perl with
such a severe C++ accent that you do a disservice to both languages.
There's no reason to insist that each class have but one constructor,
-or that that constructor be named new(), or that that constructor be
+or that a constructor be named new(), or that a constructor be
used solely as a class method and not an object method.
The next section shows how useful it can be to further distance ourselves
Assignment of return values from numeric equality tests
does not work in perl5 when the test evaluates to false (0).
-Logical tests now return an null, instead of 0
+Logical tests now return a null, instead of 0
$p = ($test == 1);
print $p,"\n";
perl's encoding on output by use of the ":encoding(...)" layer.
See L<open>.
-To mark the Perl source itself as being in an particular encoding,
+To mark the Perl source itself as being in a particular encoding,
see L<encoding>.
=item Regular Expressions
list.
The C<OUTLIST>/C<OUT> parameter differ from C<IN_OUTLIST>/C<IN_OUT>
-parameters only by the the initial value of the Perl parameter not
+parameters only by the initial value of the Perl parameter not
being read (and not being given to the C function - which gets some
garbage instead). For example, the same C function as above can be
interfaced with as
This is useful to avoid a CODE: block for a C function which takes a parameter
by reference. Typically, the parameter should be not a pointer type (an
-C<int> or C<long> but not a C<int*> or C<long*>).
+C<int> or C<long> but not an C<int*> or C<long*>).
The following XSUB will generate incorrect C code. The B<xsubpp> compiler will
turn this into code which calls C<rpcb_gettime()> with parameters C<(char
SvIVX(sv) = -(IV)value;
} else {
/* Too negative for an IV. This is a double upgrade, but
- I'm assuming it will be be rare. */
+ I'm assuming it will be rare. */
if (SvTYPE(sv) < SVt_PVNV)
sv_upgrade(sv, SVt_PVNV);
SvNOK_on(sv);
SvIVX(sv) = -(IV)value;
} else {
/* Too negative for an IV. This is a double upgrade, but
- I'm assuming it will be be rare. */
+ I'm assuming it will be rare. */
if (SvTYPE(sv) < SVt_PVNV)
sv_upgrade(sv, SVt_PVNV);
SvNOK_on(sv);
while (isDIGIT(*d)) d++;
if (*d) {
#ifdef PERL_PRESERVE_IVUV
- /* Got to punt this an an integer if needs be, but we don't issue
+ /* Got to punt this as an integer if needs be, but we don't issue
warnings. Probably ought to make the sv_iv_please() that does
the conversion if possible, and silently. */
int numtype = grok_number(SvPVX(sv), SvCUR(sv), NULL);
Returns a boolean indicating whether the SV contains an unsigned integer.
=for apidoc Am|void|SvIOK_notUV|SV* sv
-Returns a boolean indicating whether the SV contains an signed integer.
+Returns a boolean indicating whether the SV contains a signed integer.
=for apidoc Am|bool|SvNOK|SV* sv
Returns a boolean indicating whether the SV contains a double.
=for apidoc Am|IV|SvIVx|SV* sv
Coerces the given SV to an integer and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvIV> otherwise.
+sv only once. Use the more efficient C<SvIV> otherwise.
=for apidoc Am|NV|SvNV|SV* sv
Coerce the given SV to a double and return it. See C<SvNVx> for a version
=for apidoc Am|NV|SvNVx|SV* sv
Coerces the given SV to a double and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvNV> otherwise.
+sv only once. Use the more efficient C<SvNV> otherwise.
=for apidoc Am|UV|SvUV|SV* sv
Coerces the given SV to an unsigned integer and returns it. See C<SvUVx>
=for apidoc Am|UV|SvUVx|SV* sv
Coerces the given SV to an unsigned integer and returns it. Guarantees to
-evaluate sv only once. Use the more efficent C<SvUV> otherwise.
+evaluate sv only once. Use the more efficient C<SvUV> otherwise.
=for apidoc Am|bool|SvTRUE|SV* sv
Returns a boolean indicating whether Perl would evaluate the SV as true or
=for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len
Like C<SvPV_force>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
otherwise.
=for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len
Like C<SvPV>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
otherwise.
=for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len
Like C<SvPV_force>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
otherwise.
=for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len
Like C<SvPV>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
otherwise.
* as the first line of a Perl program designed to be executed directly
* by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG
* begins with a character other then #, then Perl will only treat
- * it as a command line if if finds the string "perl" in the first
+ * it as a command line if it finds the string "perl" in the first
* word; otherwise it's treated as the first line of code in the script.
* (IOW, Perl won't hand off to another interpreter via an alternate
* shebang sequence that might be legal Perl code.)
and loaded by SWASHGET, using lib/utf8_heavy.pl.
The "special" is a string like "utf8::ToSpecLower", which means
-the hash %utf8::ToSpecLower, which is stored in in the same file,
+the hash %utf8::ToSpecLower, which is stored in the same file,
lib/unicore/To/Lower.pl, and also loaded by SWASHGET. The access
to the hash is by Perl_to_utf8_case().
sv_catpvn(sv, "\n", 1); /* Taken into account in fbm_instr() */
s = (U8*)SvPV_force(sv, len);
(void)SvUPGRADE(sv, SVt_PVBM);
- if (len == 0) /* TAIL might be on on a zero-length string. */
+ if (len == 0) /* TAIL might be on a zero-length string. */
return;
if (len > 2) {
U8 mlen;
=head1 DESCRIPTION
-The libnetcfg utility can be be used to configure the libnet.
+The libnetcfg utility can be used to configure the libnet.
Starting from perl 5.8 libnet is part of the standard Perl
-distribution, but the libnetcfg can be be used for any libnet
+distribution, but the libnetcfg can be used for any libnet
installation.
=head1 USAGE
=item B<-X> use an index if present
-The B<-X> option looks for a entry whose basename matches the name given on the
+The B<-X> option looks for an entry whose basename matches the name given on the
command line in the file C<$Config{archlib}/pod.idx>. The pod.idx file should
contain fully qualified filenames, one per line.
have security issues, it will not normally execute as the superuser.
If you use the B<-U> flag, it will do so, but only after setting
the effective and real IDs to nobody's or nouser's account, or -2
-if unavailable. If it cannot relinguish its privileges, it will not
+if unavailable. If it cannot relinquish its privileges, it will not
run.
=item B<PageName|ModuleName|ProgramName>
projects / platform / upstream / perl.git / commitdiff