fixes perl_clone of perl_clone

[p5sagit/p5-mst-13.2.git] / pod / perlop.pod

diff --git a/pod/perlop.pod b/pod/perlop.pod
index 5cfdb4a..9ae3918 100644 (file)
--- a/pod/perlop.pod
+++ b/pod/perlop.pod
@@ -233,6 +233,18 @@ Binary ">>" returns the value of its left argument shifted right by
 the number of bits specified by the right argument.  Arguments should
 be integers.  (See also L<Integer Arithmetic>.)
 
+Note that both "<<" and ">>" in Perl are implemented directly using
+"<<" and ">>" in C.  If C<use integer> (see L<Integer Arithmetic>) is
+in force then signed C integers are used, else unsigned C integers are
+used.  Either way, the implementation isn't going to generate results
+larger than the size of the integer type Perl was built with (32 bits
+or 64 bits).
+
+The result of overflowing the range of the integers is undefined
+because it is undefined also in C.  In other words, using 32-bit
+integers, C<< 1 << 32 >> is undefined.  Shifting by a negative number
+of bits is also undefined.
+
 =head2 Named Unary Operators
 
 The various named unary operators are treated as functions with one
@@ -646,13 +658,15 @@ any pair of delimiters you choose.
     Customary  Generic        Meaning       Interpolates
        ''       q{}          Literal             no
        ""      qq{}          Literal             yes
-       ``      qx{}          Command             yes (unless '' is delimiter)
+       ``      qx{}          Command             yes*
                qw{}         Word list            no
-       //       m{}       Pattern match          yes (unless '' is delimiter)
-               qr{}          Pattern             yes (unless '' is delimiter)
-                s{}{}      Substitution          yes (unless '' is delimiter)
+       //       m{}       Pattern match          yes*
+               qr{}          Pattern             yes*
+                s{}{}      Substitution          yes*
                tr{}{}    Transliteration         no (but see below)
 
+       * unless the delimiter is ''.
+
 Non-bracketing delimiters use the same character fore and aft, but the four
 sorts of brackets (round, angle, square, curly) will all nest, which means
 that 
@@ -680,9 +694,8 @@ from the next line.  This allows you to write:
     s {foo}  # Replace foo
       {bar}  # with bar.
 
-For constructs that do interpolate, variables beginning with "C<$>"
-or "C<@>" are interpolated, as are the following escape sequences.  Within
-a transliteration, the first eleven of these sequences may be used.
+The following escape sequences are available in constructs that interpolate
+and in transliterations.
 
     \t         tab             (HT, TAB)
     \n         newline         (NL)
@@ -697,6 +710,9 @@ a transliteration, the first eleven of these sequences may be used.
     \c[                control char    (ESC)
     \N{name}   named char
 
+The following escape sequences are available in constructs that interpolate
+but not in transliterations.
+
     \l         lowercase next char
     \u         uppercase next char
     \L         lowercase till \E
@@ -722,6 +738,16 @@ and although they often accept just C<"\012">, they seldom tolerate just
 C<"\015">.  If you get in the habit of using C<"\n"> for networking,
 you may be burned some day.
 
+For constructs that do interpolate, variables beginning with "C<$>"
+or "C<@>" are interpolated.  Subscripted variables such as C<$a[3]> or
+C<$href->{key}[0]> are also interpolated, as are array and hash slices.
+But method calls such as C<$obj->meth> are not.
+
+Interpolating an array or slice interpolates the elements in order,
+separated by the value of C<$">, so is equivalent to interpolating
+C<join $", @array>.    "Punctuation" arrays such as C<@+> are only
+interpolated if the name is enclosed in braces C<@{+}>.
+
 You cannot include a literal C<$> or C<@> within a C<\Q> sequence. 
 An unescaped C<$> or C<@> interpolates the corresponding variable, 
 while escaping will cause the literal string C<\$> to be inserted.