develooper Front page | perl.perl5.porters | Postings from October 2005

[PATCH] remove whitespace preceding semicolon in docs

Thread Next
From:
Steven Schubiger
Date:
October 31, 2005 13:41
Subject:
[PATCH] remove whitespace preceding semicolon in docs
Message ID:
20051031214827.GH24416@accognoscere.homeunix.org
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 {



Thread Next


nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About