X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlop.pod;h=9cae3a21636583482acfe1738899a3e64ea1ab83;hb=7221edc9750be886310d7277b3cbdafafc49218c;hp=3234131f9076e0652f0ffe78e1a862b6dbe92354;hpb=87275199ef473a0bd08ce6f46db30d4d432f4876;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perlop.pod b/pod/perlop.pod index 3234131..9cae3a2 100644 --- a/pod/perlop.pod +++ b/pod/perlop.pod @@ -95,7 +95,7 @@ as well as L<"I/O Operators">. =head2 The Arrow Operator -"C<-E>" is an infix dereference operator, just as it is in C +"C<< -> >>" is an infix dereference operator, just as it is in C and C++. If the right side is either a C<[...]>, C<{...}>, or a C<(...)> subscript, then the left side must be either a hard or symbolic reference to an array, a hash, or a subroutine respectively. @@ -119,7 +119,7 @@ you increment a variable that is numeric, or that has ever been used in a numeric context, you get a normal increment. If, however, the variable has been used in only string contexts since it was set, and has a value that is not the empty string and matches the pattern -C, the increment is done as a string, preserving each +C, the increment is done as a string, preserving each character within its range, with carry: print ++($foo = '99'); # prints '100' @@ -148,9 +148,12 @@ starts with a plus or minus, a string starting with the opposite sign is returned. One effect of these rules is that C<-bareword> is equivalent to C<"-bareword">. -Unary "~" performs bitwise negation, i.e., 1's complement. For example, -C<0666 &~ 027> is 0640. (See also L and L.) +Unary "~" performs bitwise negation, i.e., 1's complement. For +example, C<0666 & ~027> is 0640. (See also L and +L.) Note that the width of the result is +platform-dependent: ~0 is 32 bits wide on a 32-bit platform, but 64 +bits wide on a 64-bit platform, so if you are expecting a certain bit +width, remember use the & operator to mask off the excess bits. Unary "+" has no effect whatsoever, even on strings. It is useful syntactically for separating a function name from a parenthesized expression @@ -169,10 +172,13 @@ search or modify the string $_ by default. This operator makes that kind of operation work on some other string. The right argument is a search pattern, substitution, or transliteration. The left argument is what is supposed to be searched, substituted, or transliterated instead of the default -$_. The return value indicates the success of the operation. (If the -right argument is an expression rather than a search pattern, +$_. When used in scalar context, the return value generally indicates the +success of the operation. Behavior in list context depends on the particular +operator. See L for details. + +If the right argument is an expression rather than a search pattern, substitution, or transliteration, it is interpreted as a search pattern at run -time. This can be is less efficient than an explicit search, because the +time. This can be less efficient than an explicit search, because the pattern must be compiled every time the expression is evaluated. Binary "!~" is just like "=~" except the return value is negated in @@ -190,15 +196,16 @@ C<$a> minus the largest multiple of C<$b> that is not greater than C<$a>. If C<$b> is negative, then C<$a % $b> is C<$a> minus the smallest multiple of C<$b> that is not less than C<$a> (i.e. the result will be less than or equal to zero). -Note than when C is in scope, "%" give you direct access +Note than when C is in scope, "%" gives you direct access to the modulus operator as implemented by your C compiler. This operator is not as well defined for negative operands, but it will execute faster. -Binary "x" is the repetition operator. In scalar context, it -returns a string consisting of the left operand repeated the number of -times specified by the right operand. In list context, if the left -operand is a list in parentheses, it repeats the list. +Binary "x" is the repetition operator. In scalar context or if the left +operand is not enclosed in parentheses, it returns a string consisting +of the left operand repeated the number of times specified by the right +operand. In list context, if the left operand is enclosed in +parentheses, it repeats the list. print '-' x 80; # print row of dashes @@ -235,14 +242,15 @@ operators, like C<-f>, C<-M>, etc. See L. If any list operator (print(), etc.) or any unary operator (chdir(), etc.) is followed by a left parenthesis as the next token, the operator and arguments within parentheses are taken to be of highest precedence, -just like a normal function call. Examples: +just like a normal function call. For example, +because named unary operators are higher precedence than ||: chdir $foo || die; # (chdir $foo) || die chdir($foo) || die; # (chdir $foo) || die chdir ($foo) || die; # (chdir $foo) || die chdir +($foo) || die; # (chdir $foo) || die -but, because * is higher precedence than ||: +but, because * is higher precedence than named operators: chdir $foo * 20; # chdir ($foo * 20) chdir($foo) * 20; # (chdir $foo) * 20 @@ -258,16 +266,16 @@ See also L<"Terms and List Operators (Leftward)">. =head2 Relational Operators -Binary "E" returns true if the left argument is numerically less than +Binary "<" returns true if the left argument is numerically less than the right argument. -Binary "E" returns true if the left argument is numerically greater +Binary ">" returns true if the left argument is numerically greater than the right argument. -Binary "E=" returns true if the left argument is numerically less than +Binary "<=" returns true if the left argument is numerically less than or equal to the right argument. -Binary "E=" returns true if the left argument is numerically greater +Binary ">=" returns true if the left argument is numerically greater than or equal to the right argument. Binary "lt" returns true if the left argument is stringwise less than @@ -290,9 +298,16 @@ the right argument. Binary "!=" returns true if the left argument is numerically not equal to the right argument. -Binary "E=E" returns -1, 0, or 1 depending on whether the left +Binary "<=>" returns -1, 0, or 1 depending on whether the left argument is numerically less than, equal to, or greater than the right -argument. +argument. If your platform supports NaNs (not-a-numbers) as numeric +values, using them with "<=>" returns undef. NaN is not "<", "==", ">", +"<=" or ">=" anything (even NaN), so those 5 return false. NaN != NaN +returns true, as does NaN != anything else. If your platform doesn't +support NaNs then NaN is just a string with numeric value 0. + + perl -le '$a = NaN; print "No NaN support here" if $a == $a' + perl -le '$a = NaN; print "NaN support here" if $a != $a' Binary "eq" returns true if the left argument is stringwise equal to the right argument. @@ -300,8 +315,9 @@ the right argument. Binary "ne" returns true if the left argument is stringwise not equal to the right argument. -Binary "cmp" returns -1, 0, or 1 depending on whether the left argument is stringwise -less than, equal to, or greater than the right argument. +Binary "cmp" returns -1, 0, or 1 depending on whether the left +argument is stringwise less than, equal to, or greater than the right +argument. "lt", "le", "ge", "gt" and "cmp" use the collation (sort) order specified by the current locale if C is in effect. See L. @@ -361,7 +377,7 @@ With the C-style operators that would have been written like this: unlink("alpha", "beta", "gamma") || (gripe(), next LINE); -Use "or" for assignment is unlikely to do what you want; see below. +Using "or" for assignment is unlikely to do what you want; see below. =head2 Range Operators @@ -510,10 +526,10 @@ The following are recognized: Although these are grouped by family, they all have the precedence of assignment. -Unlike in C, the assignment operator produces a valid lvalue. Modifying -an assignment is equivalent to doing the assignment and then modifying -the variable that was assigned to. This is useful for modifying -a copy of something, like this: +Unlike in C, the scalar assignment operator produces a valid lvalue. +Modifying an assignment is equivalent to doing the assignment and +then modifying the variable that was assigned to. This is useful +for modifying a copy of something, like this: ($tmp = $global) =~ tr [A-Z] [a-z]; @@ -526,6 +542,11 @@ is equivalent to $a += 2; $a *= 3; +Similarly, a list assignment in list context produces the list of +lvalues assigned to, and a list assignment in scalar context returns +the number of elements produced by the expression on the right hand +side of the assignment. + =head2 Comma Operator Binary "," is the comma operator. In scalar context it evaluates @@ -535,7 +556,7 @@ argument and returns that value. This is just like C's comma operator. In list context, it's just the list argument separator, and inserts both its arguments into the list. -The =E digraph is mostly just a synonym for the comma operator. It's useful for +The => digraph is mostly just a synonym for the comma operator. It's useful for documenting arguments that come in pairs. As of release 5.001, it also forces any word to the left of it to be interpreted as a string. @@ -637,7 +658,7 @@ sorts of brackets (round, angle, square, curly) will all nest, which means that q{foo{bar}baz} - + is the same as 'foo{bar}baz' @@ -673,6 +694,7 @@ a transliteration, the first eleven of these sequences may be used. \x1b hex char (ESC) \x{263a} wide hex char (SMILEY) \c[ control char (ESC) + \N{name} named char \l lowercase next char \u uppercase next char @@ -682,7 +704,8 @@ a transliteration, the first eleven of these sequences may be used. \Q quote non-word characters till \E If C is in effect, the case map used by C<\l>, C<\L>, C<\u> -and C<\U> is taken from the current locale. See L. +and C<\U> is taken from the current locale. See L. For +documentation of C<\N{name}>, see L. All systems use the virtual C<"\n"> to represent a line terminator, called a "newline". There is no such thing as an unvarying, physical @@ -693,7 +716,7 @@ on a Mac, these are reversed, and on systems without line terminator, printing C<"\n"> may emit no actual data. In general, use C<"\n"> when you mean a "newline" for your system, but use the literal ASCII when you need an exact character. For example, most networking protocols expect -and prefer a CR+LF (C<"\012\015"> or C<"\cJ\cM">) for line terminators, +and prefer a CR+LF (C<"\015\012"> or C<"\cM\cJ">) for line terminators, 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. @@ -738,7 +761,7 @@ patterns local to the current package are reset. reset if eof; # clear ?? status for next file } -This usage is vaguely depreciated, which means it just might possibly +This usage is vaguely deprecated, which means it just might possibly be removed in some distant future version of Perl, perhaps somewhere around the year 2168. @@ -774,14 +797,14 @@ If "'" is the delimiter, no interpolation is performed on the PATTERN. PATTERN may contain variables, which will be interpolated (and the pattern recompiled) every time the pattern search is evaluated, except -for when the delimiter is a single quote. (Note that C<$)> and C<$|> -might not be interpolated because they look like end-of-string tests.) +for when the delimiter is a single quote. (Note that C<$(>, C<$)>, and +C<$|> are not interpolated because they look like end-of-string tests.) If you want such a pattern to be compiled only once, add a C after the trailing delimiter. This avoids expensive run-time recompilations, and is useful when the value you are interpolating won't change over the life of the script. However, mentioning C constitutes a promise that you won't change the variables in the pattern. If you change them, -Perl won't even notice. See also L. +Perl won't even notice. See also L<"qr/STRING/imosx">. If the PATTERN evaluates to the empty string, the last I matched regular expression is used instead. @@ -834,9 +857,11 @@ string also resets the search position. You can intermix C matches with C, where C<\G> is a zero-width assertion that matches the exact position where the previous -C, if any, left off. The C<\G> assertion is not supported without -the C modifier. (Currently, without C, C<\G> behaves just like -C<\A>, but that's accidental and may change in the future.) +C, if any, left off. Without the C modifier, the C<\G> assertion +still anchors at pos(), but the match is of course only attempted once. +Using C<\G> without C on a target string that has not previously had a +C match applied to it is the same as using the C<\A> assertion to match +the beginning of the string. Examples: @@ -844,7 +869,7 @@ Examples: ($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g); # scalar context - $/ = ""; $* = 1; # $* deprecated in modern perls + $/ = ""; while (defined($paragraph = <>)) { while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) { $sentences++; @@ -862,6 +887,7 @@ Examples: print "3: '"; print $1 while /(p)/gc; print "', pos=", pos, "\n"; } + print "Final: '$1', pos=",pos,"\n" if /\G(.)/; The last example should print: @@ -871,6 +897,13 @@ The last example should print: 1: '', pos=7 2: 'q', pos=8 3: '', pos=8 + Final: 'q', pos=8 + +Notice that the final match matched C instead of C

, which a match +without the C<\G> anchor would have done. Also note that the final match +did not update C -- C is only updated on a C match. If the +final match did indeed match C

, it's a good bet that you're running an +older (pre-5.6.0) Perl. A useful idiom for C-like scanners is C. You can combine several regexps like this to process a string part-by-part, @@ -924,7 +957,7 @@ A double-quoted, interpolated string. =item qr/STRING/imosx -This operators quotes--and compiles--its I as a regular +This operator quotes (and possibly compiles) its I as a regular expression. I is interpolated the same way as I in C. If "'" is used as the delimiter, no interpolation is done. Returns a Perl value which may be used instead of the @@ -955,7 +988,7 @@ notably if the result of qr() is used standalone: my @compiled = map qr/$_/i, @$patterns; grep { my $success = 0; - foreach my $pat @compiled { + foreach my $pat (@compiled) { $success = 1, last if /$pat/; } $success; @@ -983,13 +1016,14 @@ for a detailed look at the semantics of regular expressions. =item `STRING` -A string which is (possibly) interpolated and then executed as a system -command with C or its equivalent. Shell wildcards, pipes, -and redirections will be honored. The collected standard output of the -command is returned; standard error is unaffected. In scalar context, -it comes back as a single (potentially multi-line) string. In list -context, returns a list of lines (however you've defined lines with $/ -or $INPUT_RECORD_SEPARATOR). +A string which is (possibly) interpolated and then executed as a +system command with C or its equivalent. Shell wildcards, +pipes, and redirections will be honored. The collected standard +output of the command is returned; standard error is unaffected. In +scalar context, it comes back as a single (potentially multi-line) +string, or undef if the command failed. In list context, returns a +list of lines (however you've defined lines with $/ or +$INPUT_RECORD_SEPARATOR), or an empty list if the command failed. Because backticks do not affect standard error, use shell file descriptor syntax (assuming the shell supports this) if you care to address this. @@ -1037,6 +1071,12 @@ multiple commands in a single line by separating them with the command separator character, if your shell supports that (e.g. C<;> on many Unix shells; C<&> on the Windows NT C shell). +Beginning with v5.6.0, Perl will attempt to flush all files opened for +output before starting the child process, but this may not be supported +on some platforms (see L). To be safe, you may need to set +C<$|> ($AUTOFLUSH in English) or call the C method of +C on any open handles. + Beware that some command shells may place restrictions on the length of the command line. You must ensure your strings don't exceed this limit after any necessary interpolations. See the platform-specific @@ -1066,9 +1106,9 @@ this expression: qw(foo bar baz) -is exactly equivalent to the list: +is semantically equivalent to the list: - ('foo', 'bar', 'baz') + 'foo', 'bar', 'baz' Some frequently seen examples: @@ -1077,8 +1117,8 @@ Some frequently seen examples: A common mistake is to try to separate the words with comma or to put comments into a multi-line C-string. For this reason, the -B<-w> switch (that is, the C<$^W> variable) produces warnings if -the STRING contains the "," or the "#" character. +C pragma and the B<-w> switch (that is, the C<$^W> variable) +produces warnings if the STRING contains the "," or the "#" character. =item s/PATTERN/REPLACEMENT/egimosx @@ -1119,10 +1159,11 @@ Perl 4, Perl 5 treats backticks as normal delimiters; the replacement text is not evaluated as a command. If the PATTERN is delimited by bracketing quotes, the REPLACEMENT has its own pair of quotes, which may or may not be bracketing quotes, e.g., -C or CfooE/bar/>. A C will cause the -replacement portion to be interpreted as a full-fledged Perl expression -and eval()ed right then and there. It is, however, syntax checked at -compile-time. +C or C<< s/bar/ >>. A C will cause the +replacement portion to be treated as a full-fledged Perl expression +and evaluated right then and there. It is, however, syntax checked at +compile-time. A second C modifier will cause the replacement portion +to be Ced before being run as a Perl expression. Examples: @@ -1149,8 +1190,12 @@ Examples: # symbolic dereferencing s/\$(\w+)/${$1}/g; - # /e's can even nest; this will expand - # any embedded scalar variable (including lexicals) in $_ + # Add one to the value of any numbers in the string + s/(\d+)/1 + $1/eg; + + # This will expand any embedded scalar variable + # (including lexicals) in $_ : First $1 is interpolated + # to the variable name, and then evaluated s/(\$\w+)/$1/eeg; # Delete (most) C comments. @@ -1170,8 +1215,8 @@ Examples: s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields Note the use of $ instead of \ in the last example. Unlike -B, we use the \EIE form in only the left hand side. -Anywhere else it's $EIE. +B, we use the \> form in only the left hand side. +Anywhere else it's $>. Occasionally, you can't use just a C to get all the changes to occur that you might want. Here are two common cases: @@ -1182,9 +1227,9 @@ to occur that you might want. Here are two common cases: # expand tabs to 8-column spacing 1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e; -=item tr/SEARCHLIST/REPLACEMENTLIST/cdsUC +=item tr/SEARCHLIST/REPLACEMENTLIST/cds -=item y/SEARCHLIST/REPLACEMENTLIST/cdsUC +=item y/SEARCHLIST/REPLACEMENTLIST/cds Transliterates all occurrences of the characters found in the search list with the corresponding character in the replacement list. It returns @@ -1200,6 +1245,12 @@ SEARCHLIST is delimited by bracketing quotes, the REPLACEMENTLIST has its own pair of quotes, which may or may not be bracketing quotes, e.g., C or C. +Note that C does B do regular expression character classes +such as C<\d> or C<[:lower:]>. The operator is not equivalent to +the tr(1) utility. If you want to map strings between lower/upper +cases, see L and L, and in general consider +using the C operator if you need regular expressions. + Note also that the whole range idea is rather unportable between character sets--and even within character sets they may cause results you probably didn't expect. A sound principle is to use only ranges @@ -1212,8 +1263,6 @@ Options: c Complement the SEARCHLIST. d Delete found but unreplaced characters. s Squash duplicate replaced characters. - U Translate to/from UTF-8. - C Translate to/from 8-bit char (octet). If the C modifier is specified, the SEARCHLIST character set is complemented. If the C modifier is specified, any characters @@ -1231,10 +1280,6 @@ enough. If the REPLACEMENTLIST is empty, the SEARCHLIST is replicated. This latter is useful for counting characters in a class or for squashing character sequences in a class. -The first C or C modifier applies to the left side of the translation. -The second one applies to the right side. If present, these modifiers override -the current utf8 state. - Examples: $ARGV[1] =~ tr/A-Z/a-z/; # canonicalize to lower case @@ -1254,9 +1299,6 @@ Examples: tr [\200-\377] [\000-\177]; # delete 8th bit - tr/\0-\xFF//CU; # change Latin-1 to Unicode - tr/\0-\x{FF}//UC; # change Unicode to Latin-1 - If multiple transliterations are given for a character, only the first one is used: @@ -1302,15 +1344,15 @@ their results are the same, we consider them individually. For different quoting constructs, Perl performs different numbers of passes, from one to five, but these passes are always performed in the same order. -=over +=over 4 =item Finding the end The first pass is finding the end of the quoted construct, whether it be a multicharacter delimiter C<"\nEOF\n"> in the C<< construct, a C that terminates a C construct, a C<]> which -terminates C construct, or a C> which terminates a -fileglob started with C>. +terminates C construct, or a C<< > >> which terminates a +fileglob started with C<< < >>. When searching for single-character non-pairing delimiters, such as C, combinations of C<\\> and C<\/> are skipped. However, @@ -1356,7 +1398,7 @@ used in parsing. The next step is interpolation in the text obtained, which is now delimiter-independent. There are four different cases. -=over +=over 4 =item C<<<'EOF'>, C, C, C, C @@ -1366,7 +1408,7 @@ No interpolation is performed. The only interpolation is removal of C<\> from pairs C<\\>. -=item C<"">, C<``>, C, C, C<> +=item C<"">, C<``>, C, C, C<< >> C<\Q>, C<\U>, C<\u>, C<\L>, C<\l> (possibly paired with C<\E>) are converted to corresponding Perl constructs. Thus, C<"$foo\Qbaz$bar"> @@ -1387,7 +1429,7 @@ as C<"\\\t"> (since TAB is not alphanumeric). Note also that: may be closer to the conjectural I of the writer of C<"\Q\t\E">. Interpolated scalars and arrays are converted internally to the C and -C<.> catentation operations. Thus, C<"$foo XXX '@arr'"> becomes: +C<.> catenation operations. Thus, C<"$foo XXX '@arr'"> becomes: $foo . " XXX '" . (join $", @arr) . "'"; @@ -1401,7 +1443,7 @@ scalar. Note also that the interpolation code needs to make a decision on where the interpolated scalar ends. For instance, whether -C<"a $b -E {c}"> really means: +C<< "a $b -> {c}" >> really means: "a " . $b . " -> {c}"; @@ -1438,8 +1480,8 @@ the result is not predictable. It is at this step that C<\1> is begrudgingly converted to C<$1> in the replacement text of C to correct the incorrigible I hackers who haven't picked up the saner idiom yet. A warning -is emitted if the B<-w> command-line flag (that is, the C<$^W> variable) -was set. +is emitted if the C pragma or the B<-w> command-line flag +(that is, the C<$^W> variable) was set. The lack of processing of C<\\> creates specific restrictions on the post-processed text. If the delimiter is C, one cannot get @@ -1500,7 +1542,7 @@ terminator of a C<{}>-delimited construct. It is possible to inspect both the string given to RE engine and the resulting finite automaton. See the arguments C/C in the C> pragma, as well as Perl's B<-Dr> command-line -switch documented in L. +switch documented in L. =item Optimization of regular expressions @@ -1521,19 +1563,19 @@ There are several I/O operators you should know about. A string enclosed by backticks (grave accents) first undergoes double-quote interpolation. It is then interpreted as an external command, and the output of that command is the value of the -pseudo-literal, j -string consisting of all output is returned. In list context, a -list of values is returned, one per line of output. (You can set -C<$/> to use a different line terminator.) The command is executed -each time the pseudo-literal is evaluated. The status value of the -command is returned in C<$?> (see L for the interpretation -of C<$?>). Unlike in B, no translation is done on the return -data--newlines remain newlines. Unlike in any of the shells, single -quotes do not hide variable names in the command from interpretation. -To pass a literal dollar-sign through to the shell you need to hide -it with a backslash. The generalized form of backticks is C. -(Because backticks always undergo shell expansion as well, see -L for security concerns.) +backtick string, like in a shell. In scalar context, a single string +consisting of all output is returned. In list context, a list of +values is returned, one per line of output. (You can set C<$/> to use +a different line terminator.) The command is executed each time the +pseudo-literal is evaluated. The status value of the command is +returned in C<$?> (see L for the interpretation of C<$?>). +Unlike in B, no translation is done on the return data--newlines +remain newlines. Unlike in any of the shells, single quotes do not +hide variable names in the command from interpretation. To pass a +literal dollar-sign through to the shell you need to hide it with a +backslash. The generalized form of backticks is C. (Because +backticks always undergo shell expansion as well, see L for +security concerns.) In scalar context, evaluating a filehandle in angle brackets yields the next line from that file (the newline, if any, included), or @@ -1548,7 +1590,7 @@ of a C statement (even if disguised as a C loop), the value is automatically assigned to the global variable $_, destroying whatever was there previously. (This may seem like an odd thing to you, but you'll use the construct in almost every Perl -script you write.) The $_ variables is not implicitly localized. +script you write.) The $_ variable is not implicitly localized. You'll have to put a C before the loop if you want that to happen. @@ -1576,8 +1618,9 @@ to terminate the loop, they should be tested for explicitly: while (($_ = ) ne '0') { ... } while () { last unless $_; ... } -In other boolean contexts, CIE> without an -explicit C test or comparison elicit a warning if the B<-w> +In other boolean contexts, C<< > >> without an +explicit C test or comparison elicit a warning if the +C pragma or the B<-w> command-line switch (the C<$^W> variable) is in effect. The filehandles STDIN, STDOUT, and STDERR are predefined. (The @@ -1587,18 +1630,18 @@ rather than global.) Additional filehandles may be created with the open() function, amongst others. See L and L for details on this. -If a EFILEHANDLEE is used in a context that is looking for +If a is used in a context that is looking for a list, a list comprising all input lines is returned, one line per list element. It's easy to grow to a rather large data space this way, so use with care. -EFILEHANDLEE may also be spelled C. + may also be spelled C. See L. -The null filehandle EE is special: it can be used to emulate the -behavior of B and B. Input from EE comes either from +The null filehandle <> is special: it can be used to emulate the +behavior of B and B. Input from <> comes either from standard input, or from each file listed on the command line. Here's -how it works: the first time EE is evaluated, the @ARGV array is +how it works: the first time <> is evaluated, the @ARGV array is checked, and if it is empty, C<$ARGV[0]> is set to "-", which when opened gives you standard input. The @ARGV array is then processed as a list of filenames. The loop @@ -1620,11 +1663,11 @@ is equivalent to the following Perl-like pseudo code: except that it isn't so cumbersome to say, and will actually work. It really does shift the @ARGV array and put the current filename into the $ARGV variable. It also uses filehandle I -internally--EE is just a synonym for EARGVE, which +internally--<> is just a synonym for , which is magical. (The pseudo code above doesn't work because it treats -EARGVE as non-magical.) + as non-magical.) -You can modify @ARGV before the first EE as long as the array ends up +You can modify @ARGV before the first <> as long as the array ends up containing the list of filenames you really want. Line numbers (C<$.>) continue as though the input were one big happy file. See the example in L for how to reset line numbers on each file. @@ -1654,12 +1697,12 @@ Getopts modules or put a loop on the front like this: # ... # code for each line } -The EE symbol will return C for end-of-file only once. +The <> symbol will return C for end-of-file only once. If you call it again after this, it will assume you are processing another @ARGV list, and if you haven't set @ARGV, will read input from STDIN. If angle brackets contain is a simple scalar variable (e.g., -E$fooE), then that variable contains the name of the +<$foo>), then that variable contains the name of the filehandle to input from, or its typeglob, or a reference to the same. For example: @@ -1671,16 +1714,16 @@ scalar variable containing a filehandle name, typeglob, or typeglob reference, it is interpreted as a filename pattern to be globbed, and either a list of filenames or the next filename in the list is returned, depending on context. This distinction is determined on syntactic -grounds alone. That means C$xE> is always a readline() from -an indirect handle, but C$hash{key}E> is always a glob(). +grounds alone. That means C<< <$x> >> is always a readline() from +an indirect handle, but C<< <$hash{key}> >> is always a glob(). That's because $x is a simple scalar variable, but C<$hash{key}> is not--it's a hash element. One level of double-quote interpretation is done first, but you can't -say C$fooE> because that's an indirect filehandle as explained +say C<< <$foo> >> because that's an indirect filehandle as explained in the previous paragraph. (In older versions of Perl, programmers would insert curly brackets to force interpretation as a filename glob: -C${foo}E>. These days, it's considered cleaner to call the +C<< <${foo}> >>. These days, it's considered cleaner to call the internal function directly as C, which is probably the right way to have done it in the first place.) For example: @@ -1688,33 +1731,24 @@ way to have done it in the first place.) For example: chmod 0644, $_; } -is equivalent to +is roughly equivalent to: open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|"); while () { - chop; + chomp; chmod 0644, $_; } -In fact, it's currently implemented that way, but this is expected -to be made completely internal in the near future. (Which means -it will not work on filenames with spaces in them unless you have -csh(1) on your machine.) Of course, the shortest way to do the -above is: +except that the globbing is actually done internally using the standard +C extension. Of course, the shortest way to do the above is: chmod 0644, <*.c>; -Because globbing currently invokes a shell, it's often faster to -call readdir() yourself and do your own grep() on the filenames. -Furthermore, due to its current implementation of using a shell, -the glob() routine may get "Arg list too long" errors (unless you've -installed tcsh(1L) as F or hacked your F). - A (file)glob evaluates its (embedded) argument only when it is starting a new list. All values must be read before it will start over. In list context, this isn't important because you automatically get them all anyway. However, in scalar context the operator returns -the next value each time it's called, or C +the next value each time it's called, or C when the list has run out. As with filehandle reads, an automatic C is generated when the glob occurs in the test part of a C, because legal glob returns (e.g. a file called F<0>) would otherwise @@ -1814,8 +1848,8 @@ integer>, if you take the C, you'll still get C<1.4142135623731> or so. Used on numbers, the bitwise operators ("&", "|", "^", "~", "<<", -and ">>") always produce integral results. (But see also L.) However, C still has meaning for +and ">>") always produce integral results. (But see also +L.) However, C still has meaning for them. By default, their results are interpreted as unsigned integers, but if C is in effect, their results are interpreted as signed integers. For example, C<~0> usually evaluates to a large @@ -1868,7 +1902,7 @@ need yourself. The standard Math::BigInt and Math::BigFloat modules provide variable-precision arithmetic and overloaded operators, although -they're currently pretty slow. At the cost of some space and +they're currently pretty slow. At the cost of some space and considerable speed, they avoid the normal pitfalls associated with limited-precision representations. @@ -1878,6 +1912,25 @@ limited-precision representations. # prints +15241578780673678515622620750190521 -The non-standard modules SSLeay::BN and Math::Pari provide -equivalent functionality (and much more) with a substantial -performance savings. +There are several modules that let you calculate with (bound only by +memory and cpu-time) unlimited or fixed precision. There are also +some non-standard modules that provide faster implementations via +external C libraries. + +Here is a short, but incomplete summary: + + Math::Fraction big, unlimited fractions like 9973 / 12967 + Math::String treat string sequences like numbers + Math::FixedPrecision calculate with a fixed precision + Math::Currency for currency calculations + Bit::Vector manipulate bit vectors fast (uses C) + Math::BigIntFast Bit::Vector wrapper for big numbers + Math::Pari provides access to the Pari C library + Math::BigInteger uses an external C library + Math::Cephes uses external Cephes C library (no big numbers) + Math::Cephes::Fraction fractions via the Cephes library + Math::GMP another one using an external C library + +Choose wisely. + +=cut