This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perlre: Fix some line wrap issues
authorKarl Williamson <public@khwilliamson.com>
Sat, 28 May 2011 22:16:43 +0000 (16:16 -0600)
committerKarl Williamson <public@khwilliamson.com>
Sun, 29 May 2011 01:00:04 +0000 (19:00 -0600)
This fixes some issues with the pod wrapping verbatim in 80 column
windows by indenting less, and not having the comments so far to the
right

pod/perlre.pod
t/porting/known_pod_issues.dat

index 2af5779..f779b8b 100644 (file)
@@ -1168,16 +1168,17 @@ C<local>ization are undone, so that
 
   $_ = 'a' x 8;
   m<
-     (?{ $cnt = 0 })                   # Initialize $cnt.
+     (?{ $cnt = 0 })               # Initialize $cnt.
      (
        a
        (?{
-           local $cnt = $cnt + 1;      # Update $cnt, backtracking-safe.
+           local $cnt = $cnt + 1;  # Update $cnt,
+                                   # backtracking-safe.
        })
      )*
      aaaa
-     (?{ $res = $cnt })                # On success copy to
-                                       # non-localized location.
+     (?{ $res = $cnt })            # On success copy to
+                                   # non-localized location.
    >x;
 
 will set C<$res = 4>.  Note that after the match, C<$cnt> returns to the globally
@@ -1253,15 +1254,15 @@ where the C<code> ends are currently somewhat convoluted.
 
 The following pattern matches a parenthesized group:
 
 $re = qr{
-             \(
-             (?:
-                (?> [^()]+ )       # Non-parens without backtracking
-              |
-                (??{ $re })        # Group with matching parens
-             )*
-             \)
-          }x;
+ $re = qr{
+            \(
+            (?:
+               (?> [^()]+ )  # Non-parens without backtracking
+             |
+               (??{ $re })   # Group with matching parens
+            )*
+            \)
+         }x;
 
 See also C<(?PARNO)> for a different, more efficient way to accomplish
 the same task.
@@ -1305,15 +1306,15 @@ included.
 The following pattern matches a function foo() which may contain
 balanced parentheses as the argument.
 
-  $re = qr{ (                    # paren group 1 (full function)
+  $re = qr{ (                   # paren group 1 (full function)
               foo
-              (                  # paren group 2 (parens)
+              (                 # paren group 2 (parens)
                 \(
-                  (              # paren group 3 (contents of parens)
+                  (             # paren group 3 (contents of parens)
                   (?:
-                   (?> [^()]+ )  # Non-parens without backtracking
+                   (?> [^()]+ ) # Non-parens without backtracking
                   |
-                   (?2)          # Recurse to start of paren group 2
+                   (?2)         # Recurse to start of paren group 2
                   )*
                   )
                 \)
@@ -1696,8 +1697,8 @@ executing the (*SKIP) pattern.
 Compare the following to the examples in C<(*PRUNE)>; note the string
 is twice as long:
 
   'aaabaaab' =~ /a+b?(*SKIP)(?{print "$&\n"; $count++})(*FAIL)/;
   print "Count=$count\n";
+ 'aaabaaab' =~ /a+b?(*SKIP)(?{print "$&\n"; $count++})(*FAIL)/;
+ print "Count=$count\n";
 
 outputs
 
@@ -1790,8 +1791,8 @@ into on failure it causes the match to fail outright. No further attempts
 to find a valid match by advancing the start pointer will occur again.
 For example,
 
   'aaabaaab' =~ /a+b?(*COMMIT)(?{print "$&\n"; $count++})(*FAIL)/;
   print "Count=$count\n";
+ 'aaabaaab' =~ /a+b?(*COMMIT)(?{print "$&\n"; $count++})(*FAIL)/;
+ print "Count=$count\n";
 
 outputs
 
@@ -2181,7 +2182,7 @@ However, long experience has shown that many programming tasks may
 be significantly simplified by using repeated subexpressions that
 may match zero-length substrings.  Here's a simple example being:
 
-    @chars = split //, $string;                  # // is not magic in split
+    @chars = split //, $string;           # // is not magic in split
     ($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /
 
 Thus Perl allows such constructs, by I<forcefully breaking
index 4a503d1..4d11a95 100644 (file)
@@ -283,7 +283,7 @@ pod/perlpodspec.pod Verbatim line length including indents exceeds 80 by    9
 pod/perlpodstyle.pod   Verbatim line length including indents exceeds 80 by    1
 pod/perlport.pod       Apparent broken link    27
 pod/perlre.pod ? Should you be using L<...> instead of 1
-pod/perlre.pod Verbatim line length including indents exceeds 80 by    11
+pod/perlre.pod Verbatim line length including indents exceeds 80 by    5
 pod/perlreapi.pod      Verbatim line length including indents exceeds 80 by    17
 pod/perlrebackslash.pod        Verbatim line length including indents exceeds 80 by    1
 pod/perlref.pod        Verbatim line length including indents exceeds 80 by    1