1=head1 NAME 2X<function> 3 4perlfunc - Perl builtin functions 5 6=head1 DESCRIPTION 7 8The functions in this section can serve as terms in an expression. 9They fall into two major categories: list operators and named unary 10operators. These differ in their precedence relationship with a 11following comma. (See the precedence table in L<perlop>.) List 12operators take more than one argument, while unary operators can never 13take more than one argument. Thus, a comma terminates the argument of 14a unary operator, but merely separates the arguments of a list 15operator. A unary operator generally provides scalar context to its 16argument, while a list operator may provide either scalar or list 17contexts for its arguments. If it does both, scalar arguments 18come first and list argument follow, and there can only ever 19be one such list argument. For instance, 20L<C<splice>|/splice ARRAY,OFFSET,LENGTH,LIST> has three scalar arguments 21followed by a list, whereas L<C<gethostbyname>|/gethostbyname NAME> has 22four scalar arguments. 23 24In the syntax descriptions that follow, list operators that expect a 25list (and provide list context for elements of the list) are shown 26with LIST as an argument. Such a list may consist of any combination 27of scalar arguments or list values; the list values will be included 28in the list as if each individual element were interpolated at that 29point in the list, forming a longer single-dimensional list value. 30Commas should separate literal elements of the LIST. 31 32Any function in the list below may be used either with or without 33parentheses around its arguments. (The syntax descriptions omit the 34parentheses.) If you use parentheses, the simple but occasionally 35surprising rule is this: It I<looks> like a function, therefore it I<is> a 36function, and precedence doesn't matter. Otherwise it's a list 37operator or unary operator, and precedence does matter. Whitespace 38between the function and left parenthesis doesn't count, so sometimes 39you need to be careful: 40 41 print 1+2+4; # Prints 7. 42 print(1+2) + 4; # Prints 3. 43 print (1+2)+4; # Also prints 3! 44 print +(1+2)+4; # Prints 7. 45 print ((1+2)+4); # Prints 7. 46 47If you run Perl with the L<C<use warnings>|warnings> pragma, it can warn 48you about this. For example, the third line above produces: 49 50 print (...) interpreted as function at - line 1. 51 Useless use of integer addition in void context at - line 1. 52 53A few functions take no arguments at all, and therefore work as neither 54unary nor list operators. These include such functions as 55L<C<time>|/time> and L<C<endpwent>|/endpwent>. For example, 56C<time+86_400> always means C<time() + 86_400>. 57 58For functions that can be used in either a scalar or list context, 59nonabortive failure is generally indicated in scalar context by 60returning the undefined value, and in list context by returning the 61empty list. 62 63Remember the following important rule: There is B<no rule> that relates 64the behavior of an expression in list context to its behavior in scalar 65context, or vice versa. It might do two totally different things. 66Each operator and function decides which sort of value would be most 67appropriate to return in scalar context. Some operators return the 68length of the list that would have been returned in list context. Some 69operators return the first value in the list. Some operators return the 70last value in the list. Some operators return a count of successful 71operations. In general, they do what you want, unless you want 72consistency. 73X<context> 74 75A named array in scalar context is quite different from what would at 76first glance appear to be a list in scalar context. You can't get a list 77like C<(1,2,3)> into being in scalar context, because the compiler knows 78the context at compile time. It would generate the scalar comma operator 79there, not the list concatenation version of the comma. That means it 80was never a list to start with. 81 82In general, functions in Perl that serve as wrappers for system calls 83("syscalls") of the same name (like L<chown(2)>, L<fork(2)>, 84L<closedir(2)>, etc.) return true when they succeed and 85L<C<undef>|/undef EXPR> otherwise, as is usually mentioned in the 86descriptions below. This is different from the C interfaces, which 87return C<-1> on failure. Exceptions to this rule include 88L<C<wait>|/wait>, L<C<waitpid>|/waitpid PID,FLAGS>, and 89L<C<syscall>|/syscall NUMBER, LIST>. System calls also set the special 90L<C<$!>|perlvar/$!> variable on failure. Other functions do not, except 91accidentally. 92 93Extension modules can also hook into the Perl parser to define new 94kinds of keyword-headed expression. These may look like functions, but 95may also look completely different. The syntax following the keyword 96is defined entirely by the extension. If you are an implementor, see 97L<perlapi/PL_keyword_plugin> for the mechanism. If you are using such 98a module, see the module's documentation for details of the syntax that 99it defines. 100 101=head2 Perl Functions by Category 102X<function> 103 104Here are Perl's functions (including things that look like 105functions, like some keywords and named operators) 106arranged by category. Some functions appear in more 107than one place. Any warnings, including those produced by 108keywords, are described in L<perldiag> and L<warnings>. 109 110=over 4 111 112=item Functions for SCALARs or strings 113X<scalar> X<string> X<character> 114 115=for Pod::Functions =String 116 117L<C<chomp>|/chomp VARIABLE>, L<C<chop>|/chop VARIABLE>, 118L<C<chr>|/chr NUMBER>, L<C<crypt>|/crypt PLAINTEXT,SALT>, 119L<C<fc>|/fc EXPR>, L<C<hex>|/hex EXPR>, 120L<C<index>|/index STR,SUBSTR,POSITION>, L<C<lc>|/lc EXPR>, 121L<C<lcfirst>|/lcfirst EXPR>, L<C<length>|/length EXPR>, 122L<C<oct>|/oct EXPR>, L<C<ord>|/ord EXPR>, 123L<C<pack>|/pack TEMPLATE,LIST>, 124L<C<qE<sol>E<sol>>|/qE<sol>STRINGE<sol>>, 125L<C<qqE<sol>E<sol>>|/qqE<sol>STRINGE<sol>>, L<C<reverse>|/reverse LIST>, 126L<C<rindex>|/rindex STR,SUBSTR,POSITION>, 127L<C<sprintf>|/sprintf FORMAT, LIST>, 128L<C<substr>|/substr EXPR,OFFSET,LENGTH,REPLACEMENT>, 129L<C<trE<sol>E<sol>E<sol>>|/trE<sol>E<sol>E<sol>>, L<C<uc>|/uc EXPR>, 130L<C<ucfirst>|/ucfirst EXPR>, 131L<C<yE<sol>E<sol>E<sol>>|/yE<sol>E<sol>E<sol>> 132 133L<C<fc>|/fc EXPR> is available only if the 134L<C<"fc"> feature|feature/The 'fc' feature> is enabled or if it is 135prefixed with C<CORE::>. The 136L<C<"fc"> feature|feature/The 'fc' feature> is enabled automatically 137with a C<use v5.16> (or higher) declaration in the current scope. 138 139=item Regular expressions and pattern matching 140X<regular expression> X<regex> X<regexp> 141 142=for Pod::Functions =Regexp 143 144L<C<mE<sol>E<sol>>|/mE<sol>E<sol>>, L<C<pos>|/pos SCALAR>, 145L<C<qrE<sol>E<sol>>|/qrE<sol>STRINGE<sol>>, 146L<C<quotemeta>|/quotemeta EXPR>, 147L<C<sE<sol>E<sol>E<sol>>|/sE<sol>E<sol>E<sol>>, 148L<C<split>|/split E<sol>PATTERNE<sol>,EXPR,LIMIT>, 149L<C<study>|/study SCALAR> 150 151=item Numeric functions 152X<numeric> X<number> X<trigonometric> X<trigonometry> 153 154=for Pod::Functions =Math 155 156L<C<abs>|/abs VALUE>, L<C<atan2>|/atan2 Y,X>, L<C<cos>|/cos EXPR>, 157L<C<exp>|/exp EXPR>, L<C<hex>|/hex EXPR>, L<C<int>|/int EXPR>, 158L<C<log>|/log EXPR>, L<C<oct>|/oct EXPR>, L<C<rand>|/rand EXPR>, 159L<C<sin>|/sin EXPR>, L<C<sqrt>|/sqrt EXPR>, L<C<srand>|/srand EXPR> 160 161=item Functions for real @ARRAYs 162X<array> 163 164=for Pod::Functions =ARRAY 165 166L<C<each>|/each HASH>, L<C<keys>|/keys HASH>, L<C<pop>|/pop ARRAY>, 167L<C<push>|/push ARRAY,LIST>, L<C<shift>|/shift ARRAY>, 168L<C<splice>|/splice ARRAY,OFFSET,LENGTH,LIST>, 169L<C<unshift>|/unshift ARRAY,LIST>, L<C<values>|/values HASH> 170 171=item Functions for list data 172X<list> 173 174=for Pod::Functions =LIST 175 176L<C<grep>|/grep BLOCK LIST>, L<C<join>|/join EXPR,LIST>, 177L<C<map>|/map BLOCK LIST>, L<C<qwE<sol>E<sol>>|/qwE<sol>STRINGE<sol>>, 178L<C<reverse>|/reverse LIST>, L<C<sort>|/sort SUBNAME LIST>, 179L<C<unpack>|/unpack TEMPLATE,EXPR> 180 181=item Functions for real %HASHes 182X<hash> 183 184=for Pod::Functions =HASH 185 186L<C<delete>|/delete EXPR>, L<C<each>|/each HASH>, 187L<C<exists>|/exists EXPR>, L<C<keys>|/keys HASH>, 188L<C<values>|/values HASH> 189 190=item Input and output functions 191X<I/O> X<input> X<output> X<dbm> 192 193=for Pod::Functions =I/O 194 195L<C<binmode>|/binmode FILEHANDLE, LAYER>, L<C<close>|/close FILEHANDLE>, 196L<C<closedir>|/closedir DIRHANDLE>, L<C<dbmclose>|/dbmclose HASH>, 197L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>, L<C<die>|/die LIST>, 198L<C<eof>|/eof FILEHANDLE>, L<C<fileno>|/fileno FILEHANDLE>, 199L<C<flock>|/flock FILEHANDLE,OPERATION>, L<C<format>|/format>, 200L<C<getc>|/getc FILEHANDLE>, L<C<print>|/print FILEHANDLE LIST>, 201L<C<printf>|/printf FILEHANDLE FORMAT, LIST>, 202L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET>, 203L<C<readdir>|/readdir DIRHANDLE>, L<C<readline>|/readline EXPR>, 204L<C<rewinddir>|/rewinddir DIRHANDLE>, L<C<say>|/say FILEHANDLE LIST>, 205L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 206L<C<seekdir>|/seekdir DIRHANDLE,POS>, 207L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT>, 208L<C<syscall>|/syscall NUMBER, LIST>, 209L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>, 210L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE>, 211L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET>, 212L<C<tell>|/tell FILEHANDLE>, L<C<telldir>|/telldir DIRHANDLE>, 213L<C<truncate>|/truncate FILEHANDLE,LENGTH>, L<C<warn>|/warn LIST>, 214L<C<write>|/write FILEHANDLE> 215 216L<C<say>|/say FILEHANDLE LIST> is available only if the 217L<C<"say"> feature|feature/The 'say' feature> is enabled or if it is 218prefixed with C<CORE::>. The 219L<C<"say"> feature|feature/The 'say' feature> is enabled automatically 220with a C<use v5.10> (or higher) declaration in the current scope. 221 222=item Functions for fixed-length data or records 223 224=for Pod::Functions =Binary 225 226L<C<pack>|/pack TEMPLATE,LIST>, 227L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET>, 228L<C<syscall>|/syscall NUMBER, LIST>, 229L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>, 230L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE>, 231L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET>, 232L<C<unpack>|/unpack TEMPLATE,EXPR>, L<C<vec>|/vec EXPR,OFFSET,BITS> 233 234=item Functions for filehandles, files, or directories 235X<file> X<filehandle> X<directory> X<pipe> X<link> X<symlink> 236 237=for Pod::Functions =File 238 239L<C<-I<X>>|/-X FILEHANDLE>, L<C<chdir>|/chdir EXPR>, 240L<C<chmod>|/chmod LIST>, L<C<chown>|/chown LIST>, 241L<C<chroot>|/chroot FILENAME>, 242L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR>, L<C<glob>|/glob EXPR>, 243L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>, 244L<C<link>|/link OLDFILE,NEWFILE>, L<C<lstat>|/lstat FILEHANDLE>, 245L<C<mkdir>|/mkdir FILENAME,MODE>, L<C<open>|/open FILEHANDLE,MODE,EXPR>, 246L<C<opendir>|/opendir DIRHANDLE,EXPR>, L<C<readlink>|/readlink EXPR>, 247L<C<rename>|/rename OLDNAME,NEWNAME>, L<C<rmdir>|/rmdir FILENAME>, 248L<C<select>|/select FILEHANDLE>, L<C<stat>|/stat FILEHANDLE>, 249L<C<symlink>|/symlink OLDFILE,NEWFILE>, 250L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE>, 251L<C<umask>|/umask EXPR>, L<C<unlink>|/unlink LIST>, 252L<C<utime>|/utime LIST> 253 254=item Keywords related to the control flow of your Perl program 255X<control flow> 256 257=for Pod::Functions =Flow 258 259L<C<break>|/break>, L<C<caller>|/caller EXPR>, 260L<C<continue>|/continue BLOCK>, L<C<die>|/die LIST>, L<C<do>|/do BLOCK>, 261L<C<dump>|/dump LABEL>, L<C<eval>|/eval EXPR>, 262L<C<evalbytes>|/evalbytes EXPR>, L<C<exit>|/exit EXPR>, 263L<C<__FILE__>|/__FILE__>, L<C<goto>|/goto LABEL>, 264L<C<last>|/last LABEL>, L<C<__LINE__>|/__LINE__>, 265L<C<next>|/next LABEL>, L<C<__PACKAGE__>|/__PACKAGE__>, 266L<C<redo>|/redo LABEL>, L<C<return>|/return EXPR>, 267L<C<sub>|/sub NAME BLOCK>, L<C<__SUB__>|/__SUB__>, 268L<C<wantarray>|/wantarray> 269 270L<C<break>|/break> is available only if you enable the experimental 271L<C<"switch"> feature|feature/The 'switch' feature> or use the C<CORE::> 272prefix. The L<C<"switch"> feature|feature/The 'switch' feature> also 273enables the C<default>, C<given> and C<when> statements, which are 274documented in L<perlsyn/"Switch Statements">. 275The L<C<"switch"> feature|feature/The 'switch' feature> is enabled 276automatically with a C<use v5.10> (or higher) declaration in the current 277scope. In Perl v5.14 and earlier, L<C<continue>|/continue BLOCK> 278required the L<C<"switch"> feature|feature/The 'switch' feature>, like 279the other keywords. 280 281L<C<evalbytes>|/evalbytes EXPR> is only available with the 282L<C<"evalbytes"> feature|feature/The 'unicode_eval' and 'evalbytes' features> 283(see L<feature>) or if prefixed with C<CORE::>. L<C<__SUB__>|/__SUB__> 284is only available with the 285L<C<"current_sub"> feature|feature/The 'current_sub' feature> or if 286prefixed with C<CORE::>. Both the 287L<C<"evalbytes">|feature/The 'unicode_eval' and 'evalbytes' features> 288and L<C<"current_sub">|feature/The 'current_sub' feature> features are 289enabled automatically with a C<use v5.16> (or higher) declaration in the 290current scope. 291 292=item Keywords related to scoping 293 294=for Pod::Functions =Namespace 295 296L<C<caller>|/caller EXPR>, L<C<import>|/import LIST>, 297L<C<local>|/local EXPR>, L<C<my>|/my VARLIST>, L<C<our>|/our VARLIST>, 298L<C<package>|/package NAMESPACE>, L<C<state>|/state VARLIST>, 299L<C<use>|/use Module VERSION LIST> 300 301L<C<state>|/state VARLIST> is available only if the 302L<C<"state"> feature|feature/The 'state' feature> is enabled or if it is 303prefixed with C<CORE::>. The 304L<C<"state"> feature|feature/The 'state' feature> is enabled 305automatically with a C<use v5.10> (or higher) declaration in the current 306scope. 307 308=item Miscellaneous functions 309 310=for Pod::Functions =Misc 311 312L<C<defined>|/defined EXPR>, L<C<formline>|/formline PICTURE,LIST>, 313L<C<lock>|/lock THING>, L<C<prototype>|/prototype FUNCTION>, 314L<C<reset>|/reset EXPR>, L<C<scalar>|/scalar EXPR>, 315L<C<undef>|/undef EXPR> 316 317=item Functions for processes and process groups 318X<process> X<pid> X<process id> 319 320=for Pod::Functions =Process 321 322L<C<alarm>|/alarm SECONDS>, L<C<exec>|/exec LIST>, L<C<fork>|/fork>, 323L<C<getpgrp>|/getpgrp PID>, L<C<getppid>|/getppid>, 324L<C<getpriority>|/getpriority WHICH,WHO>, L<C<kill>|/kill SIGNAL, LIST>, 325L<C<pipe>|/pipe READHANDLE,WRITEHANDLE>, 326L<C<qxE<sol>E<sol>>|/qxE<sol>STRINGE<sol>>, 327L<C<readpipe>|/readpipe EXPR>, L<C<setpgrp>|/setpgrp PID,PGRP>, 328L<C<setpriority>|/setpriority WHICH,WHO,PRIORITY>, 329L<C<sleep>|/sleep EXPR>, L<C<system>|/system LIST>, L<C<times>|/times>, 330L<C<wait>|/wait>, L<C<waitpid>|/waitpid PID,FLAGS> 331 332=item Keywords related to Perl modules 333X<module> 334 335=for Pod::Functions =Modules 336 337L<C<do>|/do EXPR>, L<C<import>|/import LIST>, 338L<C<no>|/no MODULE VERSION LIST>, L<C<package>|/package NAMESPACE>, 339L<C<require>|/require VERSION>, L<C<use>|/use Module VERSION LIST> 340 341=item Keywords related to classes and object-orientation 342X<object> X<class> X<package> 343 344=for Pod::Functions =Objects 345 346L<C<bless>|/bless REF,CLASSNAME>, L<C<dbmclose>|/dbmclose HASH>, 347L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>, 348L<C<package>|/package NAMESPACE>, L<C<ref>|/ref EXPR>, 349L<C<tie>|/tie VARIABLE,CLASSNAME,LIST>, L<C<tied>|/tied VARIABLE>, 350L<C<untie>|/untie VARIABLE>, L<C<use>|/use Module VERSION LIST> 351 352=item Low-level socket functions 353X<socket> X<sock> 354 355=for Pod::Functions =Socket 356 357L<C<accept>|/accept NEWSOCKET,GENERICSOCKET>, 358L<C<bind>|/bind SOCKET,NAME>, L<C<connect>|/connect SOCKET,NAME>, 359L<C<getpeername>|/getpeername SOCKET>, 360L<C<getsockname>|/getsockname SOCKET>, 361L<C<getsockopt>|/getsockopt SOCKET,LEVEL,OPTNAME>, 362L<C<listen>|/listen SOCKET,QUEUESIZE>, 363L<C<recv>|/recv SOCKET,SCALAR,LENGTH,FLAGS>, 364L<C<send>|/send SOCKET,MSG,FLAGS,TO>, 365L<C<setsockopt>|/setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL>, 366L<C<shutdown>|/shutdown SOCKET,HOW>, 367L<C<socket>|/socket SOCKET,DOMAIN,TYPE,PROTOCOL>, 368L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL> 369 370=item System V interprocess communication functions 371X<IPC> X<System V> X<semaphore> X<shared memory> X<memory> X<message> 372 373=for Pod::Functions =SysV 374 375L<C<msgctl>|/msgctl ID,CMD,ARG>, L<C<msgget>|/msgget KEY,FLAGS>, 376L<C<msgrcv>|/msgrcv ID,VAR,SIZE,TYPE,FLAGS>, 377L<C<msgsnd>|/msgsnd ID,MSG,FLAGS>, 378L<C<semctl>|/semctl ID,SEMNUM,CMD,ARG>, 379L<C<semget>|/semget KEY,NSEMS,FLAGS>, L<C<semop>|/semop KEY,OPSTRING>, 380L<C<shmctl>|/shmctl ID,CMD,ARG>, L<C<shmget>|/shmget KEY,SIZE,FLAGS>, 381L<C<shmread>|/shmread ID,VAR,POS,SIZE>, 382L<C<shmwrite>|/shmwrite ID,STRING,POS,SIZE> 383 384=item Fetching user and group info 385X<user> X<group> X<password> X<uid> X<gid> X<passwd> X</etc/passwd> 386 387=for Pod::Functions =User 388 389L<C<endgrent>|/endgrent>, L<C<endhostent>|/endhostent>, 390L<C<endnetent>|/endnetent>, L<C<endpwent>|/endpwent>, 391L<C<getgrent>|/getgrent>, L<C<getgrgid>|/getgrgid GID>, 392L<C<getgrnam>|/getgrnam NAME>, L<C<getlogin>|/getlogin>, 393L<C<getpwent>|/getpwent>, L<C<getpwnam>|/getpwnam NAME>, 394L<C<getpwuid>|/getpwuid UID>, L<C<setgrent>|/setgrent>, 395L<C<setpwent>|/setpwent> 396 397=item Fetching network info 398X<network> X<protocol> X<host> X<hostname> X<IP> X<address> X<service> 399 400=for Pod::Functions =Network 401 402L<C<endprotoent>|/endprotoent>, L<C<endservent>|/endservent>, 403L<C<gethostbyaddr>|/gethostbyaddr ADDR,ADDRTYPE>, 404L<C<gethostbyname>|/gethostbyname NAME>, L<C<gethostent>|/gethostent>, 405L<C<getnetbyaddr>|/getnetbyaddr ADDR,ADDRTYPE>, 406L<C<getnetbyname>|/getnetbyname NAME>, L<C<getnetent>|/getnetent>, 407L<C<getprotobyname>|/getprotobyname NAME>, 408L<C<getprotobynumber>|/getprotobynumber NUMBER>, 409L<C<getprotoent>|/getprotoent>, 410L<C<getservbyname>|/getservbyname NAME,PROTO>, 411L<C<getservbyport>|/getservbyport PORT,PROTO>, 412L<C<getservent>|/getservent>, L<C<sethostent>|/sethostent STAYOPEN>, 413L<C<setnetent>|/setnetent STAYOPEN>, 414L<C<setprotoent>|/setprotoent STAYOPEN>, 415L<C<setservent>|/setservent STAYOPEN> 416 417=item Time-related functions 418X<time> X<date> 419 420=for Pod::Functions =Time 421 422L<C<gmtime>|/gmtime EXPR>, L<C<localtime>|/localtime EXPR>, 423L<C<time>|/time>, L<C<times>|/times> 424 425=item Non-function keywords 426 427=for Pod::Functions =!Non-functions 428 429C<and>, C<AUTOLOAD>, C<BEGIN>, C<CHECK>, C<cmp>, C<CORE>, C<__DATA__>, 430C<default>, C<DESTROY>, C<else>, C<elseif>, C<elsif>, C<END>, C<__END__>, 431C<eq>, C<for>, C<foreach>, C<ge>, C<given>, C<gt>, C<if>, C<INIT>, C<le>, 432C<lt>, C<ne>, C<not>, C<or>, C<UNITCHECK>, C<unless>, C<until>, C<when>, 433C<while>, C<x>, C<xor> 434 435=back 436 437=head2 Portability 438X<portability> X<Unix> X<portable> 439 440Perl was born in Unix and can therefore access all common Unix 441system calls. In non-Unix environments, the functionality of some 442Unix system calls may not be available or details of the available 443functionality may differ slightly. The Perl functions affected 444by this are: 445 446L<C<-I<X>>|/-X FILEHANDLE>, L<C<binmode>|/binmode FILEHANDLE, LAYER>, 447L<C<chmod>|/chmod LIST>, L<C<chown>|/chown LIST>, 448L<C<chroot>|/chroot FILENAME>, L<C<crypt>|/crypt PLAINTEXT,SALT>, 449L<C<dbmclose>|/dbmclose HASH>, L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>, 450L<C<dump>|/dump LABEL>, L<C<endgrent>|/endgrent>, 451L<C<endhostent>|/endhostent>, L<C<endnetent>|/endnetent>, 452L<C<endprotoent>|/endprotoent>, L<C<endpwent>|/endpwent>, 453L<C<endservent>|/endservent>, L<C<exec>|/exec LIST>, 454L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR>, 455L<C<flock>|/flock FILEHANDLE,OPERATION>, L<C<fork>|/fork>, 456L<C<getgrent>|/getgrent>, L<C<getgrgid>|/getgrgid GID>, 457L<C<gethostbyname>|/gethostbyname NAME>, L<C<gethostent>|/gethostent>, 458L<C<getlogin>|/getlogin>, 459L<C<getnetbyaddr>|/getnetbyaddr ADDR,ADDRTYPE>, 460L<C<getnetbyname>|/getnetbyname NAME>, L<C<getnetent>|/getnetent>, 461L<C<getppid>|/getppid>, L<C<getpgrp>|/getpgrp PID>, 462L<C<getpriority>|/getpriority WHICH,WHO>, 463L<C<getprotobynumber>|/getprotobynumber NUMBER>, 464L<C<getprotoent>|/getprotoent>, L<C<getpwent>|/getpwent>, 465L<C<getpwnam>|/getpwnam NAME>, L<C<getpwuid>|/getpwuid UID>, 466L<C<getservbyport>|/getservbyport PORT,PROTO>, 467L<C<getservent>|/getservent>, 468L<C<getsockopt>|/getsockopt SOCKET,LEVEL,OPTNAME>, 469L<C<glob>|/glob EXPR>, L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>, 470L<C<kill>|/kill SIGNAL, LIST>, L<C<link>|/link OLDFILE,NEWFILE>, 471L<C<lstat>|/lstat FILEHANDLE>, L<C<msgctl>|/msgctl ID,CMD,ARG>, 472L<C<msgget>|/msgget KEY,FLAGS>, 473L<C<msgrcv>|/msgrcv ID,VAR,SIZE,TYPE,FLAGS>, 474L<C<msgsnd>|/msgsnd ID,MSG,FLAGS>, L<C<open>|/open FILEHANDLE,MODE,EXPR>, 475L<C<pipe>|/pipe READHANDLE,WRITEHANDLE>, L<C<readlink>|/readlink EXPR>, 476L<C<rename>|/rename OLDNAME,NEWNAME>, 477L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT>, 478L<C<semctl>|/semctl ID,SEMNUM,CMD,ARG>, 479L<C<semget>|/semget KEY,NSEMS,FLAGS>, L<C<semop>|/semop KEY,OPSTRING>, 480L<C<setgrent>|/setgrent>, L<C<sethostent>|/sethostent STAYOPEN>, 481L<C<setnetent>|/setnetent STAYOPEN>, L<C<setpgrp>|/setpgrp PID,PGRP>, 482L<C<setpriority>|/setpriority WHICH,WHO,PRIORITY>, 483L<C<setprotoent>|/setprotoent STAYOPEN>, L<C<setpwent>|/setpwent>, 484L<C<setservent>|/setservent STAYOPEN>, 485L<C<setsockopt>|/setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL>, 486L<C<shmctl>|/shmctl ID,CMD,ARG>, L<C<shmget>|/shmget KEY,SIZE,FLAGS>, 487L<C<shmread>|/shmread ID,VAR,POS,SIZE>, 488L<C<shmwrite>|/shmwrite ID,STRING,POS,SIZE>, 489L<C<socket>|/socket SOCKET,DOMAIN,TYPE,PROTOCOL>, 490L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL>, 491L<C<stat>|/stat FILEHANDLE>, L<C<symlink>|/symlink OLDFILE,NEWFILE>, 492L<C<syscall>|/syscall NUMBER, LIST>, 493L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE>, 494L<C<system>|/system LIST>, L<C<times>|/times>, 495L<C<truncate>|/truncate FILEHANDLE,LENGTH>, L<C<umask>|/umask EXPR>, 496L<C<unlink>|/unlink LIST>, L<C<utime>|/utime LIST>, L<C<wait>|/wait>, 497L<C<waitpid>|/waitpid PID,FLAGS> 498 499For more information about the portability of these functions, see 500L<perlport> and other available platform-specific documentation. 501 502=head2 Alphabetical Listing of Perl Functions 503 504=over 505 506=item -X FILEHANDLE 507X<-r>X<-w>X<-x>X<-o>X<-R>X<-W>X<-X>X<-O>X<-e>X<-z>X<-s>X<-f>X<-d>X<-l>X<-p> 508X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C> 509 510=item -X EXPR 511 512=item -X DIRHANDLE 513 514=item -X 515 516=for Pod::Functions a file test (-r, -x, etc) 517 518A file test, where X is one of the letters listed below. This unary 519operator takes one argument, either a filename, a filehandle, or a dirhandle, 520and tests the associated file to see if something is true about it. If the 521argument is omitted, tests L<C<$_>|perlvar/$_>, except for C<-t>, which 522tests STDIN. Unless otherwise documented, it returns C<1> for true and 523C<''> for false. If the file doesn't exist or can't be examined, it 524returns L<C<undef>|/undef EXPR> and sets L<C<$!>|perlvar/$!> (errno). 525With the exception of the C<-l> test they all follow symbolic links 526because they use C<stat()> and not C<lstat()> (so dangling symlinks can't 527be examined and will therefore report failure). 528 529Despite the funny names, precedence is the same as any other named unary 530operator. The operator may be any of: 531 532 -r File is readable by effective uid/gid. 533 -w File is writable by effective uid/gid. 534 -x File is executable by effective uid/gid. 535 -o File is owned by effective uid. 536 537 -R File is readable by real uid/gid. 538 -W File is writable by real uid/gid. 539 -X File is executable by real uid/gid. 540 -O File is owned by real uid. 541 542 -e File exists. 543 -z File has zero size (is empty). 544 -s File has nonzero size (returns size in bytes). 545 546 -f File is a plain file. 547 -d File is a directory. 548 -l File is a symbolic link (false if symlinks aren't 549 supported by the file system). 550 -p File is a named pipe (FIFO), or Filehandle is a pipe. 551 -S File is a socket. 552 -b File is a block special file. 553 -c File is a character special file. 554 -t Filehandle is opened to a tty. 555 556 -u File has setuid bit set. 557 -g File has setgid bit set. 558 -k File has sticky bit set. 559 560 -T File is an ASCII or UTF-8 text file (heuristic guess). 561 -B File is a "binary" file (opposite of -T). 562 563 -M Script start time minus file modification time, in days. 564 -A Same for access time. 565 -C Same for inode change time (Unix, may differ for other 566 platforms) 567 568Example: 569 570 while (<>) { 571 chomp; 572 next unless -f $_; # ignore specials 573 #... 574 } 575 576Note that C<-s/a/b/> does not do a negated substitution. Saying 577C<-exp($foo)> still works as expected, however: only single letters 578following a minus are interpreted as file tests. 579 580These operators are exempt from the "looks like a function rule" described 581above. That is, an opening parenthesis after the operator does not affect 582how much of the following code constitutes the argument. Put the opening 583parentheses before the operator to separate it from code that follows (this 584applies only to operators with higher precedence than unary operators, of 585course): 586 587 -s($file) + 1024 # probably wrong; same as -s($file + 1024) 588 (-s $file) + 1024 # correct 589 590The interpretation of the file permission operators C<-r>, C<-R>, 591C<-w>, C<-W>, C<-x>, and C<-X> is by default based solely on the mode 592of the file and the uids and gids of the user. There may be other 593reasons you can't actually read, write, or execute the file: for 594example network filesystem access controls, ACLs (access control lists), 595read-only filesystems, and unrecognized executable formats. Note 596that the use of these six specific operators to verify if some operation 597is possible is usually a mistake, because it may be open to race 598conditions. 599 600Also note that, for the superuser on the local filesystems, the C<-r>, 601C<-R>, C<-w>, and C<-W> tests always return 1, and C<-x> and C<-X> return 1 602if any execute bit is set in the mode. Scripts run by the superuser 603may thus need to do a L<C<stat>|/stat FILEHANDLE> to determine the 604actual mode of the file, or temporarily set their effective uid to 605something else. 606 607If you are using ACLs, there is a pragma called L<C<filetest>|filetest> 608that may produce more accurate results than the bare 609L<C<stat>|/stat FILEHANDLE> mode bits. 610When under C<use filetest 'access'>, the above-mentioned filetests 611test whether the permission can(not) be granted using the L<access(2)> 612family of system calls. Also note that the C<-x> and C<-X> tests may 613under this pragma return true even if there are no execute permission 614bits set (nor any extra execute permission ACLs). This strangeness is 615due to the underlying system calls' definitions. Note also that, due to 616the implementation of C<use filetest 'access'>, the C<_> special 617filehandle won't cache the results of the file tests when this pragma is 618in effect. Read the documentation for the L<C<filetest>|filetest> 619pragma for more information. 620 621The C<-T> and C<-B> tests work as follows. The first block or so of 622the file is examined to see if it is valid UTF-8 that includes non-ASCII 623characters. If so, it's a C<-T> file. Otherwise, that same portion of 624the file is examined for odd characters such as strange control codes or 625characters with the high bit set. If more than a third of the 626characters are strange, it's a C<-B> file; otherwise it's a C<-T> file. 627Also, any file containing a zero byte in the examined portion is 628considered a binary file. (If executed within the scope of a L<S<use 629locale>|perllocale> which includes C<LC_CTYPE>, odd characters are 630anything that isn't a printable nor space in the current locale.) If 631C<-T> or C<-B> is used on a filehandle, the current IO buffer is 632examined 633rather than the first block. Both C<-T> and C<-B> return true on an empty 634file, or a file at EOF when testing a filehandle. Because you have to 635read a file to do the C<-T> test, on most occasions you want to use a C<-f> 636against the file first, as in C<next unless -f $file && -T $file>. 637 638If any of the file tests (or either the L<C<stat>|/stat FILEHANDLE> or 639L<C<lstat>|/lstat FILEHANDLE> operator) is given the special filehandle 640consisting of a solitary underline, then the stat structure of the 641previous file test (or L<C<stat>|/stat FILEHANDLE> operator) is used, 642saving a system call. (This doesn't work with C<-t>, and you need to 643remember that L<C<lstat>|/lstat FILEHANDLE> and C<-l> leave values in 644the stat structure for the symbolic link, not the real file.) (Also, if 645the stat buffer was filled by an L<C<lstat>|/lstat FILEHANDLE> call, 646C<-T> and C<-B> will reset it with the results of C<stat _>). 647Example: 648 649 print "Can do.\n" if -r $a || -w _ || -x _; 650 651 stat($filename); 652 print "Readable\n" if -r _; 653 print "Writable\n" if -w _; 654 print "Executable\n" if -x _; 655 print "Setuid\n" if -u _; 656 print "Setgid\n" if -g _; 657 print "Sticky\n" if -k _; 658 print "Text\n" if -T _; 659 print "Binary\n" if -B _; 660 661As of Perl 5.10.0, as a form of purely syntactic sugar, you can stack file 662test operators, in a way that C<-f -w -x $file> is equivalent to 663C<-x $file && -w _ && -f _>. (This is only fancy syntax: if you use 664the return value of C<-f $file> as an argument to another filetest 665operator, no special magic will happen.) 666 667Portability issues: L<perlport/-X>. 668 669To avoid confusing would-be users of your code with mysterious 670syntax errors, put something like this at the top of your script: 671 672 use 5.010; # so filetest ops can stack 673 674=item abs VALUE 675X<abs> X<absolute> 676 677=item abs 678 679=for Pod::Functions absolute value function 680 681Returns the absolute value of its argument. 682If VALUE is omitted, uses L<C<$_>|perlvar/$_>. 683 684=item accept NEWSOCKET,GENERICSOCKET 685X<accept> 686 687=for Pod::Functions accept an incoming socket connect 688 689Accepts an incoming socket connect, just as L<accept(2)> 690does. Returns the packed address if it succeeded, false otherwise. 691See the example in L<perlipc/"Sockets: Client/Server Communication">. 692 693On systems that support a close-on-exec flag on files, the flag will 694be set for the newly opened file descriptor, as determined by the 695value of L<C<$^F>|perlvar/$^F>. See L<perlvar/$^F>. 696 697=item alarm SECONDS 698X<alarm> 699X<SIGALRM> 700X<timer> 701 702=item alarm 703 704=for Pod::Functions schedule a SIGALRM 705 706Arranges to have a SIGALRM delivered to this process after the 707specified number of wallclock seconds has elapsed. If SECONDS is not 708specified, the value stored in L<C<$_>|perlvar/$_> is used. (On some 709machines, unfortunately, the elapsed time may be up to one second less 710or more than you specified because of how seconds are counted, and 711process scheduling may delay the delivery of the signal even further.) 712 713Only one timer may be counting at once. Each call disables the 714previous timer, and an argument of C<0> may be supplied to cancel the 715previous timer without starting a new one. The returned value is the 716amount of time remaining on the previous timer. 717 718For delays of finer granularity than one second, the L<Time::HiRes> module 719(from CPAN, and starting from Perl 5.8 part of the standard 720distribution) provides 721L<C<ualarm>|Time::HiRes/ualarm ( $useconds [, $interval_useconds ] )>. 722You may also use Perl's four-argument version of 723L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> leaving the first three 724arguments undefined, or you might be able to use the 725L<C<syscall>|/syscall NUMBER, LIST> interface to access L<setitimer(2)> 726if your system supports it. See L<perlfaq8> for details. 727 728It is usually a mistake to intermix L<C<alarm>|/alarm SECONDS> and 729L<C<sleep>|/sleep EXPR> calls, because L<C<sleep>|/sleep EXPR> may be 730internally implemented on your system with L<C<alarm>|/alarm SECONDS>. 731 732If you want to use L<C<alarm>|/alarm SECONDS> to time out a system call 733you need to use an L<C<eval>|/eval EXPR>/L<C<die>|/die LIST> pair. You 734can't rely on the alarm causing the system call to fail with 735L<C<$!>|perlvar/$!> set to C<EINTR> because Perl sets up signal handlers 736to restart system calls on some systems. Using 737L<C<eval>|/eval EXPR>/L<C<die>|/die LIST> always works, modulo the 738caveats given in L<perlipc/"Signals">. 739 740 eval { 741 local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required 742 alarm $timeout; 743 my $nread = sysread $socket, $buffer, $size; 744 alarm 0; 745 }; 746 if ($@) { 747 die unless $@ eq "alarm\n"; # propagate unexpected errors 748 # timed out 749 } 750 else { 751 # didn't 752 } 753 754For more information see L<perlipc>. 755 756Portability issues: L<perlport/alarm>. 757 758=item atan2 Y,X 759X<atan2> X<arctangent> X<tan> X<tangent> 760 761=for Pod::Functions arctangent of Y/X in the range -PI to PI 762 763Returns the arctangent of Y/X in the range -PI to PI. 764 765For the tangent operation, you may use the 766L<C<Math::Trig::tan>|Math::Trig/B<tan>> function, or use the familiar 767relation: 768 769 sub tan { sin($_[0]) / cos($_[0]) } 770 771The return value for C<atan2(0,0)> is implementation-defined; consult 772your L<atan2(3)> manpage for more information. 773 774Portability issues: L<perlport/atan2>. 775 776=item bind SOCKET,NAME 777X<bind> 778 779=for Pod::Functions binds an address to a socket 780 781Binds a network address to a socket, just as L<bind(2)> 782does. Returns true if it succeeded, false otherwise. NAME should be a 783packed address of the appropriate type for the socket. See the examples in 784L<perlipc/"Sockets: Client/Server Communication">. 785 786=item binmode FILEHANDLE, LAYER 787X<binmode> X<binary> X<text> X<DOS> X<Windows> 788 789=item binmode FILEHANDLE 790 791=for Pod::Functions prepare binary files for I/O 792 793Arranges for FILEHANDLE to be read or written in "binary" or "text" 794mode on systems where the run-time libraries distinguish between 795binary and text files. If FILEHANDLE is an expression, the value is 796taken as the name of the filehandle. Returns true on success, 797otherwise it returns L<C<undef>|/undef EXPR> and sets 798L<C<$!>|perlvar/$!> (errno). 799 800On some systems (in general, DOS- and Windows-based systems) 801L<C<binmode>|/binmode FILEHANDLE, LAYER> is necessary when you're not 802working with a text file. For the sake of portability it is a good idea 803always to use it when appropriate, and never to use it when it isn't 804appropriate. Also, people can set their I/O to be by default 805UTF8-encoded Unicode, not bytes. 806 807In other words: regardless of platform, use 808L<C<binmode>|/binmode FILEHANDLE, LAYER> on binary data, like images, 809for example. 810 811If LAYER is present it is a single string, but may contain multiple 812directives. The directives alter the behaviour of the filehandle. 813When LAYER is present, using binmode on a text file makes sense. 814 815If LAYER is omitted or specified as C<:raw> the filehandle is made 816suitable for passing binary data. This includes turning off possible CRLF 817translation and marking it as bytes (as opposed to Unicode characters). 818Note that, despite what may be implied in I<"Programming Perl"> (the 819Camel, 3rd edition) or elsewhere, C<:raw> is I<not> simply the inverse of C<:crlf>. 820Other layers that would affect the binary nature of the stream are 821I<also> disabled. See L<PerlIO>, and the discussion about the PERLIO 822environment variable in L<perlrun|perlrun/PERLIO>. 823 824The C<:bytes>, C<:crlf>, C<:utf8>, and any other directives of the 825form C<:...>, are called I/O I<layers>. The L<open> pragma can be used to 826establish default I/O layers. 827 828I<The LAYER parameter of the L<C<binmode>|/binmode FILEHANDLE, LAYER> 829function is described as "DISCIPLINE" in "Programming Perl, 3rd 830Edition". However, since the publishing of this book, by many known as 831"Camel III", the consensus of the naming of this functionality has moved 832from "discipline" to "layer". All documentation of this version of Perl 833therefore refers to "layers" rather than to "disciplines". Now back to 834the regularly scheduled documentation...> 835 836To mark FILEHANDLE as UTF-8, use C<:utf8> or C<:encoding(UTF-8)>. 837C<:utf8> just marks the data as UTF-8 without further checking, 838while C<:encoding(UTF-8)> checks the data for actually being valid 839UTF-8. More details can be found in L<PerlIO::encoding>. 840 841In general, L<C<binmode>|/binmode FILEHANDLE, LAYER> should be called 842after L<C<open>|/open FILEHANDLE,MODE,EXPR> but before any I/O is done on the 843filehandle. Calling L<C<binmode>|/binmode FILEHANDLE, LAYER> normally 844flushes any pending buffered output data (and perhaps pending input 845data) on the handle. An exception to this is the C<:encoding> layer 846that changes the default character encoding of the handle. 847The C<:encoding> layer sometimes needs to be called in 848mid-stream, and it doesn't flush the stream. C<:encoding> 849also implicitly pushes on top of itself the C<:utf8> layer because 850internally Perl operates on UTF8-encoded Unicode characters. 851 852The operating system, device drivers, C libraries, and Perl run-time 853system all conspire to let the programmer treat a single 854character (C<\n>) as the line terminator, irrespective of external 855representation. On many operating systems, the native text file 856representation matches the internal representation, but on some 857platforms the external representation of C<\n> is made up of more than 858one character. 859 860All variants of Unix, Mac OS (old and new), and Stream_LF files on VMS use 861a single character to end each line in the external representation of text 862(even though that single character is CARRIAGE RETURN on old, pre-Darwin 863flavors of Mac OS, and is LINE FEED on Unix and most VMS files). In other 864systems like OS/2, DOS, and the various flavors of MS-Windows, your program 865sees a C<\n> as a simple C<\cJ>, but what's stored in text files are the 866two characters C<\cM\cJ>. That means that if you don't use 867L<C<binmode>|/binmode FILEHANDLE, LAYER> on these systems, C<\cM\cJ> 868sequences on disk will be converted to C<\n> on input, and any C<\n> in 869your program will be converted back to C<\cM\cJ> on output. This is 870what you want for text files, but it can be disastrous for binary files. 871 872Another consequence of using L<C<binmode>|/binmode FILEHANDLE, LAYER> 873(on some systems) is that special end-of-file markers will be seen as 874part of the data stream. For systems from the Microsoft family this 875means that, if your binary data contain C<\cZ>, the I/O subsystem will 876regard it as the end of the file, unless you use 877L<C<binmode>|/binmode FILEHANDLE, LAYER>. 878 879L<C<binmode>|/binmode FILEHANDLE, LAYER> is important not only for 880L<C<readline>|/readline EXPR> and L<C<print>|/print FILEHANDLE LIST> 881operations, but also when using 882L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET>, 883L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 884L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>, 885L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET> and 886L<C<tell>|/tell FILEHANDLE> (see L<perlport> for more details). See the 887L<C<$E<sol>>|perlvar/$E<sol>> and L<C<$\>|perlvar/$\> variables in 888L<perlvar> for how to manually set your input and output 889line-termination sequences. 890 891Portability issues: L<perlport/binmode>. 892 893=item bless REF,CLASSNAME 894X<bless> 895 896=item bless REF 897 898=for Pod::Functions create an object 899 900This function tells the thingy referenced by REF that it is now an object 901in the CLASSNAME package. If CLASSNAME is an empty string, it is 902interpreted as referring to the C<main> package. 903If CLASSNAME is omitted, the current package 904is used. Because a L<C<bless>|/bless REF,CLASSNAME> is often the last 905thing in a constructor, it returns the reference for convenience. 906Always use the two-argument version if a derived class might inherit the 907method doing the blessing. See L<perlobj> for more about the blessing 908(and blessings) of objects. 909 910Consider always blessing objects in CLASSNAMEs that are mixed case. 911Namespaces with all lowercase names are considered reserved for 912Perl pragmas. Builtin types have all uppercase names. To prevent 913confusion, you may wish to avoid such package names as well. 914It is advised to avoid the class name C<0>, because much code erroneously 915uses the result of L<C<ref>|/ref EXPR> as a truth value. 916 917See L<perlmod/"Perl Modules">. 918 919=item break 920 921=for Pod::Functions +switch break out of a C<given> block 922 923Break out of a C<given> block. 924 925L<C<break>|/break> is available only if the 926L<C<"switch"> feature|feature/The 'switch' feature> is enabled or if it 927is prefixed with C<CORE::>. The 928L<C<"switch"> feature|feature/The 'switch' feature> is enabled 929automatically with a C<use v5.10> (or higher) declaration in the current 930scope. 931 932=item caller EXPR 933X<caller> X<call stack> X<stack> X<stack trace> 934 935=item caller 936 937=for Pod::Functions get context of the current subroutine call 938 939Returns the context of the current pure perl subroutine call. In scalar 940context, returns the caller's package name if there I<is> a caller (that is, if 941we're in a subroutine or L<C<eval>|/eval EXPR> or 942L<C<require>|/require VERSION>) and the undefined value otherwise. 943caller never returns XS subs and they are skipped. The next pure perl 944sub will appear instead of the XS sub in caller's return values. In 945list context, caller returns 946 947 # 0 1 2 948 my ($package, $filename, $line) = caller; 949 950Like L<C<__FILE__>|/__FILE__> and L<C<__LINE__>|/__LINE__>, the filename and 951line number returned here may be altered by the mechanism described at 952L<perlsyn/"Plain Old Comments (Not!)">. 953 954With EXPR, it returns some extra information that the debugger uses to 955print a stack trace. The value of EXPR indicates how many call frames 956to go back before the current one. 957 958 # 0 1 2 3 4 959 my ($package, $filename, $line, $subroutine, $hasargs, 960 961 # 5 6 7 8 9 10 962 $wantarray, $evaltext, $is_require, $hints, $bitmask, $hinthash) 963 = caller($i); 964 965Here, $subroutine is the function that the caller called (rather than the 966function containing the caller). Note that $subroutine may be C<(eval)> if 967the frame is not a subroutine call, but an L<C<eval>|/eval EXPR>. In 968such a case additional elements $evaltext and C<$is_require> are set: 969C<$is_require> is true if the frame is created by a 970L<C<require>|/require VERSION> or L<C<use>|/use Module VERSION LIST> 971statement, $evaltext contains the text of the C<eval EXPR> statement. 972In particular, for an C<eval BLOCK> statement, $subroutine is C<(eval)>, 973but $evaltext is undefined. (Note also that each 974L<C<use>|/use Module VERSION LIST> statement creates a 975L<C<require>|/require VERSION> frame inside an C<eval EXPR> frame.) 976$subroutine may also be C<(unknown)> if this particular subroutine 977happens to have been deleted from the symbol table. C<$hasargs> is true 978if a new instance of L<C<@_>|perlvar/@_> was set up for the frame. 979C<$hints> and C<$bitmask> contain pragmatic hints that the caller was 980compiled with. C<$hints> corresponds to L<C<$^H>|perlvar/$^H>, and 981C<$bitmask> corresponds to 982L<C<${^WARNING_BITS}>|perlvar/${^WARNING_BITS}>. The C<$hints> and 983C<$bitmask> values are subject to change between versions of Perl, and 984are not meant for external use. 985 986C<$hinthash> is a reference to a hash containing the value of 987L<C<%^H>|perlvar/%^H> when the caller was compiled, or 988L<C<undef>|/undef EXPR> if L<C<%^H>|perlvar/%^H> was empty. Do not 989modify the values of this hash, as they are the actual values stored in 990the optree. 991 992Note that the only types of call frames that are visible are subroutine 993calls and C<eval>. Other forms of context, such as C<while> or C<foreach> 994loops or C<try> blocks are not considered interesting to C<caller>, as they 995do not alter the behaviour of the C<return> expression. 996 997Furthermore, when called from within the DB package in 998list context, and with an argument, caller returns more 999detailed information: it sets the list variable C<@DB::args> to be the 1000arguments with which the subroutine was invoked. 1001 1002Be aware that the optimizer might have optimized call frames away before 1003L<C<caller>|/caller EXPR> had a chance to get the information. That 1004means that C<caller(N)> might not return information about the call 1005frame you expect it to, for C<< N > 1 >>. In particular, C<@DB::args> 1006might have information from the previous time L<C<caller>|/caller EXPR> 1007was called. 1008 1009Be aware that setting C<@DB::args> is I<best effort>, intended for 1010debugging or generating backtraces, and should not be relied upon. In 1011particular, as L<C<@_>|perlvar/@_> contains aliases to the caller's 1012arguments, Perl does not take a copy of L<C<@_>|perlvar/@_>, so 1013C<@DB::args> will contain modifications the subroutine makes to 1014L<C<@_>|perlvar/@_> or its contents, not the original values at call 1015time. C<@DB::args>, like L<C<@_>|perlvar/@_>, does not hold explicit 1016references to its elements, so under certain cases its elements may have 1017become freed and reallocated for other variables or temporary values. 1018Finally, a side effect of the current implementation is that the effects 1019of C<shift @_> can I<normally> be undone (but not C<pop @_> or other 1020splicing, I<and> not if a reference to L<C<@_>|perlvar/@_> has been 1021taken, I<and> subject to the caveat about reallocated elements), so 1022C<@DB::args> is actually a hybrid of the current state and initial state 1023of L<C<@_>|perlvar/@_>. Buyer beware. 1024 1025=item chdir EXPR 1026X<chdir> 1027X<cd> 1028X<directory, change> 1029 1030=item chdir FILEHANDLE 1031 1032=item chdir DIRHANDLE 1033 1034=item chdir 1035 1036=for Pod::Functions change your current working directory 1037 1038Changes the working directory to EXPR, if possible. If EXPR is omitted, 1039changes to the directory specified by C<$ENV{HOME}>, if set; if not, 1040changes to the directory specified by C<$ENV{LOGDIR}>. (Under VMS, the 1041variable C<$ENV{'SYS$LOGIN'}> is also checked, and used if it is set.) If 1042neither is set, L<C<chdir>|/chdir EXPR> does nothing and fails. It 1043returns true on success, false otherwise. See the example under 1044L<C<die>|/die LIST>. 1045 1046On systems that support L<fchdir(2)>, you may pass a filehandle or 1047directory handle as the argument. On systems that don't support L<fchdir(2)>, 1048passing handles raises an exception. 1049 1050=item chmod LIST 1051X<chmod> X<permission> X<mode> 1052 1053=for Pod::Functions changes the permissions on a list of files 1054 1055Changes the permissions of a list of files. The first element of the 1056list must be the numeric mode, which should probably be an octal 1057number, and which definitely should I<not> be a string of octal digits: 1058C<0644> is okay, but C<"0644"> is not. Returns the number of files 1059successfully changed. See also L<C<oct>|/oct EXPR> if all you have is a 1060string. 1061 1062 my $cnt = chmod 0755, "foo", "bar"; 1063 chmod 0755, @executables; 1064 my $mode = "0644"; chmod $mode, "foo"; # !!! sets mode to 1065 # --w----r-T 1066 my $mode = "0644"; chmod oct($mode), "foo"; # this is better 1067 my $mode = 0644; chmod $mode, "foo"; # this is best 1068 1069On systems that support L<fchmod(2)>, you may pass filehandles among the 1070files. On systems that don't support L<fchmod(2)>, passing filehandles raises 1071an exception. Filehandles must be passed as globs or glob references to be 1072recognized; barewords are considered filenames. 1073 1074 open(my $fh, "<", "foo"); 1075 my $perm = (stat $fh)[2] & 07777; 1076 chmod($perm | 0600, $fh); 1077 1078You can also import the symbolic C<S_I*> constants from the 1079L<C<Fcntl>|Fcntl> module: 1080 1081 use Fcntl qw( :mode ); 1082 chmod S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, @executables; 1083 # Identical to the chmod 0755 of the example above. 1084 1085Portability issues: L<perlport/chmod>. 1086 1087=item chomp VARIABLE 1088X<chomp> X<INPUT_RECORD_SEPARATOR> X<$/> X<newline> X<eol> 1089 1090=item chomp( LIST ) 1091 1092=item chomp 1093 1094=for Pod::Functions remove a trailing record separator from a string 1095 1096This safer version of L<C<chop>|/chop VARIABLE> removes any trailing 1097string that corresponds to the current value of 1098L<C<$E<sol>>|perlvar/$E<sol>> (also known as C<$INPUT_RECORD_SEPARATOR> 1099in the L<C<English>|English> module). It returns the total 1100number of characters removed from all its arguments. It's often used to 1101remove the newline from the end of an input record when you're worried 1102that the final record may be missing its newline. When in paragraph 1103mode (C<$/ = ''>), it removes all trailing newlines from the string. 1104When in slurp mode (C<$/ = undef>) or fixed-length record mode 1105(L<C<$E<sol>>|perlvar/$E<sol>> is a reference to an integer or the like; 1106see L<perlvar>), L<C<chomp>|/chomp VARIABLE> won't remove anything. 1107If VARIABLE is omitted, it chomps L<C<$_>|perlvar/$_>. Example: 1108 1109 while (<>) { 1110 chomp; # avoid \n on last field 1111 my @array = split(/:/); 1112 # ... 1113 } 1114 1115If VARIABLE is a hash, it chomps the hash's values, but not its keys, 1116resetting the L<C<each>|/each HASH> iterator in the process. 1117 1118You can actually chomp anything that's an lvalue, including an assignment: 1119 1120 chomp(my $cwd = `pwd`); 1121 chomp(my $answer = <STDIN>); 1122 1123If you chomp a list, each element is chomped, and the total number of 1124characters removed is returned. 1125 1126Note that parentheses are necessary when you're chomping anything 1127that is not a simple variable. This is because C<chomp $cwd = `pwd`;> 1128is interpreted as C<(chomp $cwd) = `pwd`;>, rather than as 1129C<chomp( $cwd = `pwd` )> which you might expect. Similarly, 1130C<chomp $a, $b> is interpreted as C<chomp($a), $b> rather than 1131as C<chomp($a, $b)>. 1132 1133=item chop VARIABLE 1134X<chop> 1135 1136=item chop( LIST ) 1137 1138=item chop 1139 1140=for Pod::Functions remove the last character from a string 1141 1142Chops off the last character of a string and returns the character 1143chopped. It is much more efficient than C<s/.$//s> because it neither 1144scans nor copies the string. If VARIABLE is omitted, chops 1145L<C<$_>|perlvar/$_>. 1146If VARIABLE is a hash, it chops the hash's values, but not its keys, 1147resetting the L<C<each>|/each HASH> iterator in the process. 1148 1149You can actually chop anything that's an lvalue, including an assignment. 1150 1151If you chop a list, each element is chopped. Only the value of the 1152last L<C<chop>|/chop VARIABLE> is returned. 1153 1154Note that L<C<chop>|/chop VARIABLE> returns the last character. To 1155return all but the last character, use C<substr($string, 0, -1)>. 1156 1157See also L<C<chomp>|/chomp VARIABLE>. 1158 1159=item chown LIST 1160X<chown> X<owner> X<user> X<group> 1161 1162=for Pod::Functions change the ownership on a list of files 1163 1164Changes the owner (and group) of a list of files. The first two 1165elements of the list must be the I<numeric> uid and gid, in that 1166order. A value of -1 in either position is interpreted by most 1167systems to leave that value unchanged. Returns the number of files 1168successfully changed. 1169 1170 my $cnt = chown $uid, $gid, 'foo', 'bar'; 1171 chown $uid, $gid, @filenames; 1172 1173On systems that support L<fchown(2)>, you may pass filehandles among the 1174files. On systems that don't support L<fchown(2)>, passing filehandles raises 1175an exception. Filehandles must be passed as globs or glob references to be 1176recognized; barewords are considered filenames. 1177 1178Here's an example that looks up nonnumeric uids in the passwd file: 1179 1180 print "User: "; 1181 chomp(my $user = <STDIN>); 1182 print "Files: "; 1183 chomp(my $pattern = <STDIN>); 1184 1185 my ($login,$pass,$uid,$gid) = getpwnam($user) 1186 or die "$user not in passwd file"; 1187 1188 my @ary = glob($pattern); # expand filenames 1189 chown $uid, $gid, @ary; 1190 1191On most systems, you are not allowed to change the ownership of the 1192file unless you're the superuser, although you should be able to change 1193the group to any of your secondary groups. On insecure systems, these 1194restrictions may be relaxed, but this is not a portable assumption. 1195On POSIX systems, you can detect this condition this way: 1196 1197 use POSIX qw(sysconf _PC_CHOWN_RESTRICTED); 1198 my $can_chown_giveaway = ! sysconf(_PC_CHOWN_RESTRICTED); 1199 1200Portability issues: L<perlport/chown>. 1201 1202=item chr NUMBER 1203X<chr> X<character> X<ASCII> X<Unicode> 1204 1205=item chr 1206 1207=for Pod::Functions get character this number represents 1208 1209Returns the character represented by that NUMBER in the character set. 1210For example, C<chr(65)> is C<"A"> in either ASCII or Unicode, and 1211chr(0x263a) is a Unicode smiley face. 1212 1213Negative values give the Unicode replacement character (chr(0xfffd)), 1214except under the L<bytes> pragma, where the low eight bits of the value 1215(truncated to an integer) are used. 1216 1217If NUMBER is omitted, uses L<C<$_>|perlvar/$_>. 1218 1219For the reverse, use L<C<ord>|/ord EXPR>. 1220 1221Note that characters from 128 to 255 (inclusive) are by default 1222internally not encoded as UTF-8 for backward compatibility reasons. 1223 1224See L<perlunicode> for more about Unicode. 1225 1226=item chroot FILENAME 1227X<chroot> X<root> 1228 1229=item chroot 1230 1231=for Pod::Functions make directory new root for path lookups 1232 1233This function works like the system call by the same name: it makes the 1234named directory the new root directory for all further pathnames that 1235begin with a C</> by your process and all its children. (It doesn't 1236change your current working directory, which is unaffected.) For security 1237reasons, this call is restricted to the superuser. If FILENAME is 1238omitted, does a L<C<chroot>|/chroot FILENAME> to L<C<$_>|perlvar/$_>. 1239 1240B<NOTE:> It is mandatory for security to C<chdir("/")> 1241(L<C<chdir>|/chdir EXPR> to the root directory) immediately after a 1242L<C<chroot>|/chroot FILENAME>, otherwise the current working directory 1243may be outside of the new root. 1244 1245Portability issues: L<perlport/chroot>. 1246 1247=item close FILEHANDLE 1248X<close> 1249 1250=item close 1251 1252=for Pod::Functions close file (or pipe or socket) handle 1253 1254Closes the file or pipe associated with the filehandle, flushes the IO 1255buffers, and closes the system file descriptor. Returns true if those 1256operations succeed and if no error was reported by any PerlIO 1257layer. Closes the currently selected filehandle if the argument is 1258omitted. 1259 1260You don't have to close FILEHANDLE if you are immediately going to do 1261another L<C<open>|/open FILEHANDLE,MODE,EXPR> on it, because 1262L<C<open>|/open FILEHANDLE,MODE,EXPR> closes it for you. (See 1263L<C<open>|/open FILEHANDLE,MODE,EXPR>.) However, an explicit 1264L<C<close>|/close FILEHANDLE> on an input file resets the line counter 1265(L<C<$.>|perlvar/$.>), while the implicit close done by 1266L<C<open>|/open FILEHANDLE,MODE,EXPR> does not. 1267 1268If the filehandle came from a piped open, L<C<close>|/close FILEHANDLE> 1269returns false if one of the other syscalls involved fails or if its 1270program exits with non-zero status. If the only problem was that the 1271program exited non-zero, L<C<$!>|perlvar/$!> will be set to C<0>. 1272Closing a pipe also waits for the process executing on the pipe to 1273exit--in case you wish to look at the output of the pipe afterwards--and 1274implicitly puts the exit status value of that command into 1275L<C<$?>|perlvar/$?> and 1276L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>. 1277 1278If there are multiple threads running, L<C<close>|/close FILEHANDLE> on 1279a filehandle from a piped open returns true without waiting for the 1280child process to terminate, if the filehandle is still open in another 1281thread. 1282 1283Closing the read end of a pipe before the process writing to it at the 1284other end is done writing results in the writer receiving a SIGPIPE. If 1285the other end can't handle that, be sure to read all the data before 1286closing the pipe. 1287 1288Example: 1289 1290 open(OUTPUT, '|sort >foo') # pipe to sort 1291 or die "Can't start sort: $!"; 1292 #... # print stuff to output 1293 close OUTPUT # wait for sort to finish 1294 or warn $! ? "Error closing sort pipe: $!" 1295 : "Exit status $? from sort"; 1296 open(INPUT, 'foo') # get sort's results 1297 or die "Can't open 'foo' for input: $!"; 1298 1299FILEHANDLE may be an expression whose value can be used as an indirect 1300filehandle, usually the real filehandle name or an autovivified handle. 1301 1302=item closedir DIRHANDLE 1303X<closedir> 1304 1305=for Pod::Functions close directory handle 1306 1307Closes a directory opened by L<C<opendir>|/opendir DIRHANDLE,EXPR> and 1308returns the success of that system call. 1309 1310=item connect SOCKET,NAME 1311X<connect> 1312 1313=for Pod::Functions connect to a remote socket 1314 1315Attempts to connect to a remote socket, just like L<connect(2)>. 1316Returns true if it succeeded, false otherwise. NAME should be a 1317packed address of the appropriate type for the socket. See the examples in 1318L<perlipc/"Sockets: Client/Server Communication">. 1319 1320=item continue BLOCK 1321X<continue> 1322 1323=item continue 1324 1325=for Pod::Functions optional trailing block in a while or foreach 1326 1327When followed by a BLOCK, L<C<continue>|/continue BLOCK> is actually a 1328flow control statement rather than a function. If there is a 1329L<C<continue>|/continue BLOCK> BLOCK attached to a BLOCK (typically in a 1330C<while> or C<foreach>), it is always executed just before the 1331conditional is about to be evaluated again, just like the third part of 1332a C<for> loop in C. Thus it can be used to increment a loop variable, 1333even when the loop has been continued via the L<C<next>|/next LABEL> 1334statement (which is similar to the C L<C<continue>|/continue BLOCK> 1335statement). 1336 1337L<C<last>|/last LABEL>, L<C<next>|/next LABEL>, or 1338L<C<redo>|/redo LABEL> may appear within a 1339L<C<continue>|/continue BLOCK> block; L<C<last>|/last LABEL> and 1340L<C<redo>|/redo LABEL> behave as if they had been executed within the 1341main block. So will L<C<next>|/next LABEL>, but since it will execute a 1342L<C<continue>|/continue BLOCK> block, it may be more entertaining. 1343 1344 while (EXPR) { 1345 ### redo always comes here 1346 do_something; 1347 } continue { 1348 ### next always comes here 1349 do_something_else; 1350 # then back the top to re-check EXPR 1351 } 1352 ### last always comes here 1353 1354Omitting the L<C<continue>|/continue BLOCK> section is equivalent to 1355using an empty one, logically enough, so L<C<next>|/next LABEL> goes 1356directly back to check the condition at the top of the loop. 1357 1358When there is no BLOCK, L<C<continue>|/continue BLOCK> is a function 1359that falls through the current C<when> or C<default> block instead of 1360iterating a dynamically enclosing C<foreach> or exiting a lexically 1361enclosing C<given>. In Perl 5.14 and earlier, this form of 1362L<C<continue>|/continue BLOCK> was only available when the 1363L<C<"switch"> feature|feature/The 'switch' feature> was enabled. See 1364L<feature> and L<perlsyn/"Switch Statements"> for more information. 1365 1366=item cos EXPR 1367X<cos> X<cosine> X<acos> X<arccosine> 1368 1369=item cos 1370 1371=for Pod::Functions cosine function 1372 1373Returns the cosine of EXPR (expressed in radians). If EXPR is omitted, 1374takes the cosine of L<C<$_>|perlvar/$_>. 1375 1376For the inverse cosine operation, you may use the 1377L<C<Math::Trig::acos>|Math::Trig> function, or use this relation: 1378 1379 sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) } 1380 1381=item crypt PLAINTEXT,SALT 1382X<crypt> X<digest> X<hash> X<salt> X<plaintext> X<password> 1383X<decrypt> X<cryptography> X<passwd> X<encrypt> 1384 1385=for Pod::Functions one-way passwd-style encryption 1386 1387Creates a digest string exactly like the L<crypt(3)> function in the C 1388library (assuming that you actually have a version there that has not 1389been extirpated as a potential munition). 1390 1391L<C<crypt>|/crypt PLAINTEXT,SALT> is a one-way hash function. The 1392PLAINTEXT and SALT are turned 1393into a short string, called a digest, which is returned. The same 1394PLAINTEXT and SALT will always return the same string, but there is no 1395(known) way to get the original PLAINTEXT from the hash. Small 1396changes in the PLAINTEXT or SALT will result in large changes in the 1397digest. 1398 1399There is no decrypt function. This function isn't all that useful for 1400cryptography (for that, look for F<Crypt> modules on your nearby CPAN 1401mirror) and the name "crypt" is a bit of a misnomer. Instead it is 1402primarily used to check if two pieces of text are the same without 1403having to transmit or store the text itself. An example is checking 1404if a correct password is given. The digest of the password is stored, 1405not the password itself. The user types in a password that is 1406L<C<crypt>|/crypt PLAINTEXT,SALT>'d with the same salt as the stored 1407digest. If the two digests match, the password is correct. 1408 1409When verifying an existing digest string you should use the digest as 1410the salt (like C<crypt($plain, $digest) eq $digest>). The SALT used 1411to create the digest is visible as part of the digest. This ensures 1412L<C<crypt>|/crypt PLAINTEXT,SALT> will hash the new string with the same 1413salt as the digest. This allows your code to work with the standard 1414L<C<crypt>|/crypt PLAINTEXT,SALT> and with more exotic implementations. 1415In other words, assume nothing about the returned string itself nor 1416about how many bytes of SALT may matter. 1417 1418Traditionally the result is a string of 13 bytes: two first bytes of 1419the salt, followed by 11 bytes from the set C<[./0-9A-Za-z]>, and only 1420the first eight bytes of PLAINTEXT mattered. But alternative 1421hashing schemes (like MD5), higher level security schemes (like C2), 1422and implementations on non-Unix platforms may produce different 1423strings. 1424 1425When choosing a new salt create a random two character string whose 1426characters come from the set C<[./0-9A-Za-z]> (like C<join '', ('.', 1427'/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]>). This set of 1428characters is just a recommendation; the characters allowed in 1429the salt depend solely on your system's crypt library, and Perl can't 1430restrict what salts L<C<crypt>|/crypt PLAINTEXT,SALT> accepts. 1431 1432Here's an example that makes sure that whoever runs this program knows 1433their password: 1434 1435 my $pwd = (getpwuid($<))[1]; 1436 1437 system "stty -echo"; 1438 print "Password: "; 1439 chomp(my $word = <STDIN>); 1440 print "\n"; 1441 system "stty echo"; 1442 1443 if (crypt($word, $pwd) ne $pwd) { 1444 die "Sorry...\n"; 1445 } else { 1446 print "ok\n"; 1447 } 1448 1449Of course, typing in your own password to whoever asks you 1450for it is unwise. 1451 1452The L<C<crypt>|/crypt PLAINTEXT,SALT> function is unsuitable for hashing 1453large quantities of data, not least of all because you can't get the 1454information back. Look at the L<Digest> module for more robust 1455algorithms. 1456 1457If using L<C<crypt>|/crypt PLAINTEXT,SALT> on a Unicode string (which 1458I<potentially> has characters with codepoints above 255), Perl tries to 1459make sense of the situation by trying to downgrade (a copy of) the 1460string back to an eight-bit byte string before calling 1461L<C<crypt>|/crypt PLAINTEXT,SALT> (on that copy). If that works, good. 1462If not, L<C<crypt>|/crypt PLAINTEXT,SALT> dies with 1463L<C<Wide character in crypt>|perldiag/Wide character in %s>. 1464 1465Portability issues: L<perlport/crypt>. 1466 1467=item dbmclose HASH 1468X<dbmclose> 1469 1470=for Pod::Functions breaks binding on a tied dbm file 1471 1472[This function has been largely superseded by the 1473L<C<untie>|/untie VARIABLE> function.] 1474 1475Breaks the binding between a DBM file and a hash. 1476 1477Portability issues: L<perlport/dbmclose>. 1478 1479=item dbmopen HASH,DBNAME,MASK 1480X<dbmopen> X<dbm> X<ndbm> X<sdbm> X<gdbm> 1481 1482=for Pod::Functions create binding on a tied dbm file 1483 1484[This function has been largely superseded by the 1485L<C<tie>|/tie VARIABLE,CLASSNAME,LIST> function.] 1486 1487This binds a L<dbm(3)>, L<ndbm(3)>, L<sdbm(3)>, L<gdbm(3)>, or Berkeley 1488DB file to a hash. HASH is the name of the hash. (Unlike normal 1489L<C<open>|/open FILEHANDLE,MODE,EXPR>, the first argument is I<not> a 1490filehandle, even though it looks like one). DBNAME is the name of the 1491database (without the F<.dir> or F<.pag> extension if any). If the 1492database does not exist, it is created with protection specified by MASK 1493(as modified by the L<C<umask>|/umask EXPR>). To prevent creation of 1494the database if it doesn't exist, you may specify a MODE of 0, and the 1495function will return a false value if it can't find an existing 1496database. If your system supports only the older DBM functions, you may 1497make only one L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK> call in your 1498program. In older versions of Perl, if your system had neither DBM nor 1499ndbm, calling L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK> produced a fatal 1500error; it now falls back to L<sdbm(3)>. 1501 1502If you don't have write access to the DBM file, you can only read hash 1503variables, not set them. If you want to test whether you can write, 1504either use file tests or try setting a dummy hash entry inside an 1505L<C<eval>|/eval EXPR> to trap the error. 1506 1507Note that functions such as L<C<keys>|/keys HASH> and 1508L<C<values>|/values HASH> may return huge lists when used on large DBM 1509files. You may prefer to use the L<C<each>|/each HASH> function to 1510iterate over large DBM files. Example: 1511 1512 # print out history file offsets 1513 dbmopen(%HIST,'/usr/lib/news/history',0666); 1514 while (($key,$val) = each %HIST) { 1515 print $key, ' = ', unpack('L',$val), "\n"; 1516 } 1517 dbmclose(%HIST); 1518 1519See also L<AnyDBM_File> for a more general description of the pros and 1520cons of the various dbm approaches, as well as L<DB_File> for a particularly 1521rich implementation. 1522 1523You can control which DBM library you use by loading that library 1524before you call L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>: 1525 1526 use DB_File; 1527 dbmopen(%NS_Hist, "$ENV{HOME}/.netscape/history.db") 1528 or die "Can't open netscape history file: $!"; 1529 1530Portability issues: L<perlport/dbmopen>. 1531 1532=item defined EXPR 1533X<defined> X<undef> X<undefined> 1534 1535=item defined 1536 1537=for Pod::Functions test whether a value, variable, or function is defined 1538 1539Returns a Boolean value telling whether EXPR has a value other than the 1540undefined value L<C<undef>|/undef EXPR>. If EXPR is not present, 1541L<C<$_>|perlvar/$_> is checked. 1542 1543Many operations return L<C<undef>|/undef EXPR> to indicate failure, end 1544of file, system error, uninitialized variable, and other exceptional 1545conditions. This function allows you to distinguish 1546L<C<undef>|/undef EXPR> from other values. (A simple Boolean test will 1547not distinguish among L<C<undef>|/undef EXPR>, zero, the empty string, 1548and C<"0">, which are all equally false.) Note that since 1549L<C<undef>|/undef EXPR> is a valid scalar, its presence doesn't 1550I<necessarily> indicate an exceptional condition: L<C<pop>|/pop ARRAY> 1551returns L<C<undef>|/undef EXPR> when its argument is an empty array, 1552I<or> when the element to return happens to be L<C<undef>|/undef EXPR>. 1553 1554You may also use C<defined(&func)> to check whether subroutine C<func> 1555has ever been defined. The return value is unaffected by any forward 1556declarations of C<func>. A subroutine that is not defined 1557may still be callable: its package may have an C<AUTOLOAD> method that 1558makes it spring into existence the first time that it is called; see 1559L<perlsub>. 1560 1561Use of L<C<defined>|/defined EXPR> on aggregates (hashes and arrays) is 1562no longer supported. It used to report whether memory for that 1563aggregate had ever been allocated. You should instead use a simple 1564test for size: 1565 1566 if (@an_array) { print "has array elements\n" } 1567 if (%a_hash) { print "has hash members\n" } 1568 1569When used on a hash element, it tells you whether the value is defined, 1570not whether the key exists in the hash. Use L<C<exists>|/exists EXPR> 1571for the latter purpose. 1572 1573Examples: 1574 1575 print if defined $switch{D}; 1576 print "$val\n" while defined($val = pop(@ary)); 1577 die "Can't readlink $sym: $!" 1578 unless defined($value = readlink $sym); 1579 sub foo { defined &$bar ? $bar->(@_) : die "No bar"; } 1580 $debugging = 0 unless defined $debugging; 1581 1582Note: Many folks tend to overuse L<C<defined>|/defined EXPR> and are 1583then surprised to discover that the number C<0> and C<""> (the 1584zero-length string) are, in fact, defined values. For example, if you 1585say 1586 1587 "ab" =~ /a(.*)b/; 1588 1589The pattern match succeeds and C<$1> is defined, although it 1590matched "nothing". It didn't really fail to match anything. Rather, it 1591matched something that happened to be zero characters long. This is all 1592very above-board and honest. When a function returns an undefined value, 1593it's an admission that it couldn't give you an honest answer. So you 1594should use L<C<defined>|/defined EXPR> only when questioning the 1595integrity of what you're trying to do. At other times, a simple 1596comparison to C<0> or C<""> is what you want. 1597 1598See also L<C<undef>|/undef EXPR>, L<C<exists>|/exists EXPR>, 1599L<C<ref>|/ref EXPR>. 1600 1601=item delete EXPR 1602X<delete> 1603 1604=for Pod::Functions deletes a value from a hash 1605 1606Given an expression that specifies an element or slice of a hash, 1607L<C<delete>|/delete EXPR> deletes the specified elements from that hash 1608so that L<C<exists>|/exists EXPR> on that element no longer returns 1609true. Setting a hash element to the undefined value does not remove its 1610key, but deleting it does; see L<C<exists>|/exists EXPR>. 1611 1612In list context, usually returns the value or values deleted, or the last such 1613element in scalar context. The return list's length corresponds to that of 1614the argument list: deleting non-existent elements returns the undefined value 1615in their corresponding positions. Since Perl 5.28, a 1616L<keyE<sol>value hash slice|perldata/KeyE<sol>Value Hash Slices> can be passed 1617to C<delete>, and the return value is a list of key/value pairs (two elements 1618for each item deleted from the hash). 1619 1620L<C<delete>|/delete EXPR> may also be used on arrays and array slices, 1621but its behavior is less straightforward. Although 1622L<C<exists>|/exists EXPR> will return false for deleted entries, 1623deleting array elements never changes indices of existing values; use 1624L<C<shift>|/shift ARRAY> or L<C<splice>|/splice 1625ARRAY,OFFSET,LENGTH,LIST> for that. However, if any deleted elements 1626fall at the end of an array, the array's size shrinks to the position of 1627the highest element that still tests true for L<C<exists>|/exists EXPR>, 1628or to 0 if none do. In other words, an array won't have trailing 1629nonexistent elements after a delete. 1630 1631B<WARNING:> Calling L<C<delete>|/delete EXPR> on array values is 1632strongly discouraged. The 1633notion of deleting or checking the existence of Perl array elements is not 1634conceptually coherent, and can lead to surprising behavior. 1635 1636Deleting from L<C<%ENV>|perlvar/%ENV> modifies the environment. 1637Deleting from a hash tied to a DBM file deletes the entry from the DBM 1638file. Deleting from a L<C<tied>|/tied VARIABLE> hash or array may not 1639necessarily return anything; it depends on the implementation of the 1640L<C<tied>|/tied VARIABLE> package's DELETE method, which may do whatever 1641it pleases. 1642 1643The C<delete local EXPR> construct localizes the deletion to the current 1644block at run time. Until the block exits, elements locally deleted 1645temporarily no longer exist. See L<perlsub/"Localized deletion of elements 1646of composite types">. 1647 1648 my %hash = (foo => 11, bar => 22, baz => 33); 1649 my $scalar = delete $hash{foo}; # $scalar is 11 1650 $scalar = delete @hash{qw(foo bar)}; # $scalar is 22 1651 my @array = delete @hash{qw(foo baz)}; # @array is (undef,33) 1652 1653The following (inefficiently) deletes all the values of %HASH and @ARRAY: 1654 1655 foreach my $key (keys %HASH) { 1656 delete $HASH{$key}; 1657 } 1658 1659 foreach my $index (0 .. $#ARRAY) { 1660 delete $ARRAY[$index]; 1661 } 1662 1663And so do these: 1664 1665 delete @HASH{keys %HASH}; 1666 1667 delete @ARRAY[0 .. $#ARRAY]; 1668 1669But both are slower than assigning the empty list 1670or undefining %HASH or @ARRAY, which is the customary 1671way to empty out an aggregate: 1672 1673 %HASH = (); # completely empty %HASH 1674 undef %HASH; # forget %HASH ever existed 1675 1676 @ARRAY = (); # completely empty @ARRAY 1677 undef @ARRAY; # forget @ARRAY ever existed 1678 1679The EXPR can be arbitrarily complicated provided its 1680final operation is an element or slice of an aggregate: 1681 1682 delete $ref->[$x][$y]{$key}; 1683 delete $ref->[$x][$y]->@{$key1, $key2, @morekeys}; 1684 1685 delete $ref->[$x][$y][$index]; 1686 delete $ref->[$x][$y]->@[$index1, $index2, @moreindices]; 1687 1688=item die LIST 1689X<die> X<throw> X<exception> X<raise> X<$@> X<abort> 1690 1691=for Pod::Functions raise an exception or bail out 1692 1693L<C<die>|/die LIST> raises an exception. Inside an L<C<eval>|/eval EXPR> 1694the exception is stuffed into L<C<$@>|perlvar/$@> and the L<C<eval>|/eval 1695EXPR> is terminated with the undefined value. If the exception is 1696outside of all enclosing L<C<eval>|/eval EXPR>s, then the uncaught 1697exception is printed to C<STDERR> and perl exits with an exit code 1698indicating failure. If you need to exit the process with a specific 1699exit code, see L<C<exit>|/exit EXPR>. 1700 1701Equivalent examples: 1702 1703 die "Can't cd to spool: $!\n" unless chdir '/usr/spool/news'; 1704 chdir '/usr/spool/news' or die "Can't cd to spool: $!\n" 1705 1706Most of the time, C<die> is called with a string to use as the exception. 1707You may either give a single non-reference operand to serve as the 1708exception, or a list of two or more items, which will be stringified 1709and concatenated to make the exception. 1710 1711If the string exception does not end in a newline, the current 1712script line number and input line number (if any) and a newline 1713are appended to it. Note that the "input line number" (also 1714known as "chunk") is subject to whatever notion of "line" happens to 1715be currently in effect, and is also available as the special variable 1716L<C<$.>|perlvar/$.>. See L<perlvar/"$/"> and L<perlvar/"$.">. 1717 1718Hint: sometimes appending C<", stopped"> to your message will cause it 1719to make better sense when the string C<"at foo line 123"> is appended. 1720Suppose you are running script "canasta". 1721 1722 die "/etc/games is no good"; 1723 die "/etc/games is no good, stopped"; 1724 1725produce, respectively 1726 1727 /etc/games is no good at canasta line 123. 1728 /etc/games is no good, stopped at canasta line 123. 1729 1730If LIST was empty or made an empty string, and L<C<$@>|perlvar/$@> 1731already contains an exception value (typically from a previous 1732L<C<eval>|/eval EXPR>), then that value is reused after 1733appending C<"\t...propagated">. This is useful for propagating exceptions: 1734 1735 eval { ... }; 1736 die unless $@ =~ /Expected exception/; 1737 1738If LIST was empty or made an empty string, 1739and L<C<$@>|perlvar/$@> contains an object 1740reference that has a C<PROPAGATE> method, that method will be called 1741with additional file and line number parameters. The return value 1742replaces the value in L<C<$@>|perlvar/$@>; i.e., as if 1743C<< $@ = eval { $@->PROPAGATE(__FILE__, __LINE__) }; >> were called. 1744 1745If LIST was empty or made an empty string, and L<C<$@>|perlvar/$@> 1746is also empty, then the string C<"Died"> is used. 1747 1748You can also call L<C<die>|/die LIST> with a reference argument, and if 1749this is trapped within an L<C<eval>|/eval EXPR>, L<C<$@>|perlvar/$@> 1750contains that reference. This permits more elaborate exception handling 1751using objects that maintain arbitrary state about the exception. Such a 1752scheme is sometimes preferable to matching particular string values of 1753L<C<$@>|perlvar/$@> with regular expressions. 1754 1755Because Perl stringifies uncaught exception messages before display, 1756you'll probably want to overload stringification operations on 1757exception objects. See L<overload> for details about that. 1758The stringified message should be non-empty, and should end in a newline, 1759in order to fit in with the treatment of string exceptions. 1760Also, because an exception object reference cannot be stringified 1761without destroying it, Perl doesn't attempt to append location or other 1762information to a reference exception. If you want location information 1763with a complex exception object, you'll have to arrange to put the 1764location information into the object yourself. 1765 1766Because L<C<$@>|perlvar/$@> is a global variable, be careful that 1767analyzing an exception caught by C<eval> doesn't replace the reference 1768in the global variable. It's 1769easiest to make a local copy of the reference before any manipulations. 1770Here's an example: 1771 1772 use Scalar::Util "blessed"; 1773 1774 eval { ... ; die Some::Module::Exception->new( FOO => "bar" ) }; 1775 if (my $ev_err = $@) { 1776 if (blessed($ev_err) 1777 && $ev_err->isa("Some::Module::Exception")) { 1778 # handle Some::Module::Exception 1779 } 1780 else { 1781 # handle all other possible exceptions 1782 } 1783 } 1784 1785If an uncaught exception results in interpreter exit, the exit code is 1786determined from the values of L<C<$!>|perlvar/$!> and 1787L<C<$?>|perlvar/$?> with this pseudocode: 1788 1789 exit $! if $!; # errno 1790 exit $? >> 8 if $? >> 8; # child exit status 1791 exit 255; # last resort 1792 1793As with L<C<exit>|/exit EXPR>, L<C<$?>|perlvar/$?> is set prior to 1794unwinding the call stack; any C<DESTROY> or C<END> handlers can then 1795alter this value, and thus Perl's exit code. 1796 1797The intent is to squeeze as much possible information about the likely cause 1798into the limited space of the system exit code. However, as 1799L<C<$!>|perlvar/$!> is the value of C's C<errno>, which can be set by 1800any system call, this means that the value of the exit code used by 1801L<C<die>|/die LIST> can be non-predictable, so should not be relied 1802upon, other than to be non-zero. 1803 1804You can arrange for a callback to be run just before the 1805L<C<die>|/die LIST> does its deed, by setting the 1806L<C<$SIG{__DIE__}>|perlvar/%SIG> hook. The associated handler is called 1807with the exception as an argument, and can change the exception, 1808if it sees fit, by 1809calling L<C<die>|/die LIST> again. See L<perlvar/%SIG> for details on 1810setting L<C<%SIG>|perlvar/%SIG> entries, and L<C<eval>|/eval EXPR> for some 1811examples. Although this feature was to be run only right before your 1812program was to exit, this is not currently so: the 1813L<C<$SIG{__DIE__}>|perlvar/%SIG> hook is currently called even inside 1814L<C<eval>|/eval EXPR>ed blocks/strings! If one wants the hook to do 1815nothing in such situations, put 1816 1817 die @_ if $^S; 1818 1819as the first line of the handler (see L<perlvar/$^S>). Because 1820this promotes strange action at a distance, this counterintuitive 1821behavior may be fixed in a future release. 1822 1823See also L<C<exit>|/exit EXPR>, L<C<warn>|/warn LIST>, and the L<Carp> 1824module. 1825 1826=item do BLOCK 1827X<do> X<block> 1828 1829=for Pod::Functions turn a BLOCK into a TERM 1830 1831Not really a function. Returns the value of the last command in the 1832sequence of commands indicated by BLOCK. When modified by the C<while> or 1833C<until> loop modifier, executes the BLOCK once before testing the loop 1834condition. (On other statements the loop modifiers test the conditional 1835first.) 1836 1837C<do BLOCK> does I<not> count as a loop, so the loop control statements 1838L<C<next>|/next LABEL>, L<C<last>|/last LABEL>, or 1839L<C<redo>|/redo LABEL> cannot be used to leave or restart the block. 1840See L<perlsyn> for alternative strategies. 1841 1842=item do EXPR 1843X<do> 1844 1845Uses the value of EXPR as a filename and executes the contents of the 1846file as a Perl script: 1847 1848 # load the exact specified file (./ and ../ special-cased) 1849 do '/foo/stat.pl'; 1850 do './stat.pl'; 1851 do '../foo/stat.pl'; 1852 1853 # search for the named file within @INC 1854 do 'stat.pl'; 1855 do 'foo/stat.pl'; 1856 1857C<do './stat.pl'> is largely like 1858 1859 eval `cat stat.pl`; 1860 1861except that it's more concise, runs no external processes, and keeps 1862track of the current filename for error messages. It also differs in that 1863code evaluated with C<do FILE> cannot see lexicals in the enclosing 1864scope; C<eval STRING> does. It's the same, however, in that it does 1865reparse the file every time you call it, so you probably don't want 1866to do this inside a loop. 1867 1868Using C<do> with a relative path (except for F<./> and F<../>), like 1869 1870 do 'foo/stat.pl'; 1871 1872will search the L<C<@INC>|perlvar/@INC> directories, and update 1873L<C<%INC>|perlvar/%INC> if the file is found. See L<perlvar/@INC> 1874and L<perlvar/%INC> for these variables. In particular, note that 1875whilst historically L<C<@INC>|perlvar/@INC> contained '.' (the 1876current directory) making these two cases equivalent, that is no 1877longer necessarily the case, as '.' is not included in C<@INC> by default 1878in perl versions 5.26.0 onwards. Instead, perl will now warn: 1879 1880 do "stat.pl" failed, '.' is no longer in @INC; 1881 did you mean do "./stat.pl"? 1882 1883If L<C<do>|/do EXPR> can read the file but cannot compile it, it 1884returns L<C<undef>|/undef EXPR> and sets an error message in 1885L<C<$@>|perlvar/$@>. If L<C<do>|/do EXPR> cannot read the file, it 1886returns undef and sets L<C<$!>|perlvar/$!> to the error. Always check 1887L<C<$@>|perlvar/$@> first, as compilation could fail in a way that also 1888sets L<C<$!>|perlvar/$!>. If the file is successfully compiled, 1889L<C<do>|/do EXPR> returns the value of the last expression evaluated. 1890 1891Inclusion of library modules is better done with the 1892L<C<use>|/use Module VERSION LIST> and L<C<require>|/require VERSION> 1893operators, which also do automatic error checking and raise an exception 1894if there's a problem. 1895 1896You might like to use L<C<do>|/do EXPR> to read in a program 1897configuration file. Manual error checking can be done this way: 1898 1899 # Read in config files: system first, then user. 1900 # Beware of using relative pathnames here. 1901 for $file ("/share/prog/defaults.rc", 1902 "$ENV{HOME}/.someprogrc") 1903 { 1904 unless ($return = do $file) { 1905 warn "couldn't parse $file: $@" if $@; 1906 warn "couldn't do $file: $!" unless defined $return; 1907 warn "couldn't run $file" unless $return; 1908 } 1909 } 1910 1911=item dump LABEL 1912X<dump> X<core> X<undump> 1913 1914=item dump EXPR 1915 1916=item dump 1917 1918=for Pod::Functions create an immediate core dump 1919 1920This function causes an immediate core dump. See also the B<-u> 1921command-line switch in L<perlrun|perlrun/-u>, which does the same thing. 1922Primarily this is so that you can use the B<undump> program (not 1923supplied) to turn your core dump into an executable binary after 1924having initialized all your variables at the beginning of the 1925program. When the new binary is executed it will begin by executing 1926a C<goto LABEL> (with all the restrictions that L<C<goto>|/goto LABEL> 1927suffers). 1928Think of it as a goto with an intervening core dump and reincarnation. 1929If C<LABEL> is omitted, restarts the program from the top. The 1930C<dump EXPR> form, available starting in Perl 5.18.0, allows a name to be 1931computed at run time, being otherwise identical to C<dump LABEL>. 1932 1933B<WARNING>: Any files opened at the time of the dump will I<not> 1934be open any more when the program is reincarnated, with possible 1935resulting confusion by Perl. 1936 1937This function is now largely obsolete, mostly because it's very hard to 1938convert a core file into an executable. As of Perl 5.30, it must be invoked 1939as C<CORE::dump()>. 1940 1941Unlike most named operators, this has the same precedence as assignment. 1942It is also exempt from the looks-like-a-function rule, so 1943C<dump ("foo")."bar"> will cause "bar" to be part of the argument to 1944L<C<dump>|/dump LABEL>. 1945 1946Portability issues: L<perlport/dump>. 1947 1948=item each HASH 1949X<each> X<hash, iterator> 1950 1951=item each ARRAY 1952X<array, iterator> 1953 1954=for Pod::Functions retrieve the next key/value pair from a hash 1955 1956When called on a hash in list context, returns a 2-element list 1957consisting of the key and value for the next element of a hash. In Perl 19585.12 and later only, it will also return the index and value for the next 1959element of an array so that you can iterate over it; older Perls consider 1960this a syntax error. When called in scalar context, returns only the key 1961(not the value) in a hash, or the index in an array. 1962 1963Hash entries are returned in an apparently random order. The actual random 1964order is specific to a given hash; the exact same series of operations 1965on two hashes may result in a different order for each hash. Any insertion 1966into the hash may change the order, as will any deletion, with the exception 1967that the most recent key returned by L<C<each>|/each HASH> or 1968L<C<keys>|/keys HASH> may be deleted without changing the order. So 1969long as a given hash is unmodified you may rely on 1970L<C<keys>|/keys HASH>, L<C<values>|/values HASH> and 1971L<C<each>|/each HASH> to repeatedly return the same order 1972as each other. See L<perlsec/"Algorithmic Complexity Attacks"> for 1973details on why hash order is randomized. Aside from the guarantees 1974provided here the exact details of Perl's hash algorithm and the hash 1975traversal order are subject to change in any release of Perl. 1976 1977After L<C<each>|/each HASH> has returned all entries from the hash or 1978array, the next call to L<C<each>|/each HASH> returns the empty list in 1979list context and L<C<undef>|/undef EXPR> in scalar context; the next 1980call following I<that> one restarts iteration. Each hash or array has 1981its own internal iterator, accessed by L<C<each>|/each HASH>, 1982L<C<keys>|/keys HASH>, and L<C<values>|/values HASH>. The iterator is 1983implicitly reset when L<C<each>|/each HASH> has reached the end as just 1984described; it can be explicitly reset by calling L<C<keys>|/keys HASH> 1985or L<C<values>|/values HASH> on the hash or array, or by referencing 1986the hash (but not array) in list context. If you add or delete 1987a hash's elements while iterating over it, the effect on the iterator is 1988unspecified; for example, entries may be skipped or duplicated--so don't 1989do that. Exception: It is always safe to delete the item most recently 1990returned by L<C<each>|/each HASH>, so the following code works properly: 1991 1992 while (my ($key, $value) = each %hash) { 1993 print $key, "\n"; 1994 delete $hash{$key}; # This is safe 1995 } 1996 1997Tied hashes may have a different ordering behaviour to perl's hash 1998implementation. 1999 2000The iterator used by C<each> is attached to the hash or array, and is 2001shared between all iteration operations applied to the same hash or array. 2002Thus all uses of C<each> on a single hash or array advance the same 2003iterator location. All uses of C<each> are also subject to having the 2004iterator reset by any use of C<keys> or C<values> on the same hash or 2005array, or by the hash (but not array) being referenced in list context. 2006This makes C<each>-based loops quite fragile: it is easy to arrive at 2007such a loop with the iterator already part way through the object, or to 2008accidentally clobber the iterator state during execution of the loop body. 2009It's easy enough to explicitly reset the iterator before starting a loop, 2010but there is no way to insulate the iterator state used by a loop from 2011the iterator state used by anything else that might execute during the 2012loop body. To avoid these problems, use a C<foreach> loop rather than 2013C<while>-C<each>. 2014 2015This extends to using C<each> on the result of an anonymous hash or 2016array constructor. A new underlying array or hash is created each 2017time so each will always start iterating from scratch, eg: 2018 2019 # loops forever 2020 while (my ($key, $value) = each @{ +{ a => 1 } }) { 2021 print "$key=$value\n"; 2022 } 2023 2024This prints out your environment like the L<printenv(1)> program, 2025but in a different order: 2026 2027 while (my ($key,$value) = each %ENV) { 2028 print "$key=$value\n"; 2029 } 2030 2031Starting with Perl 5.14, an experimental feature allowed 2032L<C<each>|/each HASH> to take a scalar expression. This experiment has 2033been deemed unsuccessful, and was removed as of Perl 5.24. 2034 2035As of Perl 5.18 you can use a bare L<C<each>|/each HASH> in a C<while> 2036loop, which will set L<C<$_>|perlvar/$_> on every iteration. 2037If either an C<each> expression or an explicit assignment of an C<each> 2038expression to a scalar is used as a C<while>/C<for> condition, then 2039the condition actually tests for definedness of the expression's value, 2040not for its regular truth value. 2041 2042 while (each %ENV) { 2043 print "$_=$ENV{$_}\n"; 2044 } 2045 2046To avoid confusing would-be users of your code who are running earlier 2047versions of Perl with mysterious syntax errors, put this sort of thing at 2048the top of your file to signal that your code will work I<only> on Perls of 2049a recent vintage: 2050 2051 use 5.012; # so keys/values/each work on arrays 2052 use 5.018; # so each assigns to $_ in a lone while test 2053 2054See also L<C<keys>|/keys HASH>, L<C<values>|/values HASH>, and 2055L<C<sort>|/sort SUBNAME LIST>. 2056 2057=item eof FILEHANDLE 2058X<eof> 2059X<end of file> 2060X<end-of-file> 2061 2062=item eof () 2063 2064=item eof 2065 2066=for Pod::Functions test a filehandle for its end 2067 2068Returns 1 if the next read on FILEHANDLE will return end of file I<or> if 2069FILEHANDLE is not open. FILEHANDLE may be an expression whose value 2070gives the real filehandle. (Note that this function actually 2071reads a character and then C<ungetc>s it, so isn't useful in an 2072interactive context.) Do not read from a terminal file (or call 2073C<eof(FILEHANDLE)> on it) after end-of-file is reached. File types such 2074as terminals may lose the end-of-file condition if you do. 2075 2076An L<C<eof>|/eof FILEHANDLE> without an argument uses the last file 2077read. Using L<C<eof()>|/eof FILEHANDLE> with empty parentheses is 2078different. It refers to the pseudo file formed from the files listed on 2079the command line and accessed via the C<< <> >> operator. Since 2080C<< <> >> isn't explicitly opened, as a normal filehandle is, an 2081L<C<eof()>|/eof FILEHANDLE> before C<< <> >> has been used will cause 2082L<C<@ARGV>|perlvar/@ARGV> to be examined to determine if input is 2083available. Similarly, an L<C<eof()>|/eof FILEHANDLE> after C<< <> >> 2084has returned end-of-file will assume you are processing another 2085L<C<@ARGV>|perlvar/@ARGV> list, and if you haven't set 2086L<C<@ARGV>|perlvar/@ARGV>, will read input from C<STDIN>; see 2087L<perlop/"I/O Operators">. 2088 2089In a C<< while (<>) >> loop, L<C<eof>|/eof FILEHANDLE> or C<eof(ARGV)> 2090can be used to detect the end of each file, whereas 2091L<C<eof()>|/eof FILEHANDLE> will detect the end of the very last file 2092only. Examples: 2093 2094 # reset line numbering on each input file 2095 while (<>) { 2096 next if /^\s*#/; # skip comments 2097 print "$.\t$_"; 2098 } continue { 2099 close ARGV if eof; # Not eof()! 2100 } 2101 2102 # insert dashes just before last line of last file 2103 while (<>) { 2104 if (eof()) { # check for end of last file 2105 print "--------------\n"; 2106 } 2107 print; 2108 last if eof(); # needed if we're reading from a terminal 2109 } 2110 2111Practical hint: you almost never need to use L<C<eof>|/eof FILEHANDLE> 2112in Perl, because the input operators typically return L<C<undef>|/undef 2113EXPR> when they run out of data or encounter an error. 2114 2115=item eval EXPR 2116X<eval> X<try> X<catch> X<evaluate> X<parse> X<execute> 2117X<error, handling> X<exception, handling> 2118 2119=item eval BLOCK 2120 2121=item eval 2122 2123=for Pod::Functions catch exceptions or compile and run code 2124 2125C<eval> in all its forms is used to execute a little Perl program, 2126trapping any errors encountered so they don't crash the calling program. 2127 2128Plain C<eval> with no argument is just C<eval EXPR>, where the 2129expression is understood to be contained in L<C<$_>|perlvar/$_>. Thus 2130there are only two real C<eval> forms; the one with an EXPR is often 2131called "string eval". In a string eval, the value of the expression 2132(which is itself determined within scalar context) is first parsed, and 2133if there were no errors, executed as a block within the lexical context 2134of the current Perl program. This form is typically used to delay 2135parsing and subsequent execution of the text of EXPR until run time. 2136Note that the value is parsed every time the C<eval> executes. 2137 2138The other form is called "block eval". It is less general than string 2139eval, but the code within the BLOCK is parsed only once (at the same 2140time the code surrounding the C<eval> itself was parsed) and executed 2141within the context of the current Perl program. This form is typically 2142used to trap exceptions more efficiently than the first, while also 2143providing the benefit of checking the code within BLOCK at compile time. 2144BLOCK is parsed and compiled just once. Since errors are trapped, it 2145often is used to check if a given feature is available. 2146 2147In both forms, the value returned is the value of the last expression 2148evaluated inside the mini-program; a return statement may also be used, just 2149as with subroutines. The expression providing the return value is evaluated 2150in void, scalar, or list context, depending on the context of the 2151C<eval> itself. See L<C<wantarray>|/wantarray> for more 2152on how the evaluation context can be determined. 2153 2154If there is a syntax error or runtime error, or a L<C<die>|/die LIST> 2155statement is executed, C<eval> returns 2156L<C<undef>|/undef EXPR> in scalar context, or an empty list in list 2157context, and L<C<$@>|perlvar/$@> is set to the error message. (Prior to 21585.16, a bug caused L<C<undef>|/undef EXPR> to be returned in list 2159context for syntax errors, but not for runtime errors.) If there was no 2160error, L<C<$@>|perlvar/$@> is set to the empty string. A control flow 2161operator like L<C<last>|/last LABEL> or L<C<goto>|/goto LABEL> can 2162bypass the setting of L<C<$@>|perlvar/$@>. Beware that using 2163C<eval> neither silences Perl from printing warnings to 2164STDERR, nor does it stuff the text of warning messages into 2165L<C<$@>|perlvar/$@>. To do either of those, you have to use the 2166L<C<$SIG{__WARN__}>|perlvar/%SIG> facility, or turn off warnings inside 2167the BLOCK or EXPR using S<C<no warnings 'all'>>. See 2168L<C<warn>|/warn LIST>, L<perlvar>, and L<warnings>. 2169 2170Note that, because C<eval> traps otherwise-fatal errors, 2171it is useful for determining whether a particular feature (such as 2172L<C<socket>|/socket SOCKET,DOMAIN,TYPE,PROTOCOL> or 2173L<C<symlink>|/symlink OLDFILE,NEWFILE>) is implemented. It is also 2174Perl's exception-trapping mechanism, where the L<C<die>|/die LIST> 2175operator is used to raise exceptions. 2176 2177Before Perl 5.14, the assignment to L<C<$@>|perlvar/$@> occurred before 2178restoration 2179of localized variables, which means that for your code to run on older 2180versions, a temporary is required if you want to mask some, but not all 2181errors: 2182 2183 # alter $@ on nefarious repugnancy only 2184 { 2185 my $e; 2186 { 2187 local $@; # protect existing $@ 2188 eval { test_repugnancy() }; 2189 # $@ =~ /nefarious/ and die $@; # Perl 5.14 and higher only 2190 $@ =~ /nefarious/ and $e = $@; 2191 } 2192 die $e if defined $e 2193 } 2194 2195There are some different considerations for each form: 2196 2197=over 4 2198 2199=item String eval 2200 2201Since the return value of EXPR is executed as a block within the lexical 2202context of the current Perl program, any outer lexical variables are 2203visible to it, and any package variable settings or subroutine and 2204format definitions remain afterwards. 2205 2206=over 4 2207 2208=item Under the L<C<"unicode_eval"> feature|feature/The 'unicode_eval' and 'evalbytes' features> 2209 2210If this feature is enabled (which is the default under a C<use 5.16> or 2211higher declaration), Perl assumes that EXPR is a character string. 2212Any S<C<use utf8>> or S<C<no utf8>> declarations within 2213the string thus have no effect. Source filters are forbidden as well. 2214(C<unicode_strings>, however, can appear within the string.) 2215 2216See also the L<C<evalbytes>|/evalbytes EXPR> operator, which works properly 2217with source filters. 2218 2219=item Outside the C<"unicode_eval"> feature 2220 2221In this case, the behavior is problematic and is not so easily 2222described. Here are two bugs that cannot easily be fixed without 2223breaking existing programs: 2224 2225=over 4 2226 2227=item * 2228 2229Perl's internal storage of EXPR affects the behavior of the executed code. 2230For example: 2231 2232 my $v = eval "use utf8; '$expr'"; 2233 2234If $expr is C<"\xc4\x80"> (U+0100 in UTF-8), then the value stored in C<$v> 2235will depend on whether Perl stores $expr "upgraded" (cf. L<utf8>) or 2236not: 2237 2238=over 2239 2240=item * If upgraded, C<$v> will be C<"\xc4\x80"> (i.e., the 2241C<use utf8> has no effect.) 2242 2243=item * If non-upgraded, C<$v> will be C<"\x{100}">. 2244 2245=back 2246 2247This is undesirable since being 2248upgraded or not should not affect a string's behavior. 2249 2250=item * 2251 2252Source filters activated within C<eval> leak out into whichever file 2253scope is currently being compiled. To give an example with the CPAN module 2254L<Semi::Semicolons>: 2255 2256 BEGIN { eval "use Semi::Semicolons; # not filtered" } 2257 # filtered here! 2258 2259L<C<evalbytes>|/evalbytes EXPR> fixes that to work the way one would 2260expect: 2261 2262 use feature "evalbytes"; 2263 BEGIN { evalbytes "use Semi::Semicolons; # filtered" } 2264 # not filtered 2265 2266=back 2267 2268=back 2269 2270Problems can arise if the string expands a scalar containing a floating 2271point number. That scalar can expand to letters, such as C<"NaN"> or 2272C<"Infinity">; or, within the scope of a L<C<use locale>|locale>, the 2273decimal point character may be something other than a dot (such as a 2274comma). None of these are likely to parse as you are likely expecting. 2275 2276You should be especially careful to remember what's being looked at 2277when: 2278 2279 eval $x; # CASE 1 2280 eval "$x"; # CASE 2 2281 2282 eval '$x'; # CASE 3 2283 eval { $x }; # CASE 4 2284 2285 eval "\$$x++"; # CASE 5 2286 $$x++; # CASE 6 2287 2288Cases 1 and 2 above behave identically: they run the code contained in 2289the variable $x. (Although case 2 has misleading double quotes making 2290the reader wonder what else might be happening (nothing is).) Cases 3 2291and 4 likewise behave in the same way: they run the code C<'$x'>, which 2292does nothing but return the value of $x. (Case 4 is preferred for 2293purely visual reasons, but it also has the advantage of compiling at 2294compile-time instead of at run-time.) Case 5 is a place where 2295normally you I<would> like to use double quotes, except that in this 2296particular situation, you can just use symbolic references instead, as 2297in case 6. 2298 2299An C<eval ''> executed within a subroutine defined 2300in the C<DB> package doesn't see the usual 2301surrounding lexical scope, but rather the scope of the first non-DB piece 2302of code that called it. You don't normally need to worry about this unless 2303you are writing a Perl debugger. 2304 2305The final semicolon, if any, may be omitted from the value of EXPR. 2306 2307=item Block eval 2308 2309If the code to be executed doesn't vary, you may use the eval-BLOCK 2310form to trap run-time errors without incurring the penalty of 2311recompiling each time. The error, if any, is still returned in 2312L<C<$@>|perlvar/$@>. 2313Examples: 2314 2315 # make divide-by-zero nonfatal 2316 eval { $answer = $a / $b; }; warn $@ if $@; 2317 2318 # same thing, but less efficient 2319 eval '$answer = $a / $b'; warn $@ if $@; 2320 2321 # a compile-time error 2322 eval { $answer = }; # WRONG 2323 2324 # a run-time error 2325 eval '$answer ='; # sets $@ 2326 2327If you want to trap errors when loading an XS module, some problems with 2328the binary interface (such as Perl version skew) may be fatal even with 2329C<eval> unless C<$ENV{PERL_DL_NONLAZY}> is set. See 2330L<perlrun|perlrun/PERL_DL_NONLAZY>. 2331 2332Using the C<eval {}> form as an exception trap in libraries does have some 2333issues. Due to the current arguably broken state of C<__DIE__> hooks, you 2334may wish not to trigger any C<__DIE__> hooks that user code may have installed. 2335You can use the C<local $SIG{__DIE__}> construct for this purpose, 2336as this example shows: 2337 2338 # a private exception trap for divide-by-zero 2339 eval { local $SIG{'__DIE__'}; $answer = $a / $b; }; 2340 warn $@ if $@; 2341 2342This is especially significant, given that C<__DIE__> hooks can call 2343L<C<die>|/die LIST> again, which has the effect of changing their error 2344messages: 2345 2346 # __DIE__ hooks may modify error messages 2347 { 2348 local $SIG{'__DIE__'} = 2349 sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x }; 2350 eval { die "foo lives here" }; 2351 print $@ if $@; # prints "bar lives here" 2352 } 2353 2354Because this promotes action at a distance, this counterintuitive behavior 2355may be fixed in a future release. 2356 2357C<eval BLOCK> does I<not> count as a loop, so the loop control statements 2358L<C<next>|/next LABEL>, L<C<last>|/last LABEL>, or 2359L<C<redo>|/redo LABEL> cannot be used to leave or restart the block. 2360 2361The final semicolon, if any, may be omitted from within the BLOCK. 2362 2363=back 2364 2365=item evalbytes EXPR 2366X<evalbytes> 2367 2368=item evalbytes 2369 2370=for Pod::Functions +evalbytes similar to string eval, but intend to parse a bytestream 2371 2372This function is similar to a L<string eval|/eval EXPR>, except it 2373always parses its argument (or L<C<$_>|perlvar/$_> if EXPR is omitted) 2374as a byte string. If the string contains any code points above 255, then 2375it cannot be a byte string, and the C<evalbytes> will fail with the error 2376stored in C<$@>. 2377 2378C<use utf8> and C<no utf8> within the string have their usual effect. 2379 2380Source filters activated within the evaluated code apply to the code 2381itself. 2382 2383L<C<evalbytes>|/evalbytes EXPR> is available starting in Perl v5.16. To 2384access it, you must say C<CORE::evalbytes>, but you can omit the 2385C<CORE::> if the 2386L<C<"evalbytes"> feature|feature/The 'unicode_eval' and 'evalbytes' features> 2387is enabled. This is enabled automatically with a C<use v5.16> (or 2388higher) declaration in the current scope. 2389 2390=item exec LIST 2391X<exec> X<execute> 2392 2393=item exec PROGRAM LIST 2394 2395=for Pod::Functions abandon this program to run another 2396 2397The L<C<exec>|/exec LIST> function executes a system command I<and never 2398returns>; use L<C<system>|/system LIST> instead of L<C<exec>|/exec LIST> 2399if you want it to return. It fails and 2400returns false only if the command does not exist I<and> it is executed 2401directly instead of via your system's command shell (see below). 2402 2403Since it's a common mistake to use L<C<exec>|/exec LIST> instead of 2404L<C<system>|/system LIST>, Perl warns you if L<C<exec>|/exec LIST> is 2405called in void context and if there is a following statement that isn't 2406L<C<die>|/die LIST>, L<C<warn>|/warn LIST>, or L<C<exit>|/exit EXPR> (if 2407L<warnings> are enabled--but you always do that, right?). If you 2408I<really> want to follow an L<C<exec>|/exec LIST> with some other 2409statement, you can use one of these styles to avoid the warning: 2410 2411 exec ('foo') or print STDERR "couldn't exec foo: $!"; 2412 { exec ('foo') }; print STDERR "couldn't exec foo: $!"; 2413 2414If there is more than one argument in LIST, this calls L<execvp(3)> with the 2415arguments in LIST. If there is only one element in LIST, the argument is 2416checked for shell metacharacters, and if there are any, the entire 2417argument is passed to the system's command shell for parsing (this is 2418C</bin/sh -c> on Unix platforms, but varies on other platforms). If 2419there are no shell metacharacters in the argument, it is split into words 2420and passed directly to C<execvp>, which is more efficient. Examples: 2421 2422 exec '/bin/echo', 'Your arguments are: ', @ARGV; 2423 exec "sort $outfile | uniq"; 2424 2425If you don't really want to execute the first argument, but want to lie 2426to the program you are executing about its own name, you can specify 2427the program you actually want to run as an "indirect object" (without a 2428comma) in front of the LIST, as in C<exec PROGRAM LIST>. (This always 2429forces interpretation of the LIST as a multivalued list, even if there 2430is only a single scalar in the list.) Example: 2431 2432 my $shell = '/bin/csh'; 2433 exec $shell '-sh'; # pretend it's a login shell 2434 2435or, more directly, 2436 2437 exec {'/bin/csh'} '-sh'; # pretend it's a login shell 2438 2439When the arguments get executed via the system shell, results are 2440subject to its quirks and capabilities. See L<perlop/"`STRING`"> 2441for details. 2442 2443Using an indirect object with L<C<exec>|/exec LIST> or 2444L<C<system>|/system LIST> is also more secure. This usage (which also 2445works fine with L<C<system>|/system LIST>) forces 2446interpretation of the arguments as a multivalued list, even if the 2447list had just one argument. That way you're safe from the shell 2448expanding wildcards or splitting up words with whitespace in them. 2449 2450 my @args = ( "echo surprise" ); 2451 2452 exec @args; # subject to shell escapes 2453 # if @args == 1 2454 exec { $args[0] } @args; # safe even with one-arg list 2455 2456The first version, the one without the indirect object, ran the I<echo> 2457program, passing it C<"surprise"> an argument. The second version didn't; 2458it tried to run a program named I<"echo surprise">, didn't find it, and set 2459L<C<$?>|perlvar/$?> to a non-zero value indicating failure. 2460 2461On Windows, only the C<exec PROGRAM LIST> indirect object syntax will 2462reliably avoid using the shell; C<exec LIST>, even with more than one 2463element, will fall back to the shell if the first spawn fails. 2464 2465Perl attempts to flush all files opened for output before the exec, 2466but this may not be supported on some platforms (see L<perlport>). 2467To be safe, you may need to set L<C<$E<verbar>>|perlvar/$E<verbar>> 2468(C<$AUTOFLUSH> in L<English>) or call the C<autoflush> method of 2469L<C<IO::Handle>|IO::Handle/METHODS> on any open handles to avoid lost 2470output. 2471 2472Note that L<C<exec>|/exec LIST> will not call your C<END> blocks, nor 2473will it invoke C<DESTROY> methods on your objects. 2474 2475Portability issues: L<perlport/exec>. 2476 2477=item exists EXPR 2478X<exists> X<autovivification> 2479 2480=for Pod::Functions test whether a hash key is present 2481 2482Given an expression that specifies an element of a hash, returns true if the 2483specified element in the hash has ever been initialized, even if the 2484corresponding value is undefined. 2485 2486 print "Exists\n" if exists $hash{$key}; 2487 print "Defined\n" if defined $hash{$key}; 2488 print "True\n" if $hash{$key}; 2489 2490exists may also be called on array elements, but its behavior is much less 2491obvious and is strongly tied to the use of L<C<delete>|/delete EXPR> on 2492arrays. 2493 2494B<WARNING:> Calling L<C<exists>|/exists EXPR> on array values is 2495strongly discouraged. The 2496notion of deleting or checking the existence of Perl array elements is not 2497conceptually coherent, and can lead to surprising behavior. 2498 2499 print "Exists\n" if exists $array[$index]; 2500 print "Defined\n" if defined $array[$index]; 2501 print "True\n" if $array[$index]; 2502 2503A hash or array element can be true only if it's defined and defined only if 2504it exists, but the reverse doesn't necessarily hold true. 2505 2506Given an expression that specifies the name of a subroutine, 2507returns true if the specified subroutine has ever been declared, even 2508if it is undefined. Mentioning a subroutine name for exists or defined 2509does not count as declaring it. Note that a subroutine that does not 2510exist may still be callable: its package may have an C<AUTOLOAD> 2511method that makes it spring into existence the first time that it is 2512called; see L<perlsub>. 2513 2514 print "Exists\n" if exists &subroutine; 2515 print "Defined\n" if defined &subroutine; 2516 2517Note that the EXPR can be arbitrarily complicated as long as the final 2518operation is a hash or array key lookup or subroutine name: 2519 2520 if (exists $ref->{A}->{B}->{$key}) { } 2521 if (exists $hash{A}{B}{$key}) { } 2522 2523 if (exists $ref->{A}->{B}->[$ix]) { } 2524 if (exists $hash{A}{B}[$ix]) { } 2525 2526 if (exists &{$ref->{A}{B}{$key}}) { } 2527 2528Although the most deeply nested array or hash element will not spring into 2529existence just because its existence was tested, any intervening ones will. 2530Thus C<< $ref->{"A"} >> and C<< $ref->{"A"}->{"B"} >> will spring 2531into existence due to the existence test for the C<$key> element above. 2532This happens anywhere the arrow operator is used, including even here: 2533 2534 undef $ref; 2535 if (exists $ref->{"Some key"}) { } 2536 print $ref; # prints HASH(0x80d3d5c) 2537 2538Use of a subroutine call, rather than a subroutine name, as an argument 2539to L<C<exists>|/exists EXPR> is an error. 2540 2541 exists ⊂ # OK 2542 exists &sub(); # Error 2543 2544=item exit EXPR 2545X<exit> X<terminate> X<abort> 2546 2547=item exit 2548 2549=for Pod::Functions terminate this program 2550 2551Evaluates EXPR and exits immediately with that value. Example: 2552 2553 my $ans = <STDIN>; 2554 exit 0 if $ans =~ /^[Xx]/; 2555 2556See also L<C<die>|/die LIST>. If EXPR is omitted, exits with C<0> 2557status. The only 2558universally recognized values for EXPR are C<0> for success and C<1> 2559for error; other values are subject to interpretation depending on the 2560environment in which the Perl program is running. For example, exiting 256169 (EX_UNAVAILABLE) from a I<sendmail> incoming-mail filter will cause 2562the mailer to return the item undelivered, but that's not true everywhere. 2563 2564Don't use L<C<exit>|/exit EXPR> to abort a subroutine if there's any 2565chance that someone might want to trap whatever error happened. Use 2566L<C<die>|/die LIST> instead, which can be trapped by an 2567L<C<eval>|/eval EXPR>. 2568 2569The L<C<exit>|/exit EXPR> function does not always exit immediately. It 2570calls any defined C<END> routines first, but these C<END> routines may 2571not themselves abort the exit. Likewise any object destructors that 2572need to be called are called before the real exit. C<END> routines and 2573destructors can change the exit status by modifying L<C<$?>|perlvar/$?>. 2574If this is a problem, you can call 2575L<C<POSIX::_exit($status)>|POSIX/C<_exit>> to avoid C<END> and destructor 2576processing. See L<perlmod> for details. 2577 2578Portability issues: L<perlport/exit>. 2579 2580=item exp EXPR 2581X<exp> X<exponential> X<antilog> X<antilogarithm> X<e> 2582 2583=item exp 2584 2585=for Pod::Functions raise I<e> to a power 2586 2587Returns I<e> (the natural logarithm base) to the power of EXPR. 2588If EXPR is omitted, gives C<exp($_)>. 2589 2590=item fc EXPR 2591X<fc> X<foldcase> X<casefold> X<fold-case> X<case-fold> 2592 2593=item fc 2594 2595=for Pod::Functions +fc return casefolded version of a string 2596 2597Returns the casefolded version of EXPR. This is the internal function 2598implementing the C<\F> escape in double-quoted strings. 2599 2600Casefolding is the process of mapping strings to a form where case 2601differences are erased; comparing two strings in their casefolded 2602form is effectively a way of asking if two strings are equal, 2603regardless of case. 2604 2605Roughly, if you ever found yourself writing this 2606 2607 lc($this) eq lc($that) # Wrong! 2608 # or 2609 uc($this) eq uc($that) # Also wrong! 2610 # or 2611 $this =~ /^\Q$that\E\z/i # Right! 2612 2613Now you can write 2614 2615 fc($this) eq fc($that) 2616 2617And get the correct results. 2618 2619Perl only implements the full form of casefolding, but you can access 2620the simple folds using L<Unicode::UCD/B<casefold()>> and 2621L<Unicode::UCD/B<prop_invmap()>>. 2622For further information on casefolding, refer to 2623the Unicode Standard, specifically sections 3.13 C<Default Case Operations>, 26244.2 C<Case-Normative>, and 5.18 C<Case Mappings>, 2625available at L<https://www.unicode.org/versions/latest/>, as well as the 2626Case Charts available at L<https://www.unicode.org/charts/case/>. 2627 2628If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 2629 2630This function behaves the same way under various pragmas, such as within 2631L<S<C<"use feature 'unicode_strings">>|feature/The 'unicode_strings' feature>, 2632as L<C<lc>|/lc EXPR> does, with the single exception of 2633L<C<fc>|/fc EXPR> of I<LATIN CAPITAL LETTER SHARP S> (U+1E9E) within the 2634scope of L<S<C<use locale>>|locale>. The foldcase of this character 2635would normally be C<"ss">, but as explained in the L<C<lc>|/lc EXPR> 2636section, case 2637changes that cross the 255/256 boundary are problematic under locales, 2638and are hence prohibited. Therefore, this function under locale returns 2639instead the string C<"\x{17F}\x{17F}">, which is the I<LATIN SMALL LETTER 2640LONG S>. Since that character itself folds to C<"s">, the string of two 2641of them together should be equivalent to a single U+1E9E when foldcased. 2642 2643While the Unicode Standard defines two additional forms of casefolding, 2644one for Turkic languages and one that never maps one character into multiple 2645characters, these are not provided by the Perl core. However, the CPAN module 2646L<C<Unicode::Casing>|Unicode::Casing> may be used to provide an implementation. 2647 2648L<C<fc>|/fc EXPR> is available only if the 2649L<C<"fc"> feature|feature/The 'fc' feature> is enabled or if it is 2650prefixed with C<CORE::>. The 2651L<C<"fc"> feature|feature/The 'fc' feature> is enabled automatically 2652with a C<use v5.16> (or higher) declaration in the current scope. 2653 2654=item fcntl FILEHANDLE,FUNCTION,SCALAR 2655X<fcntl> 2656 2657=for Pod::Functions file control system call 2658 2659Implements the L<fcntl(2)> function. You'll probably have to say 2660 2661 use Fcntl; 2662 2663first to get the correct constant definitions. Argument processing and 2664value returned work just like L<C<ioctl>|/ioctl 2665FILEHANDLE,FUNCTION,SCALAR> below. For example: 2666 2667 use Fcntl; 2668 my $flags = fcntl($filehandle, F_GETFL, 0) 2669 or die "Can't fcntl F_GETFL: $!"; 2670 2671You don't have to check for L<C<defined>|/defined EXPR> on the return 2672from L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR>. Like 2673L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>, it maps a C<0> return 2674from the system call into C<"0 but true"> in Perl. This string is true 2675in boolean context and C<0> in numeric context. It is also exempt from 2676the normal 2677L<C<Argument "..." isn't numeric>|perldiag/Argument "%s" isn't numeric%s> 2678L<warnings> on improper numeric conversions. 2679 2680Note that L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR> raises an 2681exception if used on a machine that doesn't implement L<fcntl(2)>. See 2682the L<Fcntl> module or your L<fcntl(2)> manpage to learn what functions 2683are available on your system. 2684 2685Here's an example of setting a filehandle named C<$REMOTE> to be 2686non-blocking at the system level. You'll have to negotiate 2687L<C<$E<verbar>>|perlvar/$E<verbar>> on your own, though. 2688 2689 use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK); 2690 2691 my $flags = fcntl($REMOTE, F_GETFL, 0) 2692 or die "Can't get flags for the socket: $!\n"; 2693 2694 fcntl($REMOTE, F_SETFL, $flags | O_NONBLOCK) 2695 or die "Can't set flags for the socket: $!\n"; 2696 2697Portability issues: L<perlport/fcntl>. 2698 2699=item __FILE__ 2700X<__FILE__> 2701 2702=for Pod::Functions the name of the current source file 2703 2704A special token that returns the name of the file in which it occurs. 2705It can be altered by the mechanism described at 2706L<perlsyn/"Plain Old Comments (Not!)">. 2707 2708=item fileno FILEHANDLE 2709X<fileno> 2710 2711=item fileno DIRHANDLE 2712 2713=for Pod::Functions return file descriptor from filehandle 2714 2715Returns the file descriptor for a filehandle or directory handle, 2716or undefined if the 2717filehandle is not open. If there is no real file descriptor at the OS 2718level, as can happen with filehandles connected to memory objects via 2719L<C<open>|/open FILEHANDLE,MODE,EXPR> with a reference for the third 2720argument, -1 is returned. 2721 2722This is mainly useful for constructing bitmaps for 2723L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> and low-level POSIX 2724tty-handling operations. 2725If FILEHANDLE is an expression, the value is taken as an indirect 2726filehandle, generally its name. 2727 2728You can use this to find out whether two handles refer to the 2729same underlying descriptor: 2730 2731 if (fileno($this) != -1 && fileno($this) == fileno($that)) { 2732 print "\$this and \$that are dups\n"; 2733 } elsif (fileno($this) != -1 && fileno($that) != -1) { 2734 print "\$this and \$that have different " . 2735 "underlying file descriptors\n"; 2736 } else { 2737 print "At least one of \$this and \$that does " . 2738 "not have a real file descriptor\n"; 2739 } 2740 2741The behavior of L<C<fileno>|/fileno FILEHANDLE> on a directory handle 2742depends on the operating system. On a system with L<dirfd(3)> or 2743similar, L<C<fileno>|/fileno FILEHANDLE> on a directory 2744handle returns the underlying file descriptor associated with the 2745handle; on systems with no such support, it returns the undefined value, 2746and sets L<C<$!>|perlvar/$!> (errno). 2747 2748=item flock FILEHANDLE,OPERATION 2749X<flock> X<lock> X<locking> 2750 2751=for Pod::Functions lock an entire file with an advisory lock 2752 2753Calls L<flock(2)>, or an emulation of it, on FILEHANDLE. Returns true 2754for success, false on failure. Produces a fatal error if used on a 2755machine that doesn't implement L<flock(2)>, L<fcntl(2)> locking, or 2756L<lockf(3)>. L<C<flock>|/flock FILEHANDLE,OPERATION> is Perl's portable 2757file-locking interface, although it locks entire files only, not 2758records. 2759 2760Two potentially non-obvious but traditional L<C<flock>|/flock 2761FILEHANDLE,OPERATION> semantics are 2762that it waits indefinitely until the lock is granted, and that its locks 2763are B<merely advisory>. Such discretionary locks are more flexible, but 2764offer fewer guarantees. This means that programs that do not also use 2765L<C<flock>|/flock FILEHANDLE,OPERATION> may modify files locked with 2766L<C<flock>|/flock FILEHANDLE,OPERATION>. See L<perlport>, 2767your port's specific documentation, and your system-specific local manpages 2768for details. It's best to assume traditional behavior if you're writing 2769portable programs. (But if you're not, you should as always feel perfectly 2770free to write for your own system's idiosyncrasies (sometimes called 2771"features"). Slavish adherence to portability concerns shouldn't get 2772in the way of your getting your job done.) 2773 2774OPERATION is one of LOCK_SH, LOCK_EX, or LOCK_UN, possibly combined with 2775LOCK_NB. These constants are traditionally valued 1, 2, 8 and 4, but 2776you can use the symbolic names if you import them from the L<Fcntl> module, 2777either individually, or as a group using the C<:flock> tag. LOCK_SH 2778requests a shared lock, LOCK_EX requests an exclusive lock, and LOCK_UN 2779releases a previously requested lock. If LOCK_NB is bitwise-or'ed with 2780LOCK_SH or LOCK_EX, then L<C<flock>|/flock FILEHANDLE,OPERATION> returns 2781immediately rather than blocking waiting for the lock; check the return 2782status to see if you got it. 2783 2784To avoid the possibility of miscoordination, Perl now flushes FILEHANDLE 2785before locking or unlocking it. 2786 2787Note that the emulation built with L<lockf(3)> doesn't provide shared 2788locks, and it requires that FILEHANDLE be open with write intent. These 2789are the semantics that L<lockf(3)> implements. Most if not all systems 2790implement L<lockf(3)> in terms of L<fcntl(2)> locking, though, so the 2791differing semantics shouldn't bite too many people. 2792 2793Note that the L<fcntl(2)> emulation of L<flock(3)> requires that FILEHANDLE 2794be open with read intent to use LOCK_SH and requires that it be open 2795with write intent to use LOCK_EX. 2796 2797Note also that some versions of L<C<flock>|/flock FILEHANDLE,OPERATION> 2798cannot lock things over the network; you would need to use the more 2799system-specific L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR> for 2800that. If you like you can force Perl to ignore your system's L<flock(2)> 2801function, and so provide its own L<fcntl(2)>-based emulation, by passing 2802the switch C<-Ud_flock> to the F<Configure> program when you configure 2803and build a new Perl. 2804 2805Here's a mailbox appender for BSD systems. 2806 2807 # import LOCK_* and SEEK_END constants 2808 use Fcntl qw(:flock SEEK_END); 2809 2810 sub lock { 2811 my ($fh) = @_; 2812 flock($fh, LOCK_EX) or die "Cannot lock mailbox - $!\n"; 2813 # and, in case we're running on a very old UNIX 2814 # variant without the modern O_APPEND semantics... 2815 seek($fh, 0, SEEK_END) or die "Cannot seek - $!\n"; 2816 } 2817 2818 sub unlock { 2819 my ($fh) = @_; 2820 flock($fh, LOCK_UN) or die "Cannot unlock mailbox - $!\n"; 2821 } 2822 2823 open(my $mbox, ">>", "/usr/spool/mail/$ENV{'USER'}") 2824 or die "Can't open mailbox: $!"; 2825 2826 lock($mbox); 2827 print $mbox $msg,"\n\n"; 2828 unlock($mbox); 2829 2830On systems that support a real L<flock(2)>, locks are inherited across 2831L<C<fork>|/fork> calls, whereas those that must resort to the more 2832capricious L<fcntl(2)> function lose their locks, making it seriously 2833harder to write servers. 2834 2835See also L<DB_File> for other L<C<flock>|/flock FILEHANDLE,OPERATION> 2836examples. 2837 2838Portability issues: L<perlport/flock>. 2839 2840=item fork 2841X<fork> X<child> X<parent> 2842 2843=for Pod::Functions create a new process just like this one 2844 2845Does a L<fork(2)> system call to create a new process running the 2846same program at the same point. It returns the child pid to the 2847parent process, C<0> to the child process, or L<C<undef>|/undef EXPR> if 2848the fork is 2849unsuccessful. File descriptors (and sometimes locks on those descriptors) 2850are shared, while everything else is copied. On most systems supporting 2851L<fork(2)>, great care has gone into making it extremely efficient (for 2852example, using copy-on-write technology on data pages), making it the 2853dominant paradigm for multitasking over the last few decades. 2854 2855Perl attempts to flush all files opened for output before forking the 2856child process, but this may not be supported on some platforms (see 2857L<perlport>). To be safe, you may need to set 2858L<C<$E<verbar>>|perlvar/$E<verbar>> (C<$AUTOFLUSH> in L<English>) or 2859call the C<autoflush> method of L<C<IO::Handle>|IO::Handle/METHODS> on 2860any open handles to avoid duplicate output. 2861 2862If you L<C<fork>|/fork> without ever waiting on your children, you will 2863accumulate zombies. On some systems, you can avoid this by setting 2864L<C<$SIG{CHLD}>|perlvar/%SIG> to C<"IGNORE">. See also L<perlipc> for 2865more examples of forking and reaping moribund children. 2866 2867Note that if your forked child inherits system file descriptors like 2868STDIN and STDOUT that are actually connected by a pipe or socket, even 2869if you exit, then the remote server (such as, say, a CGI script or a 2870backgrounded job launched from a remote shell) won't think you're done. 2871You should reopen those to F</dev/null> if it's any issue. 2872 2873On some platforms such as Windows, where the L<fork(2)> system call is 2874not available, Perl can be built to emulate L<C<fork>|/fork> in the Perl 2875interpreter. The emulation is designed, at the level of the Perl 2876program, to be as compatible as possible with the "Unix" L<fork(2)>. 2877However it has limitations that have to be considered in code intended 2878to be portable. See L<perlfork> for more details. 2879 2880Portability issues: L<perlport/fork>. 2881 2882=item format 2883X<format> 2884 2885=for Pod::Functions declare a picture format with use by the write() function 2886 2887Declare a picture format for use by the L<C<write>|/write FILEHANDLE> 2888function. For example: 2889 2890 format Something = 2891 Test: @<<<<<<<< @||||| @>>>>> 2892 $str, $%, '$' . int($num) 2893 . 2894 2895 $str = "widget"; 2896 $num = $cost/$quantity; 2897 $~ = 'Something'; 2898 write; 2899 2900See L<perlform> for many details and examples. 2901 2902=item formline PICTURE,LIST 2903X<formline> 2904 2905=for Pod::Functions internal function used for formats 2906 2907This is an internal function used by L<C<format>|/format>s, though you 2908may call it, too. It formats (see L<perlform>) a list of values 2909according to the contents of PICTURE, placing the output into the format 2910output accumulator, L<C<$^A>|perlvar/$^A> (or C<$ACCUMULATOR> in 2911L<English>). Eventually, when a L<C<write>|/write FILEHANDLE> is done, 2912the contents of L<C<$^A>|perlvar/$^A> are written to some filehandle. 2913You could also read L<C<$^A>|perlvar/$^A> and then set 2914L<C<$^A>|perlvar/$^A> back to C<"">. Note that a format typically does 2915one L<C<formline>|/formline PICTURE,LIST> per line of form, but the 2916L<C<formline>|/formline PICTURE,LIST> function itself doesn't care how 2917many newlines are embedded in the PICTURE. This means that the C<~> and 2918C<~~> tokens treat the entire PICTURE as a single line. You may 2919therefore need to use multiple formlines to implement a single record 2920format, just like the L<C<format>|/format> compiler. 2921 2922Be careful if you put double quotes around the picture, because an C<@> 2923character may be taken to mean the beginning of an array name. 2924L<C<formline>|/formline PICTURE,LIST> always returns true. See 2925L<perlform> for other examples. 2926 2927If you are trying to use this instead of L<C<write>|/write FILEHANDLE> 2928to capture the output, you may find it easier to open a filehandle to a 2929scalar (C<< open my $fh, ">", \$output >>) and write to that instead. 2930 2931=item getc FILEHANDLE 2932X<getc> X<getchar> X<character> X<file, read> 2933 2934=item getc 2935 2936=for Pod::Functions get the next character from the filehandle 2937 2938Returns the next character from the input file attached to FILEHANDLE, 2939or the undefined value at end of file or if there was an error (in 2940the latter case L<C<$!>|perlvar/$!> is set). If FILEHANDLE is omitted, 2941reads from 2942STDIN. This is not particularly efficient. However, it cannot be 2943used by itself to fetch single characters without waiting for the user 2944to hit enter. For that, try something more like: 2945 2946 if ($BSD_STYLE) { 2947 system "stty cbreak </dev/tty >/dev/tty 2>&1"; 2948 } 2949 else { 2950 system "stty", '-icanon', 'eol', "\001"; 2951 } 2952 2953 my $key = getc(STDIN); 2954 2955 if ($BSD_STYLE) { 2956 system "stty -cbreak </dev/tty >/dev/tty 2>&1"; 2957 } 2958 else { 2959 system 'stty', 'icanon', 'eol', '^@'; # ASCII NUL 2960 } 2961 print "\n"; 2962 2963Determination of whether C<$BSD_STYLE> should be set is left as an 2964exercise to the reader. 2965 2966The L<C<POSIX::getattr>|POSIX/C<getattr>> function can do this more 2967portably on systems purporting POSIX compliance. See also the 2968L<C<Term::ReadKey>|Term::ReadKey> module on CPAN. 2969 2970=item getlogin 2971X<getlogin> X<login> 2972 2973=for Pod::Functions return who logged in at this tty 2974 2975This implements the C library function of the same name, which on most 2976systems returns the current login from F</etc/utmp>, if any. If it 2977returns the empty string, use L<C<getpwuid>|/getpwuid UID>. 2978 2979 my $login = getlogin || getpwuid($<) || "Kilroy"; 2980 2981Do not consider L<C<getlogin>|/getlogin> for authentication: it is not 2982as secure as L<C<getpwuid>|/getpwuid UID>. 2983 2984Portability issues: L<perlport/getlogin>. 2985 2986=item getpeername SOCKET 2987X<getpeername> X<peer> 2988 2989=for Pod::Functions find the other end of a socket connection 2990 2991Returns the packed sockaddr address of the other end of the SOCKET 2992connection. 2993 2994 use Socket; 2995 my $hersockaddr = getpeername($sock); 2996 my ($port, $iaddr) = sockaddr_in($hersockaddr); 2997 my $herhostname = gethostbyaddr($iaddr, AF_INET); 2998 my $herstraddr = inet_ntoa($iaddr); 2999 3000=item getpgrp PID 3001X<getpgrp> X<group> 3002 3003=for Pod::Functions get process group 3004 3005Returns the current process group for the specified PID. Use 3006a PID of C<0> to get the current process group for the 3007current process. Will raise an exception if used on a machine that 3008doesn't implement L<getpgrp(2)>. If PID is omitted, returns the process 3009group of the current process. Note that the POSIX version of 3010L<C<getpgrp>|/getpgrp PID> does not accept a PID argument, so only 3011C<PID==0> is truly portable. 3012 3013Portability issues: L<perlport/getpgrp>. 3014 3015=item getppid 3016X<getppid> X<parent> X<pid> 3017 3018=for Pod::Functions get parent process ID 3019 3020Returns the process id of the parent process. 3021 3022Note for Linux users: Between v5.8.1 and v5.16.0 Perl would work 3023around non-POSIX thread semantics the minority of Linux systems (and 3024Debian GNU/kFreeBSD systems) that used LinuxThreads, this emulation 3025has since been removed. See the documentation for L<$$|perlvar/$$> for 3026details. 3027 3028Portability issues: L<perlport/getppid>. 3029 3030=item getpriority WHICH,WHO 3031X<getpriority> X<priority> X<nice> 3032 3033=for Pod::Functions get current nice value 3034 3035Returns the current priority for a process, a process group, or a user. 3036(See L<getpriority(2)>.) Will raise a fatal exception if used on a 3037machine that doesn't implement L<getpriority(2)>. 3038 3039C<WHICH> can be any of C<PRIO_PROCESS>, C<PRIO_PGRP> or C<PRIO_USER> 3040imported from L<POSIX/RESOURCE CONSTANTS>. 3041 3042Portability issues: L<perlport/getpriority>. 3043 3044=item getpwnam NAME 3045X<getpwnam> X<getgrnam> X<gethostbyname> X<getnetbyname> X<getprotobyname> 3046X<getpwuid> X<getgrgid> X<getservbyname> X<gethostbyaddr> X<getnetbyaddr> 3047X<getprotobynumber> X<getservbyport> X<getpwent> X<getgrent> X<gethostent> 3048X<getnetent> X<getprotoent> X<getservent> X<setpwent> X<setgrent> X<sethostent> 3049X<setnetent> X<setprotoent> X<setservent> X<endpwent> X<endgrent> X<endhostent> 3050X<endnetent> X<endprotoent> X<endservent> 3051 3052=for Pod::Functions get passwd record given user login name 3053 3054=item getgrnam NAME 3055 3056=for Pod::Functions get group record given group name 3057 3058=item gethostbyname NAME 3059 3060=for Pod::Functions get host record given name 3061 3062=item getnetbyname NAME 3063 3064=for Pod::Functions get networks record given name 3065 3066=item getprotobyname NAME 3067 3068=for Pod::Functions get protocol record given name 3069 3070=item getpwuid UID 3071 3072=for Pod::Functions get passwd record given user ID 3073 3074=item getgrgid GID 3075 3076=for Pod::Functions get group record given group user ID 3077 3078=item getservbyname NAME,PROTO 3079 3080=for Pod::Functions get services record given its name 3081 3082=item gethostbyaddr ADDR,ADDRTYPE 3083 3084=for Pod::Functions get host record given its address 3085 3086=item getnetbyaddr ADDR,ADDRTYPE 3087 3088=for Pod::Functions get network record given its address 3089 3090=item getprotobynumber NUMBER 3091 3092=for Pod::Functions get protocol record numeric protocol 3093 3094=item getservbyport PORT,PROTO 3095 3096=for Pod::Functions get services record given numeric port 3097 3098=item getpwent 3099 3100=for Pod::Functions get next passwd record 3101 3102=item getgrent 3103 3104=for Pod::Functions get next group record 3105 3106=item gethostent 3107 3108=for Pod::Functions get next hosts record 3109 3110=item getnetent 3111 3112=for Pod::Functions get next networks record 3113 3114=item getprotoent 3115 3116=for Pod::Functions get next protocols record 3117 3118=item getservent 3119 3120=for Pod::Functions get next services record 3121 3122=item setpwent 3123 3124=for Pod::Functions prepare passwd file for use 3125 3126=item setgrent 3127 3128=for Pod::Functions prepare group file for use 3129 3130=item sethostent STAYOPEN 3131 3132=for Pod::Functions prepare hosts file for use 3133 3134=item setnetent STAYOPEN 3135 3136=for Pod::Functions prepare networks file for use 3137 3138=item setprotoent STAYOPEN 3139 3140=for Pod::Functions prepare protocols file for use 3141 3142=item setservent STAYOPEN 3143 3144=for Pod::Functions prepare services file for use 3145 3146=item endpwent 3147 3148=for Pod::Functions be done using passwd file 3149 3150=item endgrent 3151 3152=for Pod::Functions be done using group file 3153 3154=item endhostent 3155 3156=for Pod::Functions be done using hosts file 3157 3158=item endnetent 3159 3160=for Pod::Functions be done using networks file 3161 3162=item endprotoent 3163 3164=for Pod::Functions be done using protocols file 3165 3166=item endservent 3167 3168=for Pod::Functions be done using services file 3169 3170These routines are the same as their counterparts in the 3171system C library. In list context, the return values from the 3172various get routines are as follows: 3173 3174 # 0 1 2 3 4 3175 my ( $name, $passwd, $gid, $members ) = getgr* 3176 my ( $name, $aliases, $addrtype, $net ) = getnet* 3177 my ( $name, $aliases, $port, $proto ) = getserv* 3178 my ( $name, $aliases, $proto ) = getproto* 3179 my ( $name, $aliases, $addrtype, $length, @addrs ) = gethost* 3180 my ( $name, $passwd, $uid, $gid, $quota, 3181 $comment, $gcos, $dir, $shell, $expire ) = getpw* 3182 # 5 6 7 8 9 3183 3184(If the entry doesn't exist, the return value is a single meaningless true 3185value.) 3186 3187The exact meaning of the $gcos field varies but it usually contains 3188the real name of the user (as opposed to the login name) and other 3189information pertaining to the user. Beware, however, that in many 3190system users are able to change this information and therefore it 3191cannot be trusted and therefore the $gcos is tainted (see 3192L<perlsec>). The $passwd and $shell, user's encrypted password and 3193login shell, are also tainted, for the same reason. 3194 3195In scalar context, you get the name, unless the function was a 3196lookup by name, in which case you get the other thing, whatever it is. 3197(If the entry doesn't exist you get the undefined value.) For example: 3198 3199 my $uid = getpwnam($name); 3200 my $name = getpwuid($num); 3201 my $name = getpwent(); 3202 my $gid = getgrnam($name); 3203 my $name = getgrgid($num); 3204 my $name = getgrent(); 3205 # etc. 3206 3207In I<getpw*()> the fields $quota, $comment, and $expire are special 3208in that they are unsupported on many systems. If the 3209$quota is unsupported, it is an empty scalar. If it is supported, it 3210usually encodes the disk quota. If the $comment field is unsupported, 3211it is an empty scalar. If it is supported it usually encodes some 3212administrative comment about the user. In some systems the $quota 3213field may be $change or $age, fields that have to do with password 3214aging. In some systems the $comment field may be $class. The $expire 3215field, if present, encodes the expiration period of the account or the 3216password. For the availability and the exact meaning of these fields 3217in your system, please consult L<getpwnam(3)> and your system's 3218F<pwd.h> file. You can also find out from within Perl what your 3219$quota and $comment fields mean and whether you have the $expire field 3220by using the L<C<Config>|Config> module and the values C<d_pwquota>, C<d_pwage>, 3221C<d_pwchange>, C<d_pwcomment>, and C<d_pwexpire>. Shadow password 3222files are supported only if your vendor has implemented them in the 3223intuitive fashion that calling the regular C library routines gets the 3224shadow versions if you're running under privilege or if there exists 3225the L<shadow(3)> functions as found in System V (this includes Solaris 3226and Linux). Those systems that implement a proprietary shadow password 3227facility are unlikely to be supported. 3228 3229The $members value returned by I<getgr*()> is a space-separated list of 3230the login names of the members of the group. 3231 3232For the I<gethost*()> functions, if the C<h_errno> variable is supported in 3233C, it will be returned to you via L<C<$?>|perlvar/$?> if the function 3234call fails. The 3235C<@addrs> value returned by a successful call is a list of raw 3236addresses returned by the corresponding library call. In the 3237Internet domain, each address is four bytes long; you can unpack it 3238by saying something like: 3239 3240 my ($w,$x,$y,$z) = unpack('W4',$addr[0]); 3241 3242The Socket library makes this slightly easier: 3243 3244 use Socket; 3245 my $iaddr = inet_aton("127.1"); # or whatever address 3246 my $name = gethostbyaddr($iaddr, AF_INET); 3247 3248 # or going the other way 3249 my $straddr = inet_ntoa($iaddr); 3250 3251In the opposite way, to resolve a hostname to the IP address 3252you can write this: 3253 3254 use Socket; 3255 my $packed_ip = gethostbyname("www.perl.org"); 3256 my $ip_address; 3257 if (defined $packed_ip) { 3258 $ip_address = inet_ntoa($packed_ip); 3259 } 3260 3261Make sure L<C<gethostbyname>|/gethostbyname NAME> is called in SCALAR 3262context and that its return value is checked for definedness. 3263 3264The L<C<getprotobynumber>|/getprotobynumber NUMBER> function, even 3265though it only takes one argument, has the precedence of a list 3266operator, so beware: 3267 3268 getprotobynumber $number eq 'icmp' # WRONG 3269 getprotobynumber($number eq 'icmp') # actually means this 3270 getprotobynumber($number) eq 'icmp' # better this way 3271 3272If you get tired of remembering which element of the return list 3273contains which return value, by-name interfaces are provided in standard 3274modules: L<C<File::stat>|File::stat>, L<C<Net::hostent>|Net::hostent>, 3275L<C<Net::netent>|Net::netent>, L<C<Net::protoent>|Net::protoent>, 3276L<C<Net::servent>|Net::servent>, L<C<Time::gmtime>|Time::gmtime>, 3277L<C<Time::localtime>|Time::localtime>, and 3278L<C<User::grent>|User::grent>. These override the normal built-ins, 3279supplying versions that return objects with the appropriate names for 3280each field. For example: 3281 3282 use File::stat; 3283 use User::pwent; 3284 my $is_his = (stat($filename)->uid == pwent($whoever)->uid); 3285 3286Even though it looks as though they're the same method calls (uid), 3287they aren't, because a C<File::stat> object is different from 3288a C<User::pwent> object. 3289 3290Many of these functions are not safe in a multi-threaded environment 3291where more than one thread can be using them. In particular, functions 3292like C<getpwent()> iterate per-process and not per-thread, so if two 3293threads are simultaneously iterating, neither will get all the records. 3294 3295Some systems have thread-safe versions of some of the functions, such as 3296C<getpwnam_r()> instead of C<getpwnam()>. There, Perl automatically and 3297invisibly substitutes the thread-safe version, without notice. This 3298means that code that safely runs on some systems can fail on others that 3299lack the thread-safe versions. 3300 3301Portability issues: L<perlport/getpwnam> to L<perlport/endservent>. 3302 3303=item getsockname SOCKET 3304X<getsockname> 3305 3306=for Pod::Functions retrieve the sockaddr for a given socket 3307 3308Returns the packed sockaddr address of this end of the SOCKET connection, 3309in case you don't know the address because you have several different 3310IPs that the connection might have come in on. 3311 3312 use Socket; 3313 my $mysockaddr = getsockname($sock); 3314 my ($port, $myaddr) = sockaddr_in($mysockaddr); 3315 printf "Connect to %s [%s]\n", 3316 scalar gethostbyaddr($myaddr, AF_INET), 3317 inet_ntoa($myaddr); 3318 3319=item getsockopt SOCKET,LEVEL,OPTNAME 3320X<getsockopt> 3321 3322=for Pod::Functions get socket options on a given socket 3323 3324Queries the option named OPTNAME associated with SOCKET at a given LEVEL. 3325Options may exist at multiple protocol levels depending on the socket 3326type, but at least the uppermost socket level SOL_SOCKET (defined in the 3327L<C<Socket>|Socket> module) will exist. To query options at another 3328level the protocol number of the appropriate protocol controlling the 3329option should be supplied. For example, to indicate that an option is 3330to be interpreted by the TCP protocol, LEVEL should be set to the 3331protocol number of TCP, which you can get using 3332L<C<getprotobyname>|/getprotobyname NAME>. 3333 3334The function returns a packed string representing the requested socket 3335option, or L<C<undef>|/undef EXPR> on error, with the reason for the 3336error placed in L<C<$!>|perlvar/$!>. Just what is in the packed string 3337depends on LEVEL and OPTNAME; consult L<getsockopt(2)> for details. A 3338common case is that the option is an integer, in which case the result 3339is a packed integer, which you can decode using 3340L<C<unpack>|/unpack TEMPLATE,EXPR> with the C<i> (or C<I>) format. 3341 3342Here's an example to test whether Nagle's algorithm is enabled on a socket: 3343 3344 use Socket qw(:all); 3345 3346 defined(my $tcp = getprotobyname("tcp")) 3347 or die "Could not determine the protocol number for tcp"; 3348 # my $tcp = IPPROTO_TCP; # Alternative 3349 my $packed = getsockopt($socket, $tcp, TCP_NODELAY) 3350 or die "getsockopt TCP_NODELAY: $!"; 3351 my $nodelay = unpack("I", $packed); 3352 print "Nagle's algorithm is turned ", 3353 $nodelay ? "off\n" : "on\n"; 3354 3355Portability issues: L<perlport/getsockopt>. 3356 3357=item glob EXPR 3358X<glob> X<wildcard> X<filename, expansion> X<expand> 3359 3360=item glob 3361 3362=for Pod::Functions expand filenames using wildcards 3363 3364In list context, returns a (possibly empty) list of filename expansions on 3365the value of EXPR such as the Unix shell Bash would do. In 3366scalar context, glob iterates through such filename expansions, returning 3367L<C<undef>|/undef EXPR> when the list is exhausted. If EXPR is omitted, 3368L<C<$_>|perlvar/$_> is used. 3369 3370 # List context 3371 my @txt_files = glob("*.txt"); 3372 my @perl_files = glob("*.pl *.pm"); 3373 3374 # Scalar context 3375 while (my $file = glob("*.mp3")) { 3376 # Do stuff 3377 } 3378 3379Glob also supports an alternate syntax using C<< < >> C<< > >> as 3380delimiters. While this syntax is supported, it is recommended that you 3381use C<glob> instead as it is more readable and searchable. 3382 3383 my @txt_files = <"*.txt">; 3384 3385If you need case insensitive file globbing that can be achieved using the 3386C<:nocase> parameter of the L<C<bsd_glob>|File::Glob/C<bsd_glob>> module. 3387 3388 use File::Glob qw(:globally :nocase); 3389 3390 my @txt = glob("readme*"); # README readme.txt Readme.md 3391 3392Note that L<C<glob>|/glob EXPR> splits its arguments on whitespace and 3393treats 3394each segment as separate pattern. As such, C<glob("*.c *.h")> 3395matches all files with a F<.c> or F<.h> extension. The expression 3396C<glob(".* *")> matches all files in the current working directory. 3397If you want to glob filenames that might contain whitespace, you'll 3398have to use extra quotes around the spacey filename to protect it. 3399For example, to glob filenames that have an C<e> followed by a space 3400followed by an C<f>, use one of: 3401 3402 my @spacies = <"*e f*">; 3403 my @spacies = glob('"*e f*"'); 3404 my @spacies = glob(q("*e f*")); 3405 3406If you had to get a variable through, you could do this: 3407 3408 my @spacies = glob("'*${var}e f*'"); 3409 my @spacies = glob(qq("*${var}e f*")); 3410 3411If non-empty braces are the only wildcard characters used in the 3412L<C<glob>|/glob EXPR>, no filenames are matched, but potentially many 3413strings are returned. For example, this produces nine strings, one for 3414each pairing of fruits and colors: 3415 3416 my @many = glob("{apple,tomato,cherry}={green,yellow,red}"); 3417 3418This operator is implemented using the standard C<File::Glob> extension. 3419See L<C<bsd_glob>|File::Glob/C<bsd_glob>> for details, including 3420L<C<bsd_glob>|File::Glob/C<bsd_glob>>, which does not treat whitespace 3421as a pattern separator. 3422 3423If a C<glob> expression is used as the condition of a C<while> or C<for> 3424loop, then it will be implicitly assigned to C<$_>. If either a C<glob> 3425expression or an explicit assignment of a C<glob> expression to a scalar 3426is used as a C<while>/C<for> condition, then the condition actually 3427tests for definedness of the expression's value, not for its regular 3428truth value. 3429 3430Internal implemenation details: 3431 3432This is the internal function implementing the C<< <*.c> >> operator, 3433but you can use it directly. The C<< <*.c> >> operator is discussed in 3434more detail in L<perlop/"I/O Operators">. 3435 3436Portability issues: L<perlport/glob>. 3437 3438=item gmtime EXPR 3439X<gmtime> X<UTC> X<Greenwich> 3440 3441=item gmtime 3442 3443=for Pod::Functions convert UNIX time into record or string using Greenwich time 3444 3445Works just like L<C<localtime>|/localtime EXPR>, but the returned values 3446are localized for the standard Greenwich time zone. 3447 3448Note: When called in list context, $isdst, the last value 3449returned by gmtime, is always C<0>. There is no 3450Daylight Saving Time in GMT. 3451 3452Portability issues: L<perlport/gmtime>. 3453 3454=item goto LABEL 3455X<goto> X<jump> X<jmp> 3456 3457=item goto EXPR 3458 3459=item goto &NAME 3460 3461=for Pod::Functions create spaghetti code 3462 3463The C<goto LABEL> form finds the statement labeled with LABEL and 3464resumes execution there. It can't be used to get out of a block or 3465subroutine given to L<C<sort>|/sort SUBNAME LIST>. It can be used to go 3466almost anywhere else within the dynamic scope, including out of 3467subroutines, but it's usually better to use some other construct such as 3468L<C<last>|/last LABEL> or L<C<die>|/die LIST>. The author of Perl has 3469never felt the need to use this form of L<C<goto>|/goto LABEL> (in Perl, 3470that is; C is another matter). (The difference is that C does not offer 3471named loops combined with loop control. Perl does, and this replaces 3472most structured uses of L<C<goto>|/goto LABEL> in other languages.) 3473 3474The C<goto EXPR> form expects to evaluate C<EXPR> to a code reference or 3475a label name. If it evaluates to a code reference, it will be handled 3476like C<goto &NAME>, below. This is especially useful for implementing 3477tail recursion via C<goto __SUB__>. 3478 3479If the expression evaluates to a label name, its scope will be resolved 3480dynamically. This allows for computed L<C<goto>|/goto LABEL>s per 3481FORTRAN, but isn't necessarily recommended if you're optimizing for 3482maintainability: 3483 3484 goto ("FOO", "BAR", "GLARCH")[$i]; 3485 3486As shown in this example, C<goto EXPR> is exempt from the "looks like a 3487function" rule. A pair of parentheses following it does not (necessarily) 3488delimit its argument. C<goto("NE")."XT"> is equivalent to C<goto NEXT>. 3489Also, unlike most named operators, this has the same precedence as 3490assignment. 3491 3492Use of C<goto LABEL> or C<goto EXPR> to jump into a construct is 3493deprecated and will issue a warning. Even then, it may not be used to 3494go into any construct that requires initialization, such as a 3495subroutine, a C<foreach> loop, or a C<given> 3496block. In general, it may not be used to jump into the parameter 3497of a binary or list operator, but it may be used to jump into the 3498I<first> parameter of a binary operator. (The C<=> 3499assignment operator's "first" operand is its right-hand 3500operand.) It also can't be used to go into a 3501construct that is optimized away. 3502 3503The C<goto &NAME> form is quite different from the other forms of 3504L<C<goto>|/goto LABEL>. In fact, it isn't a goto in the normal sense at 3505all, and doesn't have the stigma associated with other gotos. Instead, 3506it exits the current subroutine (losing any changes set by 3507L<C<local>|/local EXPR>) and immediately calls in its place the named 3508subroutine using the current value of L<C<@_>|perlvar/@_>. This is used 3509by C<AUTOLOAD> subroutines that wish to load another subroutine and then 3510pretend that the other subroutine had been called in the first place 3511(except that any modifications to L<C<@_>|perlvar/@_> in the current 3512subroutine are propagated to the other subroutine.) After the 3513L<C<goto>|/goto LABEL>, not even L<C<caller>|/caller EXPR> will be able 3514to tell that this routine was called first. 3515 3516NAME needn't be the name of a subroutine; it can be a scalar variable 3517containing a code reference or a block that evaluates to a code 3518reference. 3519 3520=item grep BLOCK LIST 3521X<grep> 3522 3523=item grep EXPR,LIST 3524 3525=for Pod::Functions locate elements in a list test true against a given criterion 3526 3527This is similar in spirit to, but not the same as, L<grep(1)> and its 3528relatives. In particular, it is not limited to using regular expressions. 3529 3530Evaluates the BLOCK or EXPR for each element of LIST (locally setting 3531L<C<$_>|perlvar/$_> to each element) and returns the list value 3532consisting of those 3533elements for which the expression evaluated to true. In scalar 3534context, returns the number of times the expression was true. 3535 3536 my @foo = grep(!/^#/, @bar); # weed out comments 3537 3538or equivalently, 3539 3540 my @foo = grep {!/^#/} @bar; # weed out comments 3541 3542Note that L<C<$_>|perlvar/$_> is an alias to the list value, so it can 3543be used to 3544modify the elements of the LIST. While this is useful and supported, 3545it can cause bizarre results if the elements of LIST are not variables. 3546Similarly, grep returns aliases into the original list, much as a for 3547loop's index variable aliases the list elements. That is, modifying an 3548element of a list returned by grep (for example, in a C<foreach>, 3549L<C<map>|/map BLOCK LIST> or another L<C<grep>|/grep BLOCK LIST>) 3550actually modifies the element in the original list. 3551This is usually something to be avoided when writing clear code. 3552 3553See also L<C<map>|/map BLOCK LIST> for a list composed of the results of 3554the BLOCK or EXPR. 3555 3556=item hex EXPR 3557X<hex> X<hexadecimal> 3558 3559=item hex 3560 3561=for Pod::Functions convert a hexadecimal string to a number 3562 3563Interprets EXPR as a hex string and returns the corresponding numeric value. 3564If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 3565 3566 print hex '0xAf'; # prints '175' 3567 print hex 'aF'; # same 3568 $valid_input =~ /\A(?:0?[xX])?(?:_?[0-9a-fA-F])*\z/ 3569 3570A hex string consists of hex digits and an optional C<0x> or C<x> prefix. 3571Each hex digit may be preceded by a single underscore, which will be ignored. 3572Any other character triggers a warning and causes the rest of the string 3573to be ignored (even leading whitespace, unlike L<C<oct>|/oct EXPR>). 3574Only integers can be represented, and integer overflow triggers a warning. 3575 3576To convert strings that might start with any of C<0>, C<0x>, or C<0b>, 3577see L<C<oct>|/oct EXPR>. To present something as hex, look into 3578L<C<printf>|/printf FILEHANDLE FORMAT, LIST>, 3579L<C<sprintf>|/sprintf FORMAT, LIST>, and 3580L<C<unpack>|/unpack TEMPLATE,EXPR>. 3581 3582=item import LIST 3583X<import> 3584 3585=for Pod::Functions patch a module's namespace into your own 3586 3587There is no builtin L<C<import>|/import LIST> function. It is just an 3588ordinary method (subroutine) defined (or inherited) by modules that wish 3589to export names to another module. The 3590L<C<use>|/use Module VERSION LIST> function calls the 3591L<C<import>|/import LIST> method for the package used. See also 3592L<C<use>|/use Module VERSION LIST>, L<perlmod>, and L<Exporter>. 3593 3594=item index STR,SUBSTR,POSITION 3595X<index> X<indexOf> X<InStr> 3596 3597=item index STR,SUBSTR 3598 3599=for Pod::Functions find a substring within a string 3600 3601The index function searches for one string within another, but without 3602the wildcard-like behavior of a full regular-expression pattern match. 3603It returns the position of the first occurrence of SUBSTR in STR at 3604or after POSITION. If POSITION is omitted, starts searching from the 3605beginning of the string. POSITION before the beginning of the string 3606or after its end is treated as if it were the beginning or the end, 3607respectively. POSITION and the return value are based at zero. 3608If the substring is not found, L<C<index>|/index STR,SUBSTR,POSITION> 3609returns -1. 3610 3611Find characters or strings: 3612 3613 index("Perl is great", "P"); # Returns 0 3614 index("Perl is great", "g"); # Returns 8 3615 index("Perl is great", "great"); # Also returns 8 3616 3617Attempting to find something not there: 3618 3619 index("Perl is great", "Z"); # Returns -1 (not found) 3620 3621Using an offset to find the I<second> occurrence: 3622 3623 index("Perl is great", "e", 5); # Returns 10 3624 3625=item int EXPR 3626X<int> X<integer> X<truncate> X<trunc> X<floor> 3627 3628=item int 3629 3630=for Pod::Functions get the integer portion of a number 3631 3632Returns the integer portion of EXPR. If EXPR is omitted, uses 3633L<C<$_>|perlvar/$_>. 3634You should not use this function for rounding: one because it truncates 3635towards C<0>, and two because machine representations of floating-point 3636numbers can sometimes produce counterintuitive results. For example, 3637C<int(-6.725/0.025)> produces -268 rather than the correct -269; that's 3638because it's really more like -268.99999999999994315658 instead. Usually, 3639the L<C<sprintf>|/sprintf FORMAT, LIST>, 3640L<C<printf>|/printf FILEHANDLE FORMAT, LIST>, or the 3641L<C<POSIX::floor>|POSIX/C<floor>> and L<C<POSIX::ceil>|POSIX/C<ceil>> 3642functions will serve you better than will L<C<int>|/int EXPR>. 3643 3644=item ioctl FILEHANDLE,FUNCTION,SCALAR 3645X<ioctl> 3646 3647=for Pod::Functions system-dependent device control system call 3648 3649Implements the L<ioctl(2)> function. You'll probably first have to say 3650 3651 require "sys/ioctl.ph"; # probably in 3652 # $Config{archlib}/sys/ioctl.ph 3653 3654to get the correct function definitions. If F<sys/ioctl.ph> doesn't 3655exist or doesn't have the correct definitions you'll have to roll your 3656own, based on your C header files such as F<< <sys/ioctl.h> >>. 3657(There is a Perl script called B<h2ph> that comes with the Perl kit that 3658may help you in this, but it's nontrivial.) SCALAR will be read and/or 3659written depending on the FUNCTION; a C pointer to the string value of SCALAR 3660will be passed as the third argument of the actual 3661L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR> call. (If SCALAR 3662has no string value but does have a numeric value, that value will be 3663passed rather than a pointer to the string value. To guarantee this to be 3664true, add a C<0> to the scalar before using it.) The 3665L<C<pack>|/pack TEMPLATE,LIST> and L<C<unpack>|/unpack TEMPLATE,EXPR> 3666functions may be needed to manipulate the values of structures used by 3667L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>. 3668 3669The return value of L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR> (and 3670L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR>) is as follows: 3671 3672 if OS returns: then Perl returns: 3673 -1 undefined value 3674 0 string "0 but true" 3675 anything else that number 3676 3677Thus Perl returns true on success and false on failure, yet you can 3678still easily determine the actual value returned by the operating 3679system: 3680 3681 my $retval = ioctl(...) || -1; 3682 printf "System returned %d\n", $retval; 3683 3684The special string C<"0 but true"> is exempt from 3685L<C<Argument "..." isn't numeric>|perldiag/Argument "%s" isn't numeric%s> 3686L<warnings> on improper numeric conversions. 3687 3688Portability issues: L<perlport/ioctl>. 3689 3690=item join EXPR,LIST 3691X<join> 3692 3693=for Pod::Functions join a list into a string using a separator 3694 3695Joins the separate strings of LIST into a single string with fields 3696separated by the value of EXPR, and returns that new string. Example: 3697 3698 my $rec = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell); 3699 3700Beware that unlike L<C<split>|/split E<sol>PATTERNE<sol>,EXPR,LIMIT>, 3701L<C<join>|/join EXPR,LIST> doesn't take a pattern as its first argument. 3702Compare L<C<split>|/split E<sol>PATTERNE<sol>,EXPR,LIMIT>. 3703 3704=item keys HASH 3705X<keys> X<key> 3706 3707=item keys ARRAY 3708 3709=for Pod::Functions retrieve list of indices from a hash 3710 3711Called in list context, returns a list consisting of all the keys of the 3712named hash, or in Perl 5.12 or later only, the indices of an array. Perl 3713releases prior to 5.12 will produce a syntax error if you try to use an 3714array argument. In scalar context, returns the number of keys or indices. 3715 3716Hash entries are returned in an apparently random order. The actual random 3717order is specific to a given hash; the exact same series of operations 3718on two hashes may result in a different order for each hash. Any insertion 3719into the hash may change the order, as will any deletion, with the exception 3720that the most recent key returned by L<C<each>|/each HASH> or 3721L<C<keys>|/keys HASH> may be deleted without changing the order. So 3722long as a given hash is unmodified you may rely on 3723L<C<keys>|/keys HASH>, L<C<values>|/values HASH> and L<C<each>|/each 3724HASH> to repeatedly return the same order 3725as each other. See L<perlsec/"Algorithmic Complexity Attacks"> for 3726details on why hash order is randomized. Aside from the guarantees 3727provided here the exact details of Perl's hash algorithm and the hash 3728traversal order are subject to change in any release of Perl. Tied hashes 3729may behave differently to Perl's hashes with respect to changes in order on 3730insertion and deletion of items. 3731 3732As a side effect, calling L<C<keys>|/keys HASH> resets the internal 3733iterator of the HASH or ARRAY (see L<C<each>|/each HASH>) before 3734yielding the keys. In 3735particular, calling L<C<keys>|/keys HASH> in void context resets the 3736iterator with no other overhead. 3737 3738Here is yet another way to print your environment: 3739 3740 my @keys = keys %ENV; 3741 my @values = values %ENV; 3742 while (@keys) { 3743 print pop(@keys), '=', pop(@values), "\n"; 3744 } 3745 3746or how about sorted by key: 3747 3748 foreach my $key (sort(keys %ENV)) { 3749 print $key, '=', $ENV{$key}, "\n"; 3750 } 3751 3752The returned values are copies of the original keys in the hash, so 3753modifying them will not affect the original hash. Compare 3754L<C<values>|/values HASH>. 3755 3756To sort a hash by value, you'll need to use a 3757L<C<sort>|/sort SUBNAME LIST> function. Here's a descending numeric 3758sort of a hash by its values: 3759 3760 foreach my $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) { 3761 printf "%4d %s\n", $hash{$key}, $key; 3762 } 3763 3764Used as an lvalue, L<C<keys>|/keys HASH> allows you to increase the 3765number of hash buckets 3766allocated for the given hash. This can gain you a measure of efficiency if 3767you know the hash is going to get big. (This is similar to pre-extending 3768an array by assigning a larger number to $#array.) If you say 3769 3770 keys %hash = 200; 3771 3772then C<%hash> will have at least 200 buckets allocated for it--256 of them, 3773in fact, since it rounds up to the next power of two. These 3774buckets will be retained even if you do C<%hash = ()>, use C<undef 3775%hash> if you want to free the storage while C<%hash> is still in scope. 3776You can't shrink the number of buckets allocated for the hash using 3777L<C<keys>|/keys HASH> in this way (but you needn't worry about doing 3778this by accident, as trying has no effect). C<keys @array> in an lvalue 3779context is a syntax error. 3780 3781Starting with Perl 5.14, an experimental feature allowed 3782L<C<keys>|/keys HASH> to take a scalar expression. This experiment has 3783been deemed unsuccessful, and was removed as of Perl 5.24. 3784 3785To avoid confusing would-be users of your code who are running earlier 3786versions of Perl with mysterious syntax errors, put this sort of thing at 3787the top of your file to signal that your code will work I<only> on Perls of 3788a recent vintage: 3789 3790 use 5.012; # so keys/values/each work on arrays 3791 3792See also L<C<each>|/each HASH>, L<C<values>|/values HASH>, and 3793L<C<sort>|/sort SUBNAME LIST>. 3794 3795=item kill SIGNAL, LIST 3796 3797=item kill SIGNAL 3798X<kill> X<signal> 3799 3800=for Pod::Functions send a signal to a process or process group 3801 3802Sends a signal to a list of processes. Returns the number of arguments 3803that were successfully used to signal (which is not necessarily the same 3804as the number of processes actually killed, e.g. where a process group is 3805killed). 3806 3807 my $cnt = kill 'HUP', $child1, $child2; 3808 kill 'KILL', @goners; 3809 3810SIGNAL may be either a signal name (a string) or a signal number. A signal 3811name may start with a C<SIG> prefix, thus C<FOO> and C<SIGFOO> refer to the 3812same signal. The string form of SIGNAL is recommended for portability because 3813the same signal may have different numbers in different operating systems. 3814 3815A list of signal names supported by the current platform can be found in 3816C<$Config{sig_name}>, which is provided by the L<C<Config>|Config> 3817module. See L<Config> for more details. 3818 3819A negative signal name is the same as a negative signal number, killing process 3820groups instead of processes. For example, C<kill '-KILL', $pgrp> and 3821C<kill -9, $pgrp> will send C<SIGKILL> to 3822the entire process group specified. That 3823means you usually want to use positive not negative signals. 3824 3825If SIGNAL is either the number 0 or the string C<ZERO> (or C<SIGZERO>), 3826no signal is sent to the process, but L<C<kill>|/kill SIGNAL, LIST> 3827checks whether it's I<possible> to send a signal to it 3828(that means, to be brief, that the process is owned by the same user, or we are 3829the super-user). This is useful to check that a child process is still 3830alive (even if only as a zombie) and hasn't changed its UID. See 3831L<perlport> for notes on the portability of this construct. 3832 3833The behavior of kill when a I<PROCESS> number is zero or negative depends on 3834the operating system. For example, on POSIX-conforming systems, zero will 3835signal the current process group, -1 will signal all processes, and any 3836other negative PROCESS number will act as a negative signal number and 3837kill the entire process group specified. 3838 3839If both the SIGNAL and the PROCESS are negative, the results are undefined. 3840A warning may be produced in a future version. 3841 3842See L<perlipc/"Signals"> for more details. 3843 3844On some platforms such as Windows where the L<fork(2)> system call is not 3845available, Perl can be built to emulate L<C<fork>|/fork> at the 3846interpreter level. 3847This emulation has limitations related to kill that have to be considered, 3848for code running on Windows and in code intended to be portable. 3849 3850See L<perlfork> for more details. 3851 3852If there is no I<LIST> of processes, no signal is sent, and the return 3853value is 0. This form is sometimes used, however, because it causes 3854tainting checks to be run. But see 3855L<perlsec/Laundering and Detecting Tainted Data>. 3856 3857Portability issues: L<perlport/kill>. 3858 3859=item last LABEL 3860X<last> X<break> 3861 3862=item last EXPR 3863 3864=item last 3865 3866=for Pod::Functions exit a block prematurely 3867 3868The L<C<last>|/last LABEL> command is like the C<break> statement in C 3869(as used in 3870loops); it immediately exits the loop in question. If the LABEL is 3871omitted, the command refers to the innermost enclosing 3872loop. The C<last EXPR> form, available starting in Perl 38735.18.0, allows a label name to be computed at run time, 3874and is otherwise identical to C<last LABEL>. The 3875L<C<continue>|/continue BLOCK> block, if any, is not executed: 3876 3877 LINE: while (<STDIN>) { 3878 last LINE if /^$/; # exit when done with header 3879 #... 3880 } 3881 3882L<C<last>|/last LABEL> cannot return a value from a block that typically 3883returns a value, such as C<eval {}>, C<sub {}>, or C<do {}>. It will perform 3884its flow control behavior, which precludes any return value. It should not be 3885used to exit a L<C<grep>|/grep BLOCK LIST> or L<C<map>|/map BLOCK LIST> 3886operation. 3887 3888Note that a block by itself is semantically identical to a loop 3889that executes once. Thus L<C<last>|/last LABEL> can be used to effect 3890an early exit out of such a block. 3891 3892See also L<C<continue>|/continue BLOCK> for an illustration of how 3893L<C<last>|/last LABEL>, L<C<next>|/next LABEL>, and 3894L<C<redo>|/redo LABEL> work. 3895 3896Unlike most named operators, this has the same precedence as assignment. 3897It is also exempt from the looks-like-a-function rule, so 3898C<last ("foo")."bar"> will cause "bar" to be part of the argument to 3899L<C<last>|/last LABEL>. 3900 3901=item lc EXPR 3902X<lc> X<lowercase> 3903 3904=item lc 3905 3906=for Pod::Functions return lower-case version of a string 3907 3908Returns a lowercased version of EXPR. If EXPR is omitted, uses 3909L<C<$_>|perlvar/$_>. 3910 3911 my $str = lc("Perl is GREAT"); # "perl is great" 3912 3913What gets returned depends on several factors: 3914 3915=over 3916 3917=item If C<use bytes> is in effect: 3918 3919The results follow ASCII rules. Only the characters C<A-Z> change, 3920to C<a-z> respectively. 3921 3922=item Otherwise, if C<use locale> for C<LC_CTYPE> is in effect: 3923 3924Respects current C<LC_CTYPE> locale for code points < 256; and uses Unicode 3925rules for the remaining code points (this last can only happen if 3926the UTF8 flag is also set). See L<perllocale>. 3927 3928Starting in v5.20, Perl uses full Unicode rules if the locale is 3929UTF-8. Otherwise, there is a deficiency in this scheme, which is that 3930case changes that cross the 255/256 3931boundary are not well-defined. For example, the lower case of LATIN CAPITAL 3932LETTER SHARP S (U+1E9E) in Unicode rules is U+00DF (on ASCII 3933platforms). But under C<use locale> (prior to v5.20 or not a UTF-8 3934locale), the lower case of U+1E9E is 3935itself, because 0xDF may not be LATIN SMALL LETTER SHARP S in the 3936current locale, and Perl has no way of knowing if that character even 3937exists in the locale, much less what code point it is. Perl returns 3938a result that is above 255 (almost always the input character unchanged), 3939for all instances (and there aren't many) where the 255/256 boundary 3940would otherwise be crossed; and starting in v5.22, it raises a 3941L<locale|perldiag/Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".> warning. 3942 3943=item Otherwise, If EXPR has the UTF8 flag set: 3944 3945Unicode rules are used for the case change. 3946 3947=item Otherwise, if C<use feature 'unicode_strings'> or C<use locale ':not_characters'> is in effect: 3948 3949Unicode rules are used for the case change. 3950 3951=item Otherwise: 3952 3953ASCII rules are used for the case change. The lowercase of any character 3954outside the ASCII range is the character itself. 3955 3956=back 3957 3958B<Note:> This is the internal function implementing the 3959L<C<\L>|perlop/"Quote and Quote-like Operators"> escape in double-quoted 3960strings. 3961 3962 my $str = "Perl is \LGREAT\E"; # "Perl is great" 3963 3964=item lcfirst EXPR 3965X<lcfirst> X<lowercase> 3966 3967=item lcfirst 3968 3969=for Pod::Functions return a string with just the next letter in lower case 3970 3971Returns the value of EXPR with the first character lowercased. This 3972is the internal function implementing the C<\l> escape in 3973double-quoted strings. 3974 3975If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 3976 3977This function behaves the same way under various pragmas, such as in a locale, 3978as L<C<lc>|/lc EXPR> does. 3979 3980=item length EXPR 3981X<length> X<size> 3982 3983=item length 3984 3985=for Pod::Functions return the number of characters in a string 3986 3987Returns the length in I<characters> of the value of EXPR. If EXPR is 3988omitted, returns the length of L<C<$_>|perlvar/$_>. If EXPR is 3989undefined, returns L<C<undef>|/undef EXPR>. 3990 3991This function cannot be used on an entire array or hash to find out how 3992many elements these have. For that, use C<scalar @array> and C<scalar keys 3993%hash>, respectively. 3994 3995Like all Perl character operations, L<C<length>|/length EXPR> normally 3996deals in logical 3997characters, not physical bytes. For how many bytes a string encoded as 3998UTF-8 would take up, use C<length(Encode::encode('UTF-8', EXPR))> 3999(you'll have to C<use Encode> first). See L<Encode> and L<perlunicode>. 4000 4001=item __LINE__ 4002X<__LINE__> 4003 4004=for Pod::Functions the current source line number 4005 4006A special token that compiles to the current line number. 4007It can be altered by the mechanism described at 4008L<perlsyn/"Plain Old Comments (Not!)">. 4009 4010=item link OLDFILE,NEWFILE 4011X<link> 4012 4013=for Pod::Functions create a hard link in the filesystem 4014 4015Creates a new filename linked to the old filename. Returns true for 4016success, false otherwise. 4017 4018Portability issues: L<perlport/link>. 4019 4020=item listen SOCKET,QUEUESIZE 4021X<listen> 4022 4023=for Pod::Functions register your socket as a server 4024 4025Does the same thing that the L<listen(2)> system call does. Returns true if 4026it succeeded, false otherwise. See the example in 4027L<perlipc/"Sockets: Client/Server Communication">. 4028 4029=item local EXPR 4030X<local> 4031 4032=for Pod::Functions create a temporary value for a global variable (dynamic scoping) 4033 4034You really probably want to be using L<C<my>|/my VARLIST> instead, 4035because L<C<local>|/local EXPR> isn't what most people think of as 4036"local". See L<perlsub/"Private Variables via my()"> for details. 4037 4038A local modifies the listed variables to be local to the enclosing 4039block, file, or eval. If more than one value is listed, the list must 4040be placed in parentheses. See L<perlsub/"Temporary Values via local()"> 4041for details, including issues with tied arrays and hashes. 4042 4043The C<delete local EXPR> construct can also be used to localize the deletion 4044of array/hash elements to the current block. 4045See L<perlsub/"Localized deletion of elements of composite types">. 4046 4047=item localtime EXPR 4048X<localtime> X<ctime> 4049 4050=item localtime 4051 4052=for Pod::Functions convert UNIX time into record or string using local time 4053 4054Converts a time as returned by the time function to a 9-element list 4055with the time analyzed for the local time zone. Typically used as 4056follows: 4057 4058 # 0 1 2 3 4 5 6 7 8 4059 my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = 4060 localtime(time); 4061 4062All list elements are numeric and come straight out of the C `struct 4063tm'. C<$sec>, C<$min>, and C<$hour> are the seconds, minutes, and hours 4064of the specified time. 4065 4066C<$mday> is the day of the month and C<$mon> the month in 4067the range C<0..11>, with 0 indicating January and 11 indicating December. 4068This makes it easy to get a month name from a list: 4069 4070 my @abbr = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec); 4071 print "$abbr[$mon] $mday"; 4072 # $mon=9, $mday=18 gives "Oct 18" 4073 4074C<$year> contains the number of years since 1900. To get a 4-digit 4075year write: 4076 4077 $year += 1900; 4078 4079To get the last two digits of the year (e.g., "01" in 2001) do: 4080 4081 $year = sprintf("%02d", $year % 100); 4082 4083C<$wday> is the day of the week, with 0 indicating Sunday and 3 indicating 4084Wednesday. C<$yday> is the day of the year, in the range C<0..364> 4085(or C<0..365> in leap years.) 4086 4087C<$isdst> is true if the specified time occurs when Daylight Saving 4088Time is in effect, false otherwise. 4089 4090If EXPR is omitted, L<C<localtime>|/localtime EXPR> uses the current 4091time (as returned by L<C<time>|/time>). 4092 4093In scalar context, L<C<localtime>|/localtime EXPR> returns the 4094L<ctime(3)> value: 4095 4096 my $now_string = localtime; # e.g., "Thu Oct 13 04:54:34 1994" 4097 4098This scalar value is always in English, and is B<not> locale-dependent. 4099To get similar but locale-dependent date strings, try for example: 4100 4101 use POSIX qw(strftime); 4102 my $now_string = strftime "%a %b %e %H:%M:%S %Y", localtime; 4103 # or for GMT formatted appropriately for your locale: 4104 my $now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime; 4105 4106C$now_string> will be formatted according to the current LC_TIME locale 4107the program or thread is running in. See L<perllocale> for how to set 4108up and change that locale. Note that C<%a> and C<%b>, the short forms 4109of the day of the week and the month of the year, may not necessarily be 4110three characters wide. 4111 4112The L<Time::gmtime> and L<Time::localtime> modules provide a convenient, 4113by-name access mechanism to the L<C<gmtime>|/gmtime EXPR> and 4114L<C<localtime>|/localtime EXPR> functions, respectively. 4115 4116For a comprehensive date and time representation look at the 4117L<DateTime> module on CPAN. 4118 4119For GMT instead of local time use the L<C<gmtime>|/gmtime EXPR> builtin. 4120 4121See also the L<C<Time::Local>|Time::Local> module (for converting 4122seconds, minutes, hours, and such back to the integer value returned by 4123L<C<time>|/time>), and the L<POSIX> module's 4124L<C<mktime>|POSIX/C<mktime>> function. 4125 4126Portability issues: L<perlport/localtime>. 4127 4128=item lock THING 4129X<lock> 4130 4131=for Pod::Functions +5.005 get a thread lock on a variable, subroutine, or method 4132 4133This function places an advisory lock on a shared variable or referenced 4134object contained in I<THING> until the lock goes out of scope. 4135 4136The value returned is the scalar itself, if the argument is a scalar, or a 4137reference, if the argument is a hash, array or subroutine. 4138 4139L<C<lock>|/lock THING> is a "weak keyword"; this means that if you've 4140defined a function 4141by this name (before any calls to it), that function will be called 4142instead. If you are not under C<use threads::shared> this does nothing. 4143See L<threads::shared>. 4144 4145=item log EXPR 4146X<log> X<logarithm> X<e> X<ln> X<base> 4147 4148=item log 4149 4150=for Pod::Functions retrieve the natural logarithm for a number 4151 4152Returns the natural logarithm (base I<e>) of EXPR. If EXPR is omitted, 4153returns the log of L<C<$_>|perlvar/$_>. To get the 4154log of another base, use basic algebra: 4155The base-N log of a number is equal to the natural log of that number 4156divided by the natural log of N. For example: 4157 4158 sub log10 { 4159 my $n = shift; 4160 return log($n)/log(10); 4161 } 4162 4163See also L<C<exp>|/exp EXPR> for the inverse operation. 4164 4165=item lstat FILEHANDLE 4166X<lstat> 4167 4168=item lstat EXPR 4169 4170=item lstat DIRHANDLE 4171 4172=item lstat 4173 4174=for Pod::Functions stat a symbolic link 4175 4176Does the same thing as the L<C<stat>|/stat FILEHANDLE> function 4177(including setting the special C<_> filehandle) but stats a symbolic 4178link instead of the file the symbolic link points to. If symbolic links 4179are unimplemented on your system, a normal L<C<stat>|/stat FILEHANDLE> 4180is done. For much more detailed information, please see the 4181documentation for L<C<stat>|/stat FILEHANDLE>. 4182 4183If EXPR is omitted, stats L<C<$_>|perlvar/$_>. 4184 4185Portability issues: L<perlport/lstat>. 4186 4187=item m// 4188 4189=for Pod::Functions match a string with a regular expression pattern 4190 4191The match operator. See L<perlop/"Regexp Quote-Like Operators">. 4192 4193=item map BLOCK LIST 4194X<map> 4195 4196=item map EXPR,LIST 4197 4198=for Pod::Functions apply a change to a list to get back a new list with the changes 4199 4200Evaluates the BLOCK or EXPR for each element of LIST (locally setting 4201L<C<$_>|perlvar/$_> to each element) and composes a list of the results of 4202each such evaluation. Each element of LIST may produce zero, one, or more 4203elements in the generated list, so the number of elements in the generated 4204list may differ from that in LIST. In scalar context, returns the total 4205number of elements so generated. In list context, returns the generated list. 4206 4207 my @chars = map(chr, @numbers); 4208 4209translates a list of numbers to the corresponding characters. 4210 4211 my @squares = map { $_ * $_ } @numbers; 4212 4213translates a list of numbers to their squared values. 4214 4215 my @squares = map { $_ > 5 ? ($_ * $_) : () } @numbers; 4216 4217shows that number of returned elements can differ from the number of 4218input elements. To omit an element, return an empty list (). 4219This could also be achieved by writing 4220 4221 my @squares = map { $_ * $_ } grep { $_ > 5 } @numbers; 4222 4223which makes the intention more clear. 4224 4225Map always returns a list, which can be 4226assigned to a hash such that the elements 4227become key/value pairs. See L<perldata> for more details. 4228 4229 my %hash = map { get_a_key_for($_) => $_ } @array; 4230 4231is just a funny way to write 4232 4233 my %hash; 4234 foreach (@array) { 4235 $hash{get_a_key_for($_)} = $_; 4236 } 4237 4238Note that L<C<$_>|perlvar/$_> is an alias to the list value, so it can 4239be used to modify the elements of the LIST. While this is useful and 4240supported, it can cause bizarre results if the elements of LIST are not 4241variables. Using a regular C<foreach> loop for this purpose would be 4242clearer in most cases. See also L<C<grep>|/grep BLOCK LIST> for a 4243list composed of those items of the original list for which the BLOCK 4244or EXPR evaluates to true. 4245 4246C<{> starts both hash references and blocks, so C<map { ...> could be either 4247the start of map BLOCK LIST or map EXPR, LIST. Because Perl doesn't look 4248ahead for the closing C<}> it has to take a guess at which it's dealing with 4249based on what it finds just after the 4250C<{>. Usually it gets it right, but if it 4251doesn't it won't realize something is wrong until it gets to the C<}> and 4252encounters the missing (or unexpected) comma. The syntax error will be 4253reported close to the C<}>, but you'll need to change something near the C<{> 4254such as using a unary C<+> or semicolon to give Perl some help: 4255 4256 my %hash = map { "\L$_" => 1 } @array # perl guesses EXPR. wrong 4257 my %hash = map { +"\L$_" => 1 } @array # perl guesses BLOCK. right 4258 my %hash = map {; "\L$_" => 1 } @array # this also works 4259 my %hash = map { ("\L$_" => 1) } @array # as does this 4260 my %hash = map { lc($_) => 1 } @array # and this. 4261 my %hash = map +( lc($_) => 1 ), @array # this is EXPR and works! 4262 4263 my %hash = map ( lc($_), 1 ), @array # evaluates to (1, @array) 4264 4265or to force an anon hash constructor use C<+{>: 4266 4267 my @hashes = map +{ lc($_) => 1 }, @array # EXPR, so needs 4268 # comma at end 4269 4270to get a list of anonymous hashes each with only one entry apiece. 4271 4272=item mkdir FILENAME,MODE 4273X<mkdir> X<md> X<directory, create> 4274 4275=item mkdir FILENAME 4276 4277=item mkdir 4278 4279=for Pod::Functions create a directory 4280 4281Creates the directory specified by FILENAME, with permissions 4282specified by MODE (as modified by L<C<umask>|/umask EXPR>). If it 4283succeeds it returns true; otherwise it returns false and sets 4284L<C<$!>|perlvar/$!> (errno). 4285MODE defaults to 0777 if omitted, and FILENAME defaults 4286to L<C<$_>|perlvar/$_> if omitted. 4287 4288In general, it is better to create directories with a permissive MODE 4289and let the user modify that with their L<C<umask>|/umask EXPR> than it 4290is to supply 4291a restrictive MODE and give the user no way to be more permissive. 4292The exceptions to this rule are when the file or directory should be 4293kept private (mail files, for instance). The documentation for 4294L<C<umask>|/umask EXPR> discusses the choice of MODE in more detail. 4295 4296Note that according to the POSIX 1003.1-1996 the FILENAME may have any 4297number of trailing slashes. Some operating and filesystems do not get 4298this right, so Perl automatically removes all trailing slashes to keep 4299everyone happy. 4300 4301To recursively create a directory structure, look at 4302the L<C<make_path>|File::Path/make_path( $dir1, $dir2, .... )> function 4303of the L<File::Path> module. 4304 4305=item msgctl ID,CMD,ARG 4306X<msgctl> 4307 4308=for Pod::Functions SysV IPC message control operations 4309 4310Calls the System V IPC function L<msgctl(2)>. You'll probably have to say 4311 4312 use IPC::SysV; 4313 4314first to get the correct constant definitions. If CMD is C<IPC_STAT>, 4315then ARG must be a variable that will hold the returned C<msqid_ds> 4316structure. Returns like L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>: 4317the undefined value for error, C<"0 but true"> for zero, or the actual 4318return value otherwise. See also L<perlipc/"SysV IPC"> and the 4319documentation for L<C<IPC::SysV>|IPC::SysV> and 4320L<C<IPC::Semaphore>|IPC::Semaphore>. 4321 4322Portability issues: L<perlport/msgctl>. 4323 4324=item msgget KEY,FLAGS 4325X<msgget> 4326 4327=for Pod::Functions get SysV IPC message queue 4328 4329Calls the System V IPC function L<msgget(2)>. Returns the message queue 4330id, or L<C<undef>|/undef EXPR> on error. See also L<perlipc/"SysV IPC"> 4331and the documentation for L<C<IPC::SysV>|IPC::SysV> and 4332L<C<IPC::Msg>|IPC::Msg>. 4333 4334Portability issues: L<perlport/msgget>. 4335 4336=item msgrcv ID,VAR,SIZE,TYPE,FLAGS 4337X<msgrcv> 4338 4339=for Pod::Functions receive a SysV IPC message from a message queue 4340 4341Calls the System V IPC function msgrcv to receive a message from 4342message queue ID into variable VAR with a maximum message size of 4343SIZE. Note that when a message is received, the message type as a 4344native long integer will be the first thing in VAR, followed by the 4345actual message. This packing may be opened with C<unpack("l! a*")>. 4346Taints the variable. Returns true if successful, false 4347on error. See also L<perlipc/"SysV IPC"> and the documentation for 4348L<C<IPC::SysV>|IPC::SysV> and L<C<IPC::Msg>|IPC::Msg>. 4349 4350Portability issues: L<perlport/msgrcv>. 4351 4352=item msgsnd ID,MSG,FLAGS 4353X<msgsnd> 4354 4355=for Pod::Functions send a SysV IPC message to a message queue 4356 4357Calls the System V IPC function msgsnd to send the message MSG to the 4358message queue ID. MSG must begin with the native long integer message 4359type, followed by the message itself. This kind of packing can be achieved 4360with C<pack("l! a*", $type, $message)>. Returns true if successful, 4361false on error. See also L<perlipc/"SysV IPC"> and the documentation 4362for L<C<IPC::SysV>|IPC::SysV> and L<C<IPC::Msg>|IPC::Msg>. 4363 4364Portability issues: L<perlport/msgsnd>. 4365 4366=item my VARLIST 4367X<my> 4368 4369=item my TYPE VARLIST 4370 4371=item my VARLIST : ATTRS 4372 4373=item my TYPE VARLIST : ATTRS 4374 4375=for Pod::Functions declare and assign a local variable (lexical scoping) 4376 4377A L<C<my>|/my VARLIST> declares the listed variables to be local 4378(lexically) to the enclosing block, file, or L<C<eval>|/eval EXPR>. If 4379more than one variable is listed, the list must be placed in 4380parentheses. 4381 4382Note that with a parenthesised list, L<C<undef>|/undef EXPR> can be used 4383as a dummy placeholder, for example to skip assignment of initial 4384values: 4385 4386 my ( undef, $min, $hour ) = localtime; 4387 4388Redeclaring a variable in the same scope or statement will "shadow" the 4389previous declaration, creating a new instance and preventing access to 4390the previous one. This is usually undesired and, if warnings are enabled, 4391will result in a warning in the C<shadow> category. 4392 4393The exact semantics and interface of TYPE and ATTRS are still 4394evolving. TYPE may be a bareword, a constant declared 4395with L<C<use constant>|constant>, or L<C<__PACKAGE__>|/__PACKAGE__>. It 4396is 4397currently bound to the use of the L<fields> pragma, 4398and attributes are handled using the L<attributes> pragma, or starting 4399from Perl 5.8.0 also via the L<Attribute::Handlers> module. See 4400L<perlsub/"Private Variables via my()"> for details. 4401 4402=item next LABEL 4403X<next> X<continue> 4404 4405=item next EXPR 4406 4407=item next 4408 4409=for Pod::Functions iterate a block prematurely 4410 4411The L<C<next>|/next LABEL> command is like the C<continue> statement in 4412C; it starts the next iteration of the loop: 4413 4414 LINE: while (<STDIN>) { 4415 next LINE if /^#/; # discard comments 4416 #... 4417 } 4418 4419Note that if there were a L<C<continue>|/continue BLOCK> block on the 4420above, it would get 4421executed even on discarded lines. If LABEL is omitted, the command 4422refers to the innermost enclosing loop. The C<next EXPR> form, available 4423as of Perl 5.18.0, allows a label name to be computed at run time, being 4424otherwise identical to C<next LABEL>. 4425 4426L<C<next>|/next LABEL> cannot return a value from a block that typically 4427returns a value, such as C<eval {}>, C<sub {}>, or C<do {}>. It will perform 4428its flow control behavior, which precludes any return value. It should not be 4429used to exit a L<C<grep>|/grep BLOCK LIST> or L<C<map>|/map BLOCK LIST> 4430operation. 4431 4432Note that a block by itself is semantically identical to a loop 4433that executes once. Thus L<C<next>|/next LABEL> will exit such a block 4434early. 4435 4436See also L<C<continue>|/continue BLOCK> for an illustration of how 4437L<C<last>|/last LABEL>, L<C<next>|/next LABEL>, and 4438L<C<redo>|/redo LABEL> work. 4439 4440Unlike most named operators, this has the same precedence as assignment. 4441It is also exempt from the looks-like-a-function rule, so 4442C<next ("foo")."bar"> will cause "bar" to be part of the argument to 4443L<C<next>|/next LABEL>. 4444 4445=item no MODULE VERSION LIST 4446X<no declarations> 4447X<unimporting> 4448 4449=item no MODULE VERSION 4450 4451=item no MODULE LIST 4452 4453=item no MODULE 4454 4455=item no VERSION 4456 4457=for Pod::Functions unimport some module symbols or semantics at compile time 4458 4459See the L<C<use>|/use Module VERSION LIST> function, of which 4460L<C<no>|/no MODULE VERSION LIST> is the opposite. 4461 4462=item oct EXPR 4463X<oct> X<octal> X<hex> X<hexadecimal> X<binary> X<bin> 4464 4465=item oct 4466 4467=for Pod::Functions convert a string to an octal number 4468 4469Interprets EXPR as an octal string and returns the corresponding 4470value. An octal string consists of octal digits and, as of Perl 5.33.5, 4471an optional C<0o> or C<o> prefix. Each octal digit may be preceded by 4472a single underscore, which will be ignored. 4473(If EXPR happens to start off with C<0x> or C<x>, interprets it as a 4474hex string. If EXPR starts off with C<0b> or C<b>, it is interpreted as a 4475binary string. Leading whitespace is ignored in all three cases.) 4476The following will handle decimal, binary, octal, and hex in standard 4477Perl notation: 4478 4479 $val = oct($val) if $val =~ /^0/; 4480 4481If EXPR is omitted, uses L<C<$_>|perlvar/$_>. To go the other way 4482(produce a number in octal), use L<C<sprintf>|/sprintf FORMAT, LIST> or 4483L<C<printf>|/printf FILEHANDLE FORMAT, LIST>: 4484 4485 my $dec_perms = (stat("filename"))[2] & 07777; 4486 my $oct_perm_str = sprintf "%o", $perms; 4487 4488The L<C<oct>|/oct EXPR> function is commonly used when a string such as 4489C<644> needs 4490to be converted into a file mode, for example. Although Perl 4491automatically converts strings into numbers as needed, this automatic 4492conversion assumes base 10. 4493 4494Leading white space is ignored without warning, as too are any trailing 4495non-digits, such as a decimal point (L<C<oct>|/oct EXPR> only handles 4496non-negative integers, not negative integers or floating point). 4497 4498=item open FILEHANDLE,MODE,EXPR 4499X<open> X<pipe> X<file, open> X<fopen> 4500 4501=item open FILEHANDLE,MODE,EXPR,LIST 4502 4503=item open FILEHANDLE,MODE,REFERENCE 4504 4505=item open FILEHANDLE,EXPR 4506 4507=item open FILEHANDLE 4508 4509=for Pod::Functions open a file, pipe, or descriptor 4510 4511Associates an internal FILEHANDLE with the external file specified by 4512EXPR. That filehandle will subsequently allow you to perform 4513I/O operations on that file, such as reading from it or writing to it. 4514 4515Instead of a filename, you may specify an external command 4516(plus an optional argument list) or a scalar reference, in order to open 4517filehandles on commands or in-memory scalars, respectively. 4518 4519A thorough reference to C<open> follows. For a gentler introduction to 4520the basics of C<open>, see also the L<perlopentut> manual page. 4521 4522=over 4523 4524=item Working with files 4525 4526Most often, C<open> gets invoked with three arguments: the required 4527FILEHANDLE (usually an empty scalar variable), followed by MODE (usually 4528a literal describing the I/O mode the filehandle will use), and then the 4529filename that the new filehandle will refer to. 4530 4531=over 4532 4533=item Simple examples 4534 4535Reading from a file: 4536 4537 open(my $fh, "<", "input.txt") 4538 or die "Can't open < input.txt: $!"; 4539 4540 # Process every line in input.txt 4541 while (my $line = <$fh>) { 4542 # 4543 # ... do something interesting with $line here ... 4544 # 4545 } 4546 4547or writing to one: 4548 4549 open(my $fh, ">", "output.txt") 4550 or die "Can't open > output.txt: $!"; 4551 4552 print $fh "This line gets printed into output.txt.\n"; 4553 4554For a summary of common filehandle operations such as these, see 4555L<perlintro/Files and I/O>. 4556 4557=item About filehandles 4558 4559The first argument to C<open>, labeled FILEHANDLE in this reference, is 4560usually a scalar variable. (Exceptions exist, described in "Other 4561considerations", below.) If the call to C<open> succeeds, then the 4562expression provided as FILEHANDLE will get assigned an open 4563I<filehandle>. That filehandle provides an internal reference to the 4564specified external file, conveniently stored in a Perl variable, and 4565ready for I/O operations such as reading and writing. 4566 4567=item About modes 4568 4569When calling C<open> with three or more arguments, the second argument 4570-- labeled MODE here -- defines the I<open mode>. MODE is usually a 4571literal string comprising special characters that define the intended 4572I/O role of the filehandle being created: whether it's read-only, or 4573read-and-write, and so on. 4574 4575If MODE is C<< < >>, the file is opened for input (read-only). 4576If MODE is C<< > >>, the file is opened for output, with existing files 4577first being truncated ("clobbered") and nonexisting files newly created. 4578If MODE is C<<< >> >>>, the file is opened for appending, again being 4579created if necessary. 4580 4581You can put a C<+> in front of the C<< > >> or C<< < >> to 4582indicate that you want both read and write access to the file; thus 4583C<< +< >> is almost always preferred for read/write updates--the 4584C<< +> >> mode would clobber the file first. You can't usually use 4585either read-write mode for updating textfiles, since they have 4586variable-length records. See the B<-i> switch in 4587L<perlrun|perlrun/-i[extension]> for a better approach. The file is 4588created with permissions of C<0666> modified by the process's 4589L<C<umask>|/umask EXPR> value. 4590 4591These various prefixes correspond to the L<fopen(3)> modes of C<r>, 4592C<r+>, C<w>, C<w+>, C<a>, and C<a+>. 4593 4594More examples of different modes in action: 4595 4596 # Open a file for concatenation 4597 open(my $log, ">>", "/usr/spool/news/twitlog") 4598 or warn "Couldn't open log file; discarding input"; 4599 4600 # Open a file for reading and writing 4601 open(my $dbase, "+<", "dbase.mine") 4602 or die "Can't open 'dbase.mine' for update: $!"; 4603 4604=item Checking the return value 4605 4606Open returns nonzero on success, the undefined value otherwise. If the 4607C<open> involved a pipe, the return value happens to be the pid of the 4608subprocess. 4609 4610When opening a file, it's seldom a good idea to continue if the request 4611failed, so C<open> is frequently used with L<C<die>|/die LIST>. Even if 4612you want your code to do something other than C<die> on a failed open, 4613you should still always check the return value from opening a file. 4614 4615=back 4616 4617=item Specifying I/O layers in MODE 4618 4619You can use the three-argument form of open to specify 4620I/O layers (sometimes referred to as "disciplines") to apply to the new 4621filehandle. These affect how the input and output are processed (see 4622L<open> and 4623L<PerlIO> for more details). For example: 4624 4625 open(my $fh, "<:encoding(UTF-8)", $filename) 4626 || die "Can't open UTF-8 encoded $filename: $!"; 4627 4628This opens the UTF8-encoded file containing Unicode characters; 4629see L<perluniintro>. Note that if layers are specified in the 4630three-argument form, then default layers stored in 4631L<C<${^OPEN}>|perlvar/${^OPEN}> 4632(usually set by the L<open> pragma or the switch C<-CioD>) are ignored. 4633Those layers will also be ignored if you specify a colon with no name 4634following it. In that case the default layer for the operating system 4635(:raw on Unix, :crlf on Windows) is used. 4636 4637On some systems (in general, DOS- and Windows-based systems) 4638L<C<binmode>|/binmode FILEHANDLE, LAYER> is necessary when you're not 4639working with a text file. For the sake of portability it is a good idea 4640always to use it when appropriate, and never to use it when it isn't 4641appropriate. Also, people can set their I/O to be by default 4642UTF8-encoded Unicode, not bytes. 4643 4644=item Using C<undef> for temporary files 4645 4646As a special case the three-argument form with a read/write mode and the third 4647argument being L<C<undef>|/undef EXPR>: 4648 4649 open(my $tmp, "+>", undef) or die ... 4650 4651opens a filehandle to a newly created empty anonymous temporary file. 4652(This happens under any mode, which makes C<< +> >> the only useful and 4653sensible mode to use.) You will need to 4654L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE> to do the reading. 4655 4656 4657=item Opening a filehandle into an in-memory scalar 4658 4659You can open filehandles directly to Perl scalars instead of a file or 4660other resource external to the program. To do so, provide a reference to 4661that scalar as the third argument to C<open>, like so: 4662 4663 open(my $memory, ">", \$var) 4664 or die "Can't open memory file: $!"; 4665 print $memory "foo!\n"; # output will appear in $var 4666 4667To (re)open C<STDOUT> or C<STDERR> as an in-memory file, close it first: 4668 4669 close STDOUT; 4670 open(STDOUT, ">", \$variable) 4671 or die "Can't open STDOUT: $!"; 4672 4673The scalars for in-memory files are treated as octet strings: unless 4674the file is being opened with truncation the scalar may not contain 4675any code points over 0xFF. 4676 4677Opening in-memory files I<can> fail for a variety of reasons. As with 4678any other C<open>, check the return value for success. 4679 4680I<Technical note>: This feature works only when Perl is built with 4681PerlIO -- the default, except with older (pre-5.16) Perl installations 4682that were configured to not include it (e.g. via C<Configure 4683-Uuseperlio>). You can see whether your Perl was built with PerlIO by 4684running C<perl -V:useperlio>. If it says C<'define'>, you have PerlIO; 4685otherwise you don't. 4686 4687See L<perliol> for detailed info on PerlIO. 4688 4689=item Opening a filehandle into a command 4690 4691If MODE is C<|->, then the filename is 4692interpreted as a command to which output is to be piped, and if MODE 4693is C<-|>, the filename is interpreted as a command that pipes 4694output to us. In the two-argument (and one-argument) form, one should 4695replace dash (C<->) with the command. 4696See L<perlipc/"Using open() for IPC"> for more examples of this. 4697(You are not allowed to L<C<open>|/open FILEHANDLE,MODE,EXPR> to a command 4698that pipes both in I<and> out, but see L<IPC::Open2>, L<IPC::Open3>, and 4699L<perlipc/"Bidirectional Communication with Another Process"> for 4700alternatives.) 4701 4702 4703 open(my $article_fh, "-|", "caesar <$article") # decrypt 4704 # article 4705 or die "Can't start caesar: $!"; 4706 4707 open(my $article_fh, "caesar <$article |") # ditto 4708 or die "Can't start caesar: $!"; 4709 4710 open(my $out_fh, "|-", "sort >Tmp$$") # $$ is our process id 4711 or die "Can't start sort: $!"; 4712 4713 4714In the form of pipe opens taking three or more arguments, if LIST is specified 4715(extra arguments after the command name) then LIST becomes arguments 4716to the command invoked if the platform supports it. The meaning of 4717L<C<open>|/open FILEHANDLE,MODE,EXPR> with more than three arguments for 4718non-pipe modes is not yet defined, but experimental "layers" may give 4719extra LIST arguments meaning. 4720 4721If you open a pipe on the command C<-> (that is, specify either C<|-> or C<-|> 4722with the one- or two-argument forms of 4723L<C<open>|/open FILEHANDLE,MODE,EXPR>), an implicit L<C<fork>|/fork> is done, 4724so L<C<open>|/open FILEHANDLE,MODE,EXPR> returns twice: in the parent process 4725it returns the pid 4726of the child process, and in the child process it returns (a defined) C<0>. 4727Use C<defined($pid)> or C<//> to determine whether the open was successful. 4728 4729For example, use either 4730 4731 my $child_pid = open(my $from_kid, "-|") 4732 // die "Can't fork: $!"; 4733 4734or 4735 4736 my $child_pid = open(my $to_kid, "|-") 4737 // die "Can't fork: $!"; 4738 4739followed by 4740 4741 if ($child_pid) { 4742 # am the parent: 4743 # either write $to_kid or else read $from_kid 4744 ... 4745 waitpid $child_pid, 0; 4746 } else { 4747 # am the child; use STDIN/STDOUT normally 4748 ... 4749 exit; 4750 } 4751 4752The filehandle behaves normally for the parent, but I/O to that 4753filehandle is piped from/to the STDOUT/STDIN of the child process. 4754In the child process, the filehandle isn't opened--I/O happens from/to 4755the new STDOUT/STDIN. Typically this is used like the normal 4756piped open when you want to exercise more control over just how the 4757pipe command gets executed, such as when running setuid and 4758you don't want to have to scan shell commands for metacharacters. 4759 4760The following blocks are more or less equivalent: 4761 4762 open(my $fh, "|tr '[a-z]' '[A-Z]'"); 4763 open(my $fh, "|-", "tr '[a-z]' '[A-Z]'"); 4764 open(my $fh, "|-") || exec 'tr', '[a-z]', '[A-Z]'; 4765 open(my $fh, "|-", "tr", '[a-z]', '[A-Z]'); 4766 4767 open(my $fh, "cat -n '$file'|"); 4768 open(my $fh, "-|", "cat -n '$file'"); 4769 open(my $fh, "-|") || exec "cat", "-n", $file; 4770 open(my $fh, "-|", "cat", "-n", $file); 4771 4772The last two examples in each block show the pipe as "list form", which 4773is not yet supported on all platforms. (If your platform has a real 4774L<C<fork>|/fork>, such as Linux and macOS, you can use the list form; it 4775also works on Windows with Perl 5.22 or later.) You would want to use 4776the list form of the pipe so you can pass literal arguments to the 4777command without risk of the shell interpreting any shell metacharacters 4778in them. However, this also bars you from opening pipes to commands that 4779intentionally contain shell metacharacters, such as: 4780 4781 open(my $fh, "|cat -n | expand -4 | lpr") 4782 || die "Can't open pipeline to lpr: $!"; 4783 4784See L<perlipc/"Safe Pipe Opens"> for more examples of this. 4785 4786=item Duping filehandles 4787 4788You may also, in the Bourne shell tradition, specify an EXPR beginning 4789with C<< >& >>, in which case the rest of the string is interpreted 4790as the name of a filehandle (or file descriptor, if numeric) to be 4791duped (as in L<dup(2)>) and opened. You may use C<&> after C<< > >>, 4792C<<< >> >>>, C<< < >>, C<< +> >>, C<<< +>> >>>, and C<< +< >>. 4793The mode you specify should match the mode of the original filehandle. 4794(Duping a filehandle does not take into account any existing contents 4795of IO buffers.) If you use the three-argument 4796form, then you can pass either a 4797number, the name of a filehandle, or the normal "reference to a glob". 4798 4799Here is a script that saves, redirects, and restores C<STDOUT> and 4800C<STDERR> using various methods: 4801 4802 #!/usr/bin/perl 4803 open(my $oldout, ">&STDOUT") 4804 or die "Can't dup STDOUT: $!"; 4805 open(OLDERR, ">&", \*STDERR) 4806 or die "Can't dup STDERR: $!"; 4807 4808 open(STDOUT, '>', "foo.out") 4809 or die "Can't redirect STDOUT: $!"; 4810 open(STDERR, ">&STDOUT") 4811 or die "Can't dup STDOUT: $!"; 4812 4813 select STDERR; $| = 1; # make unbuffered 4814 select STDOUT; $| = 1; # make unbuffered 4815 4816 print STDOUT "stdout 1\n"; # this works for 4817 print STDERR "stderr 1\n"; # subprocesses too 4818 4819 open(STDOUT, ">&", $oldout) 4820 or die "Can't dup \$oldout: $!"; 4821 open(STDERR, ">&OLDERR") 4822 or die "Can't dup OLDERR: $!"; 4823 4824 print STDOUT "stdout 2\n"; 4825 print STDERR "stderr 2\n"; 4826 4827If you specify C<< '<&=X' >>, where C<X> is a file descriptor number 4828or a filehandle, then Perl will do an equivalent of C's L<fdopen(3)> of 4829that file descriptor (and not call L<dup(2)>); this is more 4830parsimonious of file descriptors. For example: 4831 4832 # open for input, reusing the fileno of $fd 4833 open(my $fh, "<&=", $fd) 4834 4835or 4836 4837 open(my $fh, "<&=$fd") 4838 4839or 4840 4841 # open for append, using the fileno of $oldfh 4842 open(my $fh, ">>&=", $oldfh) 4843 4844Being parsimonious on filehandles is also useful (besides being 4845parsimonious) for example when something is dependent on file 4846descriptors, like for example locking using 4847L<C<flock>|/flock FILEHANDLE,OPERATION>. If you do just 4848C<< open(my $A, ">>&", $B) >>, the filehandle C<$A> will not have the 4849same file descriptor as C<$B>, and therefore C<flock($A)> will not 4850C<flock($B)> nor vice versa. But with C<< open(my $A, ">>&=", $B) >>, 4851the filehandles will share the same underlying system file descriptor. 4852 4853Note that under Perls older than 5.8.0, Perl uses the standard C library's' 4854L<fdopen(3)> to implement the C<=> functionality. On many Unix systems, 4855L<fdopen(3)> fails when file descriptors exceed a certain value, typically 255. 4856For Perls 5.8.0 and later, PerlIO is (most often) the default. 4857 4858=item Legacy usage 4859 4860This section describes ways to call C<open> outside of best practices; 4861you may encounter these uses in older code. Perl does not consider their 4862use deprecated, exactly, but neither is it recommended in new code, for 4863the sake of clarity and readability. 4864 4865=over 4866 4867=item Specifying mode and filename as a single argument 4868 4869In the one- and two-argument forms of the call, the mode and filename 4870should be concatenated (in that order), preferably separated by white 4871space. You can--but shouldn't--omit the mode in these forms when that mode 4872is C<< < >>. It is safe to use the two-argument form of 4873L<C<open>|/open FILEHANDLE,MODE,EXPR> if the filename argument is a known literal. 4874 4875 open(my $dbase, "+<dbase.mine") # ditto 4876 or die "Can't open 'dbase.mine' for update: $!"; 4877 4878In the two-argument (and one-argument) form, opening C<< <- >> 4879or C<-> opens STDIN and opening C<< >- >> opens STDOUT. 4880 4881New code should favor the three-argument form of C<open> over this older 4882form. Declaring the mode and the filename as two distinct arguments 4883avoids any confusion between the two. 4884 4885=item Calling C<open> with one argument via global variables 4886 4887As a shortcut, a one-argument call takes the filename from the global 4888scalar variable of the same name as the filehandle: 4889 4890 $ARTICLE = 100; 4891 open(ARTICLE) 4892 or die "Can't find article $ARTICLE: $!\n"; 4893 4894Here C<$ARTICLE> must be a global (package) scalar variable - not one 4895declared with L<C<my>|/my VARLIST> or L<C<state>|/state VARLIST>. 4896 4897=item Assigning a filehandle to a bareword 4898 4899An older style is to use a bareword as the filehandle, as 4900 4901 open(FH, "<", "input.txt") 4902 or die "Can't open < input.txt: $!"; 4903 4904Then you can use C<FH> as the filehandle, in C<< close FH >> and C<< 4905<FH> >> and so on. Note that it's a global variable, so this form is 4906not recommended when dealing with filehandles other than Perl's built-in ones (e.g. STDOUT and STDIN). 4907 4908=back 4909 4910=item Other considerations 4911 4912=over 4913 4914=item Automatic filehandle closure 4915 4916The filehandle will be closed when its reference count reaches zero. If 4917it is a lexically scoped variable declared with L<C<my>|/my VARLIST>, 4918that usually means the end of the enclosing scope. However, this 4919automatic close does not check for errors, so it is better to explicitly 4920close filehandles, especially those used for writing: 4921 4922 close($handle) 4923 || warn "close failed: $!"; 4924 4925=item Automatic pipe flushing 4926 4927Perl will attempt to flush all files opened for 4928output before any operation that may do a fork, but this may not be 4929supported on some platforms (see L<perlport>). To be safe, you may need 4930to set L<C<$E<verbar>>|perlvar/$E<verbar>> (C<$AUTOFLUSH> in L<English>) 4931or call the C<autoflush> method of L<C<IO::Handle>|IO::Handle/METHODS> 4932on any open handles. 4933 4934On systems that support a close-on-exec flag on files, the flag will 4935be set for the newly opened file descriptor as determined by the value 4936of L<C<$^F>|perlvar/$^F>. See L<perlvar/$^F>. 4937 4938Closing any piped filehandle causes the parent process to wait for the 4939child to finish, then returns the status value in L<C<$?>|perlvar/$?> and 4940L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>. 4941 4942=item Direct versus by-reference assignment of filehandles 4943 4944If FILEHANDLE -- the first argument in a call to C<open> -- is an 4945undefined scalar variable (or array or hash element), a new filehandle 4946is autovivified, meaning that the variable is assigned a reference to a 4947newly allocated anonymous filehandle. Otherwise if FILEHANDLE is an 4948expression, its value is the real filehandle. (This is considered a 4949symbolic reference, so C<use strict "refs"> should I<not> be in effect.) 4950 4951=item Whitespace and special characters in the filename argument 4952 4953The filename passed to the one- and two-argument forms of 4954L<C<open>|/open FILEHANDLE,MODE,EXPR> will 4955have leading and trailing whitespace deleted and normal 4956redirection characters honored. This property, known as "magic open", 4957can often be used to good effect. A user could specify a filename of 4958F<"rsh cat file |">, or you could change certain filenames as needed: 4959 4960 $filename =~ s/(.*\.gz)\s*$/gzip -dc < $1|/; 4961 open(my $fh, $filename) 4962 or die "Can't open $filename: $!"; 4963 4964Use the three-argument form to open a file with arbitrary weird characters in it, 4965 4966 open(my $fh, "<", $file) 4967 || die "Can't open $file: $!"; 4968 4969otherwise it's necessary to protect any leading and trailing whitespace: 4970 4971 $file =~ s#^(\s)#./$1#; 4972 open(my $fh, "< $file\0") 4973 || die "Can't open $file: $!"; 4974 4975(this may not work on some bizarre filesystems). One should 4976conscientiously choose between the I<magic> and I<three-argument> form 4977of L<C<open>|/open FILEHANDLE,MODE,EXPR>: 4978 4979 open(my $in, $ARGV[0]) || die "Can't open $ARGV[0]: $!"; 4980 4981will allow the user to specify an argument of the form C<"rsh cat file |">, 4982but will not work on a filename that happens to have a trailing space, while 4983 4984 open(my $in, "<", $ARGV[0]) 4985 || die "Can't open $ARGV[0]: $!"; 4986 4987will have exactly the opposite restrictions. (However, some shells 4988support the syntax C<< perl your_program.pl <( rsh cat file ) >>, which 4989produces a filename that can be opened normally.) 4990 4991=item Invoking C-style C<open> 4992 4993If you want a "real" C L<open(2)>, then you should use the 4994L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE> function, which involves 4995no such magic (but uses different filemodes than Perl 4996L<C<open>|/open FILEHANDLE,MODE,EXPR>, which corresponds to C L<fopen(3)>). 4997This is another way to protect your filenames from interpretation. For 4998example: 4999 5000 use IO::Handle; 5001 sysopen(my $fh, $path, O_RDWR|O_CREAT|O_EXCL) 5002 or die "Can't open $path: $!"; 5003 $fh->autoflush(1); 5004 print $fh "stuff $$\n"; 5005 seek($fh, 0, 0); 5006 print "File contains: ", readline($fh); 5007 5008See L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE> for some details about 5009mixing reading and writing. 5010 5011=item Portability issues 5012 5013See L<perlport/open>. 5014 5015=back 5016 5017=back 5018 5019 5020=item opendir DIRHANDLE,EXPR 5021X<opendir> 5022 5023=for Pod::Functions open a directory 5024 5025Opens a directory named EXPR for processing by 5026L<C<readdir>|/readdir DIRHANDLE>, L<C<telldir>|/telldir DIRHANDLE>, 5027L<C<seekdir>|/seekdir DIRHANDLE,POS>, 5028L<C<rewinddir>|/rewinddir DIRHANDLE>, and 5029L<C<closedir>|/closedir DIRHANDLE>. Returns true if successful. 5030DIRHANDLE may be an expression whose value can be used as an indirect 5031dirhandle, usually the real dirhandle name. If DIRHANDLE is an undefined 5032scalar variable (or array or hash element), the variable is assigned a 5033reference to a new anonymous dirhandle; that is, it's autovivified. 5034Dirhandles are the same objects as filehandles; an I/O object can only 5035be open as one of these handle types at once. 5036 5037See the example at L<C<readdir>|/readdir DIRHANDLE>. 5038 5039=item ord EXPR 5040X<ord> X<encoding> 5041 5042=item ord 5043 5044=for Pod::Functions find a character's numeric representation 5045 5046Returns the numeric value of the first character of EXPR. 5047If EXPR is an empty string, returns 0. If EXPR is omitted, uses 5048L<C<$_>|perlvar/$_>. 5049(Note I<character>, not byte.) 5050 5051For the reverse, see L<C<chr>|/chr NUMBER>. 5052See L<perlunicode> for more about Unicode. 5053 5054=item our VARLIST 5055X<our> X<global> 5056 5057=item our TYPE VARLIST 5058 5059=item our VARLIST : ATTRS 5060 5061=item our TYPE VARLIST : ATTRS 5062 5063=for Pod::Functions +5.6.0 declare and assign a package variable (lexical scoping) 5064 5065L<C<our>|/our VARLIST> makes a lexical alias to a package (i.e. global) 5066variable of the same name in the current package for use within the 5067current lexical scope. 5068 5069L<C<our>|/our VARLIST> has the same scoping rules as 5070L<C<my>|/my VARLIST> or L<C<state>|/state VARLIST>, meaning that it is 5071only valid within a lexical scope. Unlike L<C<my>|/my VARLIST> and 5072L<C<state>|/state VARLIST>, which both declare new (lexical) variables, 5073L<C<our>|/our VARLIST> only creates an alias to an existing variable: a 5074package variable of the same name. 5075 5076This means that when C<use strict 'vars'> is in effect, L<C<our>|/our 5077VARLIST> lets you use a package variable without qualifying it with the 5078package name, but only within the lexical scope of the 5079L<C<our>|/our VARLIST> declaration. This applies immediately--even 5080within the same statement. 5081 5082 package Foo; 5083 use strict; 5084 5085 $Foo::foo = 23; 5086 5087 { 5088 our $foo; # alias to $Foo::foo 5089 print $foo; # prints 23 5090 } 5091 5092 print $Foo::foo; # prints 23 5093 5094 print $foo; # ERROR: requires explicit package name 5095 5096This works even if the package variable has not been used before, as 5097package variables spring into existence when first used. 5098 5099 package Foo; 5100 use strict; 5101 5102 our $foo = 23; # just like $Foo::foo = 23 5103 5104 print $Foo::foo; # prints 23 5105 5106Because the variable becomes legal immediately under C<use strict 'vars'>, so 5107long as there is no variable with that name is already in scope, you can then 5108reference the package variable again even within the same statement. 5109 5110 package Foo; 5111 use strict; 5112 5113 my $foo = $foo; # error, undeclared $foo on right-hand side 5114 our $foo = $foo; # no errors 5115 5116If more than one variable is listed, the list must be placed 5117in parentheses. 5118 5119 our($bar, $baz); 5120 5121An L<C<our>|/our VARLIST> declaration declares an alias for a package 5122variable that will be visible 5123across its entire lexical scope, even across package boundaries. The 5124package in which the variable is entered is determined at the point 5125of the declaration, not at the point of use. This means the following 5126behavior holds: 5127 5128 package Foo; 5129 our $bar; # declares $Foo::bar for rest of lexical scope 5130 $bar = 20; 5131 5132 package Bar; 5133 print $bar; # prints 20, as it refers to $Foo::bar 5134 5135Multiple L<C<our>|/our VARLIST> declarations with the same name in the 5136same lexical 5137scope are allowed if they are in different packages. If they happen 5138to be in the same package, Perl will emit warnings if you have asked 5139for them, just like multiple L<C<my>|/my VARLIST> declarations. Unlike 5140a second L<C<my>|/my VARLIST> declaration, which will bind the name to a 5141fresh variable, a second L<C<our>|/our VARLIST> declaration in the same 5142package, in the same scope, is merely redundant. 5143 5144 use warnings; 5145 package Foo; 5146 our $bar; # declares $Foo::bar for rest of lexical scope 5147 $bar = 20; 5148 5149 package Bar; 5150 our $bar = 30; # declares $Bar::bar for rest of lexical scope 5151 print $bar; # prints 30 5152 5153 our $bar; # emits warning but has no other effect 5154 print $bar; # still prints 30 5155 5156An L<C<our>|/our VARLIST> declaration may also have a list of attributes 5157associated with it. 5158 5159The exact semantics and interface of TYPE and ATTRS are still 5160evolving. TYPE is currently bound to the use of the L<fields> pragma, 5161and attributes are handled using the L<attributes> pragma, or, starting 5162from Perl 5.8.0, also via the L<Attribute::Handlers> module. See 5163L<perlsub/"Private Variables via my()"> for details. 5164 5165Note that with a parenthesised list, L<C<undef>|/undef EXPR> can be used 5166as a dummy placeholder, for example to skip assignment of initial 5167values: 5168 5169 our ( undef, $min, $hour ) = localtime; 5170 5171L<C<our>|/our VARLIST> differs from L<C<use vars>|vars>, which allows 5172use of an unqualified name I<only> within the affected package, but 5173across scopes. 5174 5175=item pack TEMPLATE,LIST 5176X<pack> 5177 5178=for Pod::Functions convert a list into a binary representation 5179 5180Takes a LIST of values and converts it into a string using the rules 5181given by the TEMPLATE. The resulting string is the concatenation of 5182the converted values. Typically, each converted value looks 5183like its machine-level representation. For example, on 32-bit machines 5184an integer may be represented by a sequence of 4 bytes, which will in 5185Perl be presented as a string that's 4 characters long. 5186 5187See L<perlpacktut> for an introduction to this function. 5188 5189The TEMPLATE is a sequence of characters that give the order and type 5190of values, as follows: 5191 5192 a A string with arbitrary binary data, will be null padded. 5193 A A text (ASCII) string, will be space padded. 5194 Z A null-terminated (ASCIZ) string, will be null padded. 5195 5196 b A bit string (ascending bit order inside each byte, 5197 like vec()). 5198 B A bit string (descending bit order inside each byte). 5199 h A hex string (low nybble first). 5200 H A hex string (high nybble first). 5201 5202 c A signed char (8-bit) value. 5203 C An unsigned char (octet) value. 5204 W An unsigned char value (can be greater than 255). 5205 5206 s A signed short (16-bit) value. 5207 S An unsigned short value. 5208 5209 l A signed long (32-bit) value. 5210 L An unsigned long value. 5211 5212 q A signed quad (64-bit) value. 5213 Q An unsigned quad value. 5214 (Quads are available only if your system supports 64-bit 5215 integer values _and_ if Perl has been compiled to support 5216 those. Raises an exception otherwise.) 5217 5218 i A signed integer value. 5219 I An unsigned integer value. 5220 (This 'integer' is _at_least_ 32 bits wide. Its exact 5221 size depends on what a local C compiler calls 'int'.) 5222 5223 n An unsigned short (16-bit) in "network" (big-endian) order. 5224 N An unsigned long (32-bit) in "network" (big-endian) order. 5225 v An unsigned short (16-bit) in "VAX" (little-endian) order. 5226 V An unsigned long (32-bit) in "VAX" (little-endian) order. 5227 5228 j A Perl internal signed integer value (IV). 5229 J A Perl internal unsigned integer value (UV). 5230 5231 f A single-precision float in native format. 5232 d A double-precision float in native format. 5233 5234 F A Perl internal floating-point value (NV) in native format 5235 D A float of long-double precision in native format. 5236 (Long doubles are available only if your system supports 5237 long double values. Raises an exception otherwise. 5238 Note that there are different long double formats.) 5239 5240 p A pointer to a null-terminated string. 5241 P A pointer to a structure (fixed-length string). 5242 5243 u A uuencoded string. 5244 U A Unicode character number. Encodes to a character in char- 5245 acter mode and UTF-8 (or UTF-EBCDIC in EBCDIC platforms) in 5246 byte mode. 5247 5248 w A BER compressed integer (not an ASN.1 BER, see perlpacktut 5249 for details). Its bytes represent an unsigned integer in 5250 base 128, most significant digit first, with as few digits 5251 as possible. Bit eight (the high bit) is set on each byte 5252 except the last. 5253 5254 x A null byte (a.k.a ASCII NUL, "\000", chr(0)) 5255 X Back up a byte. 5256 @ Null-fill or truncate to absolute position, counted from the 5257 start of the innermost ()-group. 5258 . Null-fill or truncate to absolute position specified by 5259 the value. 5260 ( Start of a ()-group. 5261 5262One or more modifiers below may optionally follow certain letters in the 5263TEMPLATE (the second column lists letters for which the modifier is valid): 5264 5265 ! sSlLiI Forces native (short, long, int) sizes instead 5266 of fixed (16-/32-bit) sizes. 5267 5268 ! xX Make x and X act as alignment commands. 5269 5270 ! nNvV Treat integers as signed instead of unsigned. 5271 5272 ! @. Specify position as byte offset in the internal 5273 representation of the packed string. Efficient 5274 but dangerous. 5275 5276 > sSiIlLqQ Force big-endian byte-order on the type. 5277 jJfFdDpP (The "big end" touches the construct.) 5278 5279 < sSiIlLqQ Force little-endian byte-order on the type. 5280 jJfFdDpP (The "little end" touches the construct.) 5281 5282The C<< > >> and C<< < >> modifiers can also be used on C<()> groups 5283to force a particular byte-order on all components in that group, 5284including all its subgroups. 5285 5286=begin comment 5287 5288Larry recalls that the hex and bit string formats (H, h, B, b) were added to 5289pack for processing data from NASA's Magellan probe. Magellan was in an 5290elliptical orbit, using the antenna for the radar mapping when close to 5291Venus and for communicating data back to Earth for the rest of the orbit. 5292There were two transmission units, but one of these failed, and then the 5293other developed a fault whereby it would randomly flip the sense of all the 5294bits. It was easy to automatically detect complete records with the correct 5295sense, and complete records with all the bits flipped. However, this didn't 5296recover the records where the sense flipped midway. A colleague of Larry's 5297was able to pretty much eyeball where the records flipped, so they wrote an 5298editor named kybble (a pun on the dog food Kibbles 'n Bits) to enable him to 5299manually correct the records and recover the data. For this purpose pack 5300gained the hex and bit string format specifiers. 5301 5302git shows that they were added to perl 3.0 in patch #44 (Jan 1991, commit 530327e2fb84680b9cc1), but the patch description makes no mention of their 5304addition, let alone the story behind them. 5305 5306=end comment 5307 5308The following rules apply: 5309 5310=over 5311 5312=item * 5313 5314Each letter may optionally be followed by a number indicating the repeat 5315count. A numeric repeat count may optionally be enclosed in brackets, as 5316in C<pack("C[80]", @arr)>. The repeat count gobbles that many values from 5317the LIST when used with all format types other than C<a>, C<A>, C<Z>, C<b>, 5318C<B>, C<h>, C<H>, C<@>, C<.>, C<x>, C<X>, and C<P>, where it means 5319something else, described below. Supplying a C<*> for the repeat count 5320instead of a number means to use however many items are left, except for: 5321 5322=over 5323 5324=item * 5325 5326C<@>, C<x>, and C<X>, where it is equivalent to C<0>. 5327 5328=item * 5329 5330<.>, where it means relative to the start of the string. 5331 5332=item * 5333 5334C<u>, where it is equivalent to 1 (or 45, which here is equivalent). 5335 5336=back 5337 5338One can replace a numeric repeat count with a template letter enclosed in 5339brackets to use the packed byte length of the bracketed template for the 5340repeat count. 5341 5342For example, the template C<x[L]> skips as many bytes as in a packed long, 5343and the template C<"$t X[$t] $t"> unpacks twice whatever $t (when 5344variable-expanded) unpacks. If the template in brackets contains alignment 5345commands (such as C<x![d]>), its packed length is calculated as if the 5346start of the template had the maximal possible alignment. 5347 5348When used with C<Z>, a C<*> as the repeat count is guaranteed to add a 5349trailing null byte, so the resulting string is always one byte longer than 5350the byte length of the item itself. 5351 5352When used with C<@>, the repeat count represents an offset from the start 5353of the innermost C<()> group. 5354 5355When used with C<.>, the repeat count determines the starting position to 5356calculate the value offset as follows: 5357 5358=over 5359 5360=item * 5361 5362If the repeat count is C<0>, it's relative to the current position. 5363 5364=item * 5365 5366If the repeat count is C<*>, the offset is relative to the start of the 5367packed string. 5368 5369=item * 5370 5371And if it's an integer I<n>, the offset is relative to the start of the 5372I<n>th innermost C<( )> group, or to the start of the string if I<n> is 5373bigger then the group level. 5374 5375=back 5376 5377The repeat count for C<u> is interpreted as the maximal number of bytes 5378to encode per line of output, with 0, 1 and 2 replaced by 45. The repeat 5379count should not be more than 65. 5380 5381=item * 5382 5383The C<a>, C<A>, and C<Z> types gobble just one value, but pack it as a 5384string of length count, padding with nulls or spaces as needed. When 5385unpacking, C<A> strips trailing whitespace and nulls, C<Z> strips everything 5386after the first null, and C<a> returns data with no stripping at all. 5387 5388If the value to pack is too long, the result is truncated. If it's too 5389long and an explicit count is provided, C<Z> packs only C<$count-1> bytes, 5390followed by a null byte. Thus C<Z> always packs a trailing null, except 5391when the count is 0. 5392 5393=item * 5394 5395Likewise, the C<b> and C<B> formats pack a string that's that many bits long. 5396Each such format generates 1 bit of the result. These are typically followed 5397by a repeat count like C<B8> or C<B64>. 5398 5399Each result bit is based on the least-significant bit of the corresponding 5400input character, i.e., on C<ord($char)%2>. In particular, characters C<"0"> 5401and C<"1"> generate bits 0 and 1, as do characters C<"\000"> and C<"\001">. 5402 5403Starting from the beginning of the input string, each 8-tuple 5404of characters is converted to 1 character of output. With format C<b>, 5405the first character of the 8-tuple determines the least-significant bit of a 5406character; with format C<B>, it determines the most-significant bit of 5407a character. 5408 5409If the length of the input string is not evenly divisible by 8, the 5410remainder is packed as if the input string were padded by null characters 5411at the end. Similarly during unpacking, "extra" bits are ignored. 5412 5413If the input string is longer than needed, remaining characters are ignored. 5414 5415A C<*> for the repeat count uses all characters of the input field. 5416On unpacking, bits are converted to a string of C<0>s and C<1>s. 5417 5418=item * 5419 5420The C<h> and C<H> formats pack a string that many nybbles (4-bit groups, 5421representable as hexadecimal digits, C<"0".."9"> C<"a".."f">) long. 5422 5423For each such format, L<C<pack>|/pack TEMPLATE,LIST> generates 4 bits of result. 5424With non-alphabetical characters, the result is based on the 4 least-significant 5425bits of the input character, i.e., on C<ord($char)%16>. In particular, 5426characters C<"0"> and C<"1"> generate nybbles 0 and 1, as do bytes 5427C<"\000"> and C<"\001">. For characters C<"a".."f"> and C<"A".."F">, the result 5428is compatible with the usual hexadecimal digits, so that C<"a"> and 5429C<"A"> both generate the nybble C<0xA==10>. Use only these specific hex 5430characters with this format. 5431 5432Starting from the beginning of the template to 5433L<C<pack>|/pack TEMPLATE,LIST>, each pair 5434of characters is converted to 1 character of output. With format C<h>, the 5435first character of the pair determines the least-significant nybble of the 5436output character; with format C<H>, it determines the most-significant 5437nybble. 5438 5439If the length of the input string is not even, it behaves as if padded by 5440a null character at the end. Similarly, "extra" nybbles are ignored during 5441unpacking. 5442 5443If the input string is longer than needed, extra characters are ignored. 5444 5445A C<*> for the repeat count uses all characters of the input field. For 5446L<C<unpack>|/unpack TEMPLATE,EXPR>, nybbles are converted to a string of 5447hexadecimal digits. 5448 5449=item * 5450 5451The C<p> format packs a pointer to a null-terminated string. You are 5452responsible for ensuring that the string is not a temporary value, as that 5453could potentially get deallocated before you got around to using the packed 5454result. The C<P> format packs a pointer to a structure of the size indicated 5455by the length. A null pointer is created if the corresponding value for 5456C<p> or C<P> is L<C<undef>|/undef EXPR>; similarly with 5457L<C<unpack>|/unpack TEMPLATE,EXPR>, where a null pointer unpacks into 5458L<C<undef>|/undef EXPR>. 5459 5460If your system has a strange pointer size--meaning a pointer is neither as 5461big as an int nor as big as a long--it may not be possible to pack or 5462unpack pointers in big- or little-endian byte order. Attempting to do 5463so raises an exception. 5464 5465=item * 5466 5467The C</> template character allows packing and unpacking of a sequence of 5468items where the packed structure contains a packed item count followed by 5469the packed items themselves. This is useful when the structure you're 5470unpacking has encoded the sizes or repeat counts for some of its fields 5471within the structure itself as separate fields. 5472 5473For L<C<pack>|/pack TEMPLATE,LIST>, you write 5474I<length-item>C</>I<sequence-item>, and the 5475I<length-item> describes how the length value is packed. Formats likely 5476to be of most use are integer-packing ones like C<n> for Java strings, 5477C<w> for ASN.1 or SNMP, and C<N> for Sun XDR. 5478 5479For L<C<pack>|/pack TEMPLATE,LIST>, I<sequence-item> may have a repeat 5480count, in which case 5481the minimum of that and the number of available items is used as the argument 5482for I<length-item>. If it has no repeat count or uses a '*', the number 5483of available items is used. 5484 5485For L<C<unpack>|/unpack TEMPLATE,EXPR>, an internal stack of integer 5486arguments unpacked so far is 5487used. You write C</>I<sequence-item> and the repeat count is obtained by 5488popping off the last element from the stack. The I<sequence-item> must not 5489have a repeat count. 5490 5491If I<sequence-item> refers to a string type (C<"A">, C<"a">, or C<"Z">), 5492the I<length-item> is the string length, not the number of strings. With 5493an explicit repeat count for pack, the packed string is adjusted to that 5494length. For example: 5495 5496 This code: gives this result: 5497 5498 unpack("W/a", "\004Gurusamy") ("Guru") 5499 unpack("a3/A A*", "007 Bond J ") (" Bond", "J") 5500 unpack("a3 x2 /A A*", "007: Bond, J.") ("Bond, J", ".") 5501 5502 pack("n/a* w/a","hello,","world") "\000\006hello,\005world" 5503 pack("a/W2", ord("a") .. ord("z")) "2ab" 5504 5505The I<length-item> is not returned explicitly from 5506L<C<unpack>|/unpack TEMPLATE,EXPR>. 5507 5508Supplying a count to the I<length-item> format letter is only useful with 5509C<A>, C<a>, or C<Z>. Packing with a I<length-item> of C<a> or C<Z> may 5510introduce C<"\000"> characters, which Perl does not regard as legal in 5511numeric strings. 5512 5513=item * 5514 5515The integer types C<s>, C<S>, C<l>, and C<L> may be 5516followed by a C<!> modifier to specify native shorts or 5517longs. As shown in the example above, a bare C<l> means 5518exactly 32 bits, although the native C<long> as seen by the local C compiler 5519may be larger. This is mainly an issue on 64-bit platforms. You can 5520see whether using C<!> makes any difference this way: 5521 5522 printf "format s is %d, s! is %d\n", 5523 length pack("s"), length pack("s!"); 5524 5525 printf "format l is %d, l! is %d\n", 5526 length pack("l"), length pack("l!"); 5527 5528 5529C<i!> and C<I!> are also allowed, but only for completeness' sake: 5530they are identical to C<i> and C<I>. 5531 5532The actual sizes (in bytes) of native shorts, ints, longs, and long 5533longs on the platform where Perl was built are also available from 5534the command line: 5535 5536 $ perl -V:{short,int,long{,long}}size 5537 shortsize='2'; 5538 intsize='4'; 5539 longsize='4'; 5540 longlongsize='8'; 5541 5542or programmatically via the L<C<Config>|Config> module: 5543 5544 use Config; 5545 print $Config{shortsize}, "\n"; 5546 print $Config{intsize}, "\n"; 5547 print $Config{longsize}, "\n"; 5548 print $Config{longlongsize}, "\n"; 5549 5550C<$Config{longlongsize}> is undefined on systems without 5551long long support. 5552 5553=item * 5554 5555The integer formats C<s>, C<S>, C<i>, C<I>, C<l>, C<L>, C<j>, and C<J> are 5556inherently non-portable between processors and operating systems because 5557they obey native byteorder and endianness. For example, a 4-byte integer 55580x12345678 (305419896 decimal) would be ordered natively (arranged in and 5559handled by the CPU registers) into bytes as 5560 5561 0x12 0x34 0x56 0x78 # big-endian 5562 0x78 0x56 0x34 0x12 # little-endian 5563 5564Basically, Intel and VAX CPUs are little-endian, while everybody else, 5565including Motorola m68k/88k, PPC, Sparc, HP PA, Power, and Cray, are 5566big-endian. Alpha and MIPS can be either: Digital/Compaq uses (well, used) 5567them in little-endian mode, but SGI/Cray uses them in big-endian mode. 5568 5569The names I<big-endian> and I<little-endian> are comic references to the 5570egg-eating habits of the little-endian Lilliputians and the big-endian 5571Blefuscudians from the classic Jonathan Swift satire, I<Gulliver's Travels>. 5572This entered computer lingo via the paper "On Holy Wars and a Plea for 5573Peace" by Danny Cohen, USC/ISI IEN 137, April 1, 1980. 5574 5575Some systems may have even weirder byte orders such as 5576 5577 0x56 0x78 0x12 0x34 5578 0x34 0x12 0x78 0x56 5579 5580These are called mid-endian, middle-endian, mixed-endian, or just weird. 5581 5582You can determine your system endianness with this incantation: 5583 5584 printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678); 5585 5586The byteorder on the platform where Perl was built is also available 5587via L<Config>: 5588 5589 use Config; 5590 print "$Config{byteorder}\n"; 5591 5592or from the command line: 5593 5594 $ perl -V:byteorder 5595 5596Byteorders C<"1234"> and C<"12345678"> are little-endian; C<"4321"> 5597and C<"87654321"> are big-endian. Systems with multiarchitecture binaries 5598will have C<"ffff">, signifying that static information doesn't work, 5599one must use runtime probing. 5600 5601For portably packed integers, either use the formats C<n>, C<N>, C<v>, 5602and C<V> or else use the C<< > >> and C<< < >> modifiers described 5603immediately below. See also L<perlport>. 5604 5605=item * 5606 5607Also floating point numbers have endianness. Usually (but not always) 5608this agrees with the integer endianness. Even though most platforms 5609these days use the IEEE 754 binary format, there are differences, 5610especially if the long doubles are involved. You can see the 5611C<Config> variables C<doublekind> and C<longdblkind> (also C<doublesize>, 5612C<longdblsize>): the "kind" values are enums, unlike C<byteorder>. 5613 5614Portability-wise the best option is probably to keep to the IEEE 754 561564-bit doubles, and of agreed-upon endianness. Another possibility 5616is the C<"%a">) format of L<C<printf>|/printf FILEHANDLE FORMAT, LIST>. 5617 5618=item * 5619 5620Starting with Perl 5.10.0, integer and floating-point formats, along with 5621the C<p> and C<P> formats and C<()> groups, may all be followed by the 5622C<< > >> or C<< < >> endianness modifiers to respectively enforce big- 5623or little-endian byte-order. These modifiers are especially useful 5624given how C<n>, C<N>, C<v>, and C<V> don't cover signed integers, 562564-bit integers, or floating-point values. 5626 5627Here are some concerns to keep in mind when using an endianness modifier: 5628 5629=over 5630 5631=item * 5632 5633Exchanging signed integers between different platforms works only 5634when all platforms store them in the same format. Most platforms store 5635signed integers in two's-complement notation, so usually this is not an issue. 5636 5637=item * 5638 5639The C<< > >> or C<< < >> modifiers can only be used on floating-point 5640formats on big- or little-endian machines. Otherwise, attempting to 5641use them raises an exception. 5642 5643=item * 5644 5645Forcing big- or little-endian byte-order on floating-point values for 5646data exchange can work only if all platforms use the same 5647binary representation such as IEEE floating-point. Even if all 5648platforms are using IEEE, there may still be subtle differences. Being able 5649to use C<< > >> or C<< < >> on floating-point values can be useful, 5650but also dangerous if you don't know exactly what you're doing. 5651It is not a general way to portably store floating-point values. 5652 5653=item * 5654 5655When using C<< > >> or C<< < >> on a C<()> group, this affects 5656all types inside the group that accept byte-order modifiers, 5657including all subgroups. It is silently ignored for all other 5658types. You are not allowed to override the byte-order within a group 5659that already has a byte-order modifier suffix. 5660 5661=back 5662 5663=item * 5664 5665Real numbers (floats and doubles) are in native machine format only. 5666Due to the multiplicity of floating-point formats and the lack of a 5667standard "network" representation for them, no facility for interchange has been 5668made. This means that packed floating-point data written on one machine 5669may not be readable on another, even if both use IEEE floating-point 5670arithmetic (because the endianness of the memory representation is not part 5671of the IEEE spec). See also L<perlport>. 5672 5673If you know I<exactly> what you're doing, you can use the C<< > >> or C<< < >> 5674modifiers to force big- or little-endian byte-order on floating-point values. 5675 5676Because Perl uses doubles (or long doubles, if configured) internally for 5677all numeric calculation, converting from double into float and thence 5678to double again loses precision, so C<unpack("f", pack("f", $foo)>) 5679will not in general equal $foo. 5680 5681=item * 5682 5683Pack and unpack can operate in two modes: character mode (C<C0> mode) where 5684the packed string is processed per character, and UTF-8 byte mode (C<U0> mode) 5685where the packed string is processed in its UTF-8-encoded Unicode form on 5686a byte-by-byte basis. Character mode is the default 5687unless the format string starts with C<U>. You 5688can always switch mode mid-format with an explicit 5689C<C0> or C<U0> in the format. This mode remains in effect until the next 5690mode change, or until the end of the C<()> group it (directly) applies to. 5691 5692Using C<C0> to get Unicode characters while using C<U0> to get I<non>-Unicode 5693bytes is not necessarily obvious. Probably only the first of these 5694is what you want: 5695 5696 $ perl -CS -E 'say "\x{3B1}\x{3C9}"' | 5697 perl -CS -ne 'printf "%v04X\n", $_ for unpack("C0A*", $_)' 5698 03B1.03C9 5699 $ perl -CS -E 'say "\x{3B1}\x{3C9}"' | 5700 perl -CS -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)' 5701 CE.B1.CF.89 5702 $ perl -CS -E 'say "\x{3B1}\x{3C9}"' | 5703 perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)' 5704 CE.B1.CF.89 5705 $ perl -CS -E 'say "\x{3B1}\x{3C9}"' | 5706 perl -C0 -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)' 5707 C3.8E.C2.B1.C3.8F.C2.89 5708 5709Those examples also illustrate that you should not try to use 5710L<C<pack>|/pack TEMPLATE,LIST>/L<C<unpack>|/unpack TEMPLATE,EXPR> as a 5711substitute for the L<Encode> module. 5712 5713=item * 5714 5715You must yourself do any alignment or padding by inserting, for example, 5716enough C<"x">es while packing. There is no way for 5717L<C<pack>|/pack TEMPLATE,LIST> and L<C<unpack>|/unpack TEMPLATE,EXPR> 5718to know where characters are going to or coming from, so they 5719handle their output and input as flat sequences of characters. 5720 5721=item * 5722 5723A C<()> group is a sub-TEMPLATE enclosed in parentheses. A group may 5724take a repeat count either as postfix, or for 5725L<C<unpack>|/unpack TEMPLATE,EXPR>, also via the C</> 5726template character. Within each repetition of a group, positioning with 5727C<@> starts over at 0. Therefore, the result of 5728 5729 pack("@1A((@2A)@3A)", qw[X Y Z]) 5730 5731is the string C<"\0X\0\0YZ">. 5732 5733=item * 5734 5735C<x> and C<X> accept the C<!> modifier to act as alignment commands: they 5736jump forward or back to the closest position aligned at a multiple of C<count> 5737characters. For example, to L<C<pack>|/pack TEMPLATE,LIST> or 5738L<C<unpack>|/unpack TEMPLATE,EXPR> a C structure like 5739 5740 struct { 5741 char c; /* one signed, 8-bit character */ 5742 double d; 5743 char cc[2]; 5744 } 5745 5746one may need to use the template C<c x![d] d c[2]>. This assumes that 5747doubles must be aligned to the size of double. 5748 5749For alignment commands, a C<count> of 0 is equivalent to a C<count> of 1; 5750both are no-ops. 5751 5752=item * 5753 5754C<n>, C<N>, C<v> and C<V> accept the C<!> modifier to 5755represent signed 16-/32-bit integers in big-/little-endian order. 5756This is portable only when all platforms sharing packed data use the 5757same binary representation for signed integers; for example, when all 5758platforms use two's-complement representation. 5759 5760=item * 5761 5762Comments can be embedded in a TEMPLATE using C<#> through the end of line. 5763White space can separate pack codes from each other, but modifiers and 5764repeat counts must follow immediately. Breaking complex templates into 5765individual line-by-line components, suitably annotated, can do as much to 5766improve legibility and maintainability of pack/unpack formats as C</x> can 5767for complicated pattern matches. 5768 5769=item * 5770 5771If TEMPLATE requires more arguments than L<C<pack>|/pack TEMPLATE,LIST> 5772is given, L<C<pack>|/pack TEMPLATE,LIST> 5773assumes additional C<""> arguments. If TEMPLATE requires fewer arguments 5774than given, extra arguments are ignored. 5775 5776=item * 5777 5778Attempting to pack the special floating point values C<Inf> and C<NaN> 5779(infinity, also in negative, and not-a-number) into packed integer values 5780(like C<"L">) is a fatal error. The reason for this is that there simply 5781isn't any sensible mapping for these special values into integers. 5782 5783=back 5784 5785Examples: 5786 5787 $foo = pack("WWWW",65,66,67,68); 5788 # foo eq "ABCD" 5789 $foo = pack("W4",65,66,67,68); 5790 # same thing 5791 $foo = pack("W4",0x24b6,0x24b7,0x24b8,0x24b9); 5792 # same thing with Unicode circled letters. 5793 $foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9); 5794 # same thing with Unicode circled letters. You don't get the 5795 # UTF-8 bytes because the U at the start of the format caused 5796 # a switch to U0-mode, so the UTF-8 bytes get joined into 5797 # characters 5798 $foo = pack("C0U4",0x24b6,0x24b7,0x24b8,0x24b9); 5799 # foo eq "\xe2\x92\xb6\xe2\x92\xb7\xe2\x92\xb8\xe2\x92\xb9" 5800 # This is the UTF-8 encoding of the string in the 5801 # previous example 5802 5803 $foo = pack("ccxxcc",65,66,67,68); 5804 # foo eq "AB\0\0CD" 5805 5806 # NOTE: The examples above featuring "W" and "c" are true 5807 # only on ASCII and ASCII-derived systems such as ISO Latin 1 5808 # and UTF-8. On EBCDIC systems, the first example would be 5809 # $foo = pack("WWWW",193,194,195,196); 5810 5811 $foo = pack("s2",1,2); 5812 # "\001\000\002\000" on little-endian 5813 # "\000\001\000\002" on big-endian 5814 5815 $foo = pack("a4","abcd","x","y","z"); 5816 # "abcd" 5817 5818 $foo = pack("aaaa","abcd","x","y","z"); 5819 # "axyz" 5820 5821 $foo = pack("a14","abcdefg"); 5822 # "abcdefg\0\0\0\0\0\0\0" 5823 5824 $foo = pack("i9pl", gmtime); 5825 # a real struct tm (on my system anyway) 5826 5827 $utmp_template = "Z8 Z8 Z16 L"; 5828 $utmp = pack($utmp_template, @utmp1); 5829 # a struct utmp (BSDish) 5830 5831 @utmp2 = unpack($utmp_template, $utmp); 5832 # "@utmp1" eq "@utmp2" 5833 5834 sub bintodec { 5835 unpack("N", pack("B32", substr("0" x 32 . shift, -32))); 5836 } 5837 5838 $foo = pack('sx2l', 12, 34); 5839 # short 12, two zero bytes padding, long 34 5840 $bar = pack('s@4l', 12, 34); 5841 # short 12, zero fill to position 4, long 34 5842 # $foo eq $bar 5843 $baz = pack('s.l', 12, 4, 34); 5844 # short 12, zero fill to position 4, long 34 5845 5846 $foo = pack('nN', 42, 4711); 5847 # pack big-endian 16- and 32-bit unsigned integers 5848 $foo = pack('S>L>', 42, 4711); 5849 # exactly the same 5850 $foo = pack('s<l<', -42, 4711); 5851 # pack little-endian 16- and 32-bit signed integers 5852 $foo = pack('(sl)<', -42, 4711); 5853 # exactly the same 5854 5855The same template may generally also be used in 5856L<C<unpack>|/unpack TEMPLATE,EXPR>. 5857 5858=item package NAMESPACE 5859 5860=item package NAMESPACE VERSION 5861X<package> X<module> X<namespace> X<version> 5862 5863=item package NAMESPACE BLOCK 5864 5865=item package NAMESPACE VERSION BLOCK 5866X<package> X<module> X<namespace> X<version> 5867 5868=for Pod::Functions declare a separate global namespace 5869 5870Declares the BLOCK or the rest of the compilation unit as being in the 5871given namespace. The scope of the package declaration is either the 5872supplied code BLOCK or, in the absence of a BLOCK, from the declaration 5873itself through the end of current scope (the enclosing block, file, or 5874L<C<eval>|/eval EXPR>). That is, the forms without a BLOCK are 5875operative through the end of the current scope, just like the 5876L<C<my>|/my VARLIST>, L<C<state>|/state VARLIST>, and 5877L<C<our>|/our VARLIST> operators. All unqualified dynamic identifiers 5878in this scope will be in the given namespace, except where overridden by 5879another L<C<package>|/package NAMESPACE> declaration or 5880when they're one of the special identifiers that qualify into C<main::>, 5881like C<STDOUT>, C<ARGV>, C<ENV>, and the punctuation variables. 5882 5883A package statement affects dynamic variables only, including those 5884you've used L<C<local>|/local EXPR> on, but I<not> lexically-scoped 5885variables, which are created with L<C<my>|/my VARLIST>, 5886L<C<state>|/state VARLIST>, or L<C<our>|/our VARLIST>. Typically it 5887would be the first declaration in a file included by 5888L<C<require>|/require VERSION> or L<C<use>|/use Module VERSION LIST>. 5889You can switch into a 5890package in more than one place, since this only determines which default 5891symbol table the compiler uses for the rest of that block. You can refer to 5892identifiers in other packages than the current one by prefixing the identifier 5893with the package name and a double colon, as in C<$SomePack::var> 5894or C<ThatPack::INPUT_HANDLE>. If package name is omitted, the C<main> 5895package is assumed. That is, C<$::sail> is equivalent to 5896C<$main::sail> (as well as to C<$main'sail>, still seen in ancient 5897code, mostly from Perl 4). 5898 5899If VERSION is provided, L<C<package>|/package NAMESPACE> sets the 5900C<$VERSION> variable in the given 5901namespace to a L<version> object with the VERSION provided. VERSION must be a 5902"strict" style version number as defined by the L<version> module: a positive 5903decimal number (integer or decimal-fraction) without exponentiation or else a 5904dotted-decimal v-string with a leading 'v' character and at least three 5905components. You should set C<$VERSION> only once per package. 5906 5907See L<perlmod/"Packages"> for more information about packages, modules, 5908and classes. See L<perlsub> for other scoping issues. 5909 5910=item __PACKAGE__ 5911X<__PACKAGE__> 5912 5913=for Pod::Functions +5.004 the current package 5914 5915A special token that returns the name of the package in which it occurs. 5916 5917=item pipe READHANDLE,WRITEHANDLE 5918X<pipe> 5919 5920=for Pod::Functions open a pair of connected filehandles 5921 5922Opens a pair of connected pipes like the corresponding system call. 5923Note that if you set up a loop of piped processes, deadlock can occur 5924unless you are very careful. In addition, note that Perl's pipes use 5925IO buffering, so you may need to set L<C<$E<verbar>>|perlvar/$E<verbar>> 5926to flush your WRITEHANDLE after each command, depending on the 5927application. 5928 5929Returns true on success. 5930 5931See L<IPC::Open2>, L<IPC::Open3>, and 5932L<perlipc/"Bidirectional Communication with Another Process"> 5933for examples of such things. 5934 5935On systems that support a close-on-exec flag on files, that flag is set 5936on all newly opened file descriptors whose 5937L<C<fileno>|/fileno FILEHANDLE>s are I<higher> than the current value of 5938L<C<$^F>|perlvar/$^F> (by default 2 for C<STDERR>). See L<perlvar/$^F>. 5939 5940=item pop ARRAY 5941X<pop> X<stack> 5942 5943=item pop 5944 5945=for Pod::Functions remove the last element from an array and return it 5946 5947Pops and returns the last value of the array, shortening the array by 5948one element. 5949 5950Returns the undefined value if the array is empty, although this may 5951also happen at other times. If ARRAY is omitted, pops the 5952L<C<@ARGV>|perlvar/@ARGV> array in the main program, but the 5953L<C<@_>|perlvar/@_> array in subroutines, just like 5954L<C<shift>|/shift ARRAY>. 5955 5956Starting with Perl 5.14, an experimental feature allowed 5957L<C<pop>|/pop ARRAY> to take a 5958scalar expression. This experiment has been deemed unsuccessful, and was 5959removed as of Perl 5.24. 5960 5961=item pos SCALAR 5962X<pos> X<match, position> 5963 5964=item pos 5965 5966=for Pod::Functions find or set the offset for the last/next m//g search 5967 5968Returns the offset of where the last C<m//g> search left off for the 5969variable in question (L<C<$_>|perlvar/$_> is used when the variable is not 5970specified). This offset is in characters unless the 5971(no-longer-recommended) L<C<use bytes>|bytes> pragma is in effect, in 5972which case the offset is in bytes. Note that 0 is a valid match offset. 5973L<C<undef>|/undef EXPR> indicates 5974that the search position is reset (usually due to match failure, but 5975can also be because no match has yet been run on the scalar). 5976 5977L<C<pos>|/pos SCALAR> directly accesses the location used by the regexp 5978engine to store the offset, so assigning to L<C<pos>|/pos SCALAR> will 5979change that offset, and so will also influence the C<\G> zero-width 5980assertion in regular expressions. Both of these effects take place for 5981the next match, so you can't affect the position with 5982L<C<pos>|/pos SCALAR> during the current match, such as in 5983C<(?{pos() = 5})> or C<s//pos() = 5/e>. 5984 5985Setting L<C<pos>|/pos SCALAR> also resets the I<matched with 5986zero-length> flag, described 5987under L<perlre/"Repeated Patterns Matching a Zero-length Substring">. 5988 5989Because a failed C<m//gc> match doesn't reset the offset, the return 5990from L<C<pos>|/pos SCALAR> won't change either in this case. See 5991L<perlre> and L<perlop>. 5992 5993=item print FILEHANDLE LIST 5994X<print> 5995 5996=item print FILEHANDLE 5997 5998=item print LIST 5999 6000=item print 6001 6002=for Pod::Functions output a list to a filehandle 6003 6004Prints a string or a list of strings. Returns true if successful. 6005FILEHANDLE may be a scalar variable containing the name of or a reference 6006to the filehandle, thus introducing one level of indirection. (NOTE: If 6007FILEHANDLE is a variable and the next token is a term, it may be 6008misinterpreted as an operator unless you interpose a C<+> or put 6009parentheses around the arguments.) If FILEHANDLE is omitted, prints to the 6010last selected (see L<C<select>|/select FILEHANDLE>) output handle. If 6011LIST is omitted, prints L<C<$_>|perlvar/$_> to the currently selected 6012output handle. To use FILEHANDLE alone to print the content of 6013L<C<$_>|perlvar/$_> to it, you must use a bareword filehandle like 6014C<FH>, not an indirect one like C<$fh>. To set the default output handle 6015to something other than STDOUT, use the select operation. 6016 6017The current value of L<C<$,>|perlvar/$,> (if any) is printed between 6018each LIST item. The current value of L<C<$\>|perlvar/$\> (if any) is 6019printed after the entire LIST has been printed. Because print takes a 6020LIST, anything in the LIST is evaluated in list context, including any 6021subroutines whose return lists you pass to 6022L<C<print>|/print FILEHANDLE LIST>. Be careful not to follow the print 6023keyword with a left 6024parenthesis unless you want the corresponding right parenthesis to 6025terminate the arguments to the print; put parentheses around all arguments 6026(or interpose a C<+>, but that doesn't look as good). 6027 6028If you're storing handles in an array or hash, or in general whenever 6029you're using any expression more complex than a bareword handle or a plain, 6030unsubscripted scalar variable to retrieve it, you will have to use a block 6031returning the filehandle value instead, in which case the LIST may not be 6032omitted: 6033 6034 print { $files[$i] } "stuff\n"; 6035 print { $OK ? *STDOUT : *STDERR } "stuff\n"; 6036 6037Printing to a closed pipe or socket will generate a SIGPIPE signal. See 6038L<perlipc> for more on signal handling. 6039 6040=item printf FILEHANDLE FORMAT, LIST 6041X<printf> 6042 6043=item printf FILEHANDLE 6044 6045=item printf FORMAT, LIST 6046 6047=item printf 6048 6049=for Pod::Functions output a formatted list to a filehandle 6050 6051Equivalent to C<print FILEHANDLE sprintf(FORMAT, LIST)>, except that 6052L<C<$\>|perlvar/$\> (the output record separator) is not appended. The 6053FORMAT and the LIST are actually parsed as a single list. The first 6054argument of the list will be interpreted as the 6055L<C<printf>|/printf FILEHANDLE FORMAT, LIST> format. This means that 6056C<printf(@_)> will use C<$_[0]> as the format. See 6057L<sprintf|/sprintf FORMAT, LIST> for an explanation of the format 6058argument. If C<use locale> (including C<use locale ':not_characters'>) 6059is in effect and L<C<POSIX::setlocale>|POSIX/C<setlocale>> has been 6060called, the character used for the decimal separator in formatted 6061floating-point numbers is affected by the C<LC_NUMERIC> locale setting. 6062See L<perllocale> and L<POSIX>. 6063 6064For historical reasons, if you omit the list, L<C<$_>|perlvar/$_> is 6065used as the format; 6066to use FILEHANDLE without a list, you must use a bareword filehandle like 6067C<FH>, not an indirect one like C<$fh>. However, this will rarely do what 6068you want; if L<C<$_>|perlvar/$_> contains formatting codes, they will be 6069replaced with the empty string and a warning will be emitted if 6070L<warnings> are enabled. Just use L<C<print>|/print FILEHANDLE LIST> if 6071you want to print the contents of L<C<$_>|perlvar/$_>. 6072 6073Don't fall into the trap of using a 6074L<C<printf>|/printf FILEHANDLE FORMAT, LIST> when a simple 6075L<C<print>|/print FILEHANDLE LIST> would do. The 6076L<C<print>|/print FILEHANDLE LIST> is more efficient and less error 6077prone. 6078 6079=item prototype FUNCTION 6080X<prototype> 6081 6082=item prototype 6083 6084=for Pod::Functions +5.002 get the prototype (if any) of a subroutine 6085 6086Returns the prototype of a function as a string (or 6087L<C<undef>|/undef EXPR> if the 6088function has no prototype). FUNCTION is a reference to, or the name of, 6089the function whose prototype you want to retrieve. If FUNCTION is omitted, 6090L<C<$_>|perlvar/$_> is used. 6091 6092If FUNCTION is a string starting with C<CORE::>, the rest is taken as a 6093name for a Perl builtin. If the builtin's arguments 6094cannot be adequately expressed by a prototype 6095(such as L<C<system>|/system LIST>), L<C<prototype>|/prototype FUNCTION> 6096returns L<C<undef>|/undef EXPR>, because the builtin 6097does not really behave like a Perl function. Otherwise, the string 6098describing the equivalent prototype is returned. 6099 6100=item push ARRAY,LIST 6101X<push> X<stack> 6102 6103=for Pod::Functions append one or more elements to an array 6104 6105Treats ARRAY as a stack by appending the values of LIST to the end of 6106ARRAY. The length of ARRAY increases by the length of LIST. Has the same 6107effect as 6108 6109 for my $value (LIST) { 6110 $ARRAY[++$#ARRAY] = $value; 6111 } 6112 6113but is more efficient. Returns the number of elements in the array following 6114the completed L<C<push>|/push ARRAY,LIST>. 6115 6116Starting with Perl 5.14, an experimental feature allowed 6117L<C<push>|/push ARRAY,LIST> to take a 6118scalar expression. This experiment has been deemed unsuccessful, and was 6119removed as of Perl 5.24. 6120 6121=item q/STRING/ 6122 6123=for Pod::Functions singly quote a string 6124 6125=item qq/STRING/ 6126 6127=for Pod::Functions doubly quote a string 6128 6129=item qw/STRING/ 6130 6131=for Pod::Functions quote a list of words 6132 6133=item qx/STRING/ 6134 6135=for Pod::Functions backquote quote a string 6136 6137Generalized quotes. See L<perlop/"Quote-Like Operators">. 6138 6139=item qr/STRING/ 6140 6141=for Pod::Functions +5.005 compile pattern 6142 6143Regexp-like quote. See L<perlop/"Regexp Quote-Like Operators">. 6144 6145=item quotemeta EXPR 6146X<quotemeta> X<metacharacter> 6147 6148=item quotemeta 6149 6150=for Pod::Functions quote regular expression magic characters 6151 6152Returns the value of EXPR with all the ASCII non-"word" 6153characters backslashed. (That is, all ASCII characters not matching 6154C</[A-Za-z_0-9]/> will be preceded by a backslash in the 6155returned string, regardless of any locale settings.) 6156This is the internal function implementing 6157the C<\Q> escape in double-quoted strings. 6158(See below for the behavior on non-ASCII code points.) 6159 6160If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 6161 6162quotemeta (and C<\Q> ... C<\E>) are useful when interpolating strings into 6163regular expressions, because by default an interpolated variable will be 6164considered a mini-regular expression. For example: 6165 6166 my $sentence = 'The quick brown fox jumped over the lazy dog'; 6167 my $substring = 'quick.*?fox'; 6168 $sentence =~ s{$substring}{big bad wolf}; 6169 6170Will cause C<$sentence> to become C<'The big bad wolf jumped over...'>. 6171 6172On the other hand: 6173 6174 my $sentence = 'The quick brown fox jumped over the lazy dog'; 6175 my $substring = 'quick.*?fox'; 6176 $sentence =~ s{\Q$substring\E}{big bad wolf}; 6177 6178Or: 6179 6180 my $sentence = 'The quick brown fox jumped over the lazy dog'; 6181 my $substring = 'quick.*?fox'; 6182 my $quoted_substring = quotemeta($substring); 6183 $sentence =~ s{$quoted_substring}{big bad wolf}; 6184 6185Will both leave the sentence as is. 6186Normally, when accepting literal string input from the user, 6187L<C<quotemeta>|/quotemeta EXPR> or C<\Q> must be used. 6188 6189Beware that if you put literal backslashes (those not inside 6190interpolated variables) between C<\Q> and C<\E>, double-quotish 6191backslash interpolation may lead to confusing results. If you 6192I<need> to use literal backslashes within C<\Q...\E>, 6193consult L<perlop/"Gory details of parsing quoted constructs">. 6194 6195Because the result of S<C<"\Q I<STRING> \E">> has all metacharacters 6196quoted, there is no way to insert a literal C<$> or C<@> inside a 6197C<\Q\E> pair. If protected by C<\>, C<$> will be quoted to become 6198C<"\\\$">; if not, it is interpreted as the start of an interpolated 6199scalar. 6200 6201In Perl v5.14, all non-ASCII characters are quoted in non-UTF-8-encoded 6202strings, but not quoted in UTF-8 strings. 6203 6204Starting in Perl v5.16, Perl adopted a Unicode-defined strategy for 6205quoting non-ASCII characters; the quoting of ASCII characters is 6206unchanged. 6207 6208Also unchanged is the quoting of non-UTF-8 strings when outside the 6209scope of a 6210L<C<use feature 'unicode_strings'>|feature/The 'unicode_strings' feature>, 6211which is to quote all 6212characters in the upper Latin1 range. This provides complete backwards 6213compatibility for old programs which do not use Unicode. (Note that 6214C<unicode_strings> is automatically enabled within the scope of a 6215S<C<use v5.12>> or greater.) 6216 6217Within the scope of L<C<use locale>|locale>, all non-ASCII Latin1 code 6218points 6219are quoted whether the string is encoded as UTF-8 or not. As mentioned 6220above, locale does not affect the quoting of ASCII-range characters. 6221This protects against those locales where characters such as C<"|"> are 6222considered to be word characters. 6223 6224Otherwise, Perl quotes non-ASCII characters using an adaptation from 6225Unicode (see L<https://www.unicode.org/reports/tr31/>). 6226The only code points that are quoted are those that have any of the 6227Unicode properties: Pattern_Syntax, Pattern_White_Space, White_Space, 6228Default_Ignorable_Code_Point, or General_Category=Control. 6229 6230Of these properties, the two important ones are Pattern_Syntax and 6231Pattern_White_Space. They have been set up by Unicode for exactly this 6232purpose of deciding which characters in a regular expression pattern 6233should be quoted. No character that can be in an identifier has these 6234properties. 6235 6236Perl promises, that if we ever add regular expression pattern 6237metacharacters to the dozen already defined 6238(C<\ E<verbar> ( ) [ { ^ $ * + ? .>), that we will only use ones that have the 6239Pattern_Syntax property. Perl also promises, that if we ever add 6240characters that are considered to be white space in regular expressions 6241(currently mostly affected by C</x>), they will all have the 6242Pattern_White_Space property. 6243 6244Unicode promises that the set of code points that have these two 6245properties will never change, so something that is not quoted in v5.16 6246will never need to be quoted in any future Perl release. (Not all the 6247code points that match Pattern_Syntax have actually had characters 6248assigned to them; so there is room to grow, but they are quoted 6249whether assigned or not. Perl, of course, would never use an 6250unassigned code point as an actual metacharacter.) 6251 6252Quoting characters that have the other 3 properties is done to enhance 6253the readability of the regular expression and not because they actually 6254need to be quoted for regular expression purposes (characters with the 6255White_Space property are likely to be indistinguishable on the page or 6256screen from those with the Pattern_White_Space property; and the other 6257two properties contain non-printing characters). 6258 6259=item rand EXPR 6260X<rand> X<random> 6261 6262=item rand 6263 6264=for Pod::Functions retrieve the next pseudorandom number 6265 6266Returns a random fractional number greater than or equal to C<0> and less 6267than the value of EXPR. (EXPR should be positive.) If EXPR is 6268omitted, the value C<1> is used. Currently EXPR with the value C<0> is 6269also special-cased as C<1> (this was undocumented before Perl 5.8.0 6270and is subject to change in future versions of Perl). Automatically calls 6271L<C<srand>|/srand EXPR> unless L<C<srand>|/srand EXPR> has already been 6272called. See also L<C<srand>|/srand EXPR>. 6273 6274Apply L<C<int>|/int EXPR> to the value returned by L<C<rand>|/rand EXPR> 6275if you want random integers instead of random fractional numbers. For 6276example, 6277 6278 int(rand(10)) 6279 6280returns a random integer between C<0> and C<9>, inclusive. 6281 6282(Note: If your rand function consistently returns numbers that are too 6283large or too small, then your version of Perl was probably compiled 6284with the wrong number of RANDBITS.) 6285 6286B<L<C<rand>|/rand EXPR> is not cryptographically secure. You should not rely 6287on it in security-sensitive situations.> As of this writing, a 6288number of third-party CPAN modules offer random number generators 6289intended by their authors to be cryptographically secure, 6290including: L<Data::Entropy>, L<Crypt::Random>, L<Math::Random::Secure>, 6291and L<Math::TrulyRandom>. 6292 6293=item read FILEHANDLE,SCALAR,LENGTH,OFFSET 6294X<read> X<file, read> 6295 6296=item read FILEHANDLE,SCALAR,LENGTH 6297 6298=for Pod::Functions fixed-length buffered input from a filehandle 6299 6300Attempts to read LENGTH I<characters> of data into variable SCALAR 6301from the specified FILEHANDLE. Returns the number of characters 6302actually read, C<0> at end of file, or undef if there was an error (in 6303the latter case L<C<$!>|perlvar/$!> is also set). SCALAR will be grown 6304or shrunk 6305so that the last character actually read is the last character of the 6306scalar after the read. 6307 6308An OFFSET may be specified to place the read data at some place in the 6309string other than the beginning. A negative OFFSET specifies 6310placement at that many characters counting backwards from the end of 6311the string. A positive OFFSET greater than the length of SCALAR 6312results in the string being padded to the required size with C<"\0"> 6313bytes before the result of the read is appended. 6314 6315The call is implemented in terms of either Perl's or your system's native 6316L<fread(3)> library function, via the L<PerlIO> layers applied to the 6317handle. To get a true L<read(2)> system call, see 6318L<sysread|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>. 6319 6320Note the I<characters>: depending on the status of the filehandle, 6321either (8-bit) bytes or characters are read. By default, all 6322filehandles operate on bytes, but for example if the filehandle has 6323been opened with the C<:utf8> I/O layer (see 6324L<C<open>|/open FILEHANDLE,MODE,EXPR>, and the L<open> 6325pragma), the I/O will operate on UTF8-encoded Unicode 6326characters, not bytes. Similarly for the C<:encoding> layer: 6327in that case pretty much any characters can be read. 6328 6329=item readdir DIRHANDLE 6330X<readdir> 6331 6332=for Pod::Functions get a directory from a directory handle 6333 6334Returns the next directory entry for a directory opened by 6335L<C<opendir>|/opendir DIRHANDLE,EXPR>. 6336If used in list context, returns all the rest of the entries in the 6337directory. If there are no more entries, returns the undefined value in 6338scalar context and the empty list in list context. 6339 6340If you're planning to filetest the return values out of a 6341L<C<readdir>|/readdir DIRHANDLE>, you'd better prepend the directory in 6342question. Otherwise, because we didn't L<C<chdir>|/chdir EXPR> there, 6343it would have been testing the wrong file. 6344 6345 opendir(my $dh, $some_dir) || die "Can't opendir $some_dir: $!"; 6346 my @dots = grep { /^\./ && -f "$some_dir/$_" } readdir($dh); 6347 closedir $dh; 6348 6349As of Perl 5.12 you can use a bare L<C<readdir>|/readdir DIRHANDLE> in a 6350C<while> loop, which will set L<C<$_>|perlvar/$_> on every iteration. 6351If either a C<readdir> expression or an explicit assignment of a 6352C<readdir> expression to a scalar is used as a C<while>/C<for> condition, 6353then the condition actually tests for definedness of the expression's 6354value, not for its regular truth value. 6355 6356 opendir(my $dh, $some_dir) || die "Can't open $some_dir: $!"; 6357 while (readdir $dh) { 6358 print "$some_dir/$_\n"; 6359 } 6360 closedir $dh; 6361 6362To avoid confusing would-be users of your code who are running earlier 6363versions of Perl with mysterious failures, put this sort of thing at the 6364top of your file to signal that your code will work I<only> on Perls of a 6365recent vintage: 6366 6367 use 5.012; # so readdir assigns to $_ in a lone while test 6368 6369=item readline EXPR 6370 6371=item readline 6372X<readline> X<gets> X<fgets> 6373 6374=for Pod::Functions fetch a record from a file 6375 6376Reads from the filehandle whose typeglob is contained in EXPR (or from 6377C<*ARGV> if EXPR is not provided). In scalar context, each call reads and 6378returns the next line until end-of-file is reached, whereupon the 6379subsequent call returns L<C<undef>|/undef EXPR>. In list context, reads 6380until end-of-file is reached and returns a list of lines. Note that the 6381notion of "line" used here is whatever you may have defined with 6382L<C<$E<sol>>|perlvar/$E<sol>> (or C<$INPUT_RECORD_SEPARATOR> in 6383L<English>). See L<perlvar/"$/">. 6384 6385When L<C<$E<sol>>|perlvar/$E<sol>> is set to L<C<undef>|/undef EXPR>, 6386when L<C<readline>|/readline EXPR> is in scalar context (i.e., file 6387slurp mode), and when an empty file is read, it returns C<''> the first 6388time, followed by L<C<undef>|/undef EXPR> subsequently. 6389 6390This is the internal function implementing the C<< <EXPR> >> 6391operator, but you can use it directly. The C<< <EXPR> >> 6392operator is discussed in more detail in L<perlop/"I/O Operators">. 6393 6394 my $line = <STDIN>; 6395 my $line = readline(STDIN); # same thing 6396 6397If L<C<readline>|/readline EXPR> encounters an operating system error, 6398L<C<$!>|perlvar/$!> will be set with the corresponding error message. 6399It can be helpful to check L<C<$!>|perlvar/$!> when you are reading from 6400filehandles you don't trust, such as a tty or a socket. The following 6401example uses the operator form of L<C<readline>|/readline EXPR> and dies 6402if the result is not defined. 6403 6404 while ( ! eof($fh) ) { 6405 defined( $_ = readline $fh ) or die "readline failed: $!"; 6406 ... 6407 } 6408 6409Note that you have can't handle L<C<readline>|/readline EXPR> errors 6410that way with the C<ARGV> filehandle. In that case, you have to open 6411each element of L<C<@ARGV>|perlvar/@ARGV> yourself since 6412L<C<eof>|/eof FILEHANDLE> handles C<ARGV> differently. 6413 6414 foreach my $arg (@ARGV) { 6415 open(my $fh, $arg) or warn "Can't open $arg: $!"; 6416 6417 while ( ! eof($fh) ) { 6418 defined( $_ = readline $fh ) 6419 or die "readline failed for $arg: $!"; 6420 ... 6421 } 6422 } 6423 6424Like the C<< <EXPR> >> operator, if a C<readline> expression is 6425used as the condition of a C<while> or C<for> loop, then it will be 6426implicitly assigned to C<$_>. If either a C<readline> expression or 6427an explicit assignment of a C<readline> expression to a scalar is used 6428as a C<while>/C<for> condition, then the condition actually tests for 6429definedness of the expression's value, not for its regular truth value. 6430 6431=item readlink EXPR 6432X<readlink> 6433 6434=item readlink 6435 6436=for Pod::Functions determine where a symbolic link is pointing 6437 6438Returns the value of a symbolic link, if symbolic links are 6439implemented. If not, raises an exception. If there is a system 6440error, returns the undefined value and sets L<C<$!>|perlvar/$!> (errno). 6441If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 6442 6443Portability issues: L<perlport/readlink>. 6444 6445=item readpipe EXPR 6446 6447=item readpipe 6448X<readpipe> 6449 6450=for Pod::Functions execute a system command and collect standard output 6451 6452EXPR is executed as a system command. 6453The collected standard output of the command is returned. 6454In scalar context, it comes back as a single (potentially 6455multi-line) string. In list context, returns a list of lines 6456(however you've defined lines with L<C<$E<sol>>|perlvar/$E<sol>> (or 6457C<$INPUT_RECORD_SEPARATOR> in L<English>)). 6458This is the internal function implementing the C<qx/EXPR/> 6459operator, but you can use it directly. The C<qx/EXPR/> 6460operator is discussed in more detail in L<perlop/"C<qx/I<STRING>/>">. 6461If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 6462 6463=item recv SOCKET,SCALAR,LENGTH,FLAGS 6464X<recv> 6465 6466=for Pod::Functions receive a message over a Socket 6467 6468Receives a message on a socket. Attempts to receive LENGTH characters 6469of data into variable SCALAR from the specified SOCKET filehandle. 6470SCALAR will be grown or shrunk to the length actually read. Takes the 6471same flags as the system call of the same name. Returns the address 6472of the sender if SOCKET's protocol supports this; returns an empty 6473string otherwise. If there's an error, returns the undefined value. 6474This call is actually implemented in terms of the L<recvfrom(2)> system call. 6475See L<perlipc/"UDP: Message Passing"> for examples. 6476 6477Note that if the socket has been marked as C<:utf8>, C<recv> will 6478throw an exception. The C<:encoding(...)> layer implicitly introduces 6479the C<:utf8> layer. See L<C<binmode>|/binmode FILEHANDLE, LAYER>. 6480 6481=item redo LABEL 6482X<redo> 6483 6484=item redo EXPR 6485 6486=item redo 6487 6488=for Pod::Functions start this loop iteration over again 6489 6490The L<C<redo>|/redo LABEL> command restarts the loop block without 6491evaluating the conditional again. The L<C<continue>|/continue BLOCK> 6492block, if any, is not executed. If 6493the LABEL is omitted, the command refers to the innermost enclosing 6494loop. The C<redo EXPR> form, available starting in Perl 5.18.0, allows a 6495label name to be computed at run time, and is otherwise identical to C<redo 6496LABEL>. Programs that want to lie to themselves about what was just input 6497normally use this command: 6498 6499 # a simpleminded Pascal comment stripper 6500 # (warning: assumes no { or } in strings) 6501 LINE: while (<STDIN>) { 6502 while (s|({.*}.*){.*}|$1 |) {} 6503 s|{.*}| |; 6504 if (s|{.*| |) { 6505 my $front = $_; 6506 while (<STDIN>) { 6507 if (/}/) { # end of comment? 6508 s|^|$front\{|; 6509 redo LINE; 6510 } 6511 } 6512 } 6513 print; 6514 } 6515 6516L<C<redo>|/redo LABEL> cannot return a value from a block that typically 6517returns a value, such as C<eval {}>, C<sub {}>, or C<do {}>. It will perform 6518its flow control behavior, which precludes any return value. It should not be 6519used to exit a L<C<grep>|/grep BLOCK LIST> or L<C<map>|/map BLOCK LIST> 6520operation. 6521 6522Note that a block by itself is semantically identical to a loop 6523that executes once. Thus L<C<redo>|/redo LABEL> inside such a block 6524will effectively turn it into a looping construct. 6525 6526See also L<C<continue>|/continue BLOCK> for an illustration of how 6527L<C<last>|/last LABEL>, L<C<next>|/next LABEL>, and 6528L<C<redo>|/redo LABEL> work. 6529 6530Unlike most named operators, this has the same precedence as assignment. 6531It is also exempt from the looks-like-a-function rule, so 6532C<redo ("foo")."bar"> will cause "bar" to be part of the argument to 6533L<C<redo>|/redo LABEL>. 6534 6535=item ref EXPR 6536X<ref> X<reference> 6537 6538=item ref 6539 6540=for Pod::Functions find out the type of thing being referenced 6541 6542Examines the value of EXPR, expecting it to be a reference, and returns 6543a string giving information about the reference and the type of referent. 6544If EXPR is not specified, L<C<$_>|perlvar/$_> will be used. 6545 6546If the operand is not a reference, then the empty string will be returned. 6547An empty string will only be returned in this situation. C<ref> is often 6548useful to just test whether a value is a reference, which can be done 6549by comparing the result to the empty string. It is a common mistake 6550to use the result of C<ref> directly as a truth value: this goes wrong 6551because C<0> (which is false) can be returned for a reference. 6552 6553If the operand is a reference to a blessed object, then the name of 6554the class into which the referent is blessed will be returned. C<ref> 6555doesn't care what the physical type of the referent is; blessing takes 6556precedence over such concerns. Beware that exact comparison of C<ref> 6557results against a class name doesn't perform a class membership test: 6558a class's members also include objects blessed into subclasses, for 6559which C<ref> will return the name of the subclass. Also beware that 6560class names can clash with the built-in type names (described below). 6561 6562If the operand is a reference to an unblessed object, then the return 6563value indicates the type of object. If the unblessed referent is not 6564a scalar, then the return value will be one of the strings C<ARRAY>, 6565C<HASH>, C<CODE>, C<FORMAT>, or C<IO>, indicating only which kind of 6566object it is. If the unblessed referent is a scalar, then the return 6567value will be one of the strings C<SCALAR>, C<VSTRING>, C<REF>, C<GLOB>, 6568C<LVALUE>, or C<REGEXP>, depending on the kind of value the scalar 6569currently has. But note that C<qr//> scalars are created already 6570blessed, so C<ref qr/.../> will likely return C<Regexp>. Beware that 6571these built-in type names can also be used as 6572class names, so C<ref> returning one of these names doesn't unambiguously 6573indicate that the referent is of the kind to which the name refers. 6574 6575The ambiguity between built-in type names and class names significantly 6576limits the utility of C<ref>. For unambiguous information, use 6577L<C<Scalar::Util::blessed()>|Scalar::Util/blessed> for information about 6578blessing, and L<C<Scalar::Util::reftype()>|Scalar::Util/reftype> for 6579information about physical types. Use L<the C<isa> method|UNIVERSAL/C<< 6580$obj->isa( TYPE ) >>> for class membership tests, though one must be 6581sure of blessedness before attempting a method call. Alternatively, the 6582L<C<isa> operator|perlop/"Class Instance Operator"> can test class 6583membership without checking blessedness first. 6584 6585See also L<perlref> and L<perlobj>. 6586 6587=item rename OLDNAME,NEWNAME 6588X<rename> X<move> X<mv> X<ren> 6589 6590=for Pod::Functions change a filename 6591 6592Changes the name of a file; an existing file NEWNAME will be 6593clobbered. Returns true for success; on failure returns false and sets 6594L<C<$!>|perlvar/$!>. 6595 6596Behavior of this function varies wildly depending on your system 6597implementation. For example, it will usually not work across file system 6598boundaries, even though the system I<mv> command sometimes compensates 6599for this. Other restrictions include whether it works on directories, 6600open files, or pre-existing files. Check L<perlport> and either the 6601L<rename(2)> manpage or equivalent system documentation for details. 6602 6603For a platform independent L<C<move>|File::Copy/move> function look at 6604the L<File::Copy> module. 6605 6606Portability issues: L<perlport/rename>. 6607 6608=item require VERSION 6609X<require> 6610 6611=item require EXPR 6612 6613=item require 6614 6615=for Pod::Functions load in external functions from a library at runtime 6616 6617Demands a version of Perl specified by VERSION, or demands some semantics 6618specified by EXPR or by L<C<$_>|perlvar/$_> if EXPR is not supplied. 6619 6620VERSION may be either a literal such as v5.24.1, which will be 6621compared to L<C<$^V>|perlvar/$^V> (or C<$PERL_VERSION> in L<English>), 6622or a numeric argument of the form 5.024001, which will be compared to 6623L<C<$]>|perlvar/$]>. An exception is raised if VERSION is greater than 6624the version of the current Perl interpreter. Compare with 6625L<C<use>|/use Module VERSION LIST>, which can do a similar check at 6626compile time. 6627 6628Specifying VERSION as a numeric argument of the form 5.024001 should 6629generally be avoided as older less readable syntax compared to 6630v5.24.1. Before perl 5.8.0 (released in 2002), the more verbose numeric 6631form was the only supported syntax, which is why you might see it in 6632older code. 6633 6634 require v5.24.1; # run time version check 6635 require 5.24.1; # ditto 6636 require 5.024_001; # ditto; older syntax compatible 6637 with perl 5.6 6638 6639Otherwise, L<C<require>|/require VERSION> demands that a library file be 6640included if it hasn't already been included. The file is included via 6641the do-FILE mechanism, which is essentially just a variety of 6642L<C<eval>|/eval EXPR> with the 6643caveat that lexical variables in the invoking script will be invisible 6644to the included code. If it were implemented in pure Perl, it 6645would have semantics similar to the following: 6646 6647 use Carp 'croak'; 6648 use version; 6649 6650 sub require { 6651 my ($filename) = @_; 6652 if ( my $version = eval { version->parse($filename) } ) { 6653 if ( $version > $^V ) { 6654 my $vn = $version->normal; 6655 croak "Perl $vn required--this is only $^V, stopped"; 6656 } 6657 return 1; 6658 } 6659 6660 if (exists $INC{$filename}) { 6661 return 1 if $INC{$filename}; 6662 croak "Compilation failed in require"; 6663 } 6664 6665 foreach $prefix (@INC) { 6666 if (ref($prefix)) { 6667 #... do other stuff - see text below .... 6668 } 6669 # (see text below about possible appending of .pmc 6670 # suffix to $filename) 6671 my $realfilename = "$prefix/$filename"; 6672 next if ! -e $realfilename || -d _ || -b _; 6673 $INC{$filename} = $realfilename; 6674 my $result = do($realfilename); 6675 # but run in caller's namespace 6676 6677 if (!defined $result) { 6678 $INC{$filename} = undef; 6679 croak $@ ? "$@Compilation failed in require" 6680 : "Can't locate $filename: $!\n"; 6681 } 6682 if (!$result) { 6683 delete $INC{$filename}; 6684 croak "$filename did not return true value"; 6685 } 6686 $! = 0; 6687 return $result; 6688 } 6689 croak "Can't locate $filename in \@INC ..."; 6690 } 6691 6692Note that the file will not be included twice under the same specified 6693name. 6694 6695The file must return true as the last statement to indicate 6696successful execution of any initialization code, so it's customary to 6697end such a file with C<1;> unless you're sure it'll return true 6698otherwise. But it's better just to put the C<1;>, in case you add more 6699statements. 6700 6701If EXPR is a bareword, L<C<require>|/require VERSION> assumes a F<.pm> 6702extension and replaces C<::> with C</> in the filename for you, 6703to make it easy to load standard modules. This form of loading of 6704modules does not risk altering your namespace, however it will autovivify 6705the stash for the required module. 6706 6707In other words, if you try this: 6708 6709 require Foo::Bar; # a splendid bareword 6710 6711The require function will actually look for the F<Foo/Bar.pm> file in the 6712directories specified in the L<C<@INC>|perlvar/@INC> array, and it will 6713autovivify the C<Foo::Bar::> stash at compile time. 6714 6715But if you try this: 6716 6717 my $class = 'Foo::Bar'; 6718 require $class; # $class is not a bareword 6719 #or 6720 require "Foo::Bar"; # not a bareword because of the "" 6721 6722The require function will look for the F<Foo::Bar> file in the 6723L<C<@INC>|perlvar/@INC> array and 6724will complain about not finding F<Foo::Bar> there. In this case you can do: 6725 6726 eval "require $class"; 6727 6728or you could do 6729 6730 require "Foo/Bar.pm"; 6731 6732Neither of these forms will autovivify any stashes at compile time and 6733only have run time effects. 6734 6735Now that you understand how L<C<require>|/require VERSION> looks for 6736files with a bareword argument, there is a little extra functionality 6737going on behind the scenes. Before L<C<require>|/require VERSION> looks 6738for a F<.pm> extension, it will first look for a similar filename with a 6739F<.pmc> extension. If this file is found, it will be loaded in place of 6740any file ending in a F<.pm> extension. This applies to both the explicit 6741C<require "Foo/Bar.pm";> form and the C<require Foo::Bar;> form. 6742 6743You can also insert hooks into the import facility by putting Perl code 6744directly into the L<C<@INC>|perlvar/@INC> array. There are three forms 6745of hooks: subroutine references, array references, and blessed objects. 6746 6747Subroutine references are the simplest case. When the inclusion system 6748walks through L<C<@INC>|perlvar/@INC> and encounters a subroutine, this 6749subroutine gets called with two parameters, the first a reference to 6750itself, and the second the name of the file to be included (e.g., 6751F<Foo/Bar.pm>). The subroutine should return either nothing or else a 6752list of up to four values in the following order: 6753 6754=over 6755 6756=item 1 6757 6758A reference to a scalar, containing any initial source code to prepend to 6759the file or generator output. 6760 6761=item 2 6762 6763A filehandle, from which the file will be read. 6764 6765=item 3 6766 6767A reference to a subroutine. If there is no filehandle (previous item), 6768then this subroutine is expected to generate one line of source code per 6769call, writing the line into L<C<$_>|perlvar/$_> and returning 1, then 6770finally at end of file returning 0. If there is a filehandle, then the 6771subroutine will be called to act as a simple source filter, with the 6772line as read in L<C<$_>|perlvar/$_>. 6773Again, return 1 for each valid line, and 0 after all lines have been 6774returned. 6775For historical reasons the subroutine will receive a meaningless argument 6776(in fact always the numeric value zero) as C<$_[0]>. 6777 6778=item 4 6779 6780Optional state for the subroutine. The state is passed in as C<$_[1]>. 6781 6782=back 6783 6784If an empty list, L<C<undef>|/undef EXPR>, or nothing that matches the 6785first 3 values above is returned, then L<C<require>|/require VERSION> 6786looks at the remaining elements of L<C<@INC>|perlvar/@INC>. 6787Note that this filehandle must be a real filehandle (strictly a typeglob 6788or reference to a typeglob, whether blessed or unblessed); tied filehandles 6789will be ignored and processing will stop there. 6790 6791If the hook is an array reference, its first element must be a subroutine 6792reference. This subroutine is called as above, but the first parameter is 6793the array reference. This lets you indirectly pass arguments to 6794the subroutine. 6795 6796In other words, you can write: 6797 6798 push @INC, \&my_sub; 6799 sub my_sub { 6800 my ($coderef, $filename) = @_; # $coderef is \&my_sub 6801 ... 6802 } 6803 6804or: 6805 6806 push @INC, [ \&my_sub, $x, $y, ... ]; 6807 sub my_sub { 6808 my ($arrayref, $filename) = @_; 6809 # Retrieve $x, $y, ... 6810 my (undef, @parameters) = @$arrayref; 6811 ... 6812 } 6813 6814If the hook is an object, it must provide an C<INC> method that will be 6815called as above, the first parameter being the object itself. (Note that 6816you must fully qualify the sub's name, as unqualified C<INC> is always forced 6817into package C<main>.) Here is a typical code layout: 6818 6819 # In Foo.pm 6820 package Foo; 6821 sub new { ... } 6822 sub Foo::INC { 6823 my ($self, $filename) = @_; 6824 ... 6825 } 6826 6827 # In the main program 6828 push @INC, Foo->new(...); 6829 6830These hooks are also permitted to set the L<C<%INC>|perlvar/%INC> entry 6831corresponding to the files they have loaded. See L<perlvar/%INC>. 6832 6833For a yet-more-powerful import facility, see 6834L<C<use>|/use Module VERSION LIST> and L<perlmod>. 6835 6836=item reset EXPR 6837X<reset> 6838 6839=item reset 6840 6841=for Pod::Functions clear all variables of a given name 6842 6843Generally used in a L<C<continue>|/continue BLOCK> block at the end of a 6844loop to clear variables and reset C<m?pattern?> searches so that they 6845work again. The 6846expression is interpreted as a list of single characters (hyphens 6847allowed for ranges). All variables (scalars, arrays, and hashes) 6848in the current package beginning with one of 6849those letters are reset to their pristine state. If the expression is 6850omitted, one-match searches (C<m?pattern?>) are reset to match again. 6851Only resets variables or searches in the current package. Always returns 68521. Examples: 6853 6854 reset 'X'; # reset all X variables 6855 reset 'a-z'; # reset lower case variables 6856 reset; # just reset m?one-time? searches 6857 6858Resetting C<"A-Z"> is not recommended because you'll wipe out your 6859L<C<@ARGV>|perlvar/@ARGV> and L<C<@INC>|perlvar/@INC> arrays and your 6860L<C<%ENV>|perlvar/%ENV> hash. 6861 6862Resets only package variables; lexical variables are unaffected, but 6863they clean themselves up on scope exit anyway, so you'll probably want 6864to use them instead. See L<C<my>|/my VARLIST>. 6865 6866=item return EXPR 6867X<return> 6868 6869=item return 6870 6871=for Pod::Functions get out of a function early 6872 6873Returns from a subroutine, L<C<eval>|/eval EXPR>, 6874L<C<do FILE>|/do EXPR>, L<C<sort>|/sort SUBNAME LIST> block or regex 6875eval block (but not a L<C<grep>|/grep BLOCK LIST>, 6876L<C<map>|/map BLOCK LIST>, or L<C<do BLOCK>|/do BLOCK> block) with the value 6877given in EXPR. Evaluation of EXPR may be in list, scalar, or void 6878context, depending on how the return value will be used, and the context 6879may vary from one execution to the next (see 6880L<C<wantarray>|/wantarray>). If no EXPR 6881is given, returns an empty list in list context, the undefined value in 6882scalar context, and (of course) nothing at all in void context. 6883 6884(In the absence of an explicit L<C<return>|/return EXPR>, a subroutine, 6885L<C<eval>|/eval EXPR>, 6886or L<C<do FILE>|/do EXPR> automatically returns the value of the last expression 6887evaluated.) 6888 6889Unlike most named operators, this is also exempt from the 6890looks-like-a-function rule, so C<return ("foo")."bar"> will 6891cause C<"bar"> to be part of the argument to L<C<return>|/return EXPR>. 6892 6893=item reverse LIST 6894X<reverse> X<rev> X<invert> 6895 6896=for Pod::Functions flip a string or a list 6897 6898In list context, returns a list value consisting of the elements 6899of LIST in the opposite order. In scalar context, concatenates the 6900elements of LIST and returns a string value with all characters 6901in the opposite order. 6902 6903 print join(", ", reverse "world", "Hello"); # Hello, world 6904 6905 print scalar reverse "dlrow ,", "olleH"; # Hello, world 6906 6907Used without arguments in scalar context, L<C<reverse>|/reverse LIST> 6908reverses L<C<$_>|perlvar/$_>. 6909 6910 $_ = "dlrow ,olleH"; 6911 print reverse; # No output, list context 6912 print scalar reverse; # Hello, world 6913 6914Note that reversing an array to itself (as in C<@a = reverse @a>) will 6915preserve non-existent elements whenever possible; i.e., for non-magical 6916arrays or for tied arrays with C<EXISTS> and C<DELETE> methods. 6917 6918This operator is also handy for inverting a hash, although there are some 6919caveats. If a value is duplicated in the original hash, only one of those 6920can be represented as a key in the inverted hash. Also, this has to 6921unwind one hash and build a whole new one, which may take some time 6922on a large hash, such as from a DBM file. 6923 6924 my %by_name = reverse %by_address; # Invert the hash 6925 6926=item rewinddir DIRHANDLE 6927X<rewinddir> 6928 6929=for Pod::Functions reset directory handle 6930 6931Sets the current position to the beginning of the directory for the 6932L<C<readdir>|/readdir DIRHANDLE> routine on DIRHANDLE. 6933 6934Portability issues: L<perlport/rewinddir>. 6935 6936=item rindex STR,SUBSTR,POSITION 6937X<rindex> 6938 6939=item rindex STR,SUBSTR 6940 6941=for Pod::Functions right-to-left substring search 6942 6943Works just like L<C<index>|/index STR,SUBSTR,POSITION> except that it 6944returns the position of the I<last> 6945occurrence of SUBSTR in STR. If POSITION is specified, returns the 6946last occurrence beginning at or before that position. 6947 6948=item rmdir FILENAME 6949X<rmdir> X<rd> X<directory, remove> 6950 6951=item rmdir 6952 6953=for Pod::Functions remove a directory 6954 6955Deletes the directory specified by FILENAME if that directory is 6956empty. If it succeeds it returns true; otherwise it returns false and 6957sets L<C<$!>|perlvar/$!> (errno). If FILENAME is omitted, uses 6958L<C<$_>|perlvar/$_>. 6959 6960To remove a directory tree recursively (C<rm -rf> on Unix) look at 6961the L<C<rmtree>|File::Path/rmtree( $dir )> function of the L<File::Path> 6962module. 6963 6964=item s/// 6965 6966=for Pod::Functions replace a pattern with a string 6967 6968The substitution operator. See L<perlop/"Regexp Quote-Like Operators">. 6969 6970=item say FILEHANDLE LIST 6971X<say> 6972 6973=item say FILEHANDLE 6974 6975=item say LIST 6976 6977=item say 6978 6979=for Pod::Functions +say output a list to a filehandle, appending a newline 6980 6981Just like L<C<print>|/print FILEHANDLE LIST>, but implicitly appends a 6982newline at the end of the LIST instead of any value L<C<$\>|perlvar/$\> 6983might have. To use FILEHANDLE without a LIST to 6984print the contents of L<C<$_>|perlvar/$_> to it, you must use a bareword 6985filehandle like C<FH>, not an indirect one like C<$fh>. 6986 6987L<C<say>|/say FILEHANDLE LIST> is available only if the 6988L<C<"say"> feature|feature/The 'say' feature> is enabled or if it is 6989prefixed with C<CORE::>. The 6990L<C<"say"> feature|feature/The 'say' feature> is enabled automatically 6991with a C<use v5.10> (or higher) declaration in the current scope. 6992 6993=item scalar EXPR 6994X<scalar> X<context> 6995 6996=for Pod::Functions force a scalar context 6997 6998Forces EXPR to be interpreted in scalar context and returns the value 6999of EXPR. 7000 7001 my @counts = ( scalar @a, scalar @b, scalar @c ); 7002 7003There is no equivalent operator to force an expression to 7004be interpolated in list context because in practice, this is never 7005needed. If you really wanted to do so, however, you could use 7006the construction C<@{[ (some expression) ]}>, but usually a simple 7007C<(some expression)> suffices. 7008 7009Because L<C<scalar>|/scalar EXPR> is a unary operator, if you 7010accidentally use a 7011parenthesized list for the EXPR, this behaves as a scalar comma expression, 7012evaluating all but the last element in void context and returning the final 7013element evaluated in scalar context. This is seldom what you want. 7014 7015The following single statement: 7016 7017 print uc(scalar(foo(), $bar)), $baz; 7018 7019is the moral equivalent of these two: 7020 7021 foo(); 7022 print(uc($bar), $baz); 7023 7024See L<perlop> for more details on unary operators and the comma operator, 7025and L<perldata> for details on evaluating a hash in scalar context. 7026 7027=item seek FILEHANDLE,POSITION,WHENCE 7028X<seek> X<fseek> X<filehandle, position> 7029 7030=for Pod::Functions reposition file pointer for random-access I/O 7031 7032Sets FILEHANDLE's position, just like the L<fseek(3)> call of C C<stdio>. 7033FILEHANDLE may be an expression whose value gives the name of the 7034filehandle. The values for WHENCE are C<0> to set the new position 7035I<in bytes> to POSITION; C<1> to set it to the current position plus 7036POSITION; and C<2> to set it to EOF plus POSITION, typically 7037negative. For WHENCE you may use the constants C<SEEK_SET>, 7038C<SEEK_CUR>, and C<SEEK_END> (start of the file, current position, end 7039of the file) from the L<Fcntl> module. Returns C<1> on success, false 7040otherwise. 7041 7042Note the emphasis on bytes: even if the filehandle has been set to operate 7043on characters (for example using the C<:encoding(UTF-8)> I/O layer), the 7044L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 7045L<C<tell>|/tell FILEHANDLE>, and 7046L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE> 7047family of functions use byte offsets, not character offsets, 7048because seeking to a character offset would be very slow in a UTF-8 file. 7049 7050If you want to position the file for 7051L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET> or 7052L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET>, don't use 7053L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, because buffering makes its 7054effect on the file's read-write position unpredictable and non-portable. 7055Use L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE> instead. 7056 7057Due to the rules and rigors of ANSI C, on some systems you have to do a 7058seek whenever you switch between reading and writing. Amongst other 7059things, this may have the effect of calling stdio's L<clearerr(3)>. 7060A WHENCE of C<1> (C<SEEK_CUR>) is useful for not moving the file position: 7061 7062 seek($fh, 0, 1); 7063 7064This is also useful for applications emulating C<tail -f>. Once you hit 7065EOF on your read and then sleep for a while, you (probably) have to stick in a 7066dummy L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE> to reset things. The 7067L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE> doesn't change the position, 7068but it I<does> clear the end-of-file condition on the handle, so that the 7069next C<readline FILE> makes Perl try again to read something. (We hope.) 7070 7071If that doesn't work (some I/O implementations are particularly 7072cantankerous), you might need something like this: 7073 7074 for (;;) { 7075 for ($curpos = tell($fh); $_ = readline($fh); 7076 $curpos = tell($fh)) { 7077 # search for some stuff and put it into files 7078 } 7079 sleep($for_a_while); 7080 seek($fh, $curpos, 0); 7081 } 7082 7083=item seekdir DIRHANDLE,POS 7084X<seekdir> 7085 7086=for Pod::Functions reposition directory pointer 7087 7088Sets the current position for the L<C<readdir>|/readdir DIRHANDLE> 7089routine on DIRHANDLE. POS must be a value returned by 7090L<C<telldir>|/telldir DIRHANDLE>. L<C<seekdir>|/seekdir DIRHANDLE,POS> 7091also has the same caveats about possible directory compaction as the 7092corresponding system library routine. 7093 7094=item select FILEHANDLE 7095X<select> X<filehandle, default> 7096 7097=item select 7098 7099=for Pod::Functions reset default output or do I/O multiplexing 7100 7101Returns the currently selected filehandle. If FILEHANDLE is supplied, 7102sets the new current default filehandle for output. This has two 7103effects: first, a L<C<write>|/write FILEHANDLE> or a L<C<print>|/print 7104FILEHANDLE LIST> without a filehandle 7105default to this FILEHANDLE. Second, references to variables related to 7106output will refer to this output channel. 7107 7108For example, to set the top-of-form format for more than one 7109output channel, you might do the following: 7110 7111 select(REPORT1); 7112 $^ = 'report1_top'; 7113 select(REPORT2); 7114 $^ = 'report2_top'; 7115 7116FILEHANDLE may be an expression whose value gives the name of the 7117actual filehandle. Thus: 7118 7119 my $oldfh = select(STDERR); $| = 1; select($oldfh); 7120 7121Some programmers may prefer to think of filehandles as objects with 7122methods, preferring to write the last example as: 7123 7124 STDERR->autoflush(1); 7125 7126(Prior to Perl version 5.14, you have to C<use IO::Handle;> explicitly 7127first.) 7128 7129Portability issues: L<perlport/select>. 7130 7131=item select RBITS,WBITS,EBITS,TIMEOUT 7132X<select> 7133 7134This calls the L<select(2)> syscall with the bit masks specified, which 7135can be constructed using L<C<fileno>|/fileno FILEHANDLE> and 7136L<C<vec>|/vec EXPR,OFFSET,BITS>, along these lines: 7137 7138 my $rin = my $win = my $ein = ''; 7139 vec($rin, fileno(STDIN), 1) = 1; 7140 vec($win, fileno(STDOUT), 1) = 1; 7141 $ein = $rin | $win; 7142 7143If you want to select on many filehandles, you may wish to write a 7144subroutine like this: 7145 7146 sub fhbits { 7147 my @fhlist = @_; 7148 my $bits = ""; 7149 for my $fh (@fhlist) { 7150 vec($bits, fileno($fh), 1) = 1; 7151 } 7152 return $bits; 7153 } 7154 my $rin = fhbits(\*STDIN, $tty, $mysock); 7155 7156The usual idiom is: 7157 7158 my ($nfound, $timeleft) = 7159 select(my $rout = $rin, my $wout = $win, my $eout = $ein, 7160 $timeout); 7161 7162or to block until something becomes ready just do this 7163 7164 my $nfound = 7165 select(my $rout = $rin, my $wout = $win, my $eout = $ein, undef); 7166 7167Most systems do not bother to return anything useful in C<$timeleft>, so 7168calling L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> in scalar context 7169just returns C<$nfound>. 7170 7171Any of the bit masks can also be L<C<undef>|/undef EXPR>. The timeout, 7172if specified, is 7173in seconds, which may be fractional. Note: not all implementations are 7174capable of returning the C<$timeleft>. If not, they always return 7175C<$timeleft> equal to the supplied C<$timeout>. 7176 7177You can effect a sleep of 250 milliseconds this way: 7178 7179 select(undef, undef, undef, 0.25); 7180 7181Note that whether L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> gets 7182restarted after signals (say, SIGALRM) is implementation-dependent. See 7183also L<perlport> for notes on the portability of 7184L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT>. 7185 7186On error, L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> behaves just 7187like L<select(2)>: it returns C<-1> and sets L<C<$!>|perlvar/$!>. 7188 7189On some Unixes, L<select(2)> may report a socket file descriptor as 7190"ready for reading" even when no data is available, and thus any 7191subsequent L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET> would block. 7192This can be avoided if you always use C<O_NONBLOCK> on the socket. See 7193L<select(2)> and L<fcntl(2)> for further details. 7194 7195The standard L<C<IO::Select>|IO::Select> module provides a 7196user-friendlier interface to 7197L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT>, mostly because it does 7198all the bit-mask work for you. 7199 7200B<WARNING>: One should not attempt to mix buffered I/O (like 7201L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET> or 7202L<C<readline>|/readline EXPR>) with 7203L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT>, except as permitted by 7204POSIX, and even then only on POSIX systems. You have to use 7205L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET> instead. 7206 7207Portability issues: L<perlport/select>. 7208 7209=item semctl ID,SEMNUM,CMD,ARG 7210X<semctl> 7211 7212=for Pod::Functions SysV semaphore control operations 7213 7214Calls the System V IPC function L<semctl(2)>. You'll probably have to say 7215 7216 use IPC::SysV; 7217 7218first to get the correct constant definitions. If CMD is IPC_STAT or 7219GETALL, then ARG must be a variable that will hold the returned 7220semid_ds structure or semaphore value array. Returns like 7221L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>: 7222the undefined value for error, "C<0 but true>" for zero, or the actual 7223return value otherwise. The ARG must consist of a vector of native 7224short integers, which may be created with C<pack("s!",(0)x$nsem)>. 7225See also L<perlipc/"SysV IPC"> and the documentation for 7226L<C<IPC::SysV>|IPC::SysV> and L<C<IPC::Semaphore>|IPC::Semaphore>. 7227 7228Portability issues: L<perlport/semctl>. 7229 7230=item semget KEY,NSEMS,FLAGS 7231X<semget> 7232 7233=for Pod::Functions get set of SysV semaphores 7234 7235Calls the System V IPC function L<semget(2)>. Returns the semaphore id, or 7236the undefined value on error. See also 7237L<perlipc/"SysV IPC"> and the documentation for 7238L<C<IPC::SysV>|IPC::SysV> and L<C<IPC::Semaphore>|IPC::Semaphore>. 7239 7240Portability issues: L<perlport/semget>. 7241 7242=item semop KEY,OPSTRING 7243X<semop> 7244 7245=for Pod::Functions SysV semaphore operations 7246 7247Calls the System V IPC function L<semop(2)> for semaphore operations 7248such as signalling and waiting. OPSTRING must be a packed array of 7249semop structures. Each semop structure can be generated with 7250C<pack("s!3", $semnum, $semop, $semflag)>. The length of OPSTRING 7251implies the number of semaphore operations. Returns true if 7252successful, false on error. As an example, the 7253following code waits on semaphore $semnum of semaphore id $semid: 7254 7255 my $semop = pack("s!3", $semnum, -1, 0); 7256 die "Semaphore trouble: $!\n" unless semop($semid, $semop); 7257 7258To signal the semaphore, replace C<-1> with C<1>. See also 7259L<perlipc/"SysV IPC"> and the documentation for 7260L<C<IPC::SysV>|IPC::SysV> and L<C<IPC::Semaphore>|IPC::Semaphore>. 7261 7262Portability issues: L<perlport/semop>. 7263 7264=item send SOCKET,MSG,FLAGS,TO 7265X<send> 7266 7267=item send SOCKET,MSG,FLAGS 7268 7269=for Pod::Functions send a message over a socket 7270 7271Sends a message on a socket. Attempts to send the scalar MSG to the SOCKET 7272filehandle. Takes the same flags as the system call of the same name. On 7273unconnected sockets, you must specify a destination to I<send to>, in which 7274case it does a L<sendto(2)> syscall. Returns the number of characters sent, 7275or the undefined value on error. The L<sendmsg(2)> syscall is currently 7276unimplemented. See L<perlipc/"UDP: Message Passing"> for examples. 7277 7278Note that if the socket has been marked as C<:utf8>, C<send> will 7279throw an exception. The C<:encoding(...)> layer implicitly introduces 7280the C<:utf8> layer. See L<C<binmode>|/binmode FILEHANDLE, LAYER>. 7281 7282=item setpgrp PID,PGRP 7283X<setpgrp> X<group> 7284 7285=for Pod::Functions set the process group of a process 7286 7287Sets the current process group for the specified PID, C<0> for the current 7288process. Raises an exception when used on a machine that doesn't 7289implement POSIX L<setpgid(2)> or BSD L<setpgrp(2)>. If the arguments 7290are omitted, it defaults to C<0,0>. Note that the BSD 4.2 version of 7291L<C<setpgrp>|/setpgrp PID,PGRP> does not accept any arguments, so only 7292C<setpgrp(0,0)> is portable. See also 7293L<C<POSIX::setsid()>|POSIX/C<setsid>>. 7294 7295Portability issues: L<perlport/setpgrp>. 7296 7297=item setpriority WHICH,WHO,PRIORITY 7298X<setpriority> X<priority> X<nice> X<renice> 7299 7300=for Pod::Functions set a process's nice value 7301 7302Sets the current priority for a process, a process group, or a user. 7303(See L<setpriority(2)>.) Raises an exception when used on a machine 7304that doesn't implement L<setpriority(2)>. 7305 7306C<WHICH> can be any of C<PRIO_PROCESS>, C<PRIO_PGRP> or C<PRIO_USER> 7307imported from L<POSIX/RESOURCE CONSTANTS>. 7308 7309Portability issues: L<perlport/setpriority>. 7310 7311=item setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL 7312X<setsockopt> 7313 7314=for Pod::Functions set some socket options 7315 7316Sets the socket option requested. Returns L<C<undef>|/undef EXPR> on 7317error. Use integer constants provided by the L<C<Socket>|Socket> module 7318for 7319LEVEL and OPNAME. Values for LEVEL can also be obtained from 7320getprotobyname. OPTVAL might either be a packed string or an integer. 7321An integer OPTVAL is shorthand for pack("i", OPTVAL). 7322 7323An example disabling Nagle's algorithm on a socket: 7324 7325 use Socket qw(IPPROTO_TCP TCP_NODELAY); 7326 setsockopt($socket, IPPROTO_TCP, TCP_NODELAY, 1); 7327 7328Portability issues: L<perlport/setsockopt>. 7329 7330=item shift ARRAY 7331X<shift> 7332 7333=item shift 7334 7335=for Pod::Functions remove the first element of an array, and return it 7336 7337Shifts the first value of the array off and returns it, shortening the 7338array by 1 and moving everything down. If there are no elements in the 7339array, returns the undefined value. If ARRAY is omitted, shifts the 7340L<C<@_>|perlvar/@_> array within the lexical scope of subroutines and 7341formats, and the L<C<@ARGV>|perlvar/@ARGV> array outside a subroutine 7342and also within the lexical scopes 7343established by the C<eval STRING>, C<BEGIN {}>, C<INIT {}>, C<CHECK {}>, 7344C<UNITCHECK {}>, and C<END {}> constructs. 7345 7346Starting with Perl 5.14, an experimental feature allowed 7347L<C<shift>|/shift ARRAY> to take a 7348scalar expression. This experiment has been deemed unsuccessful, and was 7349removed as of Perl 5.24. 7350 7351See also L<C<unshift>|/unshift ARRAY,LIST>, L<C<push>|/push ARRAY,LIST>, 7352and L<C<pop>|/pop ARRAY>. L<C<shift>|/shift ARRAY> and 7353L<C<unshift>|/unshift ARRAY,LIST> do the same thing to the left end of 7354an array that L<C<pop>|/pop ARRAY> and L<C<push>|/push ARRAY,LIST> do to 7355the right end. 7356 7357=item shmctl ID,CMD,ARG 7358X<shmctl> 7359 7360=for Pod::Functions SysV shared memory operations 7361 7362Calls the System V IPC function shmctl. You'll probably have to say 7363 7364 use IPC::SysV; 7365 7366first to get the correct constant definitions. If CMD is C<IPC_STAT>, 7367then ARG must be a variable that will hold the returned C<shmid_ds> 7368structure. Returns like ioctl: L<C<undef>|/undef EXPR> for error; "C<0> 7369but true" for zero; and the actual return value otherwise. 7370See also L<perlipc/"SysV IPC"> and the documentation for 7371L<C<IPC::SysV>|IPC::SysV>. 7372 7373Portability issues: L<perlport/shmctl>. 7374 7375=item shmget KEY,SIZE,FLAGS 7376X<shmget> 7377 7378=for Pod::Functions get SysV shared memory segment identifier 7379 7380Calls the System V IPC function shmget. Returns the shared memory 7381segment id, or L<C<undef>|/undef EXPR> on error. 7382See also L<perlipc/"SysV IPC"> and the documentation for 7383L<C<IPC::SysV>|IPC::SysV>. 7384 7385Portability issues: L<perlport/shmget>. 7386 7387=item shmread ID,VAR,POS,SIZE 7388X<shmread> 7389X<shmwrite> 7390 7391=for Pod::Functions read SysV shared memory 7392 7393=item shmwrite ID,STRING,POS,SIZE 7394 7395=for Pod::Functions write SysV shared memory 7396 7397Reads or writes the System V shared memory segment ID starting at 7398position POS for size SIZE by attaching to it, copying in/out, and 7399detaching from it. When reading, VAR must be a variable that will 7400hold the data read. When writing, if STRING is too long, only SIZE 7401bytes are used; if STRING is too short, nulls are written to fill out 7402SIZE bytes. Return true if successful, false on error. 7403L<C<shmread>|/shmread ID,VAR,POS,SIZE> taints the variable. See also 7404L<perlipc/"SysV IPC"> and the documentation for 7405L<C<IPC::SysV>|IPC::SysV> and the L<C<IPC::Shareable>|IPC::Shareable> 7406module from CPAN. 7407 7408Portability issues: L<perlport/shmread> and L<perlport/shmwrite>. 7409 7410=item shutdown SOCKET,HOW 7411X<shutdown> 7412 7413=for Pod::Functions close down just half of a socket connection 7414 7415Shuts down a socket connection in the manner indicated by HOW, which 7416has the same interpretation as in the syscall of the same name. 7417 7418 shutdown($socket, 0); # I/we have stopped reading data 7419 shutdown($socket, 1); # I/we have stopped writing data 7420 shutdown($socket, 2); # I/we have stopped using this socket 7421 7422This is useful with sockets when you want to tell the other 7423side you're done writing but not done reading, or vice versa. 7424It's also a more insistent form of close because it also 7425disables the file descriptor in any forked copies in other 7426processes. 7427 7428Returns C<1> for success; on error, returns L<C<undef>|/undef EXPR> if 7429the first argument is not a valid filehandle, or returns C<0> and sets 7430L<C<$!>|perlvar/$!> for any other failure. 7431 7432=item sin EXPR 7433X<sin> X<sine> X<asin> X<arcsine> 7434 7435=item sin 7436 7437=for Pod::Functions return the sine of a number 7438 7439Returns the sine of EXPR (expressed in radians). If EXPR is omitted, 7440returns sine of L<C<$_>|perlvar/$_>. 7441 7442For the inverse sine operation, you may use the C<Math::Trig::asin> 7443function, or use this relation: 7444 7445 sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) } 7446 7447=item sleep EXPR 7448X<sleep> X<pause> 7449 7450=item sleep 7451 7452=for Pod::Functions block for some number of seconds 7453 7454Causes the script to sleep for (integer) EXPR seconds, or forever if no 7455argument is given. Returns the integer number of seconds actually slept. 7456 7457EXPR should be a positive integer. If called with a negative integer, 7458L<C<sleep>|/sleep EXPR> does not sleep but instead emits a warning, sets 7459$! (C<errno>), and returns zero. 7460 7461C<sleep 0> is permitted, but a function call to the underlying platform 7462implementation still occurs, with any side effects that may have. 7463C<sleep 0> is therefore not exactly identical to not sleeping at all. 7464 7465May be interrupted if the process receives a signal such as C<SIGALRM>. 7466 7467 eval { 7468 local $SIG{ALRM} = sub { die "Alarm!\n" }; 7469 sleep; 7470 }; 7471 die $@ unless $@ eq "Alarm!\n"; 7472 7473You probably cannot mix L<C<alarm>|/alarm SECONDS> and 7474L<C<sleep>|/sleep EXPR> calls, because L<C<sleep>|/sleep EXPR> is often 7475implemented using L<C<alarm>|/alarm SECONDS>. 7476 7477On some older systems, it may sleep up to a full second less than what 7478you requested, depending on how it counts seconds. Most modern systems 7479always sleep the full amount. They may appear to sleep longer than that, 7480however, because your process might not be scheduled right away in a 7481busy multitasking system. 7482 7483For delays of finer granularity than one second, the L<Time::HiRes> 7484module (from CPAN, and starting from Perl 5.8 part of the standard 7485distribution) provides L<C<usleep>|Time::HiRes/usleep ( $useconds )>. 7486You may also use Perl's four-argument 7487version of L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> leaving the 7488first three arguments undefined, or you might be able to use the 7489L<C<syscall>|/syscall NUMBER, LIST> interface to access L<setitimer(2)> 7490if your system supports it. See L<perlfaq8> for details. 7491 7492See also the L<POSIX> module's L<C<pause>|POSIX/C<pause>> function. 7493 7494=item socket SOCKET,DOMAIN,TYPE,PROTOCOL 7495X<socket> 7496 7497=for Pod::Functions create a socket 7498 7499Opens a socket of the specified kind and attaches it to filehandle 7500SOCKET. DOMAIN, TYPE, and PROTOCOL are specified the same as for 7501the syscall of the same name. You should C<use Socket> first 7502to get the proper definitions imported. See the examples in 7503L<perlipc/"Sockets: Client/Server Communication">. 7504 7505On systems that support a close-on-exec flag on files, the flag will 7506be set for the newly opened file descriptor, as determined by the 7507value of L<C<$^F>|perlvar/$^F>. See L<perlvar/$^F>. 7508 7509=item socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL 7510X<socketpair> 7511 7512=for Pod::Functions create a pair of sockets 7513 7514Creates an unnamed pair of sockets in the specified domain, of the 7515specified type. DOMAIN, TYPE, and PROTOCOL are specified the same as 7516for the syscall of the same name. If unimplemented, raises an exception. 7517Returns true if successful. 7518 7519On systems that support a close-on-exec flag on files, the flag will 7520be set for the newly opened file descriptors, as determined by the value 7521of L<C<$^F>|perlvar/$^F>. See L<perlvar/$^F>. 7522 7523Some systems define L<C<pipe>|/pipe READHANDLE,WRITEHANDLE> in terms of 7524L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL>, in 7525which a call to C<pipe($rdr, $wtr)> is essentially: 7526 7527 use Socket; 7528 socketpair(my $rdr, my $wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC); 7529 shutdown($rdr, 1); # no more writing for reader 7530 shutdown($wtr, 0); # no more reading for writer 7531 7532See L<perlipc> for an example of socketpair use. Perl 5.8 and later will 7533emulate socketpair using IP sockets to localhost if your system implements 7534sockets but not socketpair. 7535 7536Portability issues: L<perlport/socketpair>. 7537 7538=item sort SUBNAME LIST 7539X<sort> 7540 7541=item sort BLOCK LIST 7542 7543=item sort LIST 7544 7545=for Pod::Functions sort a list of values 7546 7547In list context, this sorts the LIST and returns the sorted list value. 7548In scalar context, the behaviour of L<C<sort>|/sort SUBNAME LIST> is 7549undefined. 7550 7551If SUBNAME or BLOCK is omitted, L<C<sort>|/sort SUBNAME LIST>s in 7552standard string comparison 7553order. If SUBNAME is specified, it gives the name of a subroutine 7554that returns an integer less than, equal to, or greater than C<0>, 7555depending on how the elements of the list are to be ordered. (The 7556C<< <=> >> and C<cmp> operators are extremely useful in such routines.) 7557SUBNAME may be a scalar variable name (unsubscripted), in which case 7558the value provides the name of (or a reference to) the actual 7559subroutine to use. In place of a SUBNAME, you can provide a BLOCK as 7560an anonymous, in-line sort subroutine. 7561 7562If the subroutine's prototype is C<($$)>, the elements to be compared are 7563passed by reference in L<C<@_>|perlvar/@_>, as for a normal subroutine. 7564This is slower than unprototyped subroutines, where the elements to be 7565compared are passed into the subroutine as the package global variables 7566C<$a> and C<$b> (see example below). 7567 7568If the subroutine is an XSUB, the elements to be compared are pushed on 7569to the stack, the way arguments are usually passed to XSUBs. C<$a> and 7570C<$b> are not set. 7571 7572The values to be compared are always passed by reference and should not 7573be modified. 7574 7575You also cannot exit out of the sort block or subroutine using any of the 7576loop control operators described in L<perlsyn> or with 7577L<C<goto>|/goto LABEL>. 7578 7579When L<C<use locale>|locale> (but not C<use locale ':not_characters'>) 7580is in effect, C<sort LIST> sorts LIST according to the 7581current collation locale. See L<perllocale>. 7582 7583L<C<sort>|/sort SUBNAME LIST> returns aliases into the original list, 7584much as a for loop's index variable aliases the list elements. That is, 7585modifying an element of a list returned by L<C<sort>|/sort SUBNAME LIST> 7586(for example, in a C<foreach>, L<C<map>|/map BLOCK LIST> or 7587L<C<grep>|/grep BLOCK LIST>) 7588actually modifies the element in the original list. This is usually 7589something to be avoided when writing clear code. 7590 7591Historically Perl has varied in whether sorting is stable by default. 7592If stability matters, it can be controlled explicitly by using the 7593L<sort> pragma. 7594 7595Examples: 7596 7597 # sort lexically 7598 my @articles = sort @files; 7599 7600 # same thing, but with explicit sort routine 7601 my @articles = sort {$a cmp $b} @files; 7602 7603 # now case-insensitively 7604 my @articles = sort {fc($a) cmp fc($b)} @files; 7605 7606 # same thing in reversed order 7607 my @articles = sort {$b cmp $a} @files; 7608 7609 # sort numerically ascending 7610 my @articles = sort {$a <=> $b} @files; 7611 7612 # sort numerically descending 7613 my @articles = sort {$b <=> $a} @files; 7614 7615 # this sorts the %age hash by value instead of key 7616 # using an in-line function 7617 my @eldest = sort { $age{$b} <=> $age{$a} } keys %age; 7618 7619 # sort using explicit subroutine name 7620 sub byage { 7621 $age{$a} <=> $age{$b}; # presuming numeric 7622 } 7623 my @sortedclass = sort byage @class; 7624 7625 sub backwards { $b cmp $a } 7626 my @harry = qw(dog cat x Cain Abel); 7627 my @george = qw(gone chased yz Punished Axed); 7628 print sort @harry; 7629 # prints AbelCaincatdogx 7630 print sort backwards @harry; 7631 # prints xdogcatCainAbel 7632 print sort @george, 'to', @harry; 7633 # prints AbelAxedCainPunishedcatchaseddoggonetoxyz 7634 7635 # inefficiently sort by descending numeric compare using 7636 # the first integer after the first = sign, or the 7637 # whole record case-insensitively otherwise 7638 7639 my @new = sort { 7640 ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0] 7641 || 7642 fc($a) cmp fc($b) 7643 } @old; 7644 7645 # same thing, but much more efficiently; 7646 # we'll build auxiliary indices instead 7647 # for speed 7648 my (@nums, @caps); 7649 for (@old) { 7650 push @nums, ( /=(\d+)/ ? $1 : undef ); 7651 push @caps, fc($_); 7652 } 7653 7654 my @new = @old[ sort { 7655 $nums[$b] <=> $nums[$a] 7656 || 7657 $caps[$a] cmp $caps[$b] 7658 } 0..$#old 7659 ]; 7660 7661 # same thing, but without any temps 7662 my @new = map { $_->[0] } 7663 sort { $b->[1] <=> $a->[1] 7664 || 7665 $a->[2] cmp $b->[2] 7666 } map { [$_, /=(\d+)/, fc($_)] } @old; 7667 7668 # using a prototype allows you to use any comparison subroutine 7669 # as a sort subroutine (including other package's subroutines) 7670 package Other; 7671 sub backwards ($$) { $_[1] cmp $_[0]; } # $a and $b are 7672 # not set here 7673 package main; 7674 my @new = sort Other::backwards @old; 7675 7676 # guarantee stability 7677 use sort 'stable'; 7678 my @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old; 7679 7680Warning: syntactical care is required when sorting the list returned from 7681a function. If you want to sort the list returned by the function call 7682C<find_records(@key)>, you can use: 7683 7684 my @contact = sort { $a cmp $b } find_records @key; 7685 my @contact = sort +find_records(@key); 7686 my @contact = sort &find_records(@key); 7687 my @contact = sort(find_records(@key)); 7688 7689If instead you want to sort the array C<@key> with the comparison routine 7690C<find_records()> then you can use: 7691 7692 my @contact = sort { find_records() } @key; 7693 my @contact = sort find_records(@key); 7694 my @contact = sort(find_records @key); 7695 my @contact = sort(find_records (@key)); 7696 7697C<$a> and C<$b> are set as package globals in the package the sort() is 7698called from. That means C<$main::a> and C<$main::b> (or C<$::a> and 7699C<$::b>) in the C<main> package, C<$FooPack::a> and C<$FooPack::b> in the 7700C<FooPack> package, etc. If the sort block is in scope of a C<my> or 7701C<state> declaration of C<$a> and/or C<$b>, you I<must> spell out the full 7702name of the variables in the sort block : 7703 7704 package main; 7705 my $a = "C"; # DANGER, Will Robinson, DANGER !!! 7706 7707 print sort { $a cmp $b } qw(A C E G B D F H); 7708 # WRONG 7709 sub badlexi { $a cmp $b } 7710 print sort badlexi qw(A C E G B D F H); 7711 # WRONG 7712 # the above prints BACFEDGH or some other incorrect ordering 7713 7714 print sort { $::a cmp $::b } qw(A C E G B D F H); 7715 # OK 7716 print sort { our $a cmp our $b } qw(A C E G B D F H); 7717 # also OK 7718 print sort { our ($a, $b); $a cmp $b } qw(A C E G B D F H); 7719 # also OK 7720 sub lexi { our $a cmp our $b } 7721 print sort lexi qw(A C E G B D F H); 7722 # also OK 7723 # the above print ABCDEFGH 7724 7725With proper care you may mix package and my (or state) C<$a> and/or C<$b>: 7726 7727 my $a = { 7728 tiny => -2, 7729 small => -1, 7730 normal => 0, 7731 big => 1, 7732 huge => 2 7733 }; 7734 7735 say sort { $a->{our $a} <=> $a->{our $b} } 7736 qw{ huge normal tiny small big}; 7737 7738 # prints tinysmallnormalbighuge 7739 7740C<$a> and C<$b> are implicitly local to the sort() execution and regain their 7741former values upon completing the sort. 7742 7743Sort subroutines written using C<$a> and C<$b> are bound to their calling 7744package. It is possible, but of limited interest, to define them in a 7745different package, since the subroutine must still refer to the calling 7746package's C<$a> and C<$b> : 7747 7748 package Foo; 7749 sub lexi { $Bar::a cmp $Bar::b } 7750 package Bar; 7751 ... sort Foo::lexi ... 7752 7753Use the prototyped versions (see above) for a more generic alternative. 7754 7755The comparison function is required to behave. If it returns 7756inconsistent results (sometimes saying C<$x[1]> is less than C<$x[2]> and 7757sometimes saying the opposite, for example) the results are not 7758well-defined. 7759 7760Because C<< <=> >> returns L<C<undef>|/undef EXPR> when either operand 7761is C<NaN> (not-a-number), be careful when sorting with a 7762comparison function like C<< $a <=> $b >> any lists that might contain a 7763C<NaN>. The following example takes advantage that C<NaN != NaN> to 7764eliminate any C<NaN>s from the input list. 7765 7766 my @result = sort { $a <=> $b } grep { $_ == $_ } @input; 7767 7768In this version of F<perl>, the C<sort> function is implemented via the 7769mergesort algorithm. 7770 7771=item splice ARRAY,OFFSET,LENGTH,LIST 7772X<splice> 7773 7774=item splice ARRAY,OFFSET,LENGTH 7775 7776=item splice ARRAY,OFFSET 7777 7778=item splice ARRAY 7779 7780=for Pod::Functions add or remove elements anywhere in an array 7781 7782Removes the elements designated by OFFSET and LENGTH from an array, and 7783replaces them with the elements of LIST, if any. In list context, 7784returns the elements removed from the array. In scalar context, 7785returns the last element removed, or L<C<undef>|/undef EXPR> if no 7786elements are 7787removed. The array grows or shrinks as necessary. 7788If OFFSET is negative then it starts that far from the end of the array. 7789If LENGTH is omitted, removes everything from OFFSET onward. 7790If LENGTH is negative, removes the elements from OFFSET onward 7791except for -LENGTH elements at the end of the array. 7792If both OFFSET and LENGTH are omitted, removes everything. If OFFSET is 7793past the end of the array and a LENGTH was provided, Perl issues a warning, 7794and splices at the end of the array. 7795 7796The following equivalences hold (assuming C<< $#a >= $i >> ) 7797 7798 push(@a,$x,$y) splice(@a,@a,0,$x,$y) 7799 pop(@a) splice(@a,-1) 7800 shift(@a) splice(@a,0,1) 7801 unshift(@a,$x,$y) splice(@a,0,0,$x,$y) 7802 $a[$i] = $y splice(@a,$i,1,$y) 7803 7804L<C<splice>|/splice ARRAY,OFFSET,LENGTH,LIST> can be used, for example, 7805to implement n-ary queue processing: 7806 7807 sub nary_print { 7808 my $n = shift; 7809 while (my @next_n = splice @_, 0, $n) { 7810 say join q{ -- }, @next_n; 7811 } 7812 } 7813 7814 nary_print(3, qw(a b c d e f g h)); 7815 # prints: 7816 # a -- b -- c 7817 # d -- e -- f 7818 # g -- h 7819 7820Starting with Perl 5.14, an experimental feature allowed 7821L<C<splice>|/splice ARRAY,OFFSET,LENGTH,LIST> to take a 7822scalar expression. This experiment has been deemed unsuccessful, and was 7823removed as of Perl 5.24. 7824 7825=item split /PATTERN/,EXPR,LIMIT 7826X<split> 7827 7828=item split /PATTERN/,EXPR 7829 7830=item split /PATTERN/ 7831 7832=item split 7833 7834=for Pod::Functions split up a string using a regexp delimiter 7835 7836Splits the string EXPR into a list of strings and returns the 7837list in list context, or the size of the list in scalar context. 7838(Prior to Perl 5.11, it also overwrote C<@_> with the list in 7839void and scalar context. If you target old perls, beware.) 7840 7841If only PATTERN is given, EXPR defaults to L<C<$_>|perlvar/$_>. 7842 7843Anything in EXPR that matches PATTERN is taken to be a separator 7844that separates the EXPR into substrings (called "I<fields>") that 7845do B<not> include the separator. Note that a separator may be 7846longer than one character or even have no characters at all (the 7847empty string, which is a zero-width match). 7848 7849The PATTERN need not be constant; an expression may be used 7850to specify a pattern that varies at runtime. 7851 7852If PATTERN matches the empty string, the EXPR is split at the match 7853position (between characters). As an example, the following: 7854 7855 my @x = split(/b/, "abc"); # ("a", "c") 7856 7857uses the C<b> in C<'abc'> as a separator to produce the list ("a", "c"). 7858However, this: 7859 7860 my @x = split(//, "abc"); # ("a", "b", "c") 7861 7862uses empty string matches as separators; thus, the empty string 7863may be used to split EXPR into a list of its component characters. 7864 7865As a special case for L<C<split>|/split E<sol>PATTERNE<sol>,EXPR,LIMIT>, 7866the empty pattern given in 7867L<match operator|perlop/"m/PATTERN/msixpodualngc"> syntax (C<//>) 7868specifically matches the empty string, which is contrary to its usual 7869interpretation as the last successful match. 7870 7871If PATTERN is C</^/>, then it is treated as if it used the 7872L<multiline modifier|perlreref/OPERATORS> (C</^/m>), since it 7873isn't much use otherwise. 7874 7875C<E<sol>m> and any of the other pattern modifiers valid for C<qr> 7876(summarized in L<perlop/qrE<sol>STRINGE<sol>msixpodualn>) may be 7877specified explicitly. 7878 7879As another special case, 7880L<C<split>|/split E<sol>PATTERNE<sol>,EXPR,LIMIT> emulates the default 7881behavior of the 7882command line tool B<awk> when the PATTERN is either omitted or a 7883string composed of a single space character (such as S<C<' '>> or 7884S<C<"\x20">>, but not e.g. S<C</ />>). In this case, any leading 7885whitespace in EXPR is removed before splitting occurs, and the PATTERN is 7886instead treated as if it were C</\s+/>; in particular, this means that 7887I<any> contiguous whitespace (not just a single space character) is used as 7888a separator. 7889 7890 my @x = split(" ", " Quick brown fox\n"); 7891 # ("Quick", "brown", "fox") 7892 7893 my @x = split(" ", "RED\tGREEN\tBLUE"); 7894 # ("RED", "GREEN", "BLUE") 7895 7896Using split in this fashion is very similar to how 7897L<C<qwE<sol>E<sol>>|/qwE<sol>STRINGE<sol>> works. 7898 7899However, this special treatment can be avoided by specifying 7900the pattern S<C</ />> instead of the string S<C<" ">>, thereby allowing 7901only a single space character to be a separator. In earlier Perls this 7902special case was restricted to the use of a plain S<C<" ">> as the 7903pattern argument to split; in Perl 5.18.0 and later this special case is 7904triggered by any expression which evaluates to the simple string S<C<" ">>. 7905 7906As of Perl 5.28, this special-cased whitespace splitting works as expected in 7907the scope of L<< S<C<"use feature 'unicode_strings'">>|feature/The 7908'unicode_strings' feature >>. In previous versions, and outside the scope of 7909that feature, it exhibits L<perlunicode/The "Unicode Bug">: characters that are 7910whitespace according to Unicode rules but not according to ASCII rules can be 7911treated as part of fields rather than as field separators, depending on the 7912string's internal encoding. 7913 7914If omitted, PATTERN defaults to a single space, S<C<" ">>, triggering 7915the previously described I<awk> emulation. 7916 7917If LIMIT is specified and positive, it represents the maximum number 7918of fields into which the EXPR may be split; in other words, LIMIT is 7919one greater than the maximum number of times EXPR may be split. Thus, 7920the LIMIT value C<1> means that EXPR may be split a maximum of zero 7921times, producing a maximum of one field (namely, the entire value of 7922EXPR). For instance: 7923 7924 my @x = split(//, "abc", 1); # ("abc") 7925 my @x = split(//, "abc", 2); # ("a", "bc") 7926 my @x = split(//, "abc", 3); # ("a", "b", "c") 7927 my @x = split(//, "abc", 4); # ("a", "b", "c") 7928 7929If LIMIT is negative, it is treated as if it were instead arbitrarily 7930large; as many fields as possible are produced. 7931 7932If LIMIT is omitted (or, equivalently, zero), then it is usually 7933treated as if it were instead negative but with the exception that 7934trailing empty fields are stripped (empty leading fields are always 7935preserved); if all fields are empty, then all fields are considered to 7936be trailing (and are thus stripped in this case). Thus, the following: 7937 7938 my @x = split(/,/, "a,b,c,,,"); # ("a", "b", "c") 7939 7940produces only a three element list. 7941 7942 my @x = split(/,/, "a,b,c,,,", -1); # ("a", "b", "c", "", "", "") 7943 7944produces a six element list. 7945 7946In time-critical applications, it is worthwhile to avoid splitting 7947into more fields than necessary. Thus, when assigning to a list, 7948if LIMIT is omitted (or zero), then LIMIT is treated as though it 7949were one larger than the number of variables in the list; for the 7950following, LIMIT is implicitly 3: 7951 7952 my ($login, $passwd) = split(/:/); 7953 7954Note that splitting an EXPR that evaluates to the empty string always 7955produces zero fields, regardless of the LIMIT specified. 7956 7957An empty leading field is produced when there is a positive-width 7958match at the beginning of EXPR. For instance: 7959 7960 my @x = split(/ /, " abc"); # ("", "abc") 7961 7962splits into two elements. However, a zero-width match at the 7963beginning of EXPR never produces an empty field, so that: 7964 7965 my @x = split(//, " abc"); # (" ", "a", "b", "c") 7966 7967splits into four elements instead of five. 7968 7969An empty trailing field, on the other hand, is produced when there is a 7970match at the end of EXPR, regardless of the length of the match 7971(of course, unless a non-zero LIMIT is given explicitly, such fields are 7972removed, as in the last example). Thus: 7973 7974 my @x = split(//, " abc", -1); # (" ", "a", "b", "c", "") 7975 7976If the PATTERN contains 7977L<capturing groups|perlretut/Grouping things and hierarchical matching>, 7978then for each separator, an additional field is produced for each substring 7979captured by a group (in the order in which the groups are specified, 7980as per L<backreferences|perlretut/Backreferences>); if any group does not 7981match, then it captures the L<C<undef>|/undef EXPR> value instead of a 7982substring. Also, 7983note that any such additional field is produced whenever there is a 7984separator (that is, whenever a split occurs), and such an additional field 7985does B<not> count towards the LIMIT. Consider the following expressions 7986evaluated in list context (each returned list is provided in the associated 7987comment): 7988 7989 my @x = split(/-|,/ , "1-10,20", 3); 7990 # ("1", "10", "20") 7991 7992 my @x = split(/(-|,)/ , "1-10,20", 3); 7993 # ("1", "-", "10", ",", "20") 7994 7995 my @x = split(/-|(,)/ , "1-10,20", 3); 7996 # ("1", undef, "10", ",", "20") 7997 7998 my @x = split(/(-)|,/ , "1-10,20", 3); 7999 # ("1", "-", "10", undef, "20") 8000 8001 my @x = split(/(-)|(,)/, "1-10,20", 3); 8002 # ("1", "-", undef, "10", undef, ",", "20") 8003 8004=item sprintf FORMAT, LIST 8005X<sprintf> 8006 8007=for Pod::Functions formatted print into a string 8008 8009Returns a string formatted by the usual 8010L<C<printf>|/printf FILEHANDLE FORMAT, LIST> conventions of the C 8011library function L<C<sprintf>|/sprintf FORMAT, LIST>. See below for 8012more details and see L<sprintf(3)> or L<printf(3)> on your system for an 8013explanation of the general principles. 8014 8015For example: 8016 8017 # Format number with up to 8 leading zeroes 8018 my $result = sprintf("%08d", $number); 8019 8020 # Round number to 3 digits after decimal point 8021 my $rounded = sprintf("%.3f", $number); 8022 8023Perl does its own L<C<sprintf>|/sprintf FORMAT, LIST> formatting: it 8024emulates the C 8025function L<sprintf(3)>, but doesn't use it except for floating-point 8026numbers, and even then only standard modifiers are allowed. 8027Non-standard extensions in your local L<sprintf(3)> are 8028therefore unavailable from Perl. 8029 8030Unlike L<C<printf>|/printf FILEHANDLE FORMAT, LIST>, 8031L<C<sprintf>|/sprintf FORMAT, LIST> does not do what you probably mean 8032when you pass it an array as your first argument. 8033The array is given scalar context, 8034and instead of using the 0th element of the array as the format, Perl will 8035use the count of elements in the array as the format, which is almost never 8036useful. 8037 8038Perl's L<C<sprintf>|/sprintf FORMAT, LIST> permits the following 8039universally-known conversions: 8040 8041 %% a percent sign 8042 %c a character with the given number 8043 %s a string 8044 %d a signed integer, in decimal 8045 %u an unsigned integer, in decimal 8046 %o an unsigned integer, in octal 8047 %x an unsigned integer, in hexadecimal 8048 %e a floating-point number, in scientific notation 8049 %f a floating-point number, in fixed decimal notation 8050 %g a floating-point number, in %e or %f notation 8051 8052In addition, Perl permits the following widely-supported conversions: 8053 8054 %X like %x, but using upper-case letters 8055 %E like %e, but using an upper-case "E" 8056 %G like %g, but with an upper-case "E" (if applicable) 8057 %b an unsigned integer, in binary 8058 %B like %b, but using an upper-case "B" with the # flag 8059 %p a pointer (outputs the Perl value's address in hexadecimal) 8060 %n special: *stores* the number of characters output so far 8061 into the next argument in the parameter list 8062 %a hexadecimal floating point 8063 %A like %a, but using upper-case letters 8064 8065Finally, for backward (and we do mean "backward") compatibility, Perl 8066permits these unnecessary but widely-supported conversions: 8067 8068 %i a synonym for %d 8069 %D a synonym for %ld 8070 %U a synonym for %lu 8071 %O a synonym for %lo 8072 %F a synonym for %f 8073 8074Note that the number of exponent digits in the scientific notation produced 8075by C<%e>, C<%E>, C<%g> and C<%G> for numbers with the modulus of the 8076exponent less than 100 is system-dependent: it may be three or less 8077(zero-padded as necessary). In other words, 1.23 times ten to the 807899th may be either "1.23e99" or "1.23e099". Similarly for C<%a> and C<%A>: 8079the exponent or the hexadecimal digits may float: especially the 8080"long doubles" Perl configuration option may cause surprises. 8081 8082Between the C<%> and the format letter, you may specify several 8083additional attributes controlling the interpretation of the format. 8084In order, these are: 8085 8086=over 4 8087 8088=item format parameter index 8089 8090An explicit format parameter index, such as C<2$>. By default sprintf 8091will format the next unused argument in the list, but this allows you 8092to take the arguments out of order: 8093 8094 printf '%2$d %1$d', 12, 34; # prints "34 12" 8095 printf '%3$d %d %1$d', 1, 2, 3; # prints "3 1 1" 8096 8097=item flags 8098 8099one or more of: 8100 8101 space prefix non-negative number with a space 8102 + prefix non-negative number with a plus sign 8103 - left-justify within the field 8104 0 use zeros, not spaces, to right-justify 8105 # ensure the leading "0" for any octal, 8106 prefix non-zero hexadecimal with "0x" or "0X", 8107 prefix non-zero binary with "0b" or "0B" 8108 8109For example: 8110 8111 printf '<% d>', 12; # prints "< 12>" 8112 printf '<% d>', 0; # prints "< 0>" 8113 printf '<% d>', -12; # prints "<-12>" 8114 printf '<%+d>', 12; # prints "<+12>" 8115 printf '<%+d>', 0; # prints "<+0>" 8116 printf '<%+d>', -12; # prints "<-12>" 8117 printf '<%6s>', 12; # prints "< 12>" 8118 printf '<%-6s>', 12; # prints "<12 >" 8119 printf '<%06s>', 12; # prints "<000012>" 8120 printf '<%#o>', 12; # prints "<014>" 8121 printf '<%#x>', 12; # prints "<0xc>" 8122 printf '<%#X>', 12; # prints "<0XC>" 8123 printf '<%#b>', 12; # prints "<0b1100>" 8124 printf '<%#B>', 12; # prints "<0B1100>" 8125 8126When a space and a plus sign are given as the flags at once, 8127the space is ignored. 8128 8129 printf '<%+ d>', 12; # prints "<+12>" 8130 printf '<% +d>', 12; # prints "<+12>" 8131 8132When the # flag and a precision are given in the %o conversion, 8133the precision is incremented if it's necessary for the leading "0". 8134 8135 printf '<%#.5o>', 012; # prints "<00012>" 8136 printf '<%#.5o>', 012345; # prints "<012345>" 8137 printf '<%#.0o>', 0; # prints "<0>" 8138 8139=item vector flag 8140 8141This flag tells Perl to interpret the supplied string as a vector of 8142integers, one for each character in the string. Perl applies the format to 8143each integer in turn, then joins the resulting strings with a separator (a 8144dot C<.> by default). This can be useful for displaying ordinal values of 8145characters in arbitrary strings: 8146 8147 printf "%vd", "AB\x{100}"; # prints "65.66.256" 8148 printf "version is v%vd\n", $^V; # Perl's version 8149 8150Put an asterisk C<*> before the C<v> to override the string to 8151use to separate the numbers: 8152 8153 printf "address is %*vX\n", ":", $addr; # IPv6 address 8154 printf "bits are %0*v8b\n", " ", $bits; # random bitstring 8155 8156You can also explicitly specify the argument number to use for 8157the join string using something like C<*2$v>; for example: 8158 8159 printf '%*4$vX %*4$vX %*4$vX', # 3 IPv6 addresses 8160 @addr[1..3], ":"; 8161 8162=item (minimum) width 8163 8164Arguments are usually formatted to be only as wide as required to 8165display the given value. You can override the width by putting 8166a number here, or get the width from the next argument (with C<*>) 8167or from a specified argument (e.g., with C<*2$>): 8168 8169 printf "<%s>", "a"; # prints "<a>" 8170 printf "<%6s>", "a"; # prints "< a>" 8171 printf "<%*s>", 6, "a"; # prints "< a>" 8172 printf '<%*2$s>', "a", 6; # prints "< a>" 8173 printf "<%2s>", "long"; # prints "<long>" (does not truncate) 8174 8175If a field width obtained through C<*> is negative, it has the same 8176effect as the C<-> flag: left-justification. 8177 8178=item precision, or maximum width 8179X<precision> 8180 8181You can specify a precision (for numeric conversions) or a maximum 8182width (for string conversions) by specifying a C<.> followed by a number. 8183For floating-point formats except C<g> and C<G>, this specifies 8184how many places right of the decimal point to show (the default being 6). 8185For example: 8186 8187 # these examples are subject to system-specific variation 8188 printf '<%f>', 1; # prints "<1.000000>" 8189 printf '<%.1f>', 1; # prints "<1.0>" 8190 printf '<%.0f>', 1; # prints "<1>" 8191 printf '<%e>', 10; # prints "<1.000000e+01>" 8192 printf '<%.1e>', 10; # prints "<1.0e+01>" 8193 8194For "g" and "G", this specifies the maximum number of significant digits to 8195show; for example: 8196 8197 # These examples are subject to system-specific variation. 8198 printf '<%g>', 1; # prints "<1>" 8199 printf '<%.10g>', 1; # prints "<1>" 8200 printf '<%g>', 100; # prints "<100>" 8201 printf '<%.1g>', 100; # prints "<1e+02>" 8202 printf '<%.2g>', 100.01; # prints "<1e+02>" 8203 printf '<%.5g>', 100.01; # prints "<100.01>" 8204 printf '<%.4g>', 100.01; # prints "<100>" 8205 printf '<%.1g>', 0.0111; # prints "<0.01>" 8206 printf '<%.2g>', 0.0111; # prints "<0.011>" 8207 printf '<%.3g>', 0.0111; # prints "<0.0111>" 8208 8209For integer conversions, specifying a precision implies that the 8210output of the number itself should be zero-padded to this width, 8211where the 0 flag is ignored: 8212 8213 printf '<%.6d>', 1; # prints "<000001>" 8214 printf '<%+.6d>', 1; # prints "<+000001>" 8215 printf '<%-10.6d>', 1; # prints "<000001 >" 8216 printf '<%10.6d>', 1; # prints "< 000001>" 8217 printf '<%010.6d>', 1; # prints "< 000001>" 8218 printf '<%+10.6d>', 1; # prints "< +000001>" 8219 8220 printf '<%.6x>', 1; # prints "<000001>" 8221 printf '<%#.6x>', 1; # prints "<0x000001>" 8222 printf '<%-10.6x>', 1; # prints "<000001 >" 8223 printf '<%10.6x>', 1; # prints "< 000001>" 8224 printf '<%010.6x>', 1; # prints "< 000001>" 8225 printf '<%#10.6x>', 1; # prints "< 0x000001>" 8226 8227For string conversions, specifying a precision truncates the string 8228to fit the specified width: 8229 8230 printf '<%.5s>', "truncated"; # prints "<trunc>" 8231 printf '<%10.5s>', "truncated"; # prints "< trunc>" 8232 8233You can also get the precision from the next argument using C<.*>, or from a 8234specified argument (e.g., with C<.*2$>): 8235 8236 printf '<%.6x>', 1; # prints "<000001>" 8237 printf '<%.*x>', 6, 1; # prints "<000001>" 8238 8239 printf '<%.*2$x>', 1, 6; # prints "<000001>" 8240 8241 printf '<%6.*2$x>', 1, 4; # prints "< 0001>" 8242 8243If a precision obtained through C<*> is negative, it counts 8244as having no precision at all. 8245 8246 printf '<%.*s>', 7, "string"; # prints "<string>" 8247 printf '<%.*s>', 3, "string"; # prints "<str>" 8248 printf '<%.*s>', 0, "string"; # prints "<>" 8249 printf '<%.*s>', -1, "string"; # prints "<string>" 8250 8251 printf '<%.*d>', 1, 0; # prints "<0>" 8252 printf '<%.*d>', 0, 0; # prints "<>" 8253 printf '<%.*d>', -1, 0; # prints "<0>" 8254 8255=item size 8256 8257For numeric conversions, you can specify the size to interpret the 8258number as using C<l>, C<h>, C<V>, C<q>, C<L>, or C<ll>. For integer 8259conversions (C<d u o x X b i D U O>), numbers are usually assumed to be 8260whatever the default integer size is on your platform (usually 32 or 64 8261bits), but you can override this to use instead one of the standard C types, 8262as supported by the compiler used to build Perl: 8263 8264 hh interpret integer as C type "char" or "unsigned 8265 char" on Perl 5.14 or later 8266 h interpret integer as C type "short" or 8267 "unsigned short" 8268 j interpret integer as C type "intmax_t" on Perl 8269 5.14 or later; and prior to Perl 5.30, only with 8270 a C99 compiler (unportable) 8271 l interpret integer as C type "long" or 8272 "unsigned long" 8273 q, L, or ll interpret integer as C type "long long", 8274 "unsigned long long", or "quad" (typically 8275 64-bit integers) 8276 t interpret integer as C type "ptrdiff_t" on Perl 8277 5.14 or later 8278 z interpret integer as C types "size_t" or 8279 "ssize_t" on Perl 5.14 or later 8280 8281Note that, in general, using the C<l> modifier (for example, when writing 8282C<"%ld"> or C<"%lu"> instead of C<"%d"> and C<"%u">) is unnecessary 8283when used from Perl code. Moreover, it may be harmful, for example on 8284Windows 64-bit where a long is 32-bits. 8285 8286As of 5.14, none of these raises an exception if they are not supported on 8287your platform. However, if warnings are enabled, a warning of the 8288L<C<printf>|warnings> warning class is issued on an unsupported 8289conversion flag. Should you instead prefer an exception, do this: 8290 8291 use warnings FATAL => "printf"; 8292 8293If you would like to know about a version dependency before you 8294start running the program, put something like this at its top: 8295 8296 use 5.014; # for hh/j/t/z/ printf modifiers 8297 8298You can find out whether your Perl supports quads via L<Config>: 8299 8300 use Config; 8301 if ($Config{use64bitint} eq "define" 8302 || $Config{longsize} >= 8) { 8303 print "Nice quads!\n"; 8304 } 8305 8306For floating-point conversions (C<e f g E F G>), numbers are usually assumed 8307to be the default floating-point size on your platform (double or long double), 8308but you can force "long double" with C<q>, C<L>, or C<ll> if your 8309platform supports them. You can find out whether your Perl supports long 8310doubles via L<Config>: 8311 8312 use Config; 8313 print "long doubles\n" if $Config{d_longdbl} eq "define"; 8314 8315You can find out whether Perl considers "long double" to be the default 8316floating-point size to use on your platform via L<Config>: 8317 8318 use Config; 8319 if ($Config{uselongdouble} eq "define") { 8320 print "long doubles by default\n"; 8321 } 8322 8323It can also be that long doubles and doubles are the same thing: 8324 8325 use Config; 8326 ($Config{doublesize} == $Config{longdblsize}) && 8327 print "doubles are long doubles\n"; 8328 8329The size specifier C<V> has no effect for Perl code, but is supported for 8330compatibility with XS code. It means "use the standard size for a Perl 8331integer or floating-point number", which is the default. 8332 8333=item order of arguments 8334 8335Normally, L<C<sprintf>|/sprintf FORMAT, LIST> takes the next unused 8336argument as the value to 8337format for each format specification. If the format specification 8338uses C<*> to require additional arguments, these are consumed from 8339the argument list in the order they appear in the format 8340specification I<before> the value to format. Where an argument is 8341specified by an explicit index, this does not affect the normal 8342order for the arguments, even when the explicitly specified index 8343would have been the next argument. 8344 8345So: 8346 8347 printf "<%*.*s>", $a, $b, $c; 8348 8349uses C<$a> for the width, C<$b> for the precision, and C<$c> 8350as the value to format; while: 8351 8352 printf '<%*1$.*s>', $a, $b; 8353 8354would use C<$a> for the width and precision, and C<$b> as the 8355value to format. 8356 8357Here are some more examples; be aware that when using an explicit 8358index, the C<$> may need escaping: 8359 8360 printf "%2\$d %d\n", 12, 34; # will print "34 12\n" 8361 printf "%2\$d %d %d\n", 12, 34; # will print "34 12 34\n" 8362 printf "%3\$d %d %d\n", 12, 34, 56; # will print "56 12 34\n" 8363 printf "%2\$*3\$d %d\n", 12, 34, 3; # will print " 34 12\n" 8364 printf "%*1\$.*f\n", 4, 5, 10; # will print "5.0000\n" 8365 8366=back 8367 8368If L<C<use locale>|locale> (including C<use locale ':not_characters'>) 8369is in effect and L<C<POSIX::setlocale>|POSIX/C<setlocale>> has been 8370called, 8371the character used for the decimal separator in formatted floating-point 8372numbers is affected by the C<LC_NUMERIC> locale. See L<perllocale> 8373and L<POSIX>. 8374 8375=item sqrt EXPR 8376X<sqrt> X<root> X<square root> 8377 8378=item sqrt 8379 8380=for Pod::Functions square root function 8381 8382Return the positive square root of EXPR. If EXPR is omitted, uses 8383L<C<$_>|perlvar/$_>. Works only for non-negative operands unless you've 8384loaded the L<C<Math::Complex>|Math::Complex> module. 8385 8386 use Math::Complex; 8387 print sqrt(-4); # prints 2i 8388 8389=item srand EXPR 8390X<srand> X<seed> X<randseed> 8391 8392=item srand 8393 8394=for Pod::Functions seed the random number generator 8395 8396Sets and returns the random number seed for the L<C<rand>|/rand EXPR> 8397operator. 8398 8399The point of the function is to "seed" the L<C<rand>|/rand EXPR> 8400function so that L<C<rand>|/rand EXPR> can produce a different sequence 8401each time you run your program. When called with a parameter, 8402L<C<srand>|/srand EXPR> uses that for the seed; otherwise it 8403(semi-)randomly chooses a seed. In either case, starting with Perl 5.14, 8404it returns the seed. To signal that your code will work I<only> on Perls 8405of a recent vintage: 8406 8407 use 5.014; # so srand returns the seed 8408 8409If L<C<srand>|/srand EXPR> is not called explicitly, it is called 8410implicitly without a parameter at the first use of the 8411L<C<rand>|/rand EXPR> operator. However, there are a few situations 8412where programs are likely to want to call L<C<srand>|/srand EXPR>. One 8413is for generating predictable results, generally for testing or 8414debugging. There, you use C<srand($seed)>, with the same C<$seed> each 8415time. Another case is that you may want to call L<C<srand>|/srand EXPR> 8416after a L<C<fork>|/fork> to avoid child processes sharing the same seed 8417value as the parent (and consequently each other). 8418 8419Do B<not> call C<srand()> (i.e., without an argument) more than once per 8420process. The internal state of the random number generator should 8421contain more entropy than can be provided by any seed, so calling 8422L<C<srand>|/srand EXPR> again actually I<loses> randomness. 8423 8424Most implementations of L<C<srand>|/srand EXPR> take an integer and will 8425silently 8426truncate decimal numbers. This means C<srand(42)> will usually 8427produce the same results as C<srand(42.1)>. To be safe, always pass 8428L<C<srand>|/srand EXPR> an integer. 8429 8430A typical use of the returned seed is for a test program which has too many 8431combinations to test comprehensively in the time available to it each run. It 8432can test a random subset each time, and should there be a failure, log the seed 8433used for that run so that it can later be used to reproduce the same results. 8434 8435B<L<C<rand>|/rand EXPR> is not cryptographically secure. You should not rely 8436on it in security-sensitive situations.> As of this writing, a 8437number of third-party CPAN modules offer random number generators 8438intended by their authors to be cryptographically secure, 8439including: L<Data::Entropy>, L<Crypt::Random>, L<Math::Random::Secure>, 8440and L<Math::TrulyRandom>. 8441 8442=item stat FILEHANDLE 8443X<stat> X<file, status> X<ctime> 8444 8445=item stat EXPR 8446 8447=item stat DIRHANDLE 8448 8449=item stat 8450 8451=for Pod::Functions get a file's status information 8452 8453Returns a 13-element list giving the status info for a file, either 8454the file opened via FILEHANDLE or DIRHANDLE, or named by EXPR. If EXPR is 8455omitted, it stats L<C<$_>|perlvar/$_> (not C<_>!). Returns the empty 8456list if L<C<stat>|/stat FILEHANDLE> fails. Typically 8457used as follows: 8458 8459 my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size, 8460 $atime,$mtime,$ctime,$blksize,$blocks) 8461 = stat($filename); 8462 8463Not all fields are supported on all filesystem types. Here are the 8464meanings of the fields: 8465 8466 0 dev device number of filesystem 8467 1 ino inode number 8468 2 mode file mode (type and permissions) 8469 3 nlink number of (hard) links to the file 8470 4 uid numeric user ID of file's owner 8471 5 gid numeric group ID of file's owner 8472 6 rdev the device identifier (special files only) 8473 7 size total size of file, in bytes 8474 8 atime last access time in seconds since the epoch 8475 9 mtime last modify time in seconds since the epoch 8476 10 ctime inode change time in seconds since the epoch (*) 8477 11 blksize preferred I/O size in bytes for interacting with the 8478 file (may vary from file to file) 8479 12 blocks actual number of system-specific blocks allocated 8480 on disk (often, but not always, 512 bytes each) 8481 8482(The epoch was at 00:00 January 1, 1970 GMT.) 8483 8484(*) Not all fields are supported on all filesystem types. Notably, the 8485ctime field is non-portable. In particular, you cannot expect it to be a 8486"creation time"; see L<perlport/"Files and Filesystems"> for details. 8487 8488If L<C<stat>|/stat FILEHANDLE> is passed the special filehandle 8489consisting of an underline, no stat is done, but the current contents of 8490the stat structure from the last L<C<stat>|/stat FILEHANDLE>, 8491L<C<lstat>|/lstat FILEHANDLE>, or filetest are returned. Example: 8492 8493 if (-x $file && (($d) = stat(_)) && $d < 0) { 8494 print "$file is executable NFS file\n"; 8495 } 8496 8497(This works on machines only for which the device number is negative 8498under NFS.) 8499 8500On some platforms inode numbers are of a type larger than perl knows how 8501to handle as integer numerical values. If necessary, an inode number will 8502be returned as a decimal string in order to preserve the entire value. 8503If used in a numeric context, this will be converted to a floating-point 8504numerical value, with rounding, a fate that is best avoided. Therefore, 8505you should prefer to compare inode numbers using C<eq> rather than C<==>. 8506C<eq> will work fine on inode numbers that are represented numerically, 8507as well as those represented as strings. 8508 8509Because the mode contains both the file type and its permissions, you 8510should mask off the file type portion and (s)printf using a C<"%o"> 8511if you want to see the real permissions. 8512 8513 my $mode = (stat($filename))[2]; 8514 printf "Permissions are %04o\n", $mode & 07777; 8515 8516In scalar context, L<C<stat>|/stat FILEHANDLE> returns a boolean value 8517indicating success 8518or failure, and, if successful, sets the information associated with 8519the special filehandle C<_>. 8520 8521The L<File::stat> module provides a convenient, by-name access mechanism: 8522 8523 use File::stat; 8524 my $sb = stat($filename); 8525 printf "File is %s, size is %s, perm %04o, mtime %s\n", 8526 $filename, $sb->size, $sb->mode & 07777, 8527 scalar localtime $sb->mtime; 8528 8529You can import symbolic mode constants (C<S_IF*>) and functions 8530(C<S_IS*>) from the L<Fcntl> module: 8531 8532 use Fcntl ':mode'; 8533 8534 my $mode = (stat($filename))[2]; 8535 8536 my $user_rwx = ($mode & S_IRWXU) >> 6; 8537 my $group_read = ($mode & S_IRGRP) >> 3; 8538 my $other_execute = $mode & S_IXOTH; 8539 8540 printf "Permissions are %04o\n", S_IMODE($mode), "\n"; 8541 8542 my $is_setuid = $mode & S_ISUID; 8543 my $is_directory = S_ISDIR($mode); 8544 8545You could write the last two using the C<-u> and C<-d> operators. 8546Commonly available C<S_IF*> constants are: 8547 8548 # Permissions: read, write, execute, for user, group, others. 8549 8550 S_IRWXU S_IRUSR S_IWUSR S_IXUSR 8551 S_IRWXG S_IRGRP S_IWGRP S_IXGRP 8552 S_IRWXO S_IROTH S_IWOTH S_IXOTH 8553 8554 # Setuid/Setgid/Stickiness/SaveText. 8555 # Note that the exact meaning of these is system-dependent. 8556 8557 S_ISUID S_ISGID S_ISVTX S_ISTXT 8558 8559 # File types. Not all are necessarily available on 8560 # your system. 8561 8562 S_IFREG S_IFDIR S_IFLNK S_IFBLK S_IFCHR 8563 S_IFIFO S_IFSOCK S_IFWHT S_ENFMT 8564 8565 # The following are compatibility aliases for S_IRUSR, 8566 # S_IWUSR, and S_IXUSR. 8567 8568 S_IREAD S_IWRITE S_IEXEC 8569 8570and the C<S_IF*> functions are 8571 8572 S_IMODE($mode) the part of $mode containing the permission 8573 bits and the setuid/setgid/sticky bits 8574 8575 S_IFMT($mode) the part of $mode containing the file type 8576 which can be bit-anded with (for example) 8577 S_IFREG or with the following functions 8578 8579 # The operators -f, -d, -l, -b, -c, -p, and -S. 8580 8581 S_ISREG($mode) S_ISDIR($mode) S_ISLNK($mode) 8582 S_ISBLK($mode) S_ISCHR($mode) S_ISFIFO($mode) S_ISSOCK($mode) 8583 8584 # No direct -X operator counterpart, but for the first one 8585 # the -g operator is often equivalent. The ENFMT stands for 8586 # record flocking enforcement, a platform-dependent feature. 8587 8588 S_ISENFMT($mode) S_ISWHT($mode) 8589 8590See your native L<chmod(2)> and L<stat(2)> documentation for more details 8591about the C<S_*> constants. To get status info for a symbolic link 8592instead of the target file behind the link, use the 8593L<C<lstat>|/lstat FILEHANDLE> function. 8594 8595Portability issues: L<perlport/stat>. 8596 8597=item state VARLIST 8598X<state> 8599 8600=item state TYPE VARLIST 8601 8602=item state VARLIST : ATTRS 8603 8604=item state TYPE VARLIST : ATTRS 8605 8606=for Pod::Functions +state declare and assign a persistent lexical variable 8607 8608L<C<state>|/state VARLIST> declares a lexically scoped variable, just 8609like L<C<my>|/my VARLIST>. 8610However, those variables will never be reinitialized, contrary to 8611lexical variables that are reinitialized each time their enclosing block 8612is entered. 8613See L<perlsub/"Persistent Private Variables"> for details. 8614 8615If more than one variable is listed, the list must be placed in 8616parentheses. With a parenthesised list, L<C<undef>|/undef EXPR> can be 8617used as a 8618dummy placeholder. However, since initialization of state variables in 8619such lists is currently not possible this would serve no purpose. 8620 8621Redeclaring a variable in the same scope or statement will "shadow" the 8622previous declaration, creating a new instance and preventing access to 8623the previous one. This is usually undesired and, if warnings are enabled, 8624will result in a warning in the C<shadow> category. 8625 8626L<C<state>|/state VARLIST> is available only if the 8627L<C<"state"> feature|feature/The 'state' feature> is enabled or if it is 8628prefixed with C<CORE::>. The 8629L<C<"state"> feature|feature/The 'state' feature> is enabled 8630automatically with a C<use v5.10> (or higher) declaration in the current 8631scope. 8632 8633 8634=item study SCALAR 8635X<study> 8636 8637=item study 8638 8639=for Pod::Functions no-op, formerly optimized input data for repeated searches 8640 8641At this time, C<study> does nothing. This may change in the future. 8642 8643Prior to Perl version 5.16, it would create an inverted index of all characters 8644that occurred in the given SCALAR (or L<C<$_>|perlvar/$_> if unspecified). When 8645matching a pattern, the rarest character from the pattern would be looked up in 8646this index. Rarity was based on some static frequency tables constructed from 8647some C programs and English text. 8648 8649 8650=item sub NAME BLOCK 8651X<sub> 8652 8653=item sub NAME (PROTO) BLOCK 8654 8655=item sub NAME : ATTRS BLOCK 8656 8657=item sub NAME (PROTO) : ATTRS BLOCK 8658 8659=for Pod::Functions declare a subroutine, possibly anonymously 8660 8661This is subroutine definition, not a real function I<per se>. Without a 8662BLOCK it's just a forward declaration. Without a NAME, it's an anonymous 8663function declaration, so does return a value: the CODE ref of the closure 8664just created. 8665 8666See L<perlsub> and L<perlref> for details about subroutines and 8667references; see L<attributes> and L<Attribute::Handlers> for more 8668information about attributes. 8669 8670=item __SUB__ 8671X<__SUB__> 8672 8673=for Pod::Functions +current_sub the current subroutine, or C<undef> if not in a subroutine 8674 8675A special token that returns a reference to the current subroutine, or 8676L<C<undef>|/undef EXPR> outside of a subroutine. 8677 8678The behaviour of L<C<__SUB__>|/__SUB__> within a regex code block (such 8679as C</(?{...})/>) is subject to change. 8680 8681This token is only available under C<use v5.16> or the 8682L<C<"current_sub"> feature|feature/The 'current_sub' feature>. 8683See L<feature>. 8684 8685=item substr EXPR,OFFSET,LENGTH,REPLACEMENT 8686X<substr> X<substring> X<mid> X<left> X<right> 8687 8688=item substr EXPR,OFFSET,LENGTH 8689 8690=item substr EXPR,OFFSET 8691 8692=for Pod::Functions get or alter a portion of a string 8693 8694Extracts a substring out of EXPR and returns it. First character is at 8695offset zero. If OFFSET is negative, starts 8696that far back from the end of the string. If LENGTH is omitted, returns 8697everything through the end of the string. If LENGTH is negative, leaves that 8698many characters off the end of the string. 8699 8700 my $s = "The black cat climbed the green tree"; 8701 my $color = substr $s, 4, 5; # black 8702 my $middle = substr $s, 4, -11; # black cat climbed the 8703 my $end = substr $s, 14; # climbed the green tree 8704 my $tail = substr $s, -4; # tree 8705 my $z = substr $s, -4, 2; # tr 8706 8707You can use the L<C<substr>|/substr EXPR,OFFSET,LENGTH,REPLACEMENT> 8708function as an lvalue, in which case EXPR 8709must itself be an lvalue. If you assign something shorter than LENGTH, 8710the string will shrink, and if you assign something longer than LENGTH, 8711the string will grow to accommodate it. To keep the string the same 8712length, you may need to pad or chop your value using 8713L<C<sprintf>|/sprintf FORMAT, LIST>. 8714 8715If OFFSET and LENGTH specify a substring that is partly outside the 8716string, only the part within the string is returned. If the substring 8717is beyond either end of the string, 8718L<C<substr>|/substr EXPR,OFFSET,LENGTH,REPLACEMENT> returns the undefined 8719value and produces a warning. When used as an lvalue, specifying a 8720substring that is entirely outside the string raises an exception. 8721Here's an example showing the behavior for boundary cases: 8722 8723 my $name = 'fred'; 8724 substr($name, 4) = 'dy'; # $name is now 'freddy' 8725 my $null = substr $name, 6, 2; # returns "" (no warning) 8726 my $oops = substr $name, 7; # returns undef, with warning 8727 substr($name, 7) = 'gap'; # raises an exception 8728 8729An alternative to using 8730L<C<substr>|/substr EXPR,OFFSET,LENGTH,REPLACEMENT> as an lvalue is to 8731specify the 8732replacement string as the 4th argument. This allows you to replace 8733parts of the EXPR and return what was there before in one operation, 8734just as you can with 8735L<C<splice>|/splice ARRAY,OFFSET,LENGTH,LIST>. 8736 8737 my $s = "The black cat climbed the green tree"; 8738 my $z = substr $s, 14, 7, "jumped from"; # climbed 8739 # $s is now "The black cat jumped from the green tree" 8740 8741Note that the lvalue returned by the three-argument version of 8742L<C<substr>|/substr EXPR,OFFSET,LENGTH,REPLACEMENT> acts as 8743a 'magic bullet'; each time it is assigned to, it remembers which part 8744of the original string is being modified; for example: 8745 8746 my $x = '1234'; 8747 for (substr($x,1,2)) { 8748 $_ = 'a'; print $x,"\n"; # prints 1a4 8749 $_ = 'xyz'; print $x,"\n"; # prints 1xyz4 8750 $x = '56789'; 8751 $_ = 'pq'; print $x,"\n"; # prints 5pq9 8752 } 8753 8754With negative offsets, it remembers its position from the end of the string 8755when the target string is modified: 8756 8757 my $x = '1234'; 8758 for (substr($x, -3, 2)) { 8759 $_ = 'a'; print $x,"\n"; # prints 1a4, as above 8760 $x = 'abcdefg'; 8761 print $_,"\n"; # prints f 8762 } 8763 8764Prior to Perl version 5.10, the result of using an lvalue multiple times was 8765unspecified. Prior to 5.16, the result with negative offsets was 8766unspecified. 8767 8768=item symlink OLDFILE,NEWFILE 8769X<symlink> X<link> X<symbolic link> X<link, symbolic> 8770 8771=for Pod::Functions create a symbolic link to a file 8772 8773Creates a new filename symbolically linked to the old filename. 8774Returns C<1> for success, C<0> otherwise. On systems that don't support 8775symbolic links, raises an exception. To check for that, 8776use eval: 8777 8778 my $symlink_exists = eval { symlink("",""); 1 }; 8779 8780Portability issues: L<perlport/symlink>. 8781 8782=item syscall NUMBER, LIST 8783X<syscall> X<system call> 8784 8785=for Pod::Functions execute an arbitrary system call 8786 8787Calls the system call specified as the first element of the list, 8788passing the remaining elements as arguments to the system call. If 8789unimplemented, raises an exception. The arguments are interpreted 8790as follows: if a given argument is numeric, the argument is passed as 8791an int. If not, the pointer to the string value is passed. You are 8792responsible to make sure a string is pre-extended long enough to 8793receive any result that might be written into a string. You can't use a 8794string literal (or other read-only string) as an argument to 8795L<C<syscall>|/syscall NUMBER, LIST> because Perl has to assume that any 8796string pointer might be written through. If your 8797integer arguments are not literals and have never been interpreted in a 8798numeric context, you may need to add C<0> to them to force them to look 8799like numbers. This emulates the 8800L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET> function (or 8801vice versa): 8802 8803 require 'syscall.ph'; # may need to run h2ph 8804 my $s = "hi there\n"; 8805 syscall(SYS_write(), fileno(STDOUT), $s, length $s); 8806 8807Note that Perl supports passing of up to only 14 arguments to your syscall, 8808which in practice should (usually) suffice. 8809 8810Syscall returns whatever value returned by the system call it calls. 8811If the system call fails, L<C<syscall>|/syscall NUMBER, LIST> returns 8812C<-1> and sets L<C<$!>|perlvar/$!> (errno). 8813Note that some system calls I<can> legitimately return C<-1>. The proper 8814way to handle such calls is to assign C<$! = 0> before the call, then 8815check the value of L<C<$!>|perlvar/$!> if 8816L<C<syscall>|/syscall NUMBER, LIST> returns C<-1>. 8817 8818There's a problem with C<syscall(SYS_pipe())>: it returns the file 8819number of the read end of the pipe it creates, but there is no way 8820to retrieve the file number of the other end. You can avoid this 8821problem by using L<C<pipe>|/pipe READHANDLE,WRITEHANDLE> instead. 8822 8823Portability issues: L<perlport/syscall>. 8824 8825=item sysopen FILEHANDLE,FILENAME,MODE 8826X<sysopen> 8827 8828=item sysopen FILEHANDLE,FILENAME,MODE,PERMS 8829 8830=for Pod::Functions +5.002 open a file, pipe, or descriptor 8831 8832Opens the file whose filename is given by FILENAME, and associates it with 8833FILEHANDLE. If FILEHANDLE is an expression, its value is used as the real 8834filehandle wanted; an undefined scalar will be suitably autovivified. This 8835function calls the underlying operating system's L<open(2)> function with the 8836parameters FILENAME, MODE, and PERMS. 8837 8838Returns true on success and L<C<undef>|/undef EXPR> otherwise. 8839 8840L<PerlIO> layers will be applied to the handle the same way they would in an 8841L<C<open>|/open FILEHANDLE,MODE,EXPR> call that does not specify layers. That is, 8842the current value of L<C<${^OPEN}>|perlvar/${^OPEN}> as set by the L<open> 8843pragma in a lexical scope, or the C<-C> commandline option or C<PERL_UNICODE> 8844environment variable in the main program scope, falling back to the platform 8845defaults as described in L<PerlIO/Defaults and how to override them>. If you 8846want to remove any layers that may transform the byte stream, use 8847L<C<binmode>|/binmode FILEHANDLE, LAYER> after opening it. 8848 8849The possible values and flag bits of the MODE parameter are 8850system-dependent; they are available via the standard module 8851L<C<Fcntl>|Fcntl>. See the documentation of your operating system's 8852L<open(2)> syscall to see 8853which values and flag bits are available. You may combine several flags 8854using the C<|>-operator. 8855 8856Some of the most common values are C<O_RDONLY> for opening the file in 8857read-only mode, C<O_WRONLY> for opening the file in write-only mode, 8858and C<O_RDWR> for opening the file in read-write mode. 8859X<O_RDONLY> X<O_RDWR> X<O_WRONLY> 8860 8861For historical reasons, some values work on almost every system 8862supported by Perl: 0 means read-only, 1 means write-only, and 2 8863means read/write. We know that these values do I<not> work under 8864OS/390; you probably don't want to use them in new code. 8865 8866If the file named by FILENAME does not exist and the 8867L<C<open>|/open FILEHANDLE,MODE,EXPR> call creates 8868it (typically because MODE includes the C<O_CREAT> flag), then the value of 8869PERMS specifies the permissions of the newly created file. If you omit 8870the PERMS argument to L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE>, 8871Perl uses the octal value C<0666>. 8872These permission values need to be in octal, and are modified by your 8873process's current L<C<umask>|/umask EXPR>. 8874X<O_CREAT> 8875 8876In many systems the C<O_EXCL> flag is available for opening files in 8877exclusive mode. This is B<not> locking: exclusiveness means here that 8878if the file already exists, 8879L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE> fails. C<O_EXCL> may 8880not work 8881on network filesystems, and has no effect unless the C<O_CREAT> flag 8882is set as well. Setting C<O_CREAT|O_EXCL> prevents the file from 8883being opened if it is a symbolic link. It does not protect against 8884symbolic links in the file's path. 8885X<O_EXCL> 8886 8887Sometimes you may want to truncate an already-existing file. This 8888can be done using the C<O_TRUNC> flag. The behavior of 8889C<O_TRUNC> with C<O_RDONLY> is undefined. 8890X<O_TRUNC> 8891 8892You should seldom if ever use C<0644> as argument to 8893L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE>, because 8894that takes away the user's option to have a more permissive umask. 8895Better to omit it. See L<C<umask>|/umask EXPR> for more on this. 8896 8897This function has no direct relation to the usage of 8898L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>, 8899L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET>, 8900or L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE>. A handle opened with 8901this function can be used with buffered IO just as one opened with 8902L<C<open>|/open FILEHANDLE,MODE,EXPR> can be used with unbuffered IO. 8903 8904Note that under Perls older than 5.8.0, 8905L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE> depends on the 8906L<fdopen(3)> C library function. On many Unix systems, L<fdopen(3)> is known 8907to fail when file descriptors exceed a certain value, typically 255. If 8908you need more file descriptors than that, consider using the 8909L<C<POSIX::open>|POSIX/C<open>> function. For Perls 5.8.0 and later, 8910PerlIO is (most often) the default. 8911 8912See L<perlopentut> for a kinder, gentler explanation of opening files. 8913 8914Portability issues: L<perlport/sysopen>. 8915 8916=item sysread FILEHANDLE,SCALAR,LENGTH,OFFSET 8917X<sysread> 8918 8919=item sysread FILEHANDLE,SCALAR,LENGTH 8920 8921=for Pod::Functions fixed-length unbuffered input from a filehandle 8922 8923Attempts to read LENGTH bytes of data into variable SCALAR from the 8924specified FILEHANDLE, using L<read(2)>. It bypasses any L<PerlIO> layers 8925including buffered IO (but is affected by the presence of the C<:utf8> 8926layer as described later), so mixing this with other kinds of reads, 8927L<C<print>|/print FILEHANDLE LIST>, L<C<write>|/write FILEHANDLE>, 8928L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 8929L<C<tell>|/tell FILEHANDLE>, or L<C<eof>|/eof FILEHANDLE> can cause 8930confusion because the 8931C<:perlio> or C<:crlf> layers usually buffer data. Returns the number of 8932bytes actually read, C<0> at end of file, or undef if there was an 8933error (in the latter case L<C<$!>|perlvar/$!> is also set). SCALAR will 8934be grown or 8935shrunk so that the last byte actually read is the last byte of the 8936scalar after the read. 8937 8938An OFFSET may be specified to place the read data at some place in the 8939string other than the beginning. A negative OFFSET specifies 8940placement at that many characters counting backwards from the end of 8941the string. A positive OFFSET greater than the length of SCALAR 8942results in the string being padded to the required size with C<"\0"> 8943bytes before the result of the read is appended. 8944 8945There is no syseof() function, which is ok, since 8946L<C<eof>|/eof FILEHANDLE> doesn't work well on device files (like ttys) 8947anyway. Use L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET> and 8948check for a return value of 0 to decide whether you're done. 8949 8950Note that if the filehandle has been marked as C<:utf8>, C<sysread> will 8951throw an exception. The C<:encoding(...)> layer implicitly 8952introduces the C<:utf8> layer. See 8953L<C<binmode>|/binmode FILEHANDLE, LAYER>, 8954L<C<open>|/open FILEHANDLE,MODE,EXPR>, and the L<open> pragma. 8955 8956=item sysseek FILEHANDLE,POSITION,WHENCE 8957X<sysseek> X<lseek> 8958 8959=for Pod::Functions +5.004 position I/O pointer on handle used with sysread and syswrite 8960 8961Sets FILEHANDLE's system position I<in bytes> using L<lseek(2)>. FILEHANDLE may 8962be an expression whose value gives the name of the filehandle. The values 8963for WHENCE are C<0> to set the new position to POSITION; C<1> to set it 8964to the current position plus POSITION; and C<2> to set it to EOF plus 8965POSITION, typically negative. 8966 8967Note the emphasis on bytes: even if the filehandle has been set to operate 8968on characters (for example using the C<:encoding(UTF-8)> I/O layer), the 8969L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 8970L<C<tell>|/tell FILEHANDLE>, and 8971L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE> 8972family of functions use byte offsets, not character offsets, 8973because seeking to a character offset would be very slow in a UTF-8 file. 8974 8975L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE> bypasses normal 8976buffered IO, so mixing it with reads other than 8977L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET> (for example 8978L<C<readline>|/readline EXPR> or 8979L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET>), 8980L<C<print>|/print FILEHANDLE LIST>, L<C<write>|/write FILEHANDLE>, 8981L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 8982L<C<tell>|/tell FILEHANDLE>, or L<C<eof>|/eof FILEHANDLE> may cause 8983confusion. 8984 8985For WHENCE, you may also use the constants C<SEEK_SET>, C<SEEK_CUR>, 8986and C<SEEK_END> (start of the file, current position, end of the file) 8987from the L<Fcntl> module. Use of the constants is also more portable 8988than relying on 0, 1, and 2. For example to define a "systell" function: 8989 8990 use Fcntl 'SEEK_CUR'; 8991 sub systell { sysseek($_[0], 0, SEEK_CUR) } 8992 8993Returns the new position, or the undefined value on failure. A position 8994of zero is returned as the string C<"0 but true">; thus 8995L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE> returns 8996true on success and false on failure, yet you can still easily determine 8997the new position. 8998 8999=item system LIST 9000X<system> X<shell> 9001 9002=item system PROGRAM LIST 9003 9004=for Pod::Functions run a separate program 9005 9006Does exactly the same thing as L<C<exec>|/exec LIST>, except that a fork is 9007done first and the parent process waits for the child process to 9008exit. Note that argument processing varies depending on the 9009number of arguments. If there is more than one argument in LIST, 9010or if LIST is an array with more than one value, starts the program 9011given by the first element of the list with arguments given by the 9012rest of the list. If there is only one scalar argument, the argument 9013is checked for shell metacharacters, and if there are any, the 9014entire argument is passed to the system's command shell for parsing 9015(this is C</bin/sh -c> on Unix platforms, but varies on other 9016platforms). If there are no shell metacharacters in the argument, 9017it is split into words and passed directly to C<execvp>, which is 9018more efficient. On Windows, only the C<system PROGRAM LIST> syntax will 9019reliably avoid using the shell; C<system LIST>, even with more than one 9020element, will fall back to the shell if the first spawn fails. 9021 9022Perl will attempt to flush all files opened for 9023output before any operation that may do a fork, but this may not be 9024supported on some platforms (see L<perlport>). To be safe, you may need 9025to set L<C<$E<verbar>>|perlvar/$E<verbar>> (C<$AUTOFLUSH> in L<English>) 9026or call the C<autoflush> method of L<C<IO::Handle>|IO::Handle/METHODS> 9027on any open handles. 9028 9029The return value is the exit status of the program as returned by the 9030L<C<wait>|/wait> call. To get the actual exit value, shift right by 9031eight (see below). See also L<C<exec>|/exec LIST>. This is I<not> what 9032you want to use to capture the output from a command; for that you 9033should use merely backticks or 9034L<C<qxE<sol>E<sol>>|/qxE<sol>STRINGE<sol>>, as described in 9035L<perlop/"`STRING`">. Return value of -1 indicates a failure to start 9036the program or an error of the L<wait(2)> system call (inspect 9037L<C<$!>|perlvar/$!> for the reason). 9038 9039If you'd like to make L<C<system>|/system LIST> (and many other bits of 9040Perl) die on error, have a look at the L<autodie> pragma. 9041 9042Like L<C<exec>|/exec LIST>, L<C<system>|/system LIST> allows you to lie 9043to a program about its name if you use the C<system PROGRAM LIST> 9044syntax. Again, see L<C<exec>|/exec LIST>. 9045 9046Since C<SIGINT> and C<SIGQUIT> are ignored during the execution of 9047L<C<system>|/system LIST>, if you expect your program to terminate on 9048receipt of these signals you will need to arrange to do so yourself 9049based on the return value. 9050 9051 my @args = ("command", "arg1", "arg2"); 9052 system(@args) == 0 9053 or die "system @args failed: $?"; 9054 9055If you'd like to manually inspect L<C<system>|/system LIST>'s failure, 9056you can check all possible failure modes by inspecting 9057L<C<$?>|perlvar/$?> like this: 9058 9059 if ($? == -1) { 9060 print "failed to execute: $!\n"; 9061 } 9062 elsif ($? & 127) { 9063 printf "child died with signal %d, %s coredump\n", 9064 ($? & 127), ($? & 128) ? 'with' : 'without'; 9065 } 9066 else { 9067 printf "child exited with value %d\n", $? >> 8; 9068 } 9069 9070Alternatively, you may inspect the value of 9071L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}> with the 9072L<C<W*()>|POSIX/C<WIFEXITED>> calls from the L<POSIX> module. 9073 9074When L<C<system>|/system LIST>'s arguments are executed indirectly by 9075the shell, results and return codes are subject to its quirks. 9076See L<perlop/"`STRING`"> and L<C<exec>|/exec LIST> for details. 9077 9078Since L<C<system>|/system LIST> does a L<C<fork>|/fork> and 9079L<C<wait>|/wait> it may affect a C<SIGCHLD> handler. See L<perlipc> for 9080details. 9081 9082Portability issues: L<perlport/system>. 9083 9084=item syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET 9085X<syswrite> 9086 9087=item syswrite FILEHANDLE,SCALAR,LENGTH 9088 9089=item syswrite FILEHANDLE,SCALAR 9090 9091=for Pod::Functions fixed-length unbuffered output to a filehandle 9092 9093Attempts to write LENGTH bytes of data from variable SCALAR to the 9094specified FILEHANDLE, using L<write(2)>. If LENGTH is 9095not specified, writes whole SCALAR. It bypasses any L<PerlIO> layers 9096including buffered IO (but is affected by the presence of the C<:utf8> 9097layer as described later), so 9098mixing this with reads (other than C<sysread)>), 9099L<C<print>|/print FILEHANDLE LIST>, L<C<write>|/write FILEHANDLE>, 9100L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 9101L<C<tell>|/tell FILEHANDLE>, or L<C<eof>|/eof FILEHANDLE> may cause 9102confusion because the C<:perlio> and C<:crlf> layers usually buffer data. 9103Returns the number of bytes actually written, or L<C<undef>|/undef EXPR> 9104if there was an error (in this case the errno variable 9105L<C<$!>|perlvar/$!> is also set). If the LENGTH is greater than the 9106data available in the SCALAR after the OFFSET, only as much data as is 9107available will be written. 9108 9109An OFFSET may be specified to write the data from some part of the 9110string other than the beginning. A negative OFFSET specifies writing 9111that many characters counting backwards from the end of the string. 9112If SCALAR is of length zero, you can only use an OFFSET of 0. 9113 9114B<WARNING>: If the filehandle is marked C<:utf8>, C<syswrite> will raise an exception. 9115The C<:encoding(...)> layer implicitly introduces the C<:utf8> layer. 9116Alternately, if the handle is not marked with an encoding but you 9117attempt to write characters with code points over 255, raises an exception. 9118See L<C<binmode>|/binmode FILEHANDLE, LAYER>, 9119L<C<open>|/open FILEHANDLE,MODE,EXPR>, and the L<open> pragma. 9120 9121=item tell FILEHANDLE 9122X<tell> 9123 9124=item tell 9125 9126=for Pod::Functions get current seekpointer on a filehandle 9127 9128Returns the current position I<in bytes> for FILEHANDLE, or -1 on 9129error. FILEHANDLE may be an expression whose value gives the name of 9130the actual filehandle. If FILEHANDLE is omitted, assumes the file 9131last read. 9132 9133Note the emphasis on bytes: even if the filehandle has been set to operate 9134on characters (for example using the C<:encoding(UTF-8)> I/O layer), the 9135L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>, 9136L<C<tell>|/tell FILEHANDLE>, and 9137L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE> 9138family of functions use byte offsets, not character offsets, 9139because seeking to a character offset would be very slow in a UTF-8 file. 9140 9141The return value of L<C<tell>|/tell FILEHANDLE> for the standard streams 9142like the STDIN depends on the operating system: it may return -1 or 9143something else. L<C<tell>|/tell FILEHANDLE> on pipes, fifos, and 9144sockets usually returns -1. 9145 9146There is no C<systell> function. Use 9147L<C<sysseek($fh, 0, 1)>|/sysseek FILEHANDLE,POSITION,WHENCE> for that. 9148 9149Do not use L<C<tell>|/tell FILEHANDLE> (or other buffered I/O 9150operations) on a filehandle that has been manipulated by 9151L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>, 9152L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET>, or 9153L<C<sysseek>|/sysseek FILEHANDLE,POSITION,WHENCE>. Those functions 9154ignore the buffering, while L<C<tell>|/tell FILEHANDLE> does not. 9155 9156=item telldir DIRHANDLE 9157X<telldir> 9158 9159=for Pod::Functions get current seekpointer on a directory handle 9160 9161Returns the current position of the L<C<readdir>|/readdir DIRHANDLE> 9162routines on DIRHANDLE. Value may be given to 9163L<C<seekdir>|/seekdir DIRHANDLE,POS> to access a particular location in 9164a directory. L<C<telldir>|/telldir DIRHANDLE> has the same caveats 9165about possible directory compaction as the corresponding system library 9166routine. 9167 9168=item tie VARIABLE,CLASSNAME,LIST 9169X<tie> 9170 9171=for Pod::Functions +5.002 bind a variable to an object class 9172 9173This function binds a variable to a package class that will provide the 9174implementation for the variable. VARIABLE is the name of the variable 9175to be enchanted. CLASSNAME is the name of a class implementing objects 9176of correct type. Any additional arguments are passed to the 9177appropriate constructor 9178method of the class (meaning C<TIESCALAR>, C<TIEHANDLE>, C<TIEARRAY>, 9179or C<TIEHASH>). Typically these are arguments such as might be passed 9180to the L<dbm_open(3)> function of C. The object returned by the 9181constructor is also returned by the 9182L<C<tie>|/tie VARIABLE,CLASSNAME,LIST> function, which would be useful 9183if you want to access other methods in CLASSNAME. 9184 9185Note that functions such as L<C<keys>|/keys HASH> and 9186L<C<values>|/values HASH> may return huge lists when used on large 9187objects, like DBM files. You may prefer to use the L<C<each>|/each 9188HASH> function to iterate over such. Example: 9189 9190 # print out history file offsets 9191 use NDBM_File; 9192 tie(my %HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0); 9193 while (my ($key,$val) = each %HIST) { 9194 print $key, ' = ', unpack('L', $val), "\n"; 9195 } 9196 9197A class implementing a hash should have the following methods: 9198 9199 TIEHASH classname, LIST 9200 FETCH this, key 9201 STORE this, key, value 9202 DELETE this, key 9203 CLEAR this 9204 EXISTS this, key 9205 FIRSTKEY this 9206 NEXTKEY this, lastkey 9207 SCALAR this 9208 DESTROY this 9209 UNTIE this 9210 9211A class implementing an ordinary array should have the following methods: 9212 9213 TIEARRAY classname, LIST 9214 FETCH this, key 9215 STORE this, key, value 9216 FETCHSIZE this 9217 STORESIZE this, count 9218 CLEAR this 9219 PUSH this, LIST 9220 POP this 9221 SHIFT this 9222 UNSHIFT this, LIST 9223 SPLICE this, offset, length, LIST 9224 EXTEND this, count 9225 DELETE this, key 9226 EXISTS this, key 9227 DESTROY this 9228 UNTIE this 9229 9230A class implementing a filehandle should have the following methods: 9231 9232 TIEHANDLE classname, LIST 9233 READ this, scalar, length, offset 9234 READLINE this 9235 GETC this 9236 WRITE this, scalar, length, offset 9237 PRINT this, LIST 9238 PRINTF this, format, LIST 9239 BINMODE this 9240 EOF this 9241 FILENO this 9242 SEEK this, position, whence 9243 TELL this 9244 OPEN this, mode, LIST 9245 CLOSE this 9246 DESTROY this 9247 UNTIE this 9248 9249A class implementing a scalar should have the following methods: 9250 9251 TIESCALAR classname, LIST 9252 FETCH this, 9253 STORE this, value 9254 DESTROY this 9255 UNTIE this 9256 9257Not all methods indicated above need be implemented. See L<perltie>, 9258L<Tie::Hash>, L<Tie::Array>, L<Tie::Scalar>, and L<Tie::Handle>. 9259 9260Unlike L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>, the 9261L<C<tie>|/tie VARIABLE,CLASSNAME,LIST> function will not 9262L<C<use>|/use Module VERSION LIST> or L<C<require>|/require VERSION> a 9263module for you; you need to do that explicitly yourself. See L<DB_File> 9264or the L<Config> module for interesting 9265L<C<tie>|/tie VARIABLE,CLASSNAME,LIST> implementations. 9266 9267For further details see L<perltie>, L<C<tied>|/tied VARIABLE>. 9268 9269=item tied VARIABLE 9270X<tied> 9271 9272=for Pod::Functions get a reference to the object underlying a tied variable 9273 9274Returns a reference to the object underlying VARIABLE (the same value 9275that was originally returned by the 9276L<C<tie>|/tie VARIABLE,CLASSNAME,LIST> call that bound the variable 9277to a package.) Returns the undefined value if VARIABLE isn't tied to a 9278package. 9279 9280=item time 9281X<time> X<epoch> 9282 9283=for Pod::Functions return number of seconds since 1970 9284 9285Returns the number of non-leap seconds since whatever time the system 9286considers to be the epoch, suitable for feeding to 9287L<C<gmtime>|/gmtime EXPR> and L<C<localtime>|/localtime EXPR>. On most 9288systems the epoch is 00:00:00 UTC, January 1, 1970; 9289a prominent exception being Mac OS Classic which uses 00:00:00, January 1, 92901904 in the current local time zone for its epoch. 9291 9292For measuring time in better granularity than one second, use the 9293L<Time::HiRes> module from Perl 5.8 onwards (or from CPAN before then), or, 9294if you have L<gettimeofday(2)>, you may be able to use the 9295L<C<syscall>|/syscall NUMBER, LIST> interface of Perl. See L<perlfaq8> 9296for details. 9297 9298For date and time processing look at the many related modules on CPAN. 9299For a comprehensive date and time representation look at the 9300L<DateTime> module. 9301 9302=item times 9303X<times> 9304 9305=for Pod::Functions return elapsed time for self and child processes 9306 9307Returns a four-element list giving the user and system times in 9308seconds for this process and any exited children of this process. 9309 9310 my ($user,$system,$cuser,$csystem) = times; 9311 9312In scalar context, L<C<times>|/times> returns C<$user>. 9313 9314Children's times are only included for terminated children. 9315 9316Portability issues: L<perlport/times>. 9317 9318=item tr/// 9319 9320=for Pod::Functions transliterate a string 9321 9322The transliteration operator. Same as 9323L<C<yE<sol>E<sol>E<sol>>|/yE<sol>E<sol>E<sol>>. See 9324L<perlop/"Quote-Like Operators">. 9325 9326=item truncate FILEHANDLE,LENGTH 9327X<truncate> 9328 9329=item truncate EXPR,LENGTH 9330 9331=for Pod::Functions shorten a file 9332 9333Truncates the file opened on FILEHANDLE, or named by EXPR, to the 9334specified length. Raises an exception if truncate isn't implemented 9335on your system. Returns true if successful, L<C<undef>|/undef EXPR> on 9336error. 9337 9338The behavior is undefined if LENGTH is greater than the length of the 9339file. 9340 9341The position in the file of FILEHANDLE is left unchanged. You may want to 9342call L<seek|/"seek FILEHANDLE,POSITION,WHENCE"> before writing to the 9343file. 9344 9345Portability issues: L<perlport/truncate>. 9346 9347=item uc EXPR 9348X<uc> X<uppercase> X<toupper> 9349 9350=item uc 9351 9352=for Pod::Functions return upper-case version of a string 9353 9354Returns an uppercased version of EXPR. If EXPR is omitted, uses 9355L<C<$_>|perlvar/$_>. 9356 9357 my $str = uc("Perl is GREAT"); # "PERL IS GREAT" 9358 9359This function behaves the same way under various pragmas, such as in a locale, 9360as L<C<lc>|/lc EXPR> does. 9361 9362If you want titlecase mapping on initial letters see 9363L<C<ucfirst>|/ucfirst EXPR> instead. 9364 9365B<Note:> This is the internal function implementing the 9366L<C<\U>|perlop/"Quote and Quote-like Operators"> escape in double-quoted 9367strings. 9368 9369 my $str = "Perl is \Ugreat\E"; # "Perl is GREAT" 9370 9371=item ucfirst EXPR 9372X<ucfirst> X<uppercase> 9373 9374=item ucfirst 9375 9376=for Pod::Functions return a string with just the next letter in upper case 9377 9378Returns the value of EXPR with the first character in uppercase 9379(titlecase in Unicode). This is the internal function implementing 9380the C<\u> escape in double-quoted strings. 9381 9382If EXPR is omitted, uses L<C<$_>|perlvar/$_>. 9383 9384This function behaves the same way under various pragmas, such as in a locale, 9385as L<C<lc>|/lc EXPR> does. 9386 9387=item umask EXPR 9388X<umask> 9389 9390=item umask 9391 9392=for Pod::Functions set file creation mode mask 9393 9394Sets the umask for the process to EXPR and returns the previous value. 9395If EXPR is omitted, merely returns the current umask. 9396 9397The Unix permission C<rwxr-x---> is represented as three sets of three 9398bits, or three octal digits: C<0750> (the leading 0 indicates octal 9399and isn't one of the digits). The L<C<umask>|/umask EXPR> value is such 9400a number representing disabled permissions bits. The permission (or 9401"mode") values you pass L<C<mkdir>|/mkdir FILENAME,MODE> or 9402L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE> are modified by your 9403umask, so even if you tell 9404L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE> to create a file with 9405permissions C<0777>, if your umask is C<0022>, then the file will 9406actually be created with permissions C<0755>. If your 9407L<C<umask>|/umask EXPR> were C<0027> (group can't write; others can't 9408read, write, or execute), then passing 9409L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE> C<0666> would create a 9410file with mode C<0640> (because C<0666 &~ 027> is C<0640>). 9411 9412Here's some advice: supply a creation mode of C<0666> for regular 9413files (in L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE>) and one of 9414C<0777> for directories (in L<C<mkdir>|/mkdir FILENAME,MODE>) and 9415executable files. This gives users the freedom of 9416choice: if they want protected files, they might choose process umasks 9417of C<022>, C<027>, or even the particularly antisocial mask of C<077>. 9418Programs should rarely if ever make policy decisions better left to 9419the user. The exception to this is when writing files that should be 9420kept private: mail files, web browser cookies, F<.rhosts> files, and 9421so on. 9422 9423If L<umask(2)> is not implemented on your system and you are trying to 9424restrict access for I<yourself> (i.e., C<< (EXPR & 0700) > 0 >>), 9425raises an exception. If L<umask(2)> is not implemented and you are 9426not trying to restrict access for yourself, returns 9427L<C<undef>|/undef EXPR>. 9428 9429Remember that a umask is a number, usually given in octal; it is I<not> a 9430string of octal digits. See also L<C<oct>|/oct EXPR>, if all you have 9431is a string. 9432 9433Portability issues: L<perlport/umask>. 9434 9435=item undef EXPR 9436X<undef> X<undefine> 9437 9438=item undef 9439 9440=for Pod::Functions remove a variable or function definition 9441 9442Undefines the value of EXPR, which must be an lvalue. Use only on a 9443scalar value, an array (using C<@>), a hash (using C<%>), a subroutine 9444(using C<&>), or a typeglob (using C<*>). Saying C<undef $hash{$key}> 9445will probably not do what you expect on most predefined variables or 9446DBM list values, so don't do that; see L<C<delete>|/delete EXPR>. 9447Always returns the undefined value. 9448You can omit the EXPR, in which case nothing is 9449undefined, but you still get an undefined value that you could, for 9450instance, return from a subroutine, assign to a variable, or pass as a 9451parameter. Examples: 9452 9453 undef $foo; 9454 undef $bar{'blurfl'}; # Compare to: delete $bar{'blurfl'}; 9455 undef @ary; 9456 undef %hash; 9457 undef &mysub; 9458 undef *xyz; # destroys $xyz, @xyz, %xyz, &xyz, etc. 9459 return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it; 9460 select undef, undef, undef, 0.25; 9461 my ($x, $y, undef, $z) = foo(); # Ignore third value returned 9462 9463Note that this is a unary operator, not a list operator. 9464 9465=item unlink LIST 9466X<unlink> X<delete> X<remove> X<rm> X<del> 9467 9468=item unlink 9469 9470=for Pod::Functions remove one link to a file 9471 9472Deletes a list of files. On success, it returns the number of files 9473it successfully deleted. On failure, it returns false and sets 9474L<C<$!>|perlvar/$!> (errno): 9475 9476 my $unlinked = unlink 'a', 'b', 'c'; 9477 unlink @goners; 9478 unlink glob "*.bak"; 9479 9480On error, L<C<unlink>|/unlink LIST> will not tell you which files it 9481could not remove. 9482If you want to know which files you could not remove, try them one 9483at a time: 9484 9485 foreach my $file ( @goners ) { 9486 unlink $file or warn "Could not unlink $file: $!"; 9487 } 9488 9489Note: L<C<unlink>|/unlink LIST> will not attempt to delete directories 9490unless you are 9491superuser and the B<-U> flag is supplied to Perl. Even if these 9492conditions are met, be warned that unlinking a directory can inflict 9493damage on your filesystem. Finally, using L<C<unlink>|/unlink LIST> on 9494directories is not supported on many operating systems. Use 9495L<C<rmdir>|/rmdir FILENAME> instead. 9496 9497If LIST is omitted, L<C<unlink>|/unlink LIST> uses L<C<$_>|perlvar/$_>. 9498 9499=item unpack TEMPLATE,EXPR 9500X<unpack> 9501 9502=item unpack TEMPLATE 9503 9504=for Pod::Functions convert binary structure into normal perl variables 9505 9506L<C<unpack>|/unpack TEMPLATE,EXPR> does the reverse of 9507L<C<pack>|/pack TEMPLATE,LIST>: it takes a string 9508and expands it out into a list of values. 9509(In scalar context, it returns merely the first value produced.) 9510 9511If EXPR is omitted, unpacks the L<C<$_>|perlvar/$_> string. 9512See L<perlpacktut> for an introduction to this function. 9513 9514The string is broken into chunks described by the TEMPLATE. Each chunk 9515is converted separately to a value. Typically, either the string is a result 9516of L<C<pack>|/pack TEMPLATE,LIST>, or the characters of the string 9517represent a C structure of some kind. 9518 9519The TEMPLATE has the same format as in the 9520L<C<pack>|/pack TEMPLATE,LIST> function. 9521Here's a subroutine that does substring: 9522 9523 sub substr { 9524 my ($what, $where, $howmuch) = @_; 9525 unpack("x$where a$howmuch", $what); 9526 } 9527 9528and then there's 9529 9530 sub ordinal { unpack("W",$_[0]); } # same as ord() 9531 9532In addition to fields allowed in L<C<pack>|/pack TEMPLATE,LIST>, you may 9533prefix a field with a %<number> to indicate that 9534you want a <number>-bit checksum of the items instead of the items 9535themselves. Default is a 16-bit checksum. The checksum is calculated by 9536summing numeric values of expanded values (for string fields the sum of 9537C<ord($char)> is taken; for bit fields the sum of zeroes and ones). 9538 9539For example, the following 9540computes the same number as the System V sum program: 9541 9542 my $checksum = do { 9543 local $/; # slurp! 9544 unpack("%32W*", readline) % 65535; 9545 }; 9546 9547The following efficiently counts the number of set bits in a bit vector: 9548 9549 my $setbits = unpack("%32b*", $selectmask); 9550 9551The C<p> and C<P> formats should be used with care. Since Perl 9552has no way of checking whether the value passed to 9553L<C<unpack>|/unpack TEMPLATE,EXPR> 9554corresponds to a valid memory location, passing a pointer value that's 9555not known to be valid is likely to have disastrous consequences. 9556 9557If there are more pack codes or if the repeat count of a field or a group 9558is larger than what the remainder of the input string allows, the result 9559is not well defined: the repeat count may be decreased, or 9560L<C<unpack>|/unpack TEMPLATE,EXPR> may produce empty strings or zeros, 9561or it may raise an exception. 9562If the input string is longer than one described by the TEMPLATE, 9563the remainder of that input string is ignored. 9564 9565See L<C<pack>|/pack TEMPLATE,LIST> for more examples and notes. 9566 9567=item unshift ARRAY,LIST 9568X<unshift> 9569 9570=for Pod::Functions prepend more elements to the beginning of a list 9571 9572Does the opposite of a L<C<shift>|/shift ARRAY>. Or the opposite of a 9573L<C<push>|/push ARRAY,LIST>, 9574depending on how you look at it. Prepends list to the front of the 9575array and returns the new number of elements in the array. 9576 9577 unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/; 9578 9579Note the LIST is prepended whole, not one element at a time, so the 9580prepended elements stay in the same order. Use 9581L<C<reverse>|/reverse LIST> to do the reverse. 9582 9583Starting with Perl 5.14, an experimental feature allowed 9584L<C<unshift>|/unshift ARRAY,LIST> to take 9585a scalar expression. This experiment has been deemed unsuccessful, and was 9586removed as of Perl 5.24. 9587 9588=item untie VARIABLE 9589X<untie> 9590 9591=for Pod::Functions break a tie binding to a variable 9592 9593Breaks the binding between a variable and a package. 9594(See L<tie|/tie VARIABLE,CLASSNAME,LIST>.) 9595Has no effect if the variable is not tied. 9596 9597=item use Module VERSION LIST 9598X<use> X<module> X<import> 9599 9600=item use Module VERSION 9601 9602=item use Module LIST 9603 9604=item use Module 9605 9606=item use VERSION 9607 9608=for Pod::Functions load in a module at compile time and import its namespace 9609 9610Imports some semantics into the current package from the named module, 9611generally by aliasing certain subroutine or variable names into your 9612package. It is exactly equivalent to 9613 9614 BEGIN { require Module; Module->import( LIST ); } 9615 9616except that Module I<must> be a bareword. 9617The importation can be made conditional by using the L<if> module. 9618 9619In the C<use VERSION> form, VERSION may be either a v-string such as 9620v5.24.1, which will be compared to L<C<$^V>|perlvar/$^V> (aka 9621$PERL_VERSION), or a numeric argument of the form 5.024001, which will 9622be compared to L<C<$]>|perlvar/$]>. An exception is raised if VERSION 9623is greater than the version of the current Perl interpreter; Perl will 9624not attempt to parse the rest of the file. Compare with 9625L<C<require>|/require VERSION>, which can do a similar check at run 9626time. Symmetrically, C<no VERSION> allows you to specify that you 9627want a version of Perl older than the specified one. 9628 9629Specifying VERSION as a numeric argument of the form 5.024001 should 9630generally be avoided as older less readable syntax compared to 9631v5.24.1. Before perl 5.8.0 released in 2002 the more verbose numeric 9632form was the only supported syntax, which is why you might see it in 9633 9634 use v5.24.1; # compile time version check 9635 use 5.24.1; # ditto 9636 use 5.024_001; # ditto; older syntax compatible with perl 5.6 9637 9638This is often useful if you need to check the current Perl version before 9639L<C<use>|/use Module VERSION LIST>ing library modules that won't work 9640with older versions of Perl. 9641(We try not to do this more than we have to.) 9642 9643C<use VERSION> lexically enables all features available in the requested 9644version as defined by the L<feature> pragma, disabling any features 9645not in the requested version's feature bundle. See L<feature>. 9646If the specified Perl version is greater than or equal to 96475.12.0, strictures are enabled lexically as 9648with L<C<use strict>|strict>. 9649Similarly, L<warnings> are enabled if C<VERSION> is 5.35.0 or higher. 9650Any explicit use of C<use strict> or C<no strict> overrides C<use VERSION>, 9651even if it comes before it. 9652Later use of C<use VERSION> will override all behavior of a previous 9653C<use VERSION>, possibly removing the C<strict>, C<warnings>, and C<feature> 9654added by C<use VERSION>. C<use VERSION> does not 9655load the F<feature.pm>, F<strict.pm>, or F<warnings.pm> 9656files. 9657 9658The C<BEGIN> forces the L<C<require>|/require VERSION> and 9659L<C<import>|/import LIST> to happen at compile time. The 9660L<C<require>|/require VERSION> makes sure the module is loaded into 9661memory if it hasn't been yet. The L<C<import>|/import LIST> is not a 9662builtin; it's just an ordinary static method 9663call into the C<Module> package to tell the module to import the list of 9664features back into the current package. The module can implement its 9665L<C<import>|/import LIST> method any way it likes, though most modules 9666just choose to derive their L<C<import>|/import LIST> method via 9667inheritance from the C<Exporter> class that is defined in the 9668L<C<Exporter>|Exporter> module. See L<Exporter>. If no 9669L<C<import>|/import LIST> method can be found, then the call is skipped, 9670even if there is an AUTOLOAD method. 9671 9672If you do not want to call the package's L<C<import>|/import LIST> 9673method (for instance, 9674to stop your namespace from being altered), explicitly supply the empty list: 9675 9676 use Module (); 9677 9678That is exactly equivalent to 9679 9680 BEGIN { require Module } 9681 9682If the VERSION argument is present between Module and LIST, then the 9683L<C<use>|/use Module VERSION LIST> will call the C<VERSION> method in 9684class Module with the given version as an argument: 9685 9686 use Module 12.34; 9687 9688is equivalent to: 9689 9690 BEGIN { require Module; Module->VERSION(12.34) } 9691 9692The L<default C<VERSION> method|UNIVERSAL/C<VERSION ( [ REQUIRE ] )>>, 9693inherited from the L<C<UNIVERSAL>|UNIVERSAL> class, croaks if the given 9694version is larger than the value of the variable C<$Module::VERSION>. 9695 9696The VERSION argument cannot be an arbitrary expression. It only counts 9697as a VERSION argument if it is a version number literal, starting with 9698either a digit or C<v> followed by a digit. Anything that doesn't 9699look like a version literal will be parsed as the start of the LIST. 9700Nevertheless, many attempts to use an arbitrary expression as a VERSION 9701argument will appear to work, because L<Exporter>'s C<import> method 9702handles numeric arguments specially, performing version checks rather 9703than treating them as things to export. 9704 9705Again, there is a distinction between omitting LIST (L<C<import>|/import 9706LIST> called with no arguments) and an explicit empty LIST C<()> 9707(L<C<import>|/import LIST> not called). Note that there is no comma 9708after VERSION! 9709 9710Because this is a wide-open interface, pragmas (compiler directives) 9711are also implemented this way. Some of the currently implemented 9712pragmas are: 9713 9714 use constant; 9715 use diagnostics; 9716 use integer; 9717 use sigtrap qw(SEGV BUS); 9718 use strict qw(subs vars refs); 9719 use subs qw(afunc blurfl); 9720 use warnings qw(all); 9721 use sort qw(stable); 9722 9723Some of these pseudo-modules import semantics into the current 9724block scope (like L<C<strict>|strict> or L<C<integer>|integer>, unlike 9725ordinary modules, which import symbols into the current package (which 9726are effective through the end of the file). 9727 9728Because L<C<use>|/use Module VERSION LIST> takes effect at compile time, 9729it doesn't respect the ordinary flow control of the code being compiled. 9730In particular, putting a L<C<use>|/use Module VERSION LIST> inside the 9731false branch of a conditional doesn't prevent it 9732from being processed. If a module or pragma only needs to be loaded 9733conditionally, this can be done using the L<if> pragma: 9734 9735 use if $] < 5.008, "utf8"; 9736 use if WANT_WARNINGS, warnings => qw(all); 9737 9738There's a corresponding L<C<no>|/no MODULE VERSION LIST> declaration 9739that unimports meanings imported by L<C<use>|/use Module VERSION LIST>, 9740i.e., it calls C<< Module->unimport(LIST) >> instead of 9741L<C<import>|/import LIST>. It behaves just as L<C<import>|/import LIST> 9742does with VERSION, an omitted or empty LIST, 9743or no unimport method being found. 9744 9745 no integer; 9746 no strict 'refs'; 9747 no warnings; 9748 9749Care should be taken when using the C<no VERSION> form of L<C<no>|/no 9750MODULE VERSION LIST>. It is 9751I<only> meant to be used to assert that the running Perl is of a earlier 9752version than its argument and I<not> to undo the feature-enabling side effects 9753of C<use VERSION>. 9754 9755See L<perlmodlib> for a list of standard modules and pragmas. See 9756L<perlrun|perlrun/-m[-]module> for the C<-M> and C<-m> command-line 9757options to Perl that give L<C<use>|/use Module VERSION LIST> 9758functionality from the command-line. 9759 9760=item utime LIST 9761X<utime> 9762 9763=for Pod::Functions set a file's last access and modify times 9764 9765Changes the access and modification times on each file of a list of 9766files. The first two elements of the list must be the NUMERIC access 9767and modification times, in that order. Returns the number of files 9768successfully changed. The inode change time of each file is set 9769to the current time. For example, this code has the same effect as the 9770Unix L<touch(1)> command when the files I<already exist> and belong to 9771the user running the program: 9772 9773 #!/usr/bin/perl 9774 my $atime = my $mtime = time; 9775 utime $atime, $mtime, @ARGV; 9776 9777Since Perl 5.8.0, if the first two elements of the list are 9778L<C<undef>|/undef EXPR>, 9779the L<utime(2)> syscall from your C library is called with a null second 9780argument. On most systems, this will set the file's access and 9781modification times to the current time (i.e., equivalent to the example 9782above) and will work even on files you don't own provided you have write 9783permission: 9784 9785 for my $file (@ARGV) { 9786 utime(undef, undef, $file) 9787 || warn "Couldn't touch $file: $!"; 9788 } 9789 9790Under NFS this will use the time of the NFS server, not the time of 9791the local machine. If there is a time synchronization problem, the 9792NFS server and local machine will have different times. The Unix 9793L<touch(1)> command will in fact normally use this form instead of the 9794one shown in the first example. 9795 9796Passing only one of the first two elements as L<C<undef>|/undef EXPR> is 9797equivalent to passing a 0 and will not have the effect described when 9798both are L<C<undef>|/undef EXPR>. This also triggers an 9799uninitialized warning. 9800 9801On systems that support L<futimes(2)>, you may pass filehandles among the 9802files. On systems that don't support L<futimes(2)>, passing filehandles raises 9803an exception. Filehandles must be passed as globs or glob references to be 9804recognized; barewords are considered filenames. 9805 9806Portability issues: L<perlport/utime>. 9807 9808=item values HASH 9809X<values> 9810 9811=item values ARRAY 9812 9813=for Pod::Functions return a list of the values in a hash 9814 9815In list context, returns a list consisting of all the values of the named 9816hash. In Perl 5.12 or later only, will also return a list of the values of 9817an array; prior to that release, attempting to use an array argument will 9818produce a syntax error. In scalar context, returns the number of values. 9819 9820Hash entries are returned in an apparently random order. The actual random 9821order is specific to a given hash; the exact same series of operations 9822on two hashes may result in a different order for each hash. Any insertion 9823into the hash may change the order, as will any deletion, with the exception 9824that the most recent key returned by L<C<each>|/each HASH> or 9825L<C<keys>|/keys HASH> may be deleted without changing the order. So 9826long as a given hash is unmodified you may rely on 9827L<C<keys>|/keys HASH>, L<C<values>|/values HASH> and 9828L<C<each>|/each HASH> to repeatedly return the same order 9829as each other. See L<perlsec/"Algorithmic Complexity Attacks"> for 9830details on why hash order is randomized. Aside from the guarantees 9831provided here the exact details of Perl's hash algorithm and the hash 9832traversal order are subject to change in any release of Perl. Tied hashes 9833may behave differently to Perl's hashes with respect to changes in order on 9834insertion and deletion of items. 9835 9836As a side effect, calling L<C<values>|/values HASH> resets the HASH or 9837ARRAY's internal iterator (see L<C<each>|/each HASH>) before yielding the 9838values. In particular, 9839calling L<C<values>|/values HASH> in void context resets the iterator 9840with no other overhead. 9841 9842Apart from resetting the iterator, 9843C<values @array> in list context is the same as plain C<@array>. 9844(We recommend that you use void context C<keys @array> for this, but 9845reasoned that taking C<values @array> out would require more 9846documentation than leaving it in.) 9847 9848Note that the values are not copied, which means modifying them will 9849modify the contents of the hash: 9850 9851 for (values %hash) { s/foo/bar/g } # modifies %hash values 9852 for (@hash{keys %hash}) { s/foo/bar/g } # same 9853 9854Starting with Perl 5.14, an experimental feature allowed 9855L<C<values>|/values HASH> to take a 9856scalar expression. This experiment has been deemed unsuccessful, and was 9857removed as of Perl 5.24. 9858 9859To avoid confusing would-be users of your code who are running earlier 9860versions of Perl with mysterious syntax errors, put this sort of thing at 9861the top of your file to signal that your code will work I<only> on Perls of 9862a recent vintage: 9863 9864 use 5.012; # so keys/values/each work on arrays 9865 9866See also L<C<keys>|/keys HASH>, L<C<each>|/each HASH>, and 9867L<C<sort>|/sort SUBNAME LIST>. 9868 9869=item vec EXPR,OFFSET,BITS 9870X<vec> X<bit> X<bit vector> 9871 9872=for Pod::Functions test or set particular bits in a string 9873 9874Treats the string in EXPR as a bit vector made up of elements of 9875width BITS and returns the value of the element specified by OFFSET 9876as an unsigned integer. BITS therefore specifies the number of bits 9877that are reserved for each element in the bit vector. This must 9878be a power of two from 1 to 32 (or 64, if your platform supports 9879that). 9880 9881If BITS is 8, "elements" coincide with bytes of the input string. 9882 9883If BITS is 16 or more, bytes of the input string are grouped into chunks 9884of size BITS/8, and each group is converted to a number as with 9885L<C<pack>|/pack TEMPLATE,LIST>/L<C<unpack>|/unpack TEMPLATE,EXPR> with 9886big-endian formats C<n>/C<N> (and analogously for BITS==64). See 9887L<C<pack>|/pack TEMPLATE,LIST> for details. 9888 9889If bits is 4 or less, the string is broken into bytes, then the bits 9890of each byte are broken into 8/BITS groups. Bits of a byte are 9891numbered in a little-endian-ish way, as in C<0x01>, C<0x02>, 9892C<0x04>, C<0x08>, C<0x10>, C<0x20>, C<0x40>, C<0x80>. For example, 9893breaking the single input byte C<chr(0x36)> into two groups gives a list 9894C<(0x6, 0x3)>; breaking it into 4 groups gives C<(0x2, 0x1, 0x3, 0x0)>. 9895 9896L<C<vec>|/vec EXPR,OFFSET,BITS> may also be assigned to, in which case 9897parentheses are needed 9898to give the expression the correct precedence as in 9899 9900 vec($image, $max_x * $x + $y, 8) = 3; 9901 9902If the selected element is outside the string, the value 0 is returned. 9903If an element off the end of the string is written to, Perl will first 9904extend the string with sufficiently many zero bytes. It is an error 9905to try to write off the beginning of the string (i.e., negative OFFSET). 9906 9907If the string happens to be encoded as UTF-8 internally (and thus has 9908the UTF8 flag set), L<C<vec>|/vec EXPR,OFFSET,BITS> tries to convert it 9909to use a one-byte-per-character internal representation. However, if the 9910string contains characters with values of 256 or higher, a fatal error 9911will occur. 9912 9913Strings created with L<C<vec>|/vec EXPR,OFFSET,BITS> can also be 9914manipulated with the logical 9915operators C<|>, C<&>, C<^>, and C<~>. These operators will assume a bit 9916vector operation is desired when both operands are strings. 9917See L<perlop/"Bitwise String Operators">. 9918 9919The following code will build up an ASCII string saying C<'PerlPerlPerl'>. 9920The comments show the string after each step. Note that this code works 9921in the same way on big-endian or little-endian machines. 9922 9923 my $foo = ''; 9924 vec($foo, 0, 32) = 0x5065726C; # 'Perl' 9925 9926 # $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits 9927 print vec($foo, 0, 8); # prints 80 == 0x50 == ord('P') 9928 9929 vec($foo, 2, 16) = 0x5065; # 'PerlPe' 9930 vec($foo, 3, 16) = 0x726C; # 'PerlPerl' 9931 vec($foo, 8, 8) = 0x50; # 'PerlPerlP' 9932 vec($foo, 9, 8) = 0x65; # 'PerlPerlPe' 9933 vec($foo, 20, 4) = 2; # 'PerlPerlPe' . "\x02" 9934 vec($foo, 21, 4) = 7; # 'PerlPerlPer' 9935 # 'r' is "\x72" 9936 vec($foo, 45, 2) = 3; # 'PerlPerlPer' . "\x0c" 9937 vec($foo, 93, 1) = 1; # 'PerlPerlPer' . "\x2c" 9938 vec($foo, 94, 1) = 1; # 'PerlPerlPerl' 9939 # 'l' is "\x6c" 9940 9941To transform a bit vector into a string or list of 0's and 1's, use these: 9942 9943 my $bits = unpack("b*", $vector); 9944 my @bits = split(//, unpack("b*", $vector)); 9945 9946If you know the exact length in bits, it can be used in place of the C<*>. 9947 9948Here is an example to illustrate how the bits actually fall in place: 9949 9950 #!/usr/bin/perl -wl 9951 9952 print <<'EOT'; 9953 0 1 2 3 9954 unpack("V",$_) 01234567890123456789012345678901 9955 ------------------------------------------------------------------ 9956 EOT 9957 9958 for $w (0..3) { 9959 $width = 2**$w; 9960 for ($shift=0; $shift < $width; ++$shift) { 9961 for ($off=0; $off < 32/$width; ++$off) { 9962 $str = pack("B*", "0"x32); 9963 $bits = (1<<$shift); 9964 vec($str, $off, $width) = $bits; 9965 $res = unpack("b*",$str); 9966 $val = unpack("V", $str); 9967 write; 9968 } 9969 } 9970 } 9971 9972 format STDOUT = 9973 vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9974 $off, $width, $bits, $val, $res 9975 . 9976 __END__ 9977 9978Regardless of the machine architecture on which it runs, the 9979example above should print the following table: 9980 9981 0 1 2 3 9982 unpack("V",$_) 01234567890123456789012345678901 9983 ------------------------------------------------------------------ 9984 vec($_, 0, 1) = 1 == 1 10000000000000000000000000000000 9985 vec($_, 1, 1) = 1 == 2 01000000000000000000000000000000 9986 vec($_, 2, 1) = 1 == 4 00100000000000000000000000000000 9987 vec($_, 3, 1) = 1 == 8 00010000000000000000000000000000 9988 vec($_, 4, 1) = 1 == 16 00001000000000000000000000000000 9989 vec($_, 5, 1) = 1 == 32 00000100000000000000000000000000 9990 vec($_, 6, 1) = 1 == 64 00000010000000000000000000000000 9991 vec($_, 7, 1) = 1 == 128 00000001000000000000000000000000 9992 vec($_, 8, 1) = 1 == 256 00000000100000000000000000000000 9993 vec($_, 9, 1) = 1 == 512 00000000010000000000000000000000 9994 vec($_,10, 1) = 1 == 1024 00000000001000000000000000000000 9995 vec($_,11, 1) = 1 == 2048 00000000000100000000000000000000 9996 vec($_,12, 1) = 1 == 4096 00000000000010000000000000000000 9997 vec($_,13, 1) = 1 == 8192 00000000000001000000000000000000 9998 vec($_,14, 1) = 1 == 16384 00000000000000100000000000000000 9999 vec($_,15, 1) = 1 == 32768 00000000000000010000000000000000 10000 vec($_,16, 1) = 1 == 65536 00000000000000001000000000000000 10001 vec($_,17, 1) = 1 == 131072 00000000000000000100000000000000 10002 vec($_,18, 1) = 1 == 262144 00000000000000000010000000000000 10003 vec($_,19, 1) = 1 == 524288 00000000000000000001000000000000 10004 vec($_,20, 1) = 1 == 1048576 00000000000000000000100000000000 10005 vec($_,21, 1) = 1 == 2097152 00000000000000000000010000000000 10006 vec($_,22, 1) = 1 == 4194304 00000000000000000000001000000000 10007 vec($_,23, 1) = 1 == 8388608 00000000000000000000000100000000 10008 vec($_,24, 1) = 1 == 16777216 00000000000000000000000010000000 10009 vec($_,25, 1) = 1 == 33554432 00000000000000000000000001000000 10010 vec($_,26, 1) = 1 == 67108864 00000000000000000000000000100000 10011 vec($_,27, 1) = 1 == 134217728 00000000000000000000000000010000 10012 vec($_,28, 1) = 1 == 268435456 00000000000000000000000000001000 10013 vec($_,29, 1) = 1 == 536870912 00000000000000000000000000000100 10014 vec($_,30, 1) = 1 == 1073741824 00000000000000000000000000000010 10015 vec($_,31, 1) = 1 == 2147483648 00000000000000000000000000000001 10016 vec($_, 0, 2) = 1 == 1 10000000000000000000000000000000 10017 vec($_, 1, 2) = 1 == 4 00100000000000000000000000000000 10018 vec($_, 2, 2) = 1 == 16 00001000000000000000000000000000 10019 vec($_, 3, 2) = 1 == 64 00000010000000000000000000000000 10020 vec($_, 4, 2) = 1 == 256 00000000100000000000000000000000 10021 vec($_, 5, 2) = 1 == 1024 00000000001000000000000000000000 10022 vec($_, 6, 2) = 1 == 4096 00000000000010000000000000000000 10023 vec($_, 7, 2) = 1 == 16384 00000000000000100000000000000000 10024 vec($_, 8, 2) = 1 == 65536 00000000000000001000000000000000 10025 vec($_, 9, 2) = 1 == 262144 00000000000000000010000000000000 10026 vec($_,10, 2) = 1 == 1048576 00000000000000000000100000000000 10027 vec($_,11, 2) = 1 == 4194304 00000000000000000000001000000000 10028 vec($_,12, 2) = 1 == 16777216 00000000000000000000000010000000 10029 vec($_,13, 2) = 1 == 67108864 00000000000000000000000000100000 10030 vec($_,14, 2) = 1 == 268435456 00000000000000000000000000001000 10031 vec($_,15, 2) = 1 == 1073741824 00000000000000000000000000000010 10032 vec($_, 0, 2) = 2 == 2 01000000000000000000000000000000 10033 vec($_, 1, 2) = 2 == 8 00010000000000000000000000000000 10034 vec($_, 2, 2) = 2 == 32 00000100000000000000000000000000 10035 vec($_, 3, 2) = 2 == 128 00000001000000000000000000000000 10036 vec($_, 4, 2) = 2 == 512 00000000010000000000000000000000 10037 vec($_, 5, 2) = 2 == 2048 00000000000100000000000000000000 10038 vec($_, 6, 2) = 2 == 8192 00000000000001000000000000000000 10039 vec($_, 7, 2) = 2 == 32768 00000000000000010000000000000000 10040 vec($_, 8, 2) = 2 == 131072 00000000000000000100000000000000 10041 vec($_, 9, 2) = 2 == 524288 00000000000000000001000000000000 10042 vec($_,10, 2) = 2 == 2097152 00000000000000000000010000000000 10043 vec($_,11, 2) = 2 == 8388608 00000000000000000000000100000000 10044 vec($_,12, 2) = 2 == 33554432 00000000000000000000000001000000 10045 vec($_,13, 2) = 2 == 134217728 00000000000000000000000000010000 10046 vec($_,14, 2) = 2 == 536870912 00000000000000000000000000000100 10047 vec($_,15, 2) = 2 == 2147483648 00000000000000000000000000000001 10048 vec($_, 0, 4) = 1 == 1 10000000000000000000000000000000 10049 vec($_, 1, 4) = 1 == 16 00001000000000000000000000000000 10050 vec($_, 2, 4) = 1 == 256 00000000100000000000000000000000 10051 vec($_, 3, 4) = 1 == 4096 00000000000010000000000000000000 10052 vec($_, 4, 4) = 1 == 65536 00000000000000001000000000000000 10053 vec($_, 5, 4) = 1 == 1048576 00000000000000000000100000000000 10054 vec($_, 6, 4) = 1 == 16777216 00000000000000000000000010000000 10055 vec($_, 7, 4) = 1 == 268435456 00000000000000000000000000001000 10056 vec($_, 0, 4) = 2 == 2 01000000000000000000000000000000 10057 vec($_, 1, 4) = 2 == 32 00000100000000000000000000000000 10058 vec($_, 2, 4) = 2 == 512 00000000010000000000000000000000 10059 vec($_, 3, 4) = 2 == 8192 00000000000001000000000000000000 10060 vec($_, 4, 4) = 2 == 131072 00000000000000000100000000000000 10061 vec($_, 5, 4) = 2 == 2097152 00000000000000000000010000000000 10062 vec($_, 6, 4) = 2 == 33554432 00000000000000000000000001000000 10063 vec($_, 7, 4) = 2 == 536870912 00000000000000000000000000000100 10064 vec($_, 0, 4) = 4 == 4 00100000000000000000000000000000 10065 vec($_, 1, 4) = 4 == 64 00000010000000000000000000000000 10066 vec($_, 2, 4) = 4 == 1024 00000000001000000000000000000000 10067 vec($_, 3, 4) = 4 == 16384 00000000000000100000000000000000 10068 vec($_, 4, 4) = 4 == 262144 00000000000000000010000000000000 10069 vec($_, 5, 4) = 4 == 4194304 00000000000000000000001000000000 10070 vec($_, 6, 4) = 4 == 67108864 00000000000000000000000000100000 10071 vec($_, 7, 4) = 4 == 1073741824 00000000000000000000000000000010 10072 vec($_, 0, 4) = 8 == 8 00010000000000000000000000000000 10073 vec($_, 1, 4) = 8 == 128 00000001000000000000000000000000 10074 vec($_, 2, 4) = 8 == 2048 00000000000100000000000000000000 10075 vec($_, 3, 4) = 8 == 32768 00000000000000010000000000000000 10076 vec($_, 4, 4) = 8 == 524288 00000000000000000001000000000000 10077 vec($_, 5, 4) = 8 == 8388608 00000000000000000000000100000000 10078 vec($_, 6, 4) = 8 == 134217728 00000000000000000000000000010000 10079 vec($_, 7, 4) = 8 == 2147483648 00000000000000000000000000000001 10080 vec($_, 0, 8) = 1 == 1 10000000000000000000000000000000 10081 vec($_, 1, 8) = 1 == 256 00000000100000000000000000000000 10082 vec($_, 2, 8) = 1 == 65536 00000000000000001000000000000000 10083 vec($_, 3, 8) = 1 == 16777216 00000000000000000000000010000000 10084 vec($_, 0, 8) = 2 == 2 01000000000000000000000000000000 10085 vec($_, 1, 8) = 2 == 512 00000000010000000000000000000000 10086 vec($_, 2, 8) = 2 == 131072 00000000000000000100000000000000 10087 vec($_, 3, 8) = 2 == 33554432 00000000000000000000000001000000 10088 vec($_, 0, 8) = 4 == 4 00100000000000000000000000000000 10089 vec($_, 1, 8) = 4 == 1024 00000000001000000000000000000000 10090 vec($_, 2, 8) = 4 == 262144 00000000000000000010000000000000 10091 vec($_, 3, 8) = 4 == 67108864 00000000000000000000000000100000 10092 vec($_, 0, 8) = 8 == 8 00010000000000000000000000000000 10093 vec($_, 1, 8) = 8 == 2048 00000000000100000000000000000000 10094 vec($_, 2, 8) = 8 == 524288 00000000000000000001000000000000 10095 vec($_, 3, 8) = 8 == 134217728 00000000000000000000000000010000 10096 vec($_, 0, 8) = 16 == 16 00001000000000000000000000000000 10097 vec($_, 1, 8) = 16 == 4096 00000000000010000000000000000000 10098 vec($_, 2, 8) = 16 == 1048576 00000000000000000000100000000000 10099 vec($_, 3, 8) = 16 == 268435456 00000000000000000000000000001000 10100 vec($_, 0, 8) = 32 == 32 00000100000000000000000000000000 10101 vec($_, 1, 8) = 32 == 8192 00000000000001000000000000000000 10102 vec($_, 2, 8) = 32 == 2097152 00000000000000000000010000000000 10103 vec($_, 3, 8) = 32 == 536870912 00000000000000000000000000000100 10104 vec($_, 0, 8) = 64 == 64 00000010000000000000000000000000 10105 vec($_, 1, 8) = 64 == 16384 00000000000000100000000000000000 10106 vec($_, 2, 8) = 64 == 4194304 00000000000000000000001000000000 10107 vec($_, 3, 8) = 64 == 1073741824 00000000000000000000000000000010 10108 vec($_, 0, 8) = 128 == 128 00000001000000000000000000000000 10109 vec($_, 1, 8) = 128 == 32768 00000000000000010000000000000000 10110 vec($_, 2, 8) = 128 == 8388608 00000000000000000000000100000000 10111 vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001 10112 10113=item wait 10114X<wait> 10115 10116=for Pod::Functions wait for any child process to die 10117 10118Behaves like L<wait(2)> on your system: it waits for a child 10119process to terminate and returns the pid of the deceased process, or 10120C<-1> if there are no child processes. The status is returned in 10121L<C<$?>|perlvar/$?> and 10122L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>. 10123Note that a return value of C<-1> could mean that child processes are 10124being automatically reaped, as described in L<perlipc>. 10125 10126If you use L<C<wait>|/wait> in your handler for 10127L<C<$SIG{CHLD}>|perlvar/%SIG>, it may accidentally wait for the child 10128created by L<C<qx>|/qxE<sol>STRINGE<sol>> or L<C<system>|/system LIST>. 10129See L<perlipc> for details. 10130 10131Portability issues: L<perlport/wait>. 10132 10133=item waitpid PID,FLAGS 10134X<waitpid> 10135 10136=for Pod::Functions wait for a particular child process to die 10137 10138Waits for a particular child process to terminate and returns the pid of 10139the deceased process, or C<-1> if there is no such child process. A 10140non-blocking wait (with L<WNOHANG|POSIX/C<WNOHANG>> in FLAGS) can return 0 if 10141there are child processes matching PID but none have terminated yet. 10142The status is returned in L<C<$?>|perlvar/$?> and 10143L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>. 10144 10145A PID of C<0> indicates to wait for any child process whose process group ID is 10146equal to that of the current process. A PID of less than C<-1> indicates to 10147wait for any child process whose process group ID is equal to -PID. A PID of 10148C<-1> indicates to wait for any child process. 10149 10150If you say 10151 10152 use POSIX ":sys_wait_h"; 10153 10154 my $kid; 10155 do { 10156 $kid = waitpid(-1, WNOHANG); 10157 } while $kid > 0; 10158 10159or 10160 10161 1 while waitpid(-1, WNOHANG) > 0; 10162 10163then you can do a non-blocking wait for all pending zombie processes (see 10164L<POSIX/WAIT>). 10165Non-blocking wait is available on machines supporting either the 10166L<waitpid(2)> or L<wait4(2)> syscalls. However, waiting for a particular 10167pid with FLAGS of C<0> is implemented everywhere. (Perl emulates the 10168system call by remembering the status values of processes that have 10169exited but have not been harvested by the Perl script yet.) 10170 10171Note that on some systems, a return value of C<-1> could mean that child 10172processes are being automatically reaped. See L<perlipc> for details, 10173and for other examples. 10174 10175Portability issues: L<perlport/waitpid>. 10176 10177=item wantarray 10178X<wantarray> X<context> 10179 10180=for Pod::Functions get void vs scalar vs list context of current subroutine call 10181 10182Returns true if the context of the currently executing subroutine or 10183L<C<eval>|/eval EXPR> is looking for a list value. Returns false if the 10184context is 10185looking for a scalar. Returns the undefined value if the context is 10186looking for no value (void context). 10187 10188 return unless defined wantarray; # don't bother doing more 10189 my @a = complex_calculation(); 10190 return wantarray ? @a : "@a"; 10191 10192L<C<wantarray>|/wantarray>'s result is unspecified in the top level of a file, 10193in a C<BEGIN>, C<UNITCHECK>, C<CHECK>, C<INIT> or C<END> block, or 10194in a C<DESTROY> method. 10195 10196This function should have been named wantlist() instead. 10197 10198=item warn LIST 10199X<warn> X<warning> X<STDERR> 10200 10201=for Pod::Functions print debugging info 10202 10203Emits a warning, usually by printing it to C<STDERR>. C<warn> interprets 10204its operand LIST in the same way as C<die>, but is slightly different 10205in what it defaults to when LIST is empty or makes an empty string. 10206If it is empty and L<C<$@>|perlvar/$@> already contains an exception 10207value then that value is used after appending C<"\t...caught">. If it 10208is empty and C<$@> is also empty then the string C<"Warning: Something's 10209wrong"> is used. 10210 10211By default, the exception derived from the operand LIST is stringified 10212and printed to C<STDERR>. This behaviour can be altered by installing 10213a L<C<$SIG{__WARN__}>|perlvar/%SIG> handler. If there is such a 10214handler then no message is automatically printed; it is the handler's 10215responsibility to deal with the exception 10216as it sees fit (like, for instance, converting it into a 10217L<C<die>|/die LIST>). Most 10218handlers must therefore arrange to actually display the 10219warnings that they are not prepared to deal with, by calling 10220L<C<warn>|/warn LIST> 10221again in the handler. Note that this is quite safe and will not 10222produce an endless loop, since C<__WARN__> hooks are not called from 10223inside one. 10224 10225You will find this behavior is slightly different from that of 10226L<C<$SIG{__DIE__}>|perlvar/%SIG> handlers (which don't suppress the 10227error text, but can instead call L<C<die>|/die LIST> again to change 10228it). 10229 10230Using a C<__WARN__> handler provides a powerful way to silence all 10231warnings (even the so-called mandatory ones). An example: 10232 10233 # wipe out *all* compile-time warnings 10234 BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } } 10235 my $foo = 10; 10236 my $foo = 20; # no warning about duplicate my $foo, 10237 # but hey, you asked for it! 10238 # no compile-time or run-time warnings before here 10239 $DOWARN = 1; 10240 10241 # run-time warnings enabled after here 10242 warn "\$foo is alive and $foo!"; # does show up 10243 10244See L<perlvar> for details on setting L<C<%SIG>|perlvar/%SIG> entries 10245and for more 10246examples. See the L<Carp> module for other kinds of warnings using its 10247C<carp> and C<cluck> functions. 10248 10249=item write FILEHANDLE 10250X<write> 10251 10252=item write EXPR 10253 10254=item write 10255 10256=for Pod::Functions print a picture record 10257 10258Writes a formatted record (possibly multi-line) to the specified FILEHANDLE, 10259using the format associated with that file. By default the format for 10260a file is the one having the same name as the filehandle, but the 10261format for the current output channel (see the 10262L<C<select>|/select FILEHANDLE> function) may be set explicitly by 10263assigning the name of the format to the L<C<$~>|perlvar/$~> variable. 10264 10265Top of form processing is handled automatically: if there is insufficient 10266room on the current page for the formatted record, the page is advanced by 10267writing a form feed and a special top-of-page 10268format is used to format the new 10269page header before the record is written. By default, the top-of-page 10270format is the name of the filehandle with C<_TOP> appended, or C<top> 10271in the current package if the former does not exist. This would be a 10272problem with autovivified filehandles, but it may be dynamically set to the 10273format of your choice by assigning the name to the L<C<$^>|perlvar/$^> 10274variable while that filehandle is selected. The number of lines 10275remaining on the current page is in variable L<C<$->|perlvar/$->, which 10276can be set to C<0> to force a new page. 10277 10278If FILEHANDLE is unspecified, output goes to the current default output 10279channel, which starts out as STDOUT but may be changed by the 10280L<C<select>|/select FILEHANDLE> operator. If the FILEHANDLE is an EXPR, 10281then the expression 10282is evaluated and the resulting string is used to look up the name of 10283the FILEHANDLE at run time. For more on formats, see L<perlform>. 10284 10285Note that write is I<not> the opposite of 10286L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET>. Unfortunately. 10287 10288=item y/// 10289 10290=for Pod::Functions transliterate a string 10291 10292The transliteration operator. Same as 10293L<C<trE<sol>E<sol>E<sol>>|/trE<sol>E<sol>E<sol>>. See 10294L<perlop/"Quote-Like Operators">. 10295 10296=back 10297 10298=head2 Non-function Keywords by Cross-reference 10299 10300=head3 perldata 10301 10302=over 10303 10304=item __DATA__ 10305 10306=item __END__ 10307 10308These keywords are documented in L<perldata/"Special Literals">. 10309 10310=back 10311 10312=head3 perlmod 10313 10314=over 10315 10316=item BEGIN 10317 10318=item CHECK 10319 10320=item END 10321 10322=item INIT 10323 10324=item UNITCHECK 10325 10326These compile phase keywords are documented in L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT and END">. 10327 10328=back 10329 10330=head3 perlobj 10331 10332=over 10333 10334=item DESTROY 10335 10336This method keyword is documented in L<perlobj/"Destructors">. 10337 10338=back 10339 10340=head3 perlop 10341 10342=over 10343 10344=item and 10345 10346=item cmp 10347 10348=item eq 10349 10350=item ge 10351 10352=item gt 10353 10354=item le 10355 10356=item lt 10357 10358=item ne 10359 10360=item not 10361 10362=item or 10363 10364=item x 10365 10366=item xor 10367 10368These operators are documented in L<perlop>. 10369 10370=back 10371 10372=head3 perlsub 10373 10374=over 10375 10376=item AUTOLOAD 10377 10378This keyword is documented in L<perlsub/"Autoloading">. 10379 10380=back 10381 10382=head3 perlsyn 10383 10384=over 10385 10386=item else 10387 10388=item elsif 10389 10390=item for 10391 10392=item foreach 10393 10394=item if 10395 10396=item unless 10397 10398=item until 10399 10400=item while 10401 10402These flow-control keywords are documented in L<perlsyn/"Compound Statements">. 10403 10404=item elseif 10405 10406The "else if" keyword is spelled C<elsif> in Perl. There's no C<elif> 10407or C<else if> either. It does parse C<elseif>, but only to warn you 10408about not using it. 10409 10410See the documentation for flow-control keywords in L<perlsyn/"Compound 10411Statements">. 10412 10413=back 10414 10415=over 10416 10417=item default 10418 10419=item given 10420 10421=item when 10422 10423These flow-control keywords related to the experimental switch feature are 10424documented in L<perlsyn/"Switch Statements">. 10425 10426=back 10427 10428=cut 10429