Change 26073: [PATCH] remove whitespace preceding semicolon in docs
[email protected] (Rafael Garcia-Suarez) Thu, 10 Nov 2005 03:27:37 -0800
| Newsgroups | perl.perlfaq.workers,perl.perl5.changes |
|---|---|
| Message-ID | <[email protected]> |
Change 26073 by rgs@bloom on 2005/11/10 10:52:51 Subject: [PATCH] remove whitespace preceding semicolon in docs From: Steven Schubiger <[email protected]> Date: Mon, 31 Oct 2005 22:48:27 +0100 Message-ID: <[email protected]> Affected files ... ... //depot/perl/pod/perl561delta.pod#12 edit ... //depot/perl/pod/perl56delta.pod#23 edit ... //depot/perl/pod/perlcall.pod#27 edit ... //depot/perl/pod/perldbmfilter.pod#8 edit ... //depot/perl/pod/perldiag.pod#421 edit ... //depot/perl/pod/perlfaq5.pod#64 edit ... //depot/perl/pod/perlfilter.pod#11 edit ... //depot/perl/pod/perlipc.pod#61 edit ... //depot/perl/pod/perllexwarn.pod#28 edit ... //depot/perl/pod/perlop.pod#133 edit ... //depot/perl/pod/perlre.pod#92 edit ... //depot/perl/pod/perlsub.pod#62 edit ... //depot/perl/pod/perltrap.pod#36 edit ... //depot/perl/pod/perlxs.pod#46 edit Differences ... ==== //depot/perl/pod/perl561delta.pod#12 (text) ==== Index: perl/pod/perl561delta.pod --- perl/pod/perl561delta.pod#11~26047~ Tue Nov 8 09:35:58 2005 +++ perl/pod/perl561delta.pod Thu Nov 10 02:52:51 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 { ... ==== //depot/perl/pod/perl56delta.pod#23 (text) ==== Index: perl/pod/perl56delta.pod --- perl/pod/perl56delta.pod#22~26047~ Tue Nov 8 09:35:58 2005 +++ perl/pod/perl56delta.pod Thu Nov 10 02:52:51 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 { ... ==== //depot/perl/pod/perlcall.pod#27 (text) ==== Index: perl/pod/perlcall.pod --- perl/pod/perlcall.pod#26~26054~ Wed Nov 9 01:15:04 2005 +++ perl/pod/perlcall.pod Thu Nov 10 02:52:51 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 @@ -389,7 +389,7 @@ sub PrintUID { - print "UID is $<\n" ; + print "UID is $<\n"; } and here is a C function to call it @@ -397,10 +397,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. @@ -450,31 +450,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>. @@ -540,13 +540,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 @@ -582,8 +582,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 @@ -591,32 +591,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 @@ -687,46 +687,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 @@ -757,33 +757,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 @@ -791,7 +791,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 @@ -813,44 +813,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 @@ -872,54 +872,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 @@ -948,13 +948,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 @@ -981,7 +981,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); } @@ -1016,10 +1016,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>. @@ -1027,8 +1027,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, @@ -1043,16 +1043,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. @@ -1062,30 +1062,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. @@ -1097,10 +1097,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) @@ -1120,10 +1120,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 @@ -1132,7 +1132,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) @@ -1141,16 +1141,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, @@ -1167,7 +1167,7 @@ sub PrintList { - my(@list) = @_ ; + my(@list) = @_; foreach (@list) { print "$_\n" } } @@ -1175,14 +1175,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. @@ -1193,24 +1193,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"; } } @@ -1220,8 +1220,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 @@ -1260,10 +1260,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) @@ -1271,17 +1271,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 @@ -1297,17 +1297,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 @@ -1338,11 +1338,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). @@ -1441,7 +1441,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 @@ -1449,8 +1449,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 @@ -1460,12 +1460,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); } @@ -1475,22 +1475,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 @@ -1522,8 +1522,8 @@ void ProcessRead(fh, buffer) - int fh ; - char * buffer ; + int fh; + char * buffer; { ... } @@ -1533,7 +1533,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) @@ -1542,36 +1542,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 @@ -1582,22 +1582,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 @@ -1610,7 +1610,7 @@ void ProcessRead(buffer) - char * buffer ; + char * buffer; { ... } @@ -1623,59 +1623,59 @@ #define MAX_CB 3 #define NULL_HANDLE -1 - typedef void (*FnMap)() ; + typedef void (*FnMap)(); struct MapStruct { - FnMap Function ; - SV * PerlSub ; - int Handle ; - } ; - - static void fn1() ; - static void fn2() ; - static void fn3() ; + FnMap Function; + SV * PerlSub; + int Handle; + }; + + 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 @@ -1683,55 +1683,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 @@ -1793,36 +1793,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 @@ -1840,9 +1840,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. ==== //depot/perl/pod/perldbmfilter.pod#8 (text) ==== Index: perl/pod/perldbmfilter.pod --- perl/pod/perldbmfilter.pod#7~22258~ Sun Feb 1 09:40:02 2004 +++ perl/pod/perldbmfilter.pod Thu Nov 10 02:52:51 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 ; - - my %hash ; - my $filename = "filt" ; - unlink $filename ; + use strict; + use warnings; + use SDBM_File; + use Fcntl; + + 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. ==== //depot/perl/pod/perldiag.pod#421 (text) ==== Index: perl/pod/perldiag.pod --- perl/pod/perldiag.pod#420~26040~ Mon Nov 7 16:41:51 2005 +++ perl/pod/perldiag.pod Thu Nov 10 02:52:51 2005 @@ -4344,7 +4344,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. ==== //depot/perl/pod/perlfaq5.pod#64 (text) ==== Index: perl/pod/perlfaq5.pod --- perl/pod/perlfaq5.pod#63~25857~ Wed Oct 26 05:52:37 2005 +++ perl/pod/perlfaq5.pod Thu Nov 10 02:52:51 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(); ==== //depot/perl/pod/perlfilter.pod#11 (text) ==== Index: perl/pod/perlfilter.pod --- perl/pod/perlfilter.pod#10~19432~ Mon May 5 13:31:22 2003 +++ perl/pod/perlfilter.pod Thu Nov 10 02:52:51 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) = @_; ... } ==== //depot/perl/pod/perlipc.pod#61 (text) ==== Index: perl/pod/perlipc.pod --- perl/pod/perlipc.pod#60~24807~ Sun Jun 12 02:58:32 2005 +++ perl/pod/perlipc.pod Thu Nov 10 02:52:51 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--; ==== //depot/perl/pod/perllexwarn.pod#28 (text) ==== Index: perl/pod/perllexwarn.pod --- perl/pod/perllexwarn.pod#27~25748~ Thu Oct 13 04:20:23 2005 +++ perl/pod/perllexwarn.pod Thu Nov 10 02:52:51 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. ==== //depot/perl/pod/perlop.pod#133 (text) ==== Index: perl/pod/perlop.pod --- perl/pod/perlop.pod#132~25748~ Thu Oct 13 04:20:23 2005 +++ perl/pod/perlop.pod Thu Nov 10 02:52:51 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) ==== //depot/perl/pod/perlre.pod#92 (text) ==== Index: perl/pod/perlre.pod --- perl/pod/perlre.pod#91~25748~ Thu Oct 13 04:20:23 2005 +++ perl/pod/perlre.pod Thu Nov 10 02:52:51 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 ==== //depot/perl/pod/perlsub.pod#62 (text) ==== Index: perl/pod/perlsub.pod --- perl/pod/perlsub.pod#61~25816~ Fri Oct 21 08:06:13 2005 +++ perl/pod/perlsub.pod Thu Nov 10 02:52:51 2005 @@ -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 ==== //depot/perl/pod/perltrap.pod#36 (text) ==== Index: perl/pod/perltrap.pod --- perl/pod/perltrap.pod#35~24147~ Sun Apr 3 09:47:54 2005 +++ perl/pod/perltrap.pod Thu Nov 10 02:52:51 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"; ==== //depot/perl/pod/perlxs.pod#46 (text) ==== Index: perl/pod/perlxs.pod --- perl/pod/perlxs.pod#45~25253~ Mon Aug 1 01:13:10 2005 +++ perl/pod/perlxs.pod Thu Nov 10 02:52:51 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 { End of Patch.