[prev in list] [next in list] [prev in thread] [next in thread]
List: perl5-porters
Subject: [PATCH] remove whitespace preceding semicolon in docs
From: Steven Schubiger <schubiger () cpan ! org>
Date: 2005-10-31 21:48:27
Message-ID: 20051031214827.GH24416 () accognoscere ! homeunix ! org
[Download RAW message or body]
As I stumbled across a few pods that didn't adhere to podstyle
regarding the no-whitespace-before-semicolon recommendation, I've
applied it to all current pods that were in need of it.
diff perl-blead/pod/perl561delta.pod perl-local/pod/perl561delta.pod
--- perl-blead/pod/perl561delta.pod Fri Jun 7 16:07:48 2002
+++ perl-local/pod/perl561delta.pod Mon Oct 31 22:38:03 2005
@@ -763,13 +763,13 @@
that with a C<use attrs> pragma in the body of the subroutine.
That can now be accomplished with declaration syntax, like this:
- sub mymethod : locked method ;
+ sub mymethod : locked method;
...
sub mymethod : locked method {
...
}
- sub othermethod :locked :method ;
+ sub othermethod :locked :method;
...
sub othermethod :locked :method {
...
diff perl-blead/pod/perl56delta.pod perl-local/pod/perl56delta.pod
--- perl-blead/pod/perl56delta.pod Wed Mar 27 05:14:55 2002
+++ perl-local/pod/perl56delta.pod Mon Oct 31 22:37:54 2005
@@ -165,13 +165,13 @@
that with a C<use attrs> pragma in the body of the subroutine.
That can now be accomplished with declaration syntax, like this:
- sub mymethod : locked method ;
+ sub mymethod : locked method;
...
sub mymethod : locked method {
...
}
- sub othermethod :locked :method ;
+ sub othermethod :locked :method;
...
sub othermethod :locked :method {
...
diff perl-blead/pod/perlcall.pod perl-local/pod/perlcall.pod
--- perl-blead/pod/perlcall.pod Sat Aug 7 17:35:13 2004
+++ perl-local/pod/perlcall.pod Mon Oct 31 21:56:04 2005
@@ -53,10 +53,10 @@
Perl has a number of C functions that allow you to call Perl
subroutines. They are
- I32 call_sv(SV* sv, I32 flags) ;
- I32 call_pv(char *subname, I32 flags) ;
- I32 call_method(char *methname, I32 flags) ;
- I32 call_argv(char *subname, I32 flags, register char **argv) ;
+ I32 call_sv(SV* sv, I32 flags);
+ I32 call_pv(char *subname, I32 flags);
+ I32 call_method(char *methname, I32 flags);
+ I32 call_argv(char *subname, I32 flags, register char **argv);
The key function is I<call_sv>. All the other functions are
fairly simple wrappers which make it easier to call Perl subroutines in
@@ -265,7 +265,7 @@
sub joe
{ &fred }
- &joe(1,2,3) ;
+ &joe(1,2,3);
This will print
@@ -398,9 +398,9 @@
sub fred
{
- eval { die "Fatal Error" ; }
+ eval { die "Fatal Error" }
print "Trapped error: $@\n"
- if $@ ;
+ if $@;
}
via this XSUB
@@ -408,9 +408,9 @@
void
Call_fred()
CODE:
- PUSHMARK(SP) ;
- call_pv("fred", G_DISCARD|G_NOARGS) ;
- fprintf(stderr, "back in Call_fred\n") ;
+ PUSHMARK(SP);
+ call_pv("fred", G_DISCARD|G_NOARGS);
+ fprintf(stderr, "back in Call_fred\n");
When C<Call_fred> is executed it will print
@@ -425,9 +425,9 @@
void
Call_fred()
CODE:
- PUSHMARK(SP) ;
- call_pv("fred", G_EVAL|G_DISCARD|G_NOARGS) ;
- fprintf(stderr, "back in Call_fred\n") ;
+ PUSHMARK(SP);
+ call_pv("fred", G_EVAL|G_DISCARD|G_NOARGS);
+ fprintf(stderr, "back in Call_fred\n");
=back
@@ -456,7 +456,7 @@
sub PrintUID
{
- print "UID is $<\n" ;
+ print "UID is $<\n";
}
and here is a C function to call it
@@ -464,10 +464,10 @@
static void
call_PrintUID()
{
- dSP ;
+ dSP;
- PUSHMARK(SP) ;
- call_pv("PrintUID", G_DISCARD|G_NOARGS) ;
+ PUSHMARK(SP);
+ call_pv("PrintUID", G_DISCARD|G_NOARGS);
}
Simple, eh.
@@ -517,31 +517,31 @@
sub LeftString
{
- my($s, $n) = @_ ;
- print substr($s, 0, $n), "\n" ;
+ my($s, $n) = @_;
+ print substr($s, 0, $n), "\n";
}
The C function required to call I<LeftString> would look like this.
static void
call_LeftString(a, b)
- char * a ;
- int b ;
+ char * a;
+ int b;
{
- dSP ;
+ dSP;
- ENTER ;
- SAVETMPS ;
+ ENTER;
+ SAVETMPS;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(a, 0)));
XPUSHs(sv_2mortal(newSViv(b)));
- PUTBACK ;
+ PUTBACK;
call_pv("LeftString", G_DISCARD);
- FREETMPS ;
- LEAVE ;
+ FREETMPS;
+ LEAVE;
}
Here are a few notes on the C function I<call_LeftString>.
@@ -607,13 +607,13 @@
This is the purpose of
- ENTER ;
- SAVETMPS ;
+ ENTER;
+ SAVETMPS;
at the start of the function, and
- FREETMPS ;
- LEAVE ;
+ FREETMPS;
+ LEAVE;
at the end. The C<ENTER>/C<SAVETMPS> pair creates a boundary for any
temporaries we create. This means that the temporaries we get rid of
@@ -649,8 +649,8 @@
sub Adder
{
- my($a, $b) = @_ ;
- $a + $b ;
+ my($a, $b) = @_;
+ $a + $b;
}
Because we are now concerned with the return value from I<Adder>, the C
@@ -658,32 +658,32 @@
static void
call_Adder(a, b)
- int a ;
- int b ;
+ int a;
+ int b;
{
- dSP ;
- int count ;
+ dSP;
+ int count;
- ENTER ;
+ ENTER;
SAVETMPS;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
- PUTBACK ;
+ PUTBACK;
count = call_pv("Adder", G_SCALAR);
- SPAGAIN ;
+ SPAGAIN;
if (count != 1)
- croak("Big trouble\n") ;
+ croak("Big trouble\n");
- printf ("The sum of %d and %d is %d\n", a, b, POPi) ;
+ printf ("The sum of %d and %d is %d\n", a, b, POPi);
- PUTBACK ;
- FREETMPS ;
- LEAVE ;
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
}
Points to note this time are
@@ -754,46 +754,46 @@
sub AddSubtract
{
- my($a, $b) = @_ ;
- ($a+$b, $a-$b) ;
+ my($a, $b) = @_;
+ ($a+$b, $a-$b);
}
and this is the C function
static void
call_AddSubtract(a, b)
- int a ;
- int b ;
+ int a;
+ int b;
{
- dSP ;
- int count ;
+ dSP;
+ int count;
- ENTER ;
+ ENTER;
SAVETMPS;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
- PUTBACK ;
+ PUTBACK;
count = call_pv("AddSubtract", G_ARRAY);
- SPAGAIN ;
+ SPAGAIN;
if (count != 2)
- croak("Big trouble\n") ;
+ croak("Big trouble\n");
- printf ("%d - %d = %d\n", a, b, POPi) ;
- printf ("%d + %d = %d\n", a, b, POPi) ;
+ printf ("%d - %d = %d\n", a, b, POPi);
+ printf ("%d + %d = %d\n", a, b, POPi);
- PUTBACK ;
- FREETMPS ;
- LEAVE ;
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
}
If I<call_AddSubtract> is called like this
- call_AddSubtract(7, 4) ;
+ call_AddSubtract(7, 4);
then here is the output
@@ -824,33 +824,33 @@
static void
call_AddSubScalar(a, b)
- int a ;
- int b ;
+ int a;
+ int b;
{
- dSP ;
- int count ;
- int i ;
+ dSP;
+ int count;
+ int i;
- ENTER ;
+ ENTER;
SAVETMPS;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
- PUTBACK ;
+ PUTBACK;
count = call_pv("AddSubtract", G_SCALAR);
- SPAGAIN ;
+ SPAGAIN;
- printf ("Items Returned = %d\n", count) ;
+ printf ("Items Returned = %d\n", count);
- for (i = 1 ; i <= count ; ++i)
- printf ("Value %d = %d\n", i, POPi) ;
+ for (i = 1; i <= count; ++i)
+ printf ("Value %d = %d\n", i, POPi);
- PUTBACK ;
- FREETMPS ;
- LEAVE ;
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
}
The other modification made is that I<call_AddSubScalar> will print the
@@ -858,7 +858,7 @@
simplicity it assumes that they are integer). So if
I<call_AddSubScalar> is called
- call_AddSubScalar(7, 4) ;
+ call_AddSubScalar(7, 4);
then the output will be
@@ -880,44 +880,44 @@
sub Inc
{
- ++ $_[0] ;
- ++ $_[1] ;
+ ++ $_[0];
+ ++ $_[1];
}
and here is a C function to call it.
static void
call_Inc(a, b)
- int a ;
- int b ;
+ int a;
+ int b;
{
- dSP ;
- int count ;
- SV * sva ;
- SV * svb ;
+ dSP;
+ int count;
+ SV * sva;
+ SV * svb;
- ENTER ;
+ ENTER;
SAVETMPS;
- sva = sv_2mortal(newSViv(a)) ;
- svb = sv_2mortal(newSViv(b)) ;
+ sva = sv_2mortal(newSViv(a));
+ svb = sv_2mortal(newSViv(b));
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sva);
XPUSHs(svb);
- PUTBACK ;
+ PUTBACK;
count = call_pv("Inc", G_DISCARD);
if (count != 0)
croak ("call_Inc: expected 0 values from 'Inc', got %d\n",
- count) ;
+ count);
- printf ("%d + 1 = %d\n", a, SvIV(sva)) ;
- printf ("%d + 1 = %d\n", b, SvIV(svb)) ;
+ printf ("%d + 1 = %d\n", a, SvIV(sva));
+ printf ("%d + 1 = %d\n", b, SvIV(svb));
- FREETMPS ;
- LEAVE ;
+ FREETMPS;
+ LEAVE;
}
To be able to access the two parameters that were pushed onto the stack
@@ -939,54 +939,54 @@
sub Subtract
{
- my ($a, $b) = @_ ;
+ my ($a, $b) = @_;
- die "death can be fatal\n" if $a < $b ;
+ die "death can be fatal\n" if $a < $b;
- $a - $b ;
+ $a - $b;
}
and some C to call it
static void
call_Subtract(a, b)
- int a ;
- int b ;
+ int a;
+ int b;
{
- dSP ;
- int count ;
+ dSP;
+ int count;
- ENTER ;
+ ENTER;
SAVETMPS;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
- PUTBACK ;
+ PUTBACK;
count = call_pv("Subtract", G_EVAL|G_SCALAR);
- SPAGAIN ;
+ SPAGAIN;
/* Check the eval first */
if (SvTRUE(ERRSV))
{
STRLEN n_a;
- printf ("Uh oh - %s\n", SvPV(ERRSV, n_a)) ;
- POPs ;
+ printf ("Uh oh - %s\n", SvPV(ERRSV, n_a));
+ POPs;
}
else
{
if (count != 1)
croak("call_Subtract: wanted 1 value from 'Subtract', got %d\n",
- count) ;
+ count);
- printf ("%d - %d = %d\n", a, b, POPi) ;
+ printf ("%d - %d = %d\n", a, b, POPi);
}
- PUTBACK ;
- FREETMPS ;
- LEAVE ;
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
}
If I<call_Subtract> is called thus
@@ -1015,13 +1015,13 @@
if (SvTRUE(ERRSV))
{
STRLEN n_a;
- printf ("Uh oh - %s\n", SvPV(ERRSV, n_a)) ;
- POPs ;
+ printf ("Uh oh - %s\n", SvPV(ERRSV, n_a));
+ POPs;
}
is the direct equivalent of this bit of Perl
- print "Uh oh - $@\n" if $@ ;
+ print "Uh oh - $@\n" if $@;
C<PL_errgv> is a perl global of type C<GV *> that points to the
symbol table entry containing the error. C<ERRSV> therefore
@@ -1048,7 +1048,7 @@
sub new { bless {}, $_[0] }
sub Subtract {
my($a,$b) = @_;
- die "death can be fatal" if $a < $b ;
+ die "death can be fatal" if $a < $b;
$a - $b;
}
sub DESTROY { call_Subtract(5, 4); }
@@ -1083,10 +1083,10 @@
sub fred
{
- print "Hello there\n" ;
+ print "Hello there\n";
}
- CallSubPV("fred") ;
+ CallSubPV("fred");
Here is a snippet of XSUB which defines I<CallSubPV>.
@@ -1094,8 +1094,8 @@
CallSubPV(name)
char * name
CODE:
- PUSHMARK(SP) ;
- call_pv(name, G_DISCARD|G_NOARGS) ;
+ PUSHMARK(SP);
+ call_pv(name, G_DISCARD|G_NOARGS);
That is fine as far as it goes. The thing is, the Perl subroutine
can be specified as only a string. For Perl 4 this was adequate,
@@ -1110,16 +1110,16 @@
CallSubSV(name)
SV * name
CODE:
- PUSHMARK(SP) ;
- call_sv(name, G_DISCARD|G_NOARGS) ;
+ PUSHMARK(SP);
+ call_sv(name, G_DISCARD|G_NOARGS);
Because we are using an SV to call I<fred> the following can all be used
- CallSubSV("fred") ;
- CallSubSV(\&fred) ;
- $ref = \&fred ;
- CallSubSV($ref) ;
- CallSubSV( sub { print "Hello there\n" } ) ;
+ CallSubSV("fred");
+ CallSubSV(\&fred);
+ $ref = \&fred;
+ CallSubSV($ref);
+ CallSubSV( sub { print "Hello there\n" } );
As you can see, I<call_sv> gives you much greater flexibility in
how you can specify the Perl subroutine.
@@ -1129,30 +1129,30 @@
be used later in the program, it not enough just to store a copy of the
pointer to the SV. Say the code above had been like this
- static SV * rememberSub ;
+ static SV * rememberSub;
void
SaveSub1(name)
SV * name
CODE:
- rememberSub = name ;
+ rememberSub = name;
void
CallSavedSub1()
CODE:
- PUSHMARK(SP) ;
- call_sv(rememberSub, G_DISCARD|G_NOARGS) ;
+ PUSHMARK(SP);
+ call_sv(rememberSub, G_DISCARD|G_NOARGS);
The reason this is wrong is that by the time you come to use the
pointer C<rememberSub> in C<CallSavedSub1>, it may or may not still refer
to the Perl subroutine that was recorded in C<SaveSub1>. This is
particularly true for these cases
- SaveSub1(\&fred) ;
- CallSavedSub1() ;
+ SaveSub1(\&fred);
+ CallSavedSub1();
- SaveSub1( sub { print "Hello there\n" } ) ;
- CallSavedSub1() ;
+ SaveSub1( sub { print "Hello there\n" } );
+ CallSavedSub1();
By the time each of the C<SaveSub1> statements above have been executed,
the SV*s which corresponded to the parameters will no longer exist.
@@ -1164,10 +1164,10 @@
Similarly, with this code
- $ref = \&fred ;
- SaveSub1($ref) ;
- $ref = 47 ;
- CallSavedSub1() ;
+ $ref = \&fred;
+ SaveSub1($ref);
+ $ref = 47;
+ CallSavedSub1();
you can expect one of these messages (which you actually get is dependent on
the version of Perl you are using)
@@ -1187,10 +1187,10 @@
A similar but more subtle problem is illustrated with this code
- $ref = \&fred ;
- SaveSub1($ref) ;
- $ref = \&joe ;
- CallSavedSub1() ;
+ $ref = \&fred;
+ SaveSub1($ref);
+ $ref = \&joe;
+ CallSavedSub1();
This time whenever C<CallSavedSub1> get called it will execute the Perl
subroutine C<joe> (assuming it exists) rather than C<fred> as was
@@ -1199,7 +1199,7 @@
To get around these problems it is necessary to take a full copy of the
SV. The code below shows C<SaveSub2> modified to do that
- static SV * keepSub = (SV*)NULL ;
+ static SV * keepSub = (SV*)NULL;
void
SaveSub2(name)
@@ -1208,16 +1208,16 @@
/* Take a copy of the callback */
if (keepSub == (SV*)NULL)
/* First time, so create a new SV */
- keepSub = newSVsv(name) ;
+ keepSub = newSVsv(name);
else
/* Been here before, so overwrite */
- SvSetSV(keepSub, name) ;
+ SvSetSV(keepSub, name);
void
CallSavedSub2()
CODE:
- PUSHMARK(SP) ;
- call_sv(keepSub, G_DISCARD|G_NOARGS) ;
+ PUSHMARK(SP);
+ call_sv(keepSub, G_DISCARD|G_NOARGS);
To avoid creating a new SV every time C<SaveSub2> is called,
the function first checks to see if it has been called before. If not,
@@ -1234,7 +1234,7 @@
sub PrintList
{
- my(@list) = @_ ;
+ my(@list) = @_;
foreach (@list) { print "$_\n" }
}
@@ -1242,14 +1242,14 @@
and here is an example of I<call_argv> which will call
I<PrintList>.
- static char * words[] = {"alpha", "beta", "gamma", "delta", NULL} ;
+ static char * words[] = {"alpha", "beta", "gamma", "delta", NULL};
static void
call_PrintList()
{
- dSP ;
+ dSP;
- call_argv("PrintList", G_DISCARD, words) ;
+ call_argv("PrintList", G_DISCARD, words);
}
Note that it is not necessary to call C<PUSHMARK> in this instance.
@@ -1260,24 +1260,24 @@
Consider the following Perl code
{
- package Mine ;
+ package Mine;
sub new
{
- my($type) = shift ;
+ my($type) = shift;
bless [@_]
}
sub Display
{
- my ($self, $index) = @_ ;
- print "$index: $$self[$index]\n" ;
+ my ($self, $index) = @_;
+ print "$index: $$self[$index]\n";
}
sub PrintID
{
- my($class) = @_ ;
- print "This is Class $class version 1.0\n" ;
+ my($class) = @_;
+ print "This is Class $class version 1.0\n";
}
}
@@ -1287,8 +1287,8 @@
name and a version number. The virtual method, C<Display>, prints out a
single element of the array. Here is an all Perl example of using it.
- $a = new Mine ('red', 'green', 'blue') ;
- $a->Display(1) ;
+ $a = new Mine ('red', 'green', 'blue');
+ $a->Display(1);
PrintID Mine;
will print
@@ -1327,10 +1327,10 @@
CODE:
PUSHMARK(SP);
XPUSHs(ref);
- XPUSHs(sv_2mortal(newSViv(index))) ;
+ XPUSHs(sv_2mortal(newSViv(index)));
PUTBACK;
- call_method(method, G_DISCARD) ;
+ call_method(method, G_DISCARD);
void
call_PrintID(class, method)
@@ -1338,17 +1338,17 @@
char * method
CODE:
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSVpv(class, 0))) ;
+ XPUSHs(sv_2mortal(newSVpv(class, 0)));
PUTBACK;
- call_method(method, G_DISCARD) ;
+ call_method(method, G_DISCARD);
So the methods C<PrintID> and C<Display> can be invoked like this
- $a = new Mine ('red', 'green', 'blue') ;
- call_Method($a, 'Display', 1) ;
- call_PrintID('Mine', 'PrintID') ;
+ $a = new Mine ('red', 'green', 'blue');
+ call_Method($a, 'Display', 1);
+ call_PrintID('Mine', 'PrintID');
The only thing to note is that in both the static and virtual methods,
the method name is not passed via the stack--it is used as the first
@@ -1364,17 +1364,17 @@
CODE:
I32 gimme = GIMME_V;
if (gimme == G_VOID)
- printf ("Context is Void\n") ;
+ printf ("Context is Void\n");
else if (gimme == G_SCALAR)
- printf ("Context is Scalar\n") ;
+ printf ("Context is Scalar\n");
else
- printf ("Context is Array\n") ;
+ printf ("Context is Array\n");
and here is some Perl to test it
- PrintContext ;
- $a = PrintContext ;
- @a = PrintContext ;
+ PrintContext;
+ $a = PrintContext;
+ @a = PrintContext;
The output from that will be
@@ -1405,11 +1405,11 @@
for you automatically whenever it regains control after the callback
has terminated. This is done by simply not using the
- ENTER ;
- SAVETMPS ;
+ ENTER;
+ SAVETMPS;
...
- FREETMPS ;
- LEAVE ;
+ FREETMPS;
+ LEAVE;
sequence in the callback (and not, of course, specifying the G_DISCARD
flag).
@@ -1508,7 +1508,7 @@
hypothetical function C<register_fatal> which registers the C function
to get called when a fatal error occurs.
- register_fatal(cb1) ;
+ register_fatal(cb1);
The single parameter C<cb1> is a pointer to a function, so you must
have defined C<cb1> in your code, say something like this
@@ -1516,8 +1516,8 @@
static void
cb1()
{
- printf ("Fatal Error\n") ;
- exit(1) ;
+ printf ("Fatal Error\n");
+ exit(1);
}
Now change that to call a Perl subroutine instead
@@ -1527,12 +1527,12 @@
static void
cb1()
{
- dSP ;
+ dSP;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
/* Call the Perl sub to process the callback */
- call_sv(callback, G_DISCARD) ;
+ call_sv(callback, G_DISCARD);
}
@@ -1542,22 +1542,22 @@
CODE:
/* Remember the Perl sub */
if (callback == (SV*)NULL)
- callback = newSVsv(fn) ;
+ callback = newSVsv(fn);
else
- SvSetSV(callback, fn) ;
+ SvSetSV(callback, fn);
/* register the callback with the external library */
- register_fatal(cb1) ;
+ register_fatal(cb1);
where the Perl equivalent of C<register_fatal> and the callback it
registers, C<pcb1>, might look like this
# Register the sub pcb1
- register_fatal(\&pcb1) ;
+ register_fatal(\&pcb1);
sub pcb1
{
- die "I'm dying...\n" ;
+ die "I'm dying...\n";
}
The mapping between the C callback and the Perl equivalent is stored in
@@ -1589,8 +1589,8 @@
void
ProcessRead(fh, buffer)
- int fh ;
- char * buffer ;
+ int fh;
+ char * buffer;
{
...
}
@@ -1600,7 +1600,7 @@
hash is a convenient mechanism for storing this mapping. The code
below shows a possible implementation
- static HV * Mapping = (HV*)NULL ;
+ static HV * Mapping = (HV*)NULL;
void
asynch_read(fh, callback)
@@ -1609,36 +1609,36 @@
CODE:
/* If the hash doesn't already exist, create it */
if (Mapping == (HV*)NULL)
- Mapping = newHV() ;
+ Mapping = newHV();
/* Save the fh -> callback mapping */
- hv_store(Mapping, (char*)&fh, sizeof(fh), newSVsv(callback), 0) ;
+ hv_store(Mapping, (char*)&fh, sizeof(fh), newSVsv(callback), 0);
/* Register with the C Library */
- asynch_read(fh, asynch_read_if) ;
+ asynch_read(fh, asynch_read_if);
and C<asynch_read_if> could look like this
static void
asynch_read_if(fh, buffer)
- int fh ;
- char * buffer ;
+ int fh;
+ char * buffer;
{
- dSP ;
- SV ** sv ;
+ dSP;
+ SV ** sv;
/* Get the callback associated with fh */
- sv = hv_fetch(Mapping, (char*)&fh , sizeof(fh), FALSE) ;
+ sv = hv_fetch(Mapping, (char*)&fh , sizeof(fh), FALSE);
if (sv == (SV**)NULL)
- croak("Internal error...\n") ;
+ croak("Internal error...\n");
- PUSHMARK(SP) ;
- XPUSHs(sv_2mortal(newSViv(fh))) ;
- XPUSHs(sv_2mortal(newSVpv(buffer, 0))) ;
- PUTBACK ;
+ PUSHMARK(SP);
+ XPUSHs(sv_2mortal(newSViv(fh)));
+ XPUSHs(sv_2mortal(newSVpv(buffer, 0)));
+ PUTBACK;
/* Call the Perl sub */
- call_sv(*sv, G_DISCARD) ;
+ call_sv(*sv, G_DISCARD);
}
For completeness, here is C<asynch_close>. This shows how to remove
@@ -1649,22 +1649,22 @@
int fh
CODE:
/* Remove the entry from the hash */
- (void) hv_delete(Mapping, (char*)&fh, sizeof(fh), G_DISCARD) ;
+ (void) hv_delete(Mapping, (char*)&fh, sizeof(fh), G_DISCARD);
/* Now call the real asynch_close */
- asynch_close(fh) ;
+ asynch_close(fh);
So the Perl interface would look like this
sub callback1
{
- my($handle, $buffer) = @_ ;
+ my($handle, $buffer) = @_;
}
# Register the Perl callback
- asynch_read($fh, \&callback1) ;
+ asynch_read($fh, \&callback1);
- asynch_close($fh) ;
+ asynch_close($fh);
The mapping between the C callback and Perl is stored in the global
hash C<Mapping> this time. Using a hash has the distinct advantage that
@@ -1677,7 +1677,7 @@
void
ProcessRead(buffer)
- char * buffer ;
+ char * buffer;
{
...
}
@@ -1690,59 +1690,59 @@
#define MAX_CB 3
#define NULL_HANDLE -1
- typedef void (*FnMap)() ;
+ typedef void (*FnMap)();
struct MapStruct {
- FnMap Function ;
- SV * PerlSub ;
- int Handle ;
- } ;
+ FnMap Function;
+ SV * PerlSub;
+ int Handle;
+ };
- static void fn1() ;
- static void fn2() ;
- static void fn3() ;
+ static void fn1();
+ static void fn2();
+ static void fn3();
static struct MapStruct Map [MAX_CB] =
{
{ fn1, NULL, NULL_HANDLE },
{ fn2, NULL, NULL_HANDLE },
{ fn3, NULL, NULL_HANDLE }
- } ;
+ };
static void
Pcb(index, buffer)
- int index ;
- char * buffer ;
+ int index;
+ char * buffer;
{
- dSP ;
+ dSP;
- PUSHMARK(SP) ;
- XPUSHs(sv_2mortal(newSVpv(buffer, 0))) ;
- PUTBACK ;
+ PUSHMARK(SP);
+ XPUSHs(sv_2mortal(newSVpv(buffer, 0)));
+ PUTBACK;
/* Call the Perl sub */
- call_sv(Map[index].PerlSub, G_DISCARD) ;
+ call_sv(Map[index].PerlSub, G_DISCARD);
}
static void
fn1(buffer)
- char * buffer ;
+ char * buffer;
{
- Pcb(0, buffer) ;
+ Pcb(0, buffer);
}
static void
fn2(buffer)
- char * buffer ;
+ char * buffer;
{
- Pcb(1, buffer) ;
+ Pcb(1, buffer);
}
static void
fn3(buffer)
- char * buffer ;
+ char * buffer;
{
- Pcb(2, buffer) ;
+ Pcb(2, buffer);
}
void
@@ -1750,55 +1750,55 @@
int fh
SV * callback
CODE:
- int index ;
- int null_index = MAX_CB ;
+ int index;
+ int null_index = MAX_CB;
/* Find the same handle or an empty entry */
- for (index = 0 ; index < MAX_CB ; ++index)
+ for (index = 0; index < MAX_CB; ++index)
{
if (Map[index].Handle == fh)
- break ;
+ break;
if (Map[index].Handle == NULL_HANDLE)
- null_index = index ;
+ null_index = index;
}
if (index == MAX_CB && null_index == MAX_CB)
- croak ("Too many callback functions registered\n") ;
+ croak ("Too many callback functions registered\n");
if (index == MAX_CB)
- index = null_index ;
+ index = null_index;
/* Save the file handle */
- Map[index].Handle = fh ;
+ Map[index].Handle = fh;
/* Remember the Perl sub */
if (Map[index].PerlSub == (SV*)NULL)
- Map[index].PerlSub = newSVsv(callback) ;
+ Map[index].PerlSub = newSVsv(callback);
else
- SvSetSV(Map[index].PerlSub, callback) ;
+ SvSetSV(Map[index].PerlSub, callback);
- asynch_read(fh, Map[index].Function) ;
+ asynch_read(fh, Map[index].Function);
void
array_asynch_close(fh)
int fh
CODE:
- int index ;
+ int index;
/* Find the file handle */
- for (index = 0; index < MAX_CB ; ++ index)
+ for (index = 0; index < MAX_CB; ++ index)
if (Map[index].Handle == fh)
- break ;
+ break;
if (index == MAX_CB)
- croak ("could not close fh %d\n", fh) ;
+ croak ("could not close fh %d\n", fh);
- Map[index].Handle = NULL_HANDLE ;
- SvREFCNT_dec(Map[index].PerlSub) ;
- Map[index].PerlSub = (SV*)NULL ;
+ Map[index].Handle = NULL_HANDLE;
+ SvREFCNT_dec(Map[index].PerlSub);
+ Map[index].PerlSub = (SV*)NULL;
- asynch_close(fh) ;
+ asynch_close(fh);
In this case the functions C<fn1>, C<fn2>, and C<fn3> are used to
remember the Perl subroutine to be called. Each of the functions holds
@@ -1860,36 +1860,36 @@
static void
call_AddSubtract2(a, b)
- int a ;
- int b ;
+ int a;
+ int b;
{
- dSP ;
- I32 ax ;
- int count ;
+ dSP;
+ I32 ax;
+ int count;
- ENTER ;
+ ENTER;
SAVETMPS;
- PUSHMARK(SP) ;
+ PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
- PUTBACK ;
+ PUTBACK;
count = call_pv("AddSubtract", G_ARRAY);
- SPAGAIN ;
- SP -= count ;
- ax = (SP - PL_stack_base) + 1 ;
+ SPAGAIN;
+ SP -= count;
+ ax = (SP - PL_stack_base) + 1;
if (count != 2)
- croak("Big trouble\n") ;
+ croak("Big trouble\n");
- printf ("%d + %d = %d\n", a, b, SvIV(ST(0))) ;
- printf ("%d - %d = %d\n", a, b, SvIV(ST(1))) ;
+ printf ("%d + %d = %d\n", a, b, SvIV(ST(0)));
+ printf ("%d - %d = %d\n", a, b, SvIV(ST(1)));
- PUTBACK ;
- FREETMPS ;
- LEAVE ;
+ PUTBACK;
+ FREETMPS;
+ LEAVE;
}
Notes
@@ -1907,9 +1907,9 @@
The code
- SPAGAIN ;
- SP -= count ;
- ax = (SP - PL_stack_base) + 1 ;
+ SPAGAIN;
+ SP -= count;
+ ax = (SP - PL_stack_base) + 1;
sets the stack up so that we can use the C<ST> macro.
diff perl-blead/pod/perldbmfilter.pod perl-local/pod/perldbmfilter.pod
--- perl-blead/pod/perldbmfilter.pod Sun Feb 1 18:59:21 2004
+++ perl-local/pod/perldbmfilter.pod Mon Oct 31 22:35:54 2005
@@ -6,10 +6,10 @@
$db = tie %hash, 'DBM', ...
- $old_filter = $db->filter_store_key ( sub { ... } ) ;
- $old_filter = $db->filter_store_value( sub { ... } ) ;
- $old_filter = $db->filter_fetch_key ( sub { ... } ) ;
- $old_filter = $db->filter_fetch_value( sub { ... } ) ;
+ $old_filter = $db->filter_store_key ( sub { ... } );
+ $old_filter = $db->filter_store_value( sub { ... } );
+ $old_filter = $db->filter_fetch_key ( sub { ... } );
+ $old_filter = $db->filter_fetch_value( sub { ... } );
=head1 DESCRIPTION
@@ -73,7 +73,7 @@
your Perl application will have to manage NULL termination itself. When
you write to the database you will have to use something like this:
- $hash{"$key\0"} = "$value\0" ;
+ $hash{"$key\0"} = "$value\0";
Similarly the NULL needs to be taken into account when you are considering
the length of existing keys/values.
@@ -85,30 +85,30 @@
sure you have already guessed, this is a problem that DBM Filters can
fix very easily.
- use strict ;
- use warnings ;
- use SDBM_File ;
- use Fcntl ;
+ use strict;
+ use warnings;
+ use SDBM_File;
+ use Fcntl;
- my %hash ;
- my $filename = "filt" ;
- unlink $filename ;
+ my %hash;
+ my $filename = "filt";
+ unlink $filename;
my $db = tie(%hash, 'SDBM_File', $filename, O_RDWR|O_CREAT, 0640)
- or die "Cannot open $filename: $!\n" ;
+ or die "Cannot open $filename: $!\n";
# Install DBM Filters
- $db->filter_fetch_key ( sub { s/\0$// } ) ;
- $db->filter_store_key ( sub { $_ .= "\0" } ) ;
+ $db->filter_fetch_key ( sub { s/\0$// } );
+ $db->filter_store_key ( sub { $_ .= "\0" } );
$db->filter_fetch_value(
- sub { no warnings 'uninitialized' ;s/\0$// } ) ;
- $db->filter_store_value( sub { $_ .= "\0" } ) ;
+ sub { no warnings 'uninitialized'; s/\0$// } );
+ $db->filter_store_value( sub { $_ .= "\0" } );
- $hash{"abc"} = "def" ;
- my $a = $hash{"ABC"} ;
+ $hash{"abc"} = "def";
+ my $a = $hash{"ABC"};
# ...
- undef $db ;
- untie %hash ;
+ undef $db;
+ untie %hash;
The code above uses SDBM_File, but it will work with any of the DBM
modules.
@@ -124,7 +124,7 @@
a DBM database it always writes the key and value as strings. So when
you use this:
- $hash{12345} = "something" ;
+ $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
@@ -133,23 +133,23 @@
Here is a DBM Filter that does it:
- use strict ;
- use warnings ;
- use DB_File ;
- my %hash ;
- my $filename = "filt" ;
- unlink $filename ;
+ use strict;
+ use warnings;
+ use DB_File;
+ my %hash;
+ my $filename = "filt";
+ unlink $filename;
my $db = tie %hash, 'DB_File', $filename, O_CREAT|O_RDWR, 0666, $DB_HASH
- or die "Cannot open $filename: $!\n" ;
+ or die "Cannot open $filename: $!\n";
- $db->filter_fetch_key ( sub { $_ = unpack("i", $_) } ) ;
- $db->filter_store_key ( sub { $_ = pack ("i", $_) } ) ;
- $hash{123} = "def" ;
+ $db->filter_fetch_key ( sub { $_ = unpack("i", $_) } );
+ $db->filter_store_key ( sub { $_ = pack ("i", $_) } );
+ $hash{123} = "def";
# ...
- undef $db ;
- untie %hash ;
+ undef $db;
+ untie %hash;
The code above uses DB_File, but again it will work with any of the
DBM modules.
diff perl-blead/pod/perldiag.pod perl-local/pod/perldiag.pod
--- perl-blead/pod/perldiag.pod Mon Oct 31 20:03:32 2005
+++ perl-local/pod/perldiag.pod Mon Oct 31 22:35:02 2005
@@ -4338,7 +4338,7 @@
This warning will not be issued for numerical constants equal to 0 or 1
since they are often used in statements like
- 1 while sub_with_side_effects() ;
+ 1 while sub_with_side_effects();
String constants that would normally evaluate to 0 or 1 are warned
about.
diff perl-blead/pod/perlfaq5.pod perl-local/pod/perlfaq5.pod
--- perl-blead/pod/perlfaq5.pod Wed Oct 26 15:18:56 2005
+++ perl-local/pod/perlfaq5.pod Mon Oct 31 22:34:11 2005
@@ -57,7 +57,7 @@
or IO::Socket:
use IO::Socket; # this one is kinda a pipe?
- my $sock = IO::Socket::INET->new( 'www.example.com:80' ) ;
+ my $sock = IO::Socket::INET->new( 'www.example.com:80' );
$sock->autoflush();
diff perl-blead/pod/perlfilter.pod perl-local/pod/perlfilter.pod
--- perl-blead/pod/perlfilter.pod Mon May 5 23:45:23 2003
+++ perl-local/pod/perlfilter.pod Mon Oct 31 22:33:42 2005
@@ -89,10 +89,10 @@
Line numbers have been added to allow specific lines to be referenced
easily.
- 1: use Filter::cpp ;
+ 1: use Filter::cpp;
2: #define TRUE 1
- 3: $a = TRUE ;
- 4: print "a = $a\n" ;
+ 3: $a = TRUE;
+ 4: print "a = $a\n";
When you execute this script, Perl creates a source stream for the
file. Before the parser processes any of the lines from the file, the
@@ -122,18 +122,18 @@
The parser then sees the following code:
- use Filter::cpp ;
- $a = 1 ;
- print "a = $a\n" ;
+ use Filter::cpp;
+ $a = 1;
+ print "a = $a\n";
Let's consider what happens when the filtered code includes another
module with use:
- 1: use Filter::cpp ;
+ 1: use Filter::cpp;
2: #define TRUE 1
- 3: use Fred ;
- 4: $a = TRUE ;
- 5: print "a = $a\n" ;
+ 3: use Fred;
+ 4: $a = TRUE;
+ 5: print "a = $a\n";
The C<cpp> filter does not apply to the text of the Fred module, only
to the text of the file that used it (C<cpp_test>). Although the use
@@ -160,7 +160,7 @@
possible to stack a uudecode filter and an uncompression filter like
this:
- use Filter::uudecode ; use Filter::uncompress ;
+ use Filter::uudecode; use Filter::uncompress;
M'XL(".H<US4''V9I;F%L')Q;>7/;1I;_>_I3=&E=%:F*I"T?22Q/
M6]9*<IQCO*XFT"0[PL%%'Y+IG?WN^ZYN-$'J.[.JE$,20/?K=_[>
...
@@ -245,9 +245,9 @@
Here is an example script that uses C<Filter::sh>:
- use Filter::sh 'tr XYZ PQR' ;
- $a = 1 ;
- print "XYZ a = $a\n" ;
+ use Filter::sh 'tr XYZ PQR';
+ $a = 1;
+ print "XYZ a = $a\n";
The output you'll get when the script is executed:
@@ -274,23 +274,23 @@
becomes M.)
- package Rot13 ;
+ package Rot13;
- use Filter::Util::Call ;
+ use Filter::Util::Call;
sub import {
- my ($type) = @_ ;
- my ($ref) = [] ;
- filter_add(bless $ref) ;
+ my ($type) = @_;
+ my ($ref) = [];
+ filter_add(bless $ref);
}
sub filter {
- my ($self) = @_ ;
- my ($status) ;
+ my ($self) = @_;
+ my ($status);
tr/n-za-mN-ZA-M/a-zA-Z/
- if ($status = filter_read()) > 0 ;
- $status ;
+ if ($status = filter_read()) > 0;
+ $status;
}
1;
@@ -339,16 +339,16 @@
the source file in rot13 format. The script below, C<mkrot13>, does
just that.
- die "usage mkrot13 filename\n" unless @ARGV ;
- my $in = $ARGV[0] ;
- my $out = "$in.tmp" ;
+ die "usage mkrot13 filename\n" unless @ARGV;
+ my $in = $ARGV[0];
+ my $out = "$in.tmp";
open(IN, "<$in") or die "Cannot open file $in: $!\n";
open(OUT, ">$out") or die "Cannot open file $out: $!\n";
- print OUT "use Rot13;\n" ;
+ print OUT "use Rot13;\n";
while (<IN>) {
- tr/a-zA-Z/n-za-mN-ZA-M/ ;
- print OUT ;
+ tr/a-zA-Z/n-za-mN-ZA-M/;
+ print OUT;
}
close IN;
@@ -358,12 +358,12 @@
If we encrypt this with C<mkrot13>:
- print " hello fred \n" ;
+ print " hello fred \n";
the result will be this:
use Rot13;
- cevag "uryyb serq\a" ;
+ cevag "uryyb serq\a";
Running it produces this output:
@@ -385,7 +385,7 @@
## DEBUG_BEGIN
if ($year > 1999) {
- warn "Debug: millennium bug in year $year\n" ;
+ warn "Debug: millennium bug in year $year\n";
}
## DEBUG_END
@@ -400,7 +400,7 @@
## DEBUG_BEGIN
#if ($year > 1999) {
- # warn "Debug: millennium bug in year $year\n" ;
+ # warn "Debug: millennium bug in year $year\n";
#}
## DEBUG_END
@@ -410,62 +410,62 @@
use strict;
use warnings;
- use Filter::Util::Call ;
+ use Filter::Util::Call;
- use constant TRUE => 1 ;
- use constant FALSE => 0 ;
+ use constant TRUE => 1;
+ use constant FALSE => 0;
sub import {
- my ($type) = @_ ;
+ my ($type) = @_;
my (%context) = (
Enabled => defined $ENV{DEBUG},
InTraceBlock => FALSE,
Filename => (caller)[1],
LineNo => 0,
LastBegin => 0,
- ) ;
- filter_add(bless \%context) ;
+ );
+ filter_add(bless \%context);
}
sub Die {
- my ($self) = shift ;
- my ($message) = shift ;
- my ($line_no) = shift || $self->{LastBegin} ;
+ my ($self) = shift;
+ my ($message) = shift;
+ my ($line_no) = shift || $self->{LastBegin};
die "$message at $self->{Filename} line $line_no.\n"
}
sub filter {
- my ($self) = @_ ;
- my ($status) ;
- $status = filter_read() ;
- ++ $self->{LineNo} ;
+ my ($self) = @_;
+ my ($status);
+ $status = filter_read();
+ ++ $self->{LineNo};
# deal with EOF/error first
if ($status <= 0) {
$self->Die("DEBUG_BEGIN has no DEBUG_END")
- if $self->{InTraceBlock} ;
- return $status ;
+ if $self->{InTraceBlock};
+ return $status;
}
if ($self->{InTraceBlock}) {
if (/^\s*##\s*DEBUG_BEGIN/ ) {
$self->Die("Nested DEBUG_BEGIN", $self->{LineNo})
} elsif (/^\s*##\s*DEBUG_END/) {
- $self->{InTraceBlock} = FALSE ;
+ $self->{InTraceBlock} = FALSE;
}
# comment out the debug lines when the filter is disabled
- s/^/#/ if ! $self->{Enabled} ;
+ s/^/#/ if ! $self->{Enabled};
} elsif ( /^\s*##\s*DEBUG_BEGIN/ ) {
- $self->{InTraceBlock} = TRUE ;
- $self->{LastBegin} = $self->{LineNo} ;
+ $self->{InTraceBlock} = TRUE;
+ $self->{LastBegin} = $self->{LineNo};
} elsif ( /^\s*##\s*DEBUG_END/ ) {
$self->Die("DEBUG_END has no DEBUG_BEGIN", $self->{LineNo});
}
- return $status ;
+ return $status;
}
- 1 ;
+ 1;
The big difference between this filter and the previous example is the
use of context data in the filter object. The filter object is based on
@@ -481,23 +481,23 @@
essence of the filter is as follows:
sub filter {
- my ($self) = @_ ;
- my ($status) ;
- $status = filter_read() ;
+ my ($self) = @_;
+ my ($status);
+ $status = filter_read();
# deal with EOF/error first
- return $status if $status <= 0 ;
+ return $status if $status <= 0;
if ($self->{InTraceBlock}) {
if (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = FALSE
}
# comment out debug lines when the filter is disabled
- s/^/#/ if ! $self->{Enabled} ;
+ s/^/#/ if ! $self->{Enabled};
} elsif ( /^\s*##\s*DEBUG_BEGIN/ ) {
- $self->{InTraceBlock} = TRUE ;
+ $self->{InTraceBlock} = TRUE;
}
- return $status ;
+ return $status;
}
Be warned: just as the C-preprocessor doesn't know C, the Debug filter
@@ -539,9 +539,9 @@
into this:
sub MySub($$@) {
- my ($first) = shift ;
- my ($second) = shift ;
- my (@rest) = @_ ;
+ my ($first) = shift;
+ my ($second) = shift;
+ my (@rest) = @_;
...
}
diff perl-blead/pod/perlipc.pod perl-local/pod/perlipc.pod
--- perl-blead/pod/perlipc.pod Sun Jun 12 12:27:42 2005
+++ perl-local/pod/perlipc.pod Mon Oct 31 22:31:32 2005
@@ -1012,7 +1012,7 @@
my $rtime = ' ';
read(SOCKET, $rtime, 4);
close(SOCKET);
- my $histime = unpack("N", $rtime) - $SECS_of_70_YEARS ;
+ my $histime = unpack("N", $rtime) - $SECS_of_70_YEARS;
printf "%8d %s\n", $histime - time, ctime($histime);
}
@@ -1516,7 +1516,7 @@
($hispaddr = recv(SOCKET, $rtime, 4, 0)) || die "recv: $!";
($port, $hisiaddr) = sockaddr_in($hispaddr);
$host = gethostbyaddr($hisiaddr, AF_INET);
- $histime = unpack("N", $rtime) - $SECS_of_70_YEARS ;
+ $histime = unpack("N", $rtime) - $SECS_of_70_YEARS;
printf "%-12s ", $host;
printf "%8d %s\n", $histime - time, scalar localtime($histime);
$count--;
diff perl-blead/pod/perllexwarn.pod perl-local/pod/perllexwarn.pod
--- perl-blead/pod/perllexwarn.pod Thu Oct 13 13:50:09 2005
+++ perl-local/pod/perllexwarn.pod Mon Oct 31 22:31:15 2005
@@ -20,21 +20,21 @@
All warnings are enabled in a block by either of these:
- use warnings ;
- use warnings 'all' ;
+ use warnings;
+ use warnings 'all';
Similarly all warnings are disabled in a block by either of these:
- no warnings ;
- no warnings 'all' ;
+ no warnings;
+ no warnings 'all';
For example, consider the code below:
- use warnings ;
- my @a ;
+ use warnings;
+ my @a;
{
- no warnings ;
- my $b = @a[0] ;
+ no warnings;
+ my $b = @a[0];
}
my $c = @a[0];
@@ -63,7 +63,7 @@
be reported for the C<$a> variable.
my $a = "2:" + 3;
- no warnings ;
+ no warnings;
my $b = "2:" + 3;
Note that neither the B<-w> flag or the C<$^W> can be used to
@@ -83,9 +83,9 @@
a block of code. You might expect this to be enough to do the trick:
{
- local ($^W) = 0 ;
- my $a =+ 2 ;
- my $b ; chop $b ;
+ local ($^W) = 0;
+ my $a =+ 2;
+ my $b; chop $b;
}
When this code is run with the B<-w> flag, a warning will be produced
@@ -96,8 +96,8 @@
{
BEGIN { $^W = 0 }
- my $a =+ 2 ;
- my $b ; chop $b ;
+ my $a =+ 2;
+ my $b; chop $b;
}
The other big problem with C<$^W> is the way you can inadvertently
@@ -108,13 +108,13 @@
sub doit
{
- my $b ; chop $b ;
+ my $b; chop $b;
}
- doit() ;
+ doit();
{
- local ($^W) = 1 ;
+ local ($^W) = 1;
doit()
}
@@ -306,17 +306,17 @@
Just like the "strict" pragma any of these categories can be combined
- use warnings qw(void redefine) ;
- no warnings qw(io syntax untie) ;
+ use warnings qw(void redefine);
+ no warnings qw(io syntax untie);
Also like the "strict" pragma, if there is more than one instance of the
C<warnings> pragma in a given scope the cumulative effect is additive.
- use warnings qw(void) ; # only "void" warnings enabled
+ use warnings qw(void); # only "void" warnings enabled
...
- use warnings qw(io) ; # only "void" & "io" warnings enabled
+ use warnings qw(io); # only "void" & "io" warnings enabled
...
- no warnings qw(void) ; # only "io" warnings enabled
+ no warnings qw(void); # only "io" warnings enabled
To determine which category a specific warning has been assigned to see
L<perldiag>.
@@ -335,18 +335,18 @@
and C<join> can all produce a C<"Useless use of xxx in void context">
warning.
- use warnings ;
+ use warnings;
- time ;
+ time;
{
- use warnings FATAL => qw(void) ;
- length "abc" ;
+ use warnings FATAL => qw(void);
+ length "abc";
}
- join "", 1,2,3 ;
+ join "", 1,2,3;
- print "done\n" ;
+ print "done\n";
When run it produces this output
@@ -386,7 +386,7 @@
use warnings::register;
sub open {
- my $path = shift ;
+ my $path = shift;
if ($path !~ m#^/#) {
warnings::warn("changing relative path to /var/abc")
if warnings::enabled();
@@ -394,7 +394,7 @@
}
}
- 1 ;
+ 1;
The call to C<warnings::register> will create a new warnings category
called "MyMod::abc", i.e. the new category name matches the current
@@ -416,13 +416,13 @@
sub open {
warnings::warnif("deprecated",
- "open is deprecated, use new instead") ;
- new(@_) ;
+ "open is deprecated, use new instead");
+ new(@_);
}
sub new
...
- 1 ;
+ 1;
The function C<open> has been deprecated, so code has been included to
display a warning message whenever the calling module has (at least) the
@@ -431,7 +431,7 @@
use warnings 'deprecated';
use MyMod::Abc;
...
- MyMod::Abc::open($filename) ;
+ MyMod::Abc::open($filename);
Either the C<warnings::warn> or C<warnings::warnif> function should be
used to actually display the warnings message. This is because they can
@@ -453,21 +453,21 @@
Consider this example:
- package Original ;
+ package Original;
- no warnings ;
- use warnings::register ;
+ no warnings;
+ use warnings::register;
sub new
{
- my $class = shift ;
- bless [], $class ;
+ my $class = shift;
+ bless [], $class;
}
sub check
{
- my $self = shift ;
- my $value = shift ;
+ my $self = shift;
+ my $value = shift;
if ($value % 2 && warnings::enabled($self))
{ warnings::warn($self, "Odd numbers are unsafe") }
@@ -475,38 +475,38 @@
sub doit
{
- my $self = shift ;
- my $value = shift ;
- $self->check($value) ;
+ my $self = shift;
+ my $value = shift;
+ $self->check($value);
# ...
}
- 1 ;
+ 1;
- package Derived ;
+ package Derived;
- use warnings::register ;
- use Original ;
- our @ISA = qw( Original ) ;
+ use warnings::register;
+ use Original;
+ our @ISA = qw( Original );
sub new
{
- my $class = shift ;
- bless [], $class ;
+ my $class = shift;
+ bless [], $class;
}
- 1 ;
+ 1;
The code below makes use of both modules, but it only enables warnings from
C<Derived>.
- use Original ;
- use Derived ;
+ use Original;
+ use Derived;
use warnings 'Derived';
- my $a = new Original ;
- $a->doit(1) ;
- my $b = new Derived ;
- $a->doit(1) ;
+ my $a = new Original;
+ $a->doit(1);
+ my $b = new Derived;
+ $a->doit(1);
When this code is run only the C<Derived> object, C<$b>, will generate
a warning.
diff perl-blead/pod/perlop.pod perl-local/pod/perlop.pod
--- perl-blead/pod/perlop.pod Thu Oct 13 13:50:09 2005
+++ perl-local/pod/perlop.pod Mon Oct 31 22:27:57 2005
@@ -2215,8 +2215,8 @@
a B<numeric> bitwise operation. You may explicitly show which type of
operation you intend by using C<""> or C<0+>, as in the examples below.
- $foo = 150 | 105 ; # yields 255 (0x96 | 0x69 is 0xFF)
- $foo = '150' | 105 ; # yields 255
+ $foo = 150 | 105; # yields 255 (0x96 | 0x69 is 0xFF)
+ $foo = '150' | 105; # yields 255
$foo = 150 | '105'; # yields 255
$foo = '150' | '105'; # yields string '155' (under ASCII)
diff perl-blead/pod/perlre.pod perl-local/pod/perlre.pod
--- perl-blead/pod/perlre.pod Thu Oct 13 13:50:09 2005
+++ perl-local/pod/perlre.pod Mon Oct 31 22:27:10 2005
@@ -960,14 +960,14 @@
claims that there is no 123 in the string. Here's a clearer picture of
why that pattern matches, contrary to popular expectations:
- $x = 'ABC123' ;
- $y = 'ABC445' ;
+ $x = 'ABC123';
+ $y = 'ABC445';
- print "1: got $1\n" if $x =~ /^(ABC)(?!123)/ ;
- print "2: got $1\n" if $y =~ /^(ABC)(?!123)/ ;
+ print "1: got $1\n" if $x =~ /^(ABC)(?!123)/;
+ print "2: got $1\n" if $y =~ /^(ABC)(?!123)/;
- print "3: got $1\n" if $x =~ /^(\D*)(?!123)/ ;
- print "4: got $1\n" if $y =~ /^(\D*)(?!123)/ ;
+ print "3: got $1\n" if $x =~ /^(\D*)(?!123)/;
+ print "4: got $1\n" if $y =~ /^(\D*)(?!123)/;
This prints
@@ -1002,8 +1002,8 @@
of the string in their match. So rewriting this way produces what
you'd expect; that is, case 5 will fail, but case 6 succeeds:
- print "5: got $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/ ;
- print "6: got $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/ ;
+ print "5: got $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/;
+ print "6: got $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/;
6: got ABC
diff perl-blead/pod/perlsub.pod perl-local/pod/perlsub.pod
--- perl-blead/pod/perlsub.pod Fri Oct 21 17:35:01 2005
+++ perl-local/pod/perlsub.pod Mon Oct 31 22:26:20 2005
@@ -573,7 +573,7 @@
# Read the whole contents of FILE in $slurp
{ local $/ = undef; $slurp = <FILE>; }
-Note, however, that this restricts localization of some values ; for
+Note, however, that this restricts localization of some values; for
example, the following statement dies, as of perl 5.9.0, with an error
I<Modification of a read-only value attempted>, because the $1 variable is
magical and read-only :
@@ -1400,17 +1400,17 @@
Examples of valid syntax (even though the attributes are unknown):
- sub fnord (&\%) : switch(10,foo(7,3)) : expensive ;
- sub plugh () : Ugly('\(") :Bad ;
+ sub fnord (&\%) : switch(10,foo(7,3)) : expensive;
+ sub plugh () : Ugly('\(") :Bad;
sub xyzzy : _5x5 { ... }
Examples of invalid syntax:
- sub fnord : switch(10,foo() ; # ()-string not balanced
- sub snoid : Ugly('(') ; # ()-string not balanced
- sub xyzzy : 5x5 ; # "5x5" not a valid identifier
- sub plugh : Y2::north ; # "Y2::north" not a simple identifier
- sub snurt : foo + bar ; # "+" not a colon or space
+ sub fnord : switch(10,foo(); # ()-string not balanced
+ sub snoid : Ugly('('); # ()-string not balanced
+ sub xyzzy : 5x5; # "5x5" not a valid identifier
+ sub plugh : Y2::north; # "Y2::north" not a simple identifier
+ sub snurt : foo + bar; # "+" not a colon or space
The attribute list is passed as a list of constant strings to the code
which associates them with the subroutine. In particular, the second example
diff perl-blead/pod/perltrap.pod perl-local/pod/perltrap.pod
--- perl-blead/pod/perltrap.pod Sun Apr 3 19:14:16 2005
+++ perl-local/pod/perltrap.pod Mon Oct 31 22:24:40 2005
@@ -448,8 +448,8 @@
whether this should be classed as a bug or not.
(The older package delimiter, ' ,is used here)
- $x = 10 ;
- print "x=${'x}\n" ;
+ $x = 10;
+ print "x=${'x}\n";
# perl4 prints: x=10
# perl5 prints: Can't find string terminator "'" anywhere before EOF
@@ -457,8 +457,8 @@
You can avoid this problem, and remain compatible with perl4, if you
always explicitly include the package name:
- $x = 10 ;
- print "x=${main'x}\n" ;
+ $x = 10;
+ print "x=${main'x}\n";
Also see precedence traps, for parsing C<$:>.
@@ -497,7 +497,7 @@
Double darn.
$a = ("foo bar");
- $b = q baz ;
+ $b = q baz;
print "a is $a, b is $b\n";
# perl4 prints: a is foo bar, b is baz
@@ -1219,7 +1219,7 @@
$opt = 'r';
$_ = 'bar';
s/^([^$grpc]*$grpc[$opt]?)/foo/;
- print ;
+ print;
# perl4 prints: foo
# perl5 prints: foobar
@@ -1334,11 +1334,11 @@
the file.
open(TEST,">>seek.test");
- $start = tell TEST ;
+ $start = tell TEST;
foreach(1 .. 9){
print TEST "$_ ";
}
- $end = tell TEST ;
+ $end = tell TEST;
seek(TEST,$start,0);
print TEST "18 characters here";
diff perl-blead/pod/perlxs.pod perl-local/pod/perlxs.pod
--- perl-blead/pod/perlxs.pod Mon Aug 1 10:42:33 2005
+++ perl-local/pod/perlxs.pod Mon Oct 31 21:57:52 2005
@@ -588,7 +588,7 @@
bool_t
rpcb_gettime(host,timep)
- time_t &timep ; /* \$v{timep}=@{[$v{timep}=$arg]} */
+ time_t &timep; /* \$v{timep}=@{[$v{timep}=$arg]} */
char *host + SvOK($v{timep}) ? SvPV($arg,PL_na) : NULL;
OUTPUT:
timep
@@ -1902,7 +1902,7 @@
dMY_CXT;
CODE:
if (MY_CXT.count >= 3) {
- warn("Already have 3 blind mice") ;
+ warn("Already have 3 blind mice");
RETVAL = 0;
}
else {
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic