This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
narrow scope of argsv in sv_vcatpvfn_flags()
[perl5.git] / pod / perlfunc.pod
CommitLineData
a0d0e21e 1=head1 NAME
d74e8afc 2X<function>
a0d0e21e
LW
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
8f1da26d 15operator. A unary operator generally provides scalar context to its
2b5ab1e7 16argument, while a list operator may provide either scalar or list
2263ed23 17contexts for its arguments. If it does both, scalar arguments
3b10bc60 18come first and list argument follow, and there can only ever
2263ed23
LM
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.
a0d0e21e
LW
23
24In the syntax descriptions that follow, list operators that expect a
3b10bc60 25list (and provide list context for elements of the list) are shown
a0d0e21e
LW
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.
8bdbc703 30Commas should separate literal elements of the LIST.
a0d0e21e
LW
31
32Any function in the list below may be used either with or without
33parentheses around its arguments. (The syntax descriptions omit the
2263ed23 34parentheses.) If you use parentheses, the simple but occasionally
3b10bc60 35surprising rule is this: It I<looks> like a function, therefore it I<is> a
a0d0e21e 36function, and precedence doesn't matter. Otherwise it's a list
3b10bc60 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:
a0d0e21e 40
5ed4f2ec 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.
a0d0e21e 46
2263ed23
LM
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:
a0d0e21e
LW
49
50 print (...) interpreted as function at - line 1.
51 Useless use of integer addition in void context at - line 1.
52
2b5ab1e7 53A few functions take no arguments at all, and therefore work as neither
2263ed23
LM
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>.
2b5ab1e7 57
a0d0e21e 58For functions that can be used in either a scalar or list context,
8f1da26d
TC
59nonabortive failure is generally indicated in scalar context by
60returning the undefined value, and in list context by returning the
3b10bc60 61empty list.
a0d0e21e 62
5a964f20
TC
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.
80d38338 66Each operator and function decides which sort of value would be most
2b5ab1e7 67appropriate to return in scalar context. Some operators return the
5a964f20 68length of the list that would have been returned in list context. Some
a0d0e21e
LW
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.
d74e8afc 73X<context>
a0d0e21e 74
d1be9408 75A named array in scalar context is quite different from what would at
5a964f20
TC
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
2263ed23 79there, not the list concatenation version of the comma. That means it
5a964f20
TC
80was never a list to start with.
81
2263ed23
LM
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.
5a964f20 92
88e1f1a2
JV
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
cb1a09d0 101=head2 Perl Functions by Category
d74e8afc 102X<function>
cb1a09d0
AD
103
104Here are Perl's functions (including things that look like
5a964f20 105functions, like some keywords and named operators)
cb1a09d0 106arranged by category. Some functions appear in more
e135ff69 107than one place. Any warnings, including those produced by
3cd73558 108keywords, are described in L<perldiag> and L<warnings>.
cb1a09d0 109
13a2d996 110=over 4
cb1a09d0
AD
111
112=item Functions for SCALARs or strings
d74e8afc 113X<scalar> X<string> X<character>
cb1a09d0 114
c17cdb72
NC
115=for Pod::Functions =String
116
2263ed23
LM
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
3dd9a840 137with a C<use v5.16> (or higher) declaration in the current scope.
4fe70ef9 138
cb1a09d0 139=item Regular expressions and pattern matching
d74e8afc 140X<regular expression> X<regex> X<regexp>
cb1a09d0 141
c17cdb72
NC
142=for Pod::Functions =Regexp
143
2263ed23
LM
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>
cb1a09d0
AD
150
151=item Numeric functions
d74e8afc 152X<numeric> X<number> X<trigonometric> X<trigonometry>
cb1a09d0 153
c17cdb72
NC
154=for Pod::Functions =Math
155
2263ed23
LM
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>
cb1a09d0
AD
160
161=item Functions for real @ARRAYs
d74e8afc 162X<array>
cb1a09d0 163
c17cdb72
NC
164=for Pod::Functions =ARRAY
165
2263ed23
LM
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>
cb1a09d0
AD
170
171=item Functions for list data
d74e8afc 172X<list>
cb1a09d0 173
c17cdb72
NC
174=for Pod::Functions =LIST
175
2263ed23
LM
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>
cb1a09d0
AD
180
181=item Functions for real %HASHes
d74e8afc 182X<hash>
cb1a09d0 183
c17cdb72
NC
184=for Pod::Functions =HASH
185
2263ed23
LM
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>
cb1a09d0
AD
189
190=item Input and output functions
d74e8afc 191X<I/O> X<input> X<output> X<dbm>
cb1a09d0 192
c17cdb72
NC
193=for Pod::Functions =I/O
194
2263ed23
LM
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>,
db5fc40a 203L<C<readdir>|/readdir DIRHANDLE>, L<C<readline>|/readline EXPR>,
2263ed23
LM
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
4fe70ef9
NC
220with a C<use v5.10> (or higher) declaration in the current scope.
221
5dac7880 222=item Functions for fixed-length data or records
cb1a09d0 223
c17cdb72
NC
224=for Pod::Functions =Binary
225
2263ed23
LM
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>
cb1a09d0
AD
233
234=item Functions for filehandles, files, or directories
d74e8afc 235X<file> X<filehandle> X<directory> X<pipe> X<link> X<symlink>
cb1a09d0 236
c17cdb72
NC
237=for Pod::Functions =File
238
2263ed23
LM
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>,
c6841f36 245L<C<mkdir>|/mkdir FILENAME,MODE>, L<C<open>|/open FILEHANDLE,EXPR>,
2263ed23
LM
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>
cb1a09d0 253
cf264981 254=item Keywords related to the control flow of your Perl program
d74e8afc 255X<control flow>
cb1a09d0 256
c17cdb72
NC
257=for Pod::Functions =Flow
258
97b4caa6 259L<C<caller>|/caller EXPR>,
2263ed23
LM
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>,
db5fc40a 262L<C<evalbytes>|/evalbytes EXPR>, L<C<exit>|/exit EXPR>,
2263ed23
LM
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
97b4caa6
Z
270In Perl v5.14 and earlier, L<C<continue>|/continue BLOCK>
271required the L<C<"switch"> feature|feature/The 'switch' feature> to
272be enabled.
2263ed23
LM
273
274L<C<evalbytes>|/evalbytes EXPR> is only available with the
275L<C<"evalbytes"> feature|feature/The 'unicode_eval' and 'evalbytes' features>
276(see L<feature>) or if prefixed with C<CORE::>. L<C<__SUB__>|/__SUB__>
277is only available with the
278L<C<"current_sub"> feature|feature/The 'current_sub' feature> or if
279prefixed with C<CORE::>. Both the
280L<C<"evalbytes">|feature/The 'unicode_eval' and 'evalbytes' features>
281and L<C<"current_sub">|feature/The 'current_sub' feature> features are
282enabled automatically with a C<use v5.16> (or higher) declaration in the
283current scope.
cb1a09d0 284
54310121 285=item Keywords related to scoping
cb1a09d0 286
c17cdb72
NC
287=for Pod::Functions =Namespace
288
2263ed23
LM
289L<C<caller>|/caller EXPR>, L<C<import>|/import LIST>,
290L<C<local>|/local EXPR>, L<C<my>|/my VARLIST>, L<C<our>|/our VARLIST>,
291L<C<package>|/package NAMESPACE>, L<C<state>|/state VARLIST>,
292L<C<use>|/use Module VERSION LIST>
36fb85f3 293
2263ed23
LM
294L<C<state>|/state VARLIST> is available only if the
295L<C<"state"> feature|feature/The 'state' feature> is enabled or if it is
296prefixed with C<CORE::>. The
297L<C<"state"> feature|feature/The 'state' feature> is enabled
298automatically with a C<use v5.10> (or higher) declaration in the current
299scope.
cb1a09d0
AD
300
301=item Miscellaneous functions
302
c17cdb72
NC
303=for Pod::Functions =Misc
304
2263ed23
LM
305L<C<defined>|/defined EXPR>, L<C<formline>|/formline PICTURE,LIST>,
306L<C<lock>|/lock THING>, L<C<prototype>|/prototype FUNCTION>,
307L<C<reset>|/reset EXPR>, L<C<scalar>|/scalar EXPR>,
308L<C<undef>|/undef EXPR>
cb1a09d0
AD
309
310=item Functions for processes and process groups
d74e8afc 311X<process> X<pid> X<process id>
cb1a09d0 312
c17cdb72
NC
313=for Pod::Functions =Process
314
2263ed23
LM
315L<C<alarm>|/alarm SECONDS>, L<C<exec>|/exec LIST>, L<C<fork>|/fork>,
316L<C<getpgrp>|/getpgrp PID>, L<C<getppid>|/getppid>,
317L<C<getpriority>|/getpriority WHICH,WHO>, L<C<kill>|/kill SIGNAL, LIST>,
318L<C<pipe>|/pipe READHANDLE,WRITEHANDLE>,
319L<C<qxE<sol>E<sol>>|/qxE<sol>STRINGE<sol>>,
320L<C<readpipe>|/readpipe EXPR>, L<C<setpgrp>|/setpgrp PID,PGRP>,
321L<C<setpriority>|/setpriority WHICH,WHO,PRIORITY>,
322L<C<sleep>|/sleep EXPR>, L<C<system>|/system LIST>, L<C<times>|/times>,
323L<C<wait>|/wait>, L<C<waitpid>|/waitpid PID,FLAGS>
cb1a09d0 324
3b10bc60 325=item Keywords related to Perl modules
d74e8afc 326X<module>
cb1a09d0 327
c17cdb72
NC
328=for Pod::Functions =Modules
329
2263ed23
LM
330L<C<do>|/do EXPR>, L<C<import>|/import LIST>,
331L<C<no>|/no MODULE VERSION LIST>, L<C<package>|/package NAMESPACE>,
332L<C<require>|/require VERSION>, L<C<use>|/use Module VERSION LIST>
cb1a09d0 333
353c6505 334=item Keywords related to classes and object-orientation
d74e8afc 335X<object> X<class> X<package>
cb1a09d0 336
c17cdb72
NC
337=for Pod::Functions =Objects
338
2263ed23
LM
339L<C<bless>|/bless REF,CLASSNAME>, L<C<dbmclose>|/dbmclose HASH>,
340L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>,
341L<C<package>|/package NAMESPACE>, L<C<ref>|/ref EXPR>,
342L<C<tie>|/tie VARIABLE,CLASSNAME,LIST>, L<C<tied>|/tied VARIABLE>,
343L<C<untie>|/untie VARIABLE>, L<C<use>|/use Module VERSION LIST>
cb1a09d0
AD
344
345=item Low-level socket functions
d74e8afc 346X<socket> X<sock>
cb1a09d0 347
c17cdb72
NC
348=for Pod::Functions =Socket
349
2263ed23
LM
350L<C<accept>|/accept NEWSOCKET,GENERICSOCKET>,
351L<C<bind>|/bind SOCKET,NAME>, L<C<connect>|/connect SOCKET,NAME>,
352L<C<getpeername>|/getpeername SOCKET>,
353L<C<getsockname>|/getsockname SOCKET>,
354L<C<getsockopt>|/getsockopt SOCKET,LEVEL,OPTNAME>,
355L<C<listen>|/listen SOCKET,QUEUESIZE>,
356L<C<recv>|/recv SOCKET,SCALAR,LENGTH,FLAGS>,
357L<C<send>|/send SOCKET,MSG,FLAGS,TO>,
358L<C<setsockopt>|/setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL>,
359L<C<shutdown>|/shutdown SOCKET,HOW>,
360L<C<socket>|/socket SOCKET,DOMAIN,TYPE,PROTOCOL>,
361L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL>
cb1a09d0
AD
362
363=item System V interprocess communication functions
d74e8afc 364X<IPC> X<System V> X<semaphore> X<shared memory> X<memory> X<message>
cb1a09d0 365
c17cdb72
NC
366=for Pod::Functions =SysV
367
2263ed23
LM
368L<C<msgctl>|/msgctl ID,CMD,ARG>, L<C<msgget>|/msgget KEY,FLAGS>,
369L<C<msgrcv>|/msgrcv ID,VAR,SIZE,TYPE,FLAGS>,
370L<C<msgsnd>|/msgsnd ID,MSG,FLAGS>,
371L<C<semctl>|/semctl ID,SEMNUM,CMD,ARG>,
372L<C<semget>|/semget KEY,NSEMS,FLAGS>, L<C<semop>|/semop KEY,OPSTRING>,
373L<C<shmctl>|/shmctl ID,CMD,ARG>, L<C<shmget>|/shmget KEY,SIZE,FLAGS>,
374L<C<shmread>|/shmread ID,VAR,POS,SIZE>,
375L<C<shmwrite>|/shmwrite ID,STRING,POS,SIZE>
cb1a09d0
AD
376
377=item Fetching user and group info
d74e8afc 378X<user> X<group> X<password> X<uid> X<gid> X<passwd> X</etc/passwd>
cb1a09d0 379
c17cdb72
NC
380=for Pod::Functions =User
381
2263ed23
LM
382L<C<endgrent>|/endgrent>, L<C<endhostent>|/endhostent>,
383L<C<endnetent>|/endnetent>, L<C<endpwent>|/endpwent>,
384L<C<getgrent>|/getgrent>, L<C<getgrgid>|/getgrgid GID>,
385L<C<getgrnam>|/getgrnam NAME>, L<C<getlogin>|/getlogin>,
386L<C<getpwent>|/getpwent>, L<C<getpwnam>|/getpwnam NAME>,
387L<C<getpwuid>|/getpwuid UID>, L<C<setgrent>|/setgrent>,
388L<C<setpwent>|/setpwent>
cb1a09d0
AD
389
390=item Fetching network info
d74e8afc 391X<network> X<protocol> X<host> X<hostname> X<IP> X<address> X<service>
cb1a09d0 392
c17cdb72
NC
393=for Pod::Functions =Network
394
2263ed23
LM
395L<C<endprotoent>|/endprotoent>, L<C<endservent>|/endservent>,
396L<C<gethostbyaddr>|/gethostbyaddr ADDR,ADDRTYPE>,
397L<C<gethostbyname>|/gethostbyname NAME>, L<C<gethostent>|/gethostent>,
398L<C<getnetbyaddr>|/getnetbyaddr ADDR,ADDRTYPE>,
399L<C<getnetbyname>|/getnetbyname NAME>, L<C<getnetent>|/getnetent>,
400L<C<getprotobyname>|/getprotobyname NAME>,
401L<C<getprotobynumber>|/getprotobynumber NUMBER>,
402L<C<getprotoent>|/getprotoent>,
403L<C<getservbyname>|/getservbyname NAME,PROTO>,
404L<C<getservbyport>|/getservbyport PORT,PROTO>,
405L<C<getservent>|/getservent>, L<C<sethostent>|/sethostent STAYOPEN>,
406L<C<setnetent>|/setnetent STAYOPEN>,
407L<C<setprotoent>|/setprotoent STAYOPEN>,
408L<C<setservent>|/setservent STAYOPEN>
cb1a09d0
AD
409
410=item Time-related functions
d74e8afc 411X<time> X<date>
cb1a09d0 412
c17cdb72
NC
413=for Pod::Functions =Time
414
2263ed23
LM
415L<C<gmtime>|/gmtime EXPR>, L<C<localtime>|/localtime EXPR>,
416L<C<time>|/time>, L<C<times>|/times>
cb1a09d0 417
8f0d6a61
RS
418=item Non-function keywords
419
c17cdb72
NC
420=for Pod::Functions =!Non-functions
421
f5fa2679 422C<and>, C<AUTOLOAD>, C<BEGIN>, C<CHECK>, C<cmp>, C<CORE>, C<__DATA__>,
869b8c11 423C<DESTROY>, C<else>, C<elseif>, C<elsif>, C<END>, C<__END__>,
dba7b065 424C<eq>, C<for>, C<foreach>, C<ge>, C<given>, C<gt>, C<if>, C<INIT>, C<le>,
f68519ee
Z
425C<lt>, C<ne>, C<not>, C<or>, C<UNITCHECK>, C<unless>, C<until>,
426C<whereis>, C<whereso>, C<while>, C<x>, C<xor>
8f0d6a61 427
cb1a09d0
AD
428=back
429
60f9f73c 430=head2 Portability
d74e8afc 431X<portability> X<Unix> X<portable>
60f9f73c 432
2b5ab1e7
TC
433Perl was born in Unix and can therefore access all common Unix
434system calls. In non-Unix environments, the functionality of some
8f1da26d 435Unix system calls may not be available or details of the available
2b5ab1e7 436functionality may differ slightly. The Perl functions affected
60f9f73c
JH
437by this are:
438
2263ed23
LM
439L<C<-I<X>>|/-X FILEHANDLE>, L<C<binmode>|/binmode FILEHANDLE, LAYER>,
440L<C<chmod>|/chmod LIST>, L<C<chown>|/chown LIST>,
441L<C<chroot>|/chroot FILENAME>, L<C<crypt>|/crypt PLAINTEXT,SALT>,
442L<C<dbmclose>|/dbmclose HASH>, L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>,
443L<C<dump>|/dump LABEL>, L<C<endgrent>|/endgrent>,
444L<C<endhostent>|/endhostent>, L<C<endnetent>|/endnetent>,
445L<C<endprotoent>|/endprotoent>, L<C<endpwent>|/endpwent>,
446L<C<endservent>|/endservent>, L<C<exec>|/exec LIST>,
447L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR>,
448L<C<flock>|/flock FILEHANDLE,OPERATION>, L<C<fork>|/fork>,
449L<C<getgrent>|/getgrent>, L<C<getgrgid>|/getgrgid GID>,
450L<C<gethostbyname>|/gethostbyname NAME>, L<C<gethostent>|/gethostent>,
451L<C<getlogin>|/getlogin>,
452L<C<getnetbyaddr>|/getnetbyaddr ADDR,ADDRTYPE>,
453L<C<getnetbyname>|/getnetbyname NAME>, L<C<getnetent>|/getnetent>,
454L<C<getppid>|/getppid>, L<C<getpgrp>|/getpgrp PID>,
455L<C<getpriority>|/getpriority WHICH,WHO>,
456L<C<getprotobynumber>|/getprotobynumber NUMBER>,
457L<C<getprotoent>|/getprotoent>, L<C<getpwent>|/getpwent>,
458L<C<getpwnam>|/getpwnam NAME>, L<C<getpwuid>|/getpwuid UID>,
459L<C<getservbyport>|/getservbyport PORT,PROTO>,
460L<C<getservent>|/getservent>,
461L<C<getsockopt>|/getsockopt SOCKET,LEVEL,OPTNAME>,
462L<C<glob>|/glob EXPR>, L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>,
463L<C<kill>|/kill SIGNAL, LIST>, L<C<link>|/link OLDFILE,NEWFILE>,
464L<C<lstat>|/lstat FILEHANDLE>, L<C<msgctl>|/msgctl ID,CMD,ARG>,
465L<C<msgget>|/msgget KEY,FLAGS>,
466L<C<msgrcv>|/msgrcv ID,VAR,SIZE,TYPE,FLAGS>,
467L<C<msgsnd>|/msgsnd ID,MSG,FLAGS>, L<C<open>|/open FILEHANDLE,EXPR>,
468L<C<pipe>|/pipe READHANDLE,WRITEHANDLE>, L<C<readlink>|/readlink EXPR>,
469L<C<rename>|/rename OLDNAME,NEWNAME>,
470L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT>,
471L<C<semctl>|/semctl ID,SEMNUM,CMD,ARG>,
472L<C<semget>|/semget KEY,NSEMS,FLAGS>, L<C<semop>|/semop KEY,OPSTRING>,
473L<C<setgrent>|/setgrent>, L<C<sethostent>|/sethostent STAYOPEN>,
474L<C<setnetent>|/setnetent STAYOPEN>, L<C<setpgrp>|/setpgrp PID,PGRP>,
475L<C<setpriority>|/setpriority WHICH,WHO,PRIORITY>,
476L<C<setprotoent>|/setprotoent STAYOPEN>, L<C<setpwent>|/setpwent>,
477L<C<setservent>|/setservent STAYOPEN>,
478L<C<setsockopt>|/setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL>,
479L<C<shmctl>|/shmctl ID,CMD,ARG>, L<C<shmget>|/shmget KEY,SIZE,FLAGS>,
480L<C<shmread>|/shmread ID,VAR,POS,SIZE>,
481L<C<shmwrite>|/shmwrite ID,STRING,POS,SIZE>,
482L<C<socket>|/socket SOCKET,DOMAIN,TYPE,PROTOCOL>,
483L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL>,
484L<C<stat>|/stat FILEHANDLE>, L<C<symlink>|/symlink OLDFILE,NEWFILE>,
485L<C<syscall>|/syscall NUMBER, LIST>,
486L<C<sysopen>|/sysopen FILEHANDLE,FILENAME,MODE>,
487L<C<system>|/system LIST>, L<C<times>|/times>,
488L<C<truncate>|/truncate FILEHANDLE,LENGTH>, L<C<umask>|/umask EXPR>,
489L<C<unlink>|/unlink LIST>, L<C<utime>|/utime LIST>, L<C<wait>|/wait>,
490L<C<waitpid>|/waitpid PID,FLAGS>
60f9f73c
JH
491
492For more information about the portability of these functions, see
493L<perlport> and other available platform-specific documentation.
494
cb1a09d0
AD
495=head2 Alphabetical Listing of Perl Functions
496
2263ed23 497=over
a0d0e21e 498
5b3c99c0 499=item -X FILEHANDLE
d74e8afc
ITB
500X<-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>
501X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C>
a0d0e21e 502
5b3c99c0 503=item -X EXPR
a0d0e21e 504
5228a96c
SP
505=item -X DIRHANDLE
506
5b3c99c0 507=item -X
a0d0e21e 508
c17cdb72
NC
509=for Pod::Functions a file test (-r, -x, etc)
510
a0d0e21e 511A file test, where X is one of the letters listed below. This unary
2263ed23 512operator takes one argument, either a filename, a filehandle, or a dirhandle,
5228a96c 513and tests the associated file to see if something is true about it. If the
2263ed23
LM
514argument is omitted, tests L<C<$_>|perlvar/$_>, except for C<-t>, which
515tests STDIN. Unless otherwise documented, it returns C<1> for true and
516C<''> for false. If the file doesn't exist or can't be examined, it
517returns L<C<undef>|/undef EXPR> and sets L<C<$!>|perlvar/$!> (errno).
518Despite the funny names, precedence is the same as any other named unary
519operator. The operator may be any of:
a0d0e21e 520
5ed4f2ec 521 -r File is readable by effective uid/gid.
522 -w File is writable by effective uid/gid.
523 -x File is executable by effective uid/gid.
524 -o File is owned by effective uid.
a0d0e21e 525
5ed4f2ec 526 -R File is readable by real uid/gid.
527 -W File is writable by real uid/gid.
528 -X File is executable by real uid/gid.
529 -O File is owned by real uid.
a0d0e21e 530
5ed4f2ec 531 -e File exists.
532 -z File has zero size (is empty).
533 -s File has nonzero size (returns size in bytes).
a0d0e21e 534
5ed4f2ec 535 -f File is a plain file.
536 -d File is a directory.
ae07d0f9
S
537 -l File is a symbolic link (false if symlinks aren't
538 supported by the file system).
5ed4f2ec 539 -p File is a named pipe (FIFO), or Filehandle is a pipe.
540 -S File is a socket.
541 -b File is a block special file.
542 -c File is a character special file.
543 -t Filehandle is opened to a tty.
a0d0e21e 544
5ed4f2ec 545 -u File has setuid bit set.
546 -g File has setgid bit set.
547 -k File has sticky bit set.
a0d0e21e 548
65cc07c9 549 -T File is an ASCII or UTF-8 text file (heuristic guess).
5ed4f2ec 550 -B File is a "binary" file (opposite of -T).
a0d0e21e 551
5ed4f2ec 552 -M Script start time minus file modification time, in days.
553 -A Same for access time.
f7051f2c
FC
554 -C Same for inode change time (Unix, may differ for other
555 platforms)
a0d0e21e 556
a0d0e21e
LW
557Example:
558
559 while (<>) {
a9a5a0dc
VP
560 chomp;
561 next unless -f $_; # ignore specials
562 #...
a0d0e21e
LW
563 }
564
4fb67938
FC
565Note that C<-s/a/b/> does not do a negated substitution. Saying
566C<-exp($foo)> still works as expected, however: only single letters
567following a minus are interpreted as file tests.
568
569These operators are exempt from the "looks like a function rule" described
4d0444a3
FC
570above. That is, an opening parenthesis after the operator does not affect
571how much of the following code constitutes the argument. Put the opening
4fb67938
FC
572parentheses before the operator to separate it from code that follows (this
573applies only to operators with higher precedence than unary operators, of
574course):
575
576 -s($file) + 1024 # probably wrong; same as -s($file + 1024)
577 (-s $file) + 1024 # correct
578
5ff3f7a4
GS
579The interpretation of the file permission operators C<-r>, C<-R>,
580C<-w>, C<-W>, C<-x>, and C<-X> is by default based solely on the mode
581of the file and the uids and gids of the user. There may be other
ecae030f
MO
582reasons you can't actually read, write, or execute the file: for
583example network filesystem access controls, ACLs (access control lists),
584read-only filesystems, and unrecognized executable formats. Note
585that the use of these six specific operators to verify if some operation
586is possible is usually a mistake, because it may be open to race
587conditions.
5ff3f7a4 588
2b5ab1e7
TC
589Also note that, for the superuser on the local filesystems, the C<-r>,
590C<-R>, C<-w>, and C<-W> tests always return 1, and C<-x> and C<-X> return 1
5ff3f7a4 591if any execute bit is set in the mode. Scripts run by the superuser
2263ed23
LM
592may thus need to do a L<C<stat>|/stat FILEHANDLE> to determine the
593actual mode of the file, or temporarily set their effective uid to
594something else.
595
596If you are using ACLs, there is a pragma called L<C<filetest>|filetest>
597that may produce more accurate results than the bare
598L<C<stat>|/stat FILEHANDLE> mode bits.
599When under C<use filetest 'access'>, the above-mentioned filetests
600test whether the permission can(not) be granted using the L<access(2)>
601family of system calls. Also note that the C<-x> and C<-X> tests may
5ff3f7a4
GS
602under this pragma return true even if there are no execute permission
603bits set (nor any extra execute permission ACLs). This strangeness is
391b733c 604due to the underlying system calls' definitions. Note also that, due to
ecae030f
MO
605the implementation of C<use filetest 'access'>, the C<_> special
606filehandle won't cache the results of the file tests when this pragma is
2263ed23
LM
607in effect. Read the documentation for the L<C<filetest>|filetest>
608pragma for more information.
5ff3f7a4 609
2263ed23 610The C<-T> and C<-B> tests work as follows. The first block or so of
65cc07c9 611the file is examined to see if it is valid UTF-8 that includes non-ASCII
2263ed23 612characters. If so, it's a C<-T> file. Otherwise, that same portion of
65cc07c9
KW
613the file is examined for odd characters such as strange control codes or
614characters with the high bit set. If more than a third of the
615characters are strange, it's a C<-B> file; otherwise it's a C<-T> file.
616Also, any file containing a zero byte in the examined portion is
617considered a binary file. (If executed within the scope of a L<S<use
618locale>|perllocale> which includes C<LC_CTYPE>, odd characters are
444d4f5c 619anything that isn't a printable nor space in the current locale.) If
65cc07c9
KW
620C<-T> or C<-B> is used on a filehandle, the current IO buffer is
621examined
3b10bc60 622rather than the first block. Both C<-T> and C<-B> return true on an empty
54310121 623file, or a file at EOF when testing a filehandle. Because you have to
4633a7c4
LW
624read a file to do the C<-T> test, on most occasions you want to use a C<-f>
625against the file first, as in C<next unless -f $file && -T $file>.
a0d0e21e 626
2263ed23
LM
627If any of the file tests (or either the L<C<stat>|/stat FILEHANDLE> or
628L<C<lstat>|/lstat FILEHANDLE> operator) is given the special filehandle
629consisting of a solitary underline, then the stat structure of the
630previous file test (or L<C<stat>|/stat FILEHANDLE> operator) is used,
631saving a system call. (This doesn't work with C<-t>, and you need to
632remember that L<C<lstat>|/lstat FILEHANDLE> and C<-l> leave values in
633the stat structure for the symbolic link, not the real file.) (Also, if
634the stat buffer was filled by an L<C<lstat>|/lstat FILEHANDLE> call,
635C<-T> and C<-B> will reset it with the results of C<stat _>).
5c9aa243 636Example:
a0d0e21e
LW
637
638 print "Can do.\n" if -r $a || -w _ || -x _;
639
640 stat($filename);
641 print "Readable\n" if -r _;
642 print "Writable\n" if -w _;
643 print "Executable\n" if -x _;
644 print "Setuid\n" if -u _;
645 print "Setgid\n" if -g _;
646 print "Sticky\n" if -k _;
647 print "Text\n" if -T _;
648 print "Binary\n" if -B _;
649
e9fa405d 650As of Perl 5.10.0, as a form of purely syntactic sugar, you can stack file
fbb0b3b3 651test operators, in a way that C<-f -w -x $file> is equivalent to
a5840dee 652C<-x $file && -w _ && -f _>. (This is only fancy syntax: if you use
fbb0b3b3
RGS
653the return value of C<-f $file> as an argument to another filetest
654operator, no special magic will happen.)
655
bee96257 656Portability issues: L<perlport/-X>.
ea9eb35a 657
bade7fbc
TC
658To avoid confusing would-be users of your code with mysterious
659syntax errors, put something like this at the top of your script:
660
661 use 5.010; # so filetest ops can stack
662
a0d0e21e 663=item abs VALUE
d74e8afc 664X<abs> X<absolute>
a0d0e21e 665
54310121 666=item abs
bbce6d69 667
c17cdb72
NC
668=for Pod::Functions absolute value function
669
a0d0e21e 670Returns the absolute value of its argument.
2263ed23 671If VALUE is omitted, uses L<C<$_>|perlvar/$_>.
a0d0e21e
LW
672
673=item accept NEWSOCKET,GENERICSOCKET
d74e8afc 674X<accept>
a0d0e21e 675
c17cdb72
NC
676=for Pod::Functions accept an incoming socket connect
677
2263ed23 678Accepts an incoming socket connect, just as L<accept(2)>
19799a22 679does. Returns the packed address if it succeeded, false otherwise.
2b5ab1e7 680See the example in L<perlipc/"Sockets: Client/Server Communication">.
a0d0e21e 681
8d2a6795
GS
682On systems that support a close-on-exec flag on files, the flag will
683be set for the newly opened file descriptor, as determined by the
2263ed23 684value of L<C<$^F>|perlvar/$^F>. See L<perlvar/$^F>.
8d2a6795 685
a0d0e21e 686=item alarm SECONDS
d74e8afc
ITB
687X<alarm>
688X<SIGALRM>
689X<timer>
a0d0e21e 690
54310121 691=item alarm
bbce6d69 692
c17cdb72
NC
693=for Pod::Functions schedule a SIGALRM
694
a0d0e21e 695Arranges to have a SIGALRM delivered to this process after the
cf264981 696specified number of wallclock seconds has elapsed. If SECONDS is not
2263ed23
LM
697specified, the value stored in L<C<$_>|perlvar/$_> is used. (On some
698machines, unfortunately, the elapsed time may be up to one second less
699or more than you specified because of how seconds are counted, and
700process scheduling may delay the delivery of the signal even further.)
d400eac8
JH
701
702Only one timer may be counting at once. Each call disables the
703previous timer, and an argument of C<0> may be supplied to cancel the
704previous timer without starting a new one. The returned value is the
705amount of time remaining on the previous timer.
a0d0e21e 706
2263ed23 707For delays of finer granularity than one second, the L<Time::HiRes> module
2bc69794 708(from CPAN, and starting from Perl 5.8 part of the standard
2263ed23
LM
709distribution) provides
710L<C<ualarm>|Time::HiRes/ualarm ( $useconds [, $interval_useconds ] )>.
711You may also use Perl's four-argument version of
712L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> leaving the first three
713arguments undefined, or you might be able to use the
714L<C<syscall>|/syscall NUMBER, LIST> interface to access L<setitimer(2)>
715if your system supports it. See L<perlfaq8> for details.
716
717It is usually a mistake to intermix L<C<alarm>|/alarm SECONDS> and
718L<C<sleep>|/sleep EXPR> calls, because L<C<sleep>|/sleep EXPR> may be
719internally implemented on your system with L<C<alarm>|/alarm SECONDS>.
720
721If you want to use L<C<alarm>|/alarm SECONDS> to time out a system call
722you need to use an L<C<eval>|/eval EXPR>/L<C<die>|/die LIST> pair. You
723can't rely on the alarm causing the system call to fail with
724L<C<$!>|perlvar/$!> set to C<EINTR> because Perl sets up signal handlers
725to restart system calls on some systems. Using
726L<C<eval>|/eval EXPR>/L<C<die>|/die LIST> always works, modulo the
727caveats given in L<perlipc/"Signals">.
ff68c719
PP
728
729 eval {
a9a5a0dc
VP
730 local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required
731 alarm $timeout;
2263ed23 732 my $nread = sysread $socket, $buffer, $size;
a9a5a0dc 733 alarm 0;
ff68c719 734 };
ff68c719 735 if ($@) {
a9a5a0dc 736 die unless $@ eq "alarm\n"; # propagate unexpected errors
5ed4f2ec 737 # timed out
ff68c719
PP
738 }
739 else {
5ed4f2ec 740 # didn't
ff68c719
PP
741 }
742
91d81acc
JH
743For more information see L<perlipc>.
744
ea9eb35a 745Portability issues: L<perlport/alarm>.
746
a0d0e21e 747=item atan2 Y,X
d74e8afc 748X<atan2> X<arctangent> X<tan> X<tangent>
a0d0e21e 749
c17cdb72
NC
750=for Pod::Functions arctangent of Y/X in the range -PI to PI
751
a0d0e21e
LW
752Returns the arctangent of Y/X in the range -PI to PI.
753
2263ed23
LM
754For the tangent operation, you may use the
755L<C<Math::Trig::tan>|Math::Trig/B<tan>> function, or use the familiar
756relation:
28757baa
PP
757
758 sub tan { sin($_[0]) / cos($_[0]) }
759
a1021d57 760The return value for C<atan2(0,0)> is implementation-defined; consult
2263ed23 761your L<atan2(3)> manpage for more information.
bf5f1b4c 762
ea9eb35a 763Portability issues: L<perlport/atan2>.
764
a0d0e21e 765=item bind SOCKET,NAME
d74e8afc 766X<bind>
a0d0e21e 767
c17cdb72
NC
768=for Pod::Functions binds an address to a socket
769
2263ed23 770Binds a network address to a socket, just as L<bind(2)>
19799a22 771does. Returns true if it succeeded, false otherwise. NAME should be a
4633a7c4
LW
772packed address of the appropriate type for the socket. See the examples in
773L<perlipc/"Sockets: Client/Server Communication">.
a0d0e21e 774
fae2c0fb 775=item binmode FILEHANDLE, LAYER
d74e8afc 776X<binmode> X<binary> X<text> X<DOS> X<Windows>
1c1fc3ea 777
a0d0e21e
LW
778=item binmode FILEHANDLE
779
c17cdb72
NC
780=for Pod::Functions prepare binary files for I/O
781
1cbfc93d
NIS
782Arranges for FILEHANDLE to be read or written in "binary" or "text"
783mode on systems where the run-time libraries distinguish between
784binary and text files. If FILEHANDLE is an expression, the value is
785taken as the name of the filehandle. Returns true on success,
2263ed23
LM
786otherwise it returns L<C<undef>|/undef EXPR> and sets
787L<C<$!>|perlvar/$!> (errno).
1cbfc93d 788
2263ed23
LM
789On some systems (in general, DOS- and Windows-based systems)
790L<C<binmode>|/binmode FILEHANDLE, LAYER> is necessary when you're not
791working with a text file. For the sake of portability it is a good idea
792always to use it when appropriate, and never to use it when it isn't
793appropriate. Also, people can set their I/O to be by default
794UTF8-encoded Unicode, not bytes.
d807c6f4 795
2263ed23
LM
796In other words: regardless of platform, use
797L<C<binmode>|/binmode FILEHANDLE, LAYER> on binary data, like images,
798for example.
d807c6f4
JH
799
800If LAYER is present it is a single string, but may contain multiple
391b733c 801directives. The directives alter the behaviour of the filehandle.
d7a0d798 802When LAYER is present, using binmode on a text file makes sense.
d807c6f4 803
fae2c0fb 804If LAYER is omitted or specified as C<:raw> the filehandle is made
391b733c 805suitable for passing binary data. This includes turning off possible CRLF
0226bbdb 806translation and marking it as bytes (as opposed to Unicode characters).
749683d2 807Note that, despite what may be implied in I<"Programming Perl"> (the
3b10bc60 808Camel, 3rd edition) or elsewhere, C<:raw> is I<not> simply the inverse of C<:crlf>.
809Other layers that would affect the binary nature of the stream are
391b733c 810I<also> disabled. See L<PerlIO>, L<perlrun>, and the discussion about the
0226bbdb 811PERLIO environment variable.
01e6739c 812
3b10bc60 813The C<:bytes>, C<:crlf>, C<:utf8>, and any other directives of the
2263ed23
LM
814form C<:...>, are called I/O I<layers>. The L<open> pragma can be used to
815establish default I/O layers.
d807c6f4 816
2263ed23
LM
817I<The LAYER parameter of the L<C<binmode>|/binmode FILEHANDLE, LAYER>
818function is described as "DISCIPLINE" in "Programming Perl, 3rd
819Edition". However, since the publishing of this book, by many known as
820"Camel III", the consensus of the naming of this functionality has moved
821from "discipline" to "layer". All documentation of this version of Perl
822therefore refers to "layers" rather than to "disciplines". Now back to
823the regularly scheduled documentation...>
fae2c0fb 824
8f1da26d 825To mark FILEHANDLE as UTF-8, use C<:utf8> or C<:encoding(UTF-8)>.
6902c96a 826C<:utf8> just marks the data as UTF-8 without further checking,
8f1da26d 827while C<:encoding(UTF-8)> checks the data for actually being valid
391b733c 828UTF-8. More details can be found in L<PerlIO::encoding>.
1cbfc93d 829
2263ed23
LM
830In general, L<C<binmode>|/binmode FILEHANDLE, LAYER> should be called
831after L<C<open>|/open FILEHANDLE,EXPR> but before any I/O is done on the
832filehandle. Calling L<C<binmode>|/binmode FILEHANDLE, LAYER> normally
833flushes any pending buffered output data (and perhaps pending input
834data) on the handle. An exception to this is the C<:encoding> layer
835that changes the default character encoding of the handle.
fae2c0fb 836The C<:encoding> layer sometimes needs to be called in
2263ed23 837mid-stream, and it doesn't flush the stream. C<:encoding>
3874323d 838also implicitly pushes on top of itself the C<:utf8> layer because
3b10bc60 839internally Perl operates on UTF8-encoded Unicode characters.
16fe6d59 840
19799a22 841The operating system, device drivers, C libraries, and Perl run-time
8f1da26d
TC
842system all conspire to let the programmer treat a single
843character (C<\n>) as the line terminator, irrespective of external
30168b04
GS
844representation. On many operating systems, the native text file
845representation matches the internal representation, but on some
846platforms the external representation of C<\n> is made up of more than
847one character.
848
8f1da26d
TC
849All variants of Unix, Mac OS (old and new), and Stream_LF files on VMS use
850a single character to end each line in the external representation of text
851(even though that single character is CARRIAGE RETURN on old, pre-Darwin
391b733c 852flavors of Mac OS, and is LINE FEED on Unix and most VMS files). In other
8f1da26d
TC
853systems like OS/2, DOS, and the various flavors of MS-Windows, your program
854sees a C<\n> as a simple C<\cJ>, but what's stored in text files are the
2263ed23
LM
855two characters C<\cM\cJ>. That means that if you don't use
856L<C<binmode>|/binmode FILEHANDLE, LAYER> on these systems, C<\cM\cJ>
857sequences on disk will be converted to C<\n> on input, and any C<\n> in
858your program will be converted back to C<\cM\cJ> on output. This is
859what you want for text files, but it can be disastrous for binary files.
860
861Another consequence of using L<C<binmode>|/binmode FILEHANDLE, LAYER>
862(on some systems) is that special end-of-file markers will be seen as
863part of the data stream. For systems from the Microsoft family this
864means that, if your binary data contain C<\cZ>, the I/O subsystem will
865regard it as the end of the file, unless you use
866L<C<binmode>|/binmode FILEHANDLE, LAYER>.
867
868L<C<binmode>|/binmode FILEHANDLE, LAYER> is important not only for
869L<C<readline>|/readline EXPR> and L<C<print>|/print FILEHANDLE LIST>
870operations, but also when using
871L<C<read>|/read FILEHANDLE,SCALAR,LENGTH,OFFSET>,
872L<C<seek>|/seek FILEHANDLE,POSITION,WHENCE>,
873L<C<sysread>|/sysread FILEHANDLE,SCALAR,LENGTH,OFFSET>,
874L<C<syswrite>|/syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET> and
875L<C<tell>|/tell FILEHANDLE> (see L<perlport> for more details). See the
876L<C<$E<sol>>|perlvar/$E<sol>> and L<C<$\>|perlvar/$\> variables in
877L<perlvar> for how to manually set your input and output
30168b04 878line-termination sequences.
a0d0e21e 879
ea9eb35a 880Portability issues: L<perlport/binmode>.
881
4633a7c4 882=item bless REF,CLASSNAME
d74e8afc 883X<bless>
a0d0e21e
LW
884
885=item bless REF
886
c17cdb72
NC
887=for Pod::Functions create an object
888
2b5ab1e7 889This function tells the thingy referenced by REF that it is now an object
b3893bfa
Z
890in the CLASSNAME package. If CLASSNAME is an empty string, it is
891interpreted as referring to the C<main> package.
892If CLASSNAME is omitted, the current package
2263ed23
LM
893is used. Because a L<C<bless>|/bless REF,CLASSNAME> is often the last
894thing in a constructor, it returns the reference for convenience.
895Always use the two-argument version if a derived class might inherit the
896method doing the blessing. See L<perlobj> for more about the blessing
897(and blessings) of objects.
a0d0e21e 898
57668c4d 899Consider always blessing objects in CLASSNAMEs that are mixed case.
2b5ab1e7 900Namespaces with all lowercase names are considered reserved for
2263ed23 901Perl pragmas. Builtin types have all uppercase names. To prevent
b3893bfa
Z
902confusion, you may wish to avoid such package names as well.
903It is advised to avoid the class name C<0>, because much code erroneously
904uses the result of L<C<ref>|/ref EXPR> as a truth value.
60ad88b8
GS
905
906See L<perlmod/"Perl Modules">.
907
a0d0e21e 908=item caller EXPR
d74e8afc 909X<caller> X<call stack> X<stack> X<stack trace>
a0d0e21e
LW
910
911=item caller
912
c17cdb72
NC
913=for Pod::Functions get context of the current subroutine call
914
1d56df50
DD
915Returns the context of the current pure perl subroutine call. In scalar
916context, returns the caller's package name if there I<is> a caller (that is, if
2263ed23
LM
917we're in a subroutine or L<C<eval>|/eval EXPR> or
918L<C<require>|/require VERSION>) and the undefined value otherwise.
919caller never returns XS subs and they are skipped. The next pure perl
920sub will appear instead of the XS sub in caller's return values. In
921list context, caller returns
a0d0e21e 922
2263ed23
LM
923 # 0 1 2
924 my ($package, $filename, $line) = caller;
a0d0e21e
LW
925
926With EXPR, it returns some extra information that the debugger uses to
927print a stack trace. The value of EXPR indicates how many call frames
928to go back before the current one.
929
e46aa1dd
KW
930 # 0 1 2 3 4
931 my ($package, $filename, $line, $subroutine, $hasargs,
ee6b43cc 932
e46aa1dd
KW
933 # 5 6 7 8 9 10
934 $wantarray, $evaltext, $is_require, $hints, $bitmask, $hinthash)
935 = caller($i);
e7ea3e70 936
02729fef 937Here, $subroutine is the function that the caller called (rather than the
444d4f5c 938function containing the caller). Note that $subroutine may be C<(eval)> if
2263ed23
LM
939the frame is not a subroutine call, but an L<C<eval>|/eval EXPR>. In
940such a case additional elements $evaltext and C<$is_require> are set:
941C<$is_require> is true if the frame is created by a
942L<C<require>|/require VERSION> or L<C<use>|/use Module VERSION LIST>
943statement, $evaltext contains the text of the C<eval EXPR> statement.
944In particular, for an C<eval BLOCK> statement, $subroutine is C<(eval)>,
945but $evaltext is undefined. (Note also that each
946L<C<use>|/use Module VERSION LIST> statement creates a
947L<C<require>|/require VERSION> frame inside an C<eval EXPR> frame.)
948$subroutine may also be C<(unknown)> if this particular subroutine
949happens to have been deleted from the symbol table. C<$hasargs> is true
950if a new instance of L<C<@_>|perlvar/@_> was set up for the frame.
0fc9dec4 951C<$hints> and C<$bitmask> contain pragmatic hints that the caller was
2263ed23
LM
952compiled with. C<$hints> corresponds to L<C<$^H>|perlvar/$^H>, and
953C<$bitmask> corresponds to
954L<C<${^WARNING_BITS}>|perlvar/${^WARNING_BITS}>. The C<$hints> and
955C<$bitmask> values are subject to change between versions of Perl, and
956are not meant for external use.
957
958C<$hinthash> is a reference to a hash containing the value of
959L<C<%^H>|perlvar/%^H> when the caller was compiled, or
960L<C<undef>|/undef EXPR> if L<C<%^H>|perlvar/%^H> was empty. Do not
961modify the values of this hash, as they are the actual values stored in
962the optree.
b3ca2e83 963
ffe0c19d
FC
964Furthermore, when called from within the DB package in
965list context, and with an argument, caller returns more
7660c0ab 966detailed information: it sets the list variable C<@DB::args> to be the
54310121 967arguments with which the subroutine was invoked.
748a9306 968
7660c0ab 969Be aware that the optimizer might have optimized call frames away before
2263ed23
LM
970L<C<caller>|/caller EXPR> had a chance to get the information. That
971means that C<caller(N)> might not return information about the call
972frame you expect it to, for C<< N > 1 >>. In particular, C<@DB::args>
973might have information from the previous time L<C<caller>|/caller EXPR>
974was called.
7660c0ab 975
8f1da26d 976Be aware that setting C<@DB::args> is I<best effort>, intended for
391b733c 977debugging or generating backtraces, and should not be relied upon. In
2263ed23
LM
978particular, as L<C<@_>|perlvar/@_> contains aliases to the caller's
979arguments, Perl does not take a copy of L<C<@_>|perlvar/@_>, so
980C<@DB::args> will contain modifications the subroutine makes to
981L<C<@_>|perlvar/@_> or its contents, not the original values at call
982time. C<@DB::args>, like L<C<@_>|perlvar/@_>, does not hold explicit
983references to its elements, so under certain cases its elements may have
984become freed and reallocated for other variables or temporary values.
985Finally, a side effect of the current implementation is that the effects
986of C<shift @_> can I<normally> be undone (but not C<pop @_> or other
987splicing, I<and> not if a reference to L<C<@_>|perlvar/@_> has been
988taken, I<and> subject to the caveat about reallocated elements), so
989C<@DB::args> is actually a hybrid of the current state and initial state
990of L<C<@_>|perlvar/@_>. Buyer beware.
ca9f0cb5 991
a0d0e21e 992=item chdir EXPR
d74e8afc
ITB
993X<chdir>
994X<cd>
f723aae1 995X<directory, change>
a0d0e21e 996
c4aca7d0
GA
997=item chdir FILEHANDLE
998
999=item chdir DIRHANDLE
1000
ce2984c3
PF
1001=item chdir
1002
c17cdb72
NC
1003=for Pod::Functions change your current working directory
1004
391b733c 1005Changes the working directory to EXPR, if possible. If EXPR is omitted,
0bfc1ec4 1006changes to the directory specified by C<$ENV{HOME}>, if set; if not,
391b733c 1007changes to the directory specified by C<$ENV{LOGDIR}>. (Under VMS, the
201e9e2a 1008variable C<$ENV{'SYS$LOGIN'}> is also checked, and used if it is set.) If
2263ed23
LM
1009neither is set, L<C<chdir>|/chdir EXPR> does nothing and fails. It
1010returns true on success, false otherwise. See the example under
1011L<C<die>|/die LIST>.
a0d0e21e 1012
2263ed23
LM
1013On systems that support L<fchdir(2)>, you may pass a filehandle or
1014directory handle as the argument. On systems that don't support L<fchdir(2)>,
3b10bc60 1015passing handles raises an exception.
c4aca7d0 1016
a0d0e21e 1017=item chmod LIST
d74e8afc 1018X<chmod> X<permission> X<mode>
a0d0e21e 1019
c17cdb72
NC
1020=for Pod::Functions changes the permissions on a list of files
1021
a0d0e21e 1022Changes the permissions of a list of files. The first element of the
8f1da26d 1023list must be the numeric mode, which should probably be an octal
4ad40acf 1024number, and which definitely should I<not> be a string of octal digits:
3b10bc60 1025C<0644> is okay, but C<"0644"> is not. Returns the number of files
2263ed23
LM
1026successfully changed. See also L<C<oct>|/oct EXPR> if all you have is a
1027string.
a0d0e21e 1028
2263ed23 1029 my $cnt = chmod 0755, "foo", "bar";
a0d0e21e 1030 chmod 0755, @executables;
2263ed23
LM
1031 my $mode = "0644"; chmod $mode, "foo"; # !!! sets mode to
1032 # --w----r-T
1033 my $mode = "0644"; chmod oct($mode), "foo"; # this is better
1034 my $mode = 0644; chmod $mode, "foo"; # this is best
a0d0e21e 1035
2263ed23
LM
1036On systems that support L<fchmod(2)>, you may pass filehandles among the
1037files. On systems that don't support L<fchmod(2)>, passing filehandles raises
3b10bc60 1038an exception. Filehandles must be passed as globs or glob references to be
1039recognized; barewords are considered filenames.
c4aca7d0
GA
1040
1041 open(my $fh, "<", "foo");
1042 my $perm = (stat $fh)[2] & 07777;
1043 chmod($perm | 0600, $fh);
1044
2263ed23
LM
1045You can also import the symbolic C<S_I*> constants from the
1046L<C<Fcntl>|Fcntl> module:
ca6e1c26 1047
3b10bc60 1048 use Fcntl qw( :mode );
ca6e1c26 1049 chmod S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, @executables;
3b10bc60 1050 # Identical to the chmod 0755 of the example above.
ca6e1c26 1051
ea9eb35a 1052Portability issues: L<perlport/chmod>.
1053
a0d0e21e 1054=item chomp VARIABLE
d74e8afc 1055X<chomp> X<INPUT_RECORD_SEPARATOR> X<$/> X<newline> X<eol>
a0d0e21e 1056
313c9f5c 1057=item chomp( LIST )
a0d0e21e
LW
1058
1059=item chomp
1060
c17cdb72
NC
1061=for Pod::Functions remove a trailing record separator from a string
1062
2263ed23
LM
1063This safer version of L<C<chop>|/chop VARIABLE> removes any trailing
1064string that corresponds to the current value of
1065L<C<$E<sol>>|perlvar/$E<sol>> (also known as C<$INPUT_RECORD_SEPARATOR>
1066in the L<C<English>|English> module). It returns the total
28757baa
PP
1067number of characters removed from all its arguments. It's often used to
1068remove the newline from the end of an input record when you're worried
2b5ab1e7 1069that the final record may be missing its newline. When in paragraph
cd3ae2ed 1070mode (C<$/ = ''>), it removes all trailing newlines from the string.
2263ed23
LM
1071When in slurp mode (C<$/ = undef>) or fixed-length record mode
1072(L<C<$E<sol>>|perlvar/$E<sol>> is a reference to an integer or the like;
1073see L<perlvar>), L<C<chomp>|/chomp VARIABLE> won't remove anything.
1074If VARIABLE is omitted, it chomps L<C<$_>|perlvar/$_>. Example:
a0d0e21e
LW
1075
1076 while (<>) {
a9a5a0dc 1077 chomp; # avoid \n on last field
2263ed23 1078 my @array = split(/:/);
a9a5a0dc 1079 # ...
a0d0e21e
LW
1080 }
1081
feef49c9 1082If VARIABLE is a hash, it chomps the hash's values, but not its keys,
2263ed23 1083resetting the L<C<each>|/each HASH> iterator in the process.
4bf21a6d 1084
a0d0e21e
LW
1085You can actually chomp anything that's an lvalue, including an assignment:
1086
2263ed23
LM
1087 chomp(my $cwd = `pwd`);
1088 chomp(my $answer = <STDIN>);
a0d0e21e
LW
1089
1090If you chomp a list, each element is chomped, and the total number of
1091characters removed is returned.
1092
15e44fd8
RGS
1093Note that parentheses are necessary when you're chomping anything
1094that is not a simple variable. This is because C<chomp $cwd = `pwd`;>
1095is interpreted as C<(chomp $cwd) = `pwd`;>, rather than as
1096C<chomp( $cwd = `pwd` )> which you might expect. Similarly,
1097C<chomp $a, $b> is interpreted as C<chomp($a), $b> rather than
1098as C<chomp($a, $b)>.
1099
a0d0e21e 1100=item chop VARIABLE
d74e8afc 1101X<chop>
a0d0e21e 1102
313c9f5c 1103=item chop( LIST )
a0d0e21e
LW
1104
1105=item chop
1106
c17cdb72
NC
1107=for Pod::Functions remove the last character from a string
1108
a0d0e21e 1109Chops off the last character of a string and returns the character
5b3eff12 1110chopped. It is much more efficient than C<s/.$//s> because it neither
2263ed23
LM
1111scans nor copies the string. If VARIABLE is omitted, chops
1112L<C<$_>|perlvar/$_>.
feef49c9 1113If VARIABLE is a hash, it chops the hash's values, but not its keys,
2263ed23 1114resetting the L<C<each>|/each HASH> iterator in the process.
4bf21a6d 1115
5b3eff12 1116You can actually chop anything that's an lvalue, including an assignment.
a0d0e21e
LW
1117
1118If you chop a list, each element is chopped. Only the value of the
2263ed23 1119last L<C<chop>|/chop VARIABLE> is returned.
a0d0e21e 1120
2263ed23
LM
1121Note that L<C<chop>|/chop VARIABLE> returns the last character. To
1122return all but the last character, use C<substr($string, 0, -1)>.
748a9306 1123
2263ed23 1124See also L<C<chomp>|/chomp VARIABLE>.
15e44fd8 1125
a0d0e21e 1126=item chown LIST
d74e8afc 1127X<chown> X<owner> X<user> X<group>
a0d0e21e 1128
c17cdb72
NC
1129=for Pod::Functions change the ownership on a list of files
1130
a0d0e21e 1131Changes the owner (and group) of a list of files. The first two
19799a22
GS
1132elements of the list must be the I<numeric> uid and gid, in that
1133order. A value of -1 in either position is interpreted by most
1134systems to leave that value unchanged. Returns the number of files
1135successfully changed.
a0d0e21e 1136
2263ed23 1137 my $cnt = chown $uid, $gid, 'foo', 'bar';
a0d0e21e
LW
1138 chown $uid, $gid, @filenames;
1139
2263ed23
LM
1140On systems that support L<fchown(2)>, you may pass filehandles among the
1141files. On systems that don't support L<fchown(2)>, passing filehandles raises
3b10bc60 1142an exception. Filehandles must be passed as globs or glob references to be
1143recognized; barewords are considered filenames.
c4aca7d0 1144
54310121 1145Here's an example that looks up nonnumeric uids in the passwd file:
a0d0e21e
LW
1146
1147 print "User: ";
2263ed23 1148 chomp(my $user = <STDIN>);
5a964f20 1149 print "Files: ";
2263ed23 1150 chomp(my $pattern = <STDIN>);
a0d0e21e 1151
2263ed23 1152 my ($login,$pass,$uid,$gid) = getpwnam($user)
a9a5a0dc 1153 or die "$user not in passwd file";
a0d0e21e 1154
2263ed23 1155 my @ary = glob($pattern); # expand filenames
a0d0e21e
LW
1156 chown $uid, $gid, @ary;
1157
54310121 1158On most systems, you are not allowed to change the ownership of the
4633a7c4
LW
1159file unless you're the superuser, although you should be able to change
1160the group to any of your secondary groups. On insecure systems, these
1161restrictions may be relaxed, but this is not a portable assumption.
19799a22
GS
1162On POSIX systems, you can detect this condition this way:
1163
1164 use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
2263ed23 1165 my $can_chown_giveaway = ! sysconf(_PC_CHOWN_RESTRICTED);
4633a7c4 1166
f48496b1 1167Portability issues: L<perlport/chown>.
ea9eb35a 1168
a0d0e21e 1169=item chr NUMBER
d74e8afc 1170X<chr> X<character> X<ASCII> X<Unicode>
a0d0e21e 1171
54310121 1172=item chr
bbce6d69 1173
c17cdb72
NC
1174=for Pod::Functions get character this number represents
1175
a0d0e21e 1176Returns the character represented by that NUMBER in the character set.
a0ed51b3 1177For example, C<chr(65)> is C<"A"> in either ASCII or Unicode, and
2263ed23 1178chr(0x263a) is a Unicode smiley face.
aaa68c4a 1179
8a064bd6 1180Negative values give the Unicode replacement character (chr(0xfffd)),
80d38338 1181except under the L<bytes> pragma, where the low eight bits of the value
8a064bd6
JH
1182(truncated to an integer) are used.
1183
2263ed23 1184If NUMBER is omitted, uses L<C<$_>|perlvar/$_>.
974da8e5 1185
2263ed23 1186For the reverse, use L<C<ord>|/ord EXPR>.
a0d0e21e 1187
2575c402
JW
1188Note that characters from 128 to 255 (inclusive) are by default
1189internally not encoded as UTF-8 for backward compatibility reasons.
974da8e5 1190
2575c402 1191See L<perlunicode> for more about Unicode.
bbce6d69 1192
a0d0e21e 1193=item chroot FILENAME
d74e8afc 1194X<chroot> X<root>
a0d0e21e 1195
54310121 1196=item chroot
bbce6d69 1197
c17cdb72
NC
1198=for Pod::Functions make directory new root for path lookups
1199
5a964f20 1200This function works like the system call by the same name: it makes the
4633a7c4 1201named directory the new root directory for all further pathnames that
951ba7fe 1202begin with a C</> by your process and all its children. (It doesn't
28757baa 1203change your current working directory, which is unaffected.) For security
4633a7c4 1204reasons, this call is restricted to the superuser. If FILENAME is
2263ed23 1205omitted, does a L<C<chroot>|/chroot FILENAME> to L<C<$_>|perlvar/$_>.
a0d0e21e 1206
2263ed23
LM
1207B<NOTE:> It is good security practice to do C<chdir("/")>
1208(L<C<chdir>|/chdir EXPR> to the root directory) immediately after a
1209L<C<chroot>|/chroot FILENAME>.
b00d10dc 1210
ea9eb35a 1211Portability issues: L<perlport/chroot>.
1212
a0d0e21e 1213=item close FILEHANDLE
d74e8afc 1214X<close>
a0d0e21e 1215
6a518fbc
TP
1216=item close
1217
c17cdb72
NC
1218=for Pod::Functions close file (or pipe or socket) handle
1219
3b10bc60 1220Closes the file or pipe associated with the filehandle, flushes the IO
e0f13c26 1221buffers, and closes the system file descriptor. Returns true if those
8f1da26d 1222operations succeed and if no error was reported by any PerlIO
e0f13c26
RGS
1223layer. Closes the currently selected filehandle if the argument is
1224omitted.
fb73857a
PP
1225
1226You don't have to close FILEHANDLE if you are immediately going to do
2263ed23
LM
1227another L<C<open>|/open FILEHANDLE,EXPR> on it, because
1228L<C<open>|/open FILEHANDLE,EXPR> closes it for you. (See
1229L<C<open>|/open FILEHANDLE,EXPR>.) However, an explicit
1230L<C<close>|/close FILEHANDLE> on an input file resets the line counter
1231(L<C<$.>|perlvar/$.>), while the implicit close done by
1232L<C<open>|/open FILEHANDLE,EXPR> does not.
1233
1234If the filehandle came from a piped open, L<C<close>|/close FILEHANDLE>
1235returns false if one of the other syscalls involved fails or if its
1236program exits with non-zero status. If the only problem was that the
1237program exited non-zero, L<C<$!>|perlvar/$!> will be set to C<0>.
1238Closing a pipe also waits for the process executing on the pipe to
1239exit--in case you wish to look at the output of the pipe afterwards--and
1240implicitly puts the exit status value of that command into
1241L<C<$?>|perlvar/$?> and
1242L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>.
1243
1244If there are multiple threads running, L<C<close>|/close FILEHANDLE> on
1245a filehandle from a piped open returns true without waiting for the
1246child process to terminate, if the filehandle is still open in another
1247thread.
2e0cfa16 1248
80d38338
TC
1249Closing the read end of a pipe before the process writing to it at the
1250other end is done writing results in the writer receiving a SIGPIPE. If
1251the other end can't handle that, be sure to read all the data before
1252closing the pipe.
73689b13 1253
fb73857a 1254Example:
a0d0e21e 1255
fb73857a
PP
1256 open(OUTPUT, '|sort >foo') # pipe to sort
1257 or die "Can't start sort: $!";
5ed4f2ec 1258 #... # print stuff to output
1259 close OUTPUT # wait for sort to finish
fb73857a
PP
1260 or warn $! ? "Error closing sort pipe: $!"
1261 : "Exit status $? from sort";
5ed4f2ec 1262 open(INPUT, 'foo') # get sort's results
fb73857a 1263 or die "Can't open 'foo' for input: $!";
a0d0e21e 1264
5a964f20 1265FILEHANDLE may be an expression whose value can be used as an indirect
8f1da26d 1266filehandle, usually the real filehandle name or an autovivified handle.
a0d0e21e
LW
1267
1268=item closedir DIRHANDLE
d74e8afc 1269X<closedir>
a0d0e21e 1270
c17cdb72
NC
1271=for Pod::Functions close directory handle
1272
2263ed23
LM
1273Closes a directory opened by L<C<opendir>|/opendir DIRHANDLE,EXPR> and
1274returns the success of that system call.
5a964f20 1275
a0d0e21e 1276=item connect SOCKET,NAME
d74e8afc 1277X<connect>
a0d0e21e 1278
c17cdb72
NC
1279=for Pod::Functions connect to a remote socket
1280
2263ed23 1281Attempts to connect to a remote socket, just like L<connect(2)>.
80d38338 1282Returns true if it succeeded, false otherwise. NAME should be a
4633a7c4
LW
1283packed address of the appropriate type for the socket. See the examples in
1284L<perlipc/"Sockets: Client/Server Communication">.
a0d0e21e 1285
cb1a09d0 1286=item continue BLOCK
d74e8afc 1287X<continue>
cb1a09d0 1288
0d863452
RH
1289=item continue
1290
c17cdb72
NC
1291=for Pod::Functions optional trailing block in a while or foreach
1292
2263ed23
LM
1293When followed by a BLOCK, L<C<continue>|/continue BLOCK> is actually a
1294flow control statement rather than a function. If there is a
1295L<C<continue>|/continue BLOCK> BLOCK attached to a BLOCK (typically in a
1296C<while> or C<foreach>), it is always executed just before the
1297conditional is about to be evaluated again, just like the third part of
1298a C<for> loop in C. Thus it can be used to increment a loop variable,
1299even when the loop has been continued via the L<C<next>|/next LABEL>
1300statement (which is similar to the C L<C<continue>|/continue BLOCK>
cb1a09d0
AD
1301statement).
1302
2263ed23
LM
1303L<C<last>|/last LABEL>, L<C<next>|/next LABEL>, or
1304L<C<redo>|/redo LABEL> may appear within a
1305L<C<continue>|/continue BLOCK> block; L<C<last>|/last LABEL> and
1306L<C<redo>|/redo LABEL> behave as if they had been executed within the
1307main block. So will L<C<next>|/next LABEL>, but since it will execute a
1308L<C<continue>|/continue BLOCK> block, it may be more entertaining.
1d2dff63
GS
1309
1310 while (EXPR) {
a9a5a0dc
VP
1311 ### redo always comes here
1312 do_something;
1d2dff63 1313 } continue {
a9a5a0dc
VP
1314 ### next always comes here
1315 do_something_else;
1316 # then back the top to re-check EXPR
1d2dff63
GS
1317 }
1318 ### last always comes here
1319
2263ed23
LM
1320Omitting the L<C<continue>|/continue BLOCK> section is equivalent to
1321using an empty one, logically enough, so L<C<next>|/next LABEL> goes
1322directly back to check the condition at the top of the loop.
1d2dff63 1323
2263ed23 1324When there is no BLOCK, L<C<continue>|/continue BLOCK> is a function
f68519ee
Z
1325that exits the current C<whereis> or C<whereso> block,
1326avoiding the implicit C<next>
b4904f80 1327that happens when execution reaches the end of such a block.
98729e54 1328In Perl 5.14 and earlier, this form of
2263ed23
LM
1329L<C<continue>|/continue BLOCK> was only available when the
1330L<C<"switch"> feature|feature/The 'switch' feature> was enabled. See
1331L<feature> and L<perlsyn/"Switch Statements"> for more information.
0d863452 1332
a0d0e21e 1333=item cos EXPR
d74e8afc 1334X<cos> X<cosine> X<acos> X<arccosine>
a0d0e21e 1335
d6217f1e
GS
1336=item cos
1337
c17cdb72
NC
1338=for Pod::Functions cosine function
1339
5a964f20 1340Returns the cosine of EXPR (expressed in radians). If EXPR is omitted,
2263ed23 1341takes the cosine of L<C<$_>|perlvar/$_>.
a0d0e21e 1342
2263ed23
LM
1343For the inverse cosine operation, you may use the
1344L<C<Math::Trig::acos>|Math::Trig> function, or use this relation:
28757baa
PP
1345
1346 sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }
1347
a0d0e21e 1348=item crypt PLAINTEXT,SALT
d74e8afc 1349X<crypt> X<digest> X<hash> X<salt> X<plaintext> X<password>
f723aae1 1350X<decrypt> X<cryptography> X<passwd> X<encrypt>
a0d0e21e 1351
c17cdb72
NC
1352=for Pod::Functions one-way passwd-style encryption
1353
2263ed23 1354Creates a digest string exactly like the L<crypt(3)> function in the C
ef2e6798 1355library (assuming that you actually have a version there that has not
bb23f8d1 1356been extirpated as a potential munition).
ef2e6798 1357
2263ed23
LM
1358L<C<crypt>|/crypt PLAINTEXT,SALT> is a one-way hash function. The
1359PLAINTEXT and SALT are turned
ef2e6798
MS
1360into a short string, called a digest, which is returned. The same
1361PLAINTEXT and SALT will always return the same string, but there is no
1362(known) way to get the original PLAINTEXT from the hash. Small
1363changes in the PLAINTEXT or SALT will result in large changes in the
1364digest.
1365
1366There is no decrypt function. This function isn't all that useful for
1367cryptography (for that, look for F<Crypt> modules on your nearby CPAN
1368mirror) and the name "crypt" is a bit of a misnomer. Instead it is
1369primarily used to check if two pieces of text are the same without
1370having to transmit or store the text itself. An example is checking
1371if a correct password is given. The digest of the password is stored,
cf264981 1372not the password itself. The user types in a password that is
2263ed23
LM
1373L<C<crypt>|/crypt PLAINTEXT,SALT>'d with the same salt as the stored
1374digest. If the two digests match, the password is correct.
ef2e6798
MS
1375
1376When verifying an existing digest string you should use the digest as
1377the salt (like C<crypt($plain, $digest) eq $digest>). The SALT used
cf264981 1378to create the digest is visible as part of the digest. This ensures
2263ed23
LM
1379L<C<crypt>|/crypt PLAINTEXT,SALT> will hash the new string with the same
1380salt as the digest. This allows your code to work with the standard
1381L<C<crypt>|/crypt PLAINTEXT,SALT> and with more exotic implementations.
1382In other words, assume nothing about the returned string itself nor
1383about how many bytes of SALT may matter.
85c16d83
JH
1384
1385Traditionally the result is a string of 13 bytes: two first bytes of
1386the salt, followed by 11 bytes from the set C<[./0-9A-Za-z]>, and only
391b733c 1387the first eight bytes of PLAINTEXT mattered. But alternative
ef2e6798 1388hashing schemes (like MD5), higher level security schemes (like C2),
e1020413 1389and implementations on non-Unix platforms may produce different
ef2e6798 1390strings.
85c16d83
JH
1391
1392When choosing a new salt create a random two character string whose
1393characters come from the set C<[./0-9A-Za-z]> (like C<join '', ('.',
d3989d75
CW
1394'/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]>). This set of
1395characters is just a recommendation; the characters allowed in
1396the salt depend solely on your system's crypt library, and Perl can't
2263ed23 1397restrict what salts L<C<crypt>|/crypt PLAINTEXT,SALT> accepts.
e71965be 1398
a0d0e21e 1399Here's an example that makes sure that whoever runs this program knows
cf264981 1400their password:
a0d0e21e 1401
2263ed23 1402 my $pwd = (getpwuid($<))[1];
a0d0e21e
LW
1403
1404 system "stty -echo";
1405 print "Password: ";
2263ed23 1406 chomp(my $word = <STDIN>);
a0d0e21e
LW
1407 print "\n";
1408 system "stty echo";
1409
e71965be 1410 if (crypt($word, $pwd) ne $pwd) {
a9a5a0dc 1411 die "Sorry...\n";
a0d0e21e 1412 } else {
a9a5a0dc 1413 print "ok\n";
54310121 1414 }
a0d0e21e 1415
9f8f0c9d 1416Of course, typing in your own password to whoever asks you
748a9306 1417for it is unwise.
a0d0e21e 1418
2263ed23
LM
1419The L<C<crypt>|/crypt PLAINTEXT,SALT> function is unsuitable for hashing
1420large quantities of data, not least of all because you can't get the
1421information back. Look at the L<Digest> module for more robust
1422algorithms.
19799a22 1423
2263ed23
LM
1424If using L<C<crypt>|/crypt PLAINTEXT,SALT> on a Unicode string (which
1425I<potentially> has characters with codepoints above 255), Perl tries to
1426make sense of the situation by trying to downgrade (a copy of) the
1427string back to an eight-bit byte string before calling
1428L<C<crypt>|/crypt PLAINTEXT,SALT> (on that copy). If that works, good.
1429If not, L<C<crypt>|/crypt PLAINTEXT,SALT> dies with
1430L<C<Wide character in crypt>|perldiag/Wide character in %s>.
85c16d83 1431
ea9eb35a 1432Portability issues: L<perlport/crypt>.
1433
aa689395 1434=item dbmclose HASH
d74e8afc 1435X<dbmclose>
a0d0e21e 1436
c17cdb72
NC
1437=for Pod::Functions breaks binding on a tied dbm file
1438
2263ed23
LM
1439[This function has been largely superseded by the
1440L<C<untie>|/untie VARIABLE> function.]
a0d0e21e 1441
aa689395 1442Breaks the binding between a DBM file and a hash.
a0d0e21e 1443
ea9eb35a 1444Portability issues: L<perlport/dbmclose>.
1445
19799a22 1446=item dbmopen HASH,DBNAME,MASK
d74e8afc 1447X<dbmopen> X<dbm> X<ndbm> X<sdbm> X<gdbm>
a0d0e21e 1448
c17cdb72
NC
1449=for Pod::Functions create binding on a tied dbm file
1450
01aa884e 1451[This function has been largely superseded by the
2263ed23
LM
1452L<C<tie>|/tie VARIABLE,CLASSNAME,LIST> function.]
1453
1454This binds a L<dbm(3)>, L<ndbm(3)>, L<sdbm(3)>, L<gdbm(3)>, or Berkeley
1455DB file to a hash. HASH is the name of the hash. (Unlike normal
1456L<C<open>|/open FILEHANDLE,EXPR>, the first argument is I<not> a
1457filehandle, even though it looks like one). DBNAME is the name of the
1458database (without the F<.dir> or F<.pag> extension if any). If the
1459database does not exist, it is created with protection specified by MASK
1460(as modified by the L<C<umask>|/umask EXPR>). To prevent creation of
1461the database if it doesn't exist, you may specify a MODE of 0, and the
1462function will return a false value if it can't find an existing
1463database. If your system supports only the older DBM functions, you may
1464make only one L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK> call in your
aa689395 1465program. In older versions of Perl, if your system had neither DBM nor
2263ed23
LM
1466ndbm, calling L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK> produced a fatal
1467error; it now falls back to L<sdbm(3)>.
aa689395
PP
1468
1469If you don't have write access to the DBM file, you can only read hash
1470variables, not set them. If you want to test whether you can write,
2263ed23
LM
1471either use file tests or try setting a dummy hash entry inside an
1472L<C<eval>|/eval EXPR> to trap the error.
a0d0e21e 1473
2263ed23
LM
1474Note that functions such as L<C<keys>|/keys HASH> and
1475L<C<values>|/values HASH> may return huge lists when used on large DBM
1476files. You may prefer to use the L<C<each>|/each HASH> function to
1477iterate over large DBM files. Example:
a0d0e21e
LW
1478
1479 # print out history file offsets
1480 dbmopen(%HIST,'/usr/lib/news/history',0666);
1481 while (($key,$val) = each %HIST) {
a9a5a0dc 1482 print $key, ' = ', unpack('L',$val), "\n";
a0d0e21e
LW
1483 }
1484 dbmclose(%HIST);
1485
cb1a09d0 1486See also L<AnyDBM_File> for a more general description of the pros and
184e9718 1487cons of the various dbm approaches, as well as L<DB_File> for a particularly
cb1a09d0 1488rich implementation.
4633a7c4 1489
2b5ab1e7 1490You can control which DBM library you use by loading that library
2263ed23 1491before you call L<C<dbmopen>|/dbmopen HASH,DBNAME,MASK>:
2b5ab1e7
TC
1492
1493 use DB_File;
1494 dbmopen(%NS_Hist, "$ENV{HOME}/.netscape/history.db")
a9a5a0dc 1495 or die "Can't open netscape history file: $!";
2b5ab1e7 1496
ea9eb35a 1497Portability issues: L<perlport/dbmopen>.
1498
a0d0e21e 1499=item defined EXPR
d74e8afc 1500X<defined> X<undef> X<undefined>
a0d0e21e 1501
54310121 1502=item defined
bbce6d69 1503
c17cdb72
NC
1504=for Pod::Functions test whether a value, variable, or function is defined
1505
2263ed23
LM
1506Returns a Boolean value telling whether EXPR has a value other than the
1507undefined value L<C<undef>|/undef EXPR>. If EXPR is not present,
1508L<C<$_>|perlvar/$_> is checked.
1509
1510Many operations return L<C<undef>|/undef EXPR> to indicate failure, end
1511of file, system error, uninitialized variable, and other exceptional
1512conditions. This function allows you to distinguish
1513L<C<undef>|/undef EXPR> from other values. (A simple Boolean test will
1514not distinguish among L<C<undef>|/undef EXPR>, zero, the empty string,
1515and C<"0">, which are all equally false.) Note that since
1516L<C<undef>|/undef EXPR> is a valid scalar, its presence doesn't
1517I<necessarily> indicate an exceptional condition: L<C<pop>|/pop ARRAY>
1518returns L<C<undef>|/undef EXPR> when its argument is an empty array,
1519I<or> when the element to return happens to be L<C<undef>|/undef EXPR>.
1520
1521You may also use C<defined(&func)> to check whether subroutine C<func>
f10b0346 1522has ever been defined. The return value is unaffected by any forward
2263ed23 1523declarations of C<func>. A subroutine that is not defined
847c7ebe 1524may still be callable: its package may have an C<AUTOLOAD> method that
3b10bc60 1525makes it spring into existence the first time that it is called; see
847c7ebe 1526L<perlsub>.
f10b0346 1527
2263ed23 1528Use of L<C<defined>|/defined EXPR> on aggregates (hashes and arrays) is
8556cefc
A
1529no longer supported. It used to report whether memory for that
1530aggregate had ever been allocated. You should instead use a simple
1531test for size:
f10b0346
GS
1532
1533 if (@an_array) { print "has array elements\n" }
1534 if (%a_hash) { print "has hash members\n" }
2f9daede
TPG
1535
1536When used on a hash element, it tells you whether the value is defined,
2263ed23
LM
1537not whether the key exists in the hash. Use L<C<exists>|/exists EXPR>
1538for the latter purpose.
a0d0e21e
LW
1539
1540Examples:
1541
8f1da26d 1542 print if defined $switch{D};
a0d0e21e
LW
1543 print "$val\n" while defined($val = pop(@ary));
1544 die "Can't readlink $sym: $!"
a9a5a0dc 1545 unless defined($value = readlink $sym);
2263ed23 1546 sub foo { defined &$bar ? $bar->(@_) : die "No bar"; }
2f9daede 1547 $debugging = 0 unless defined $debugging;
a0d0e21e 1548
2263ed23
LM
1549Note: Many folks tend to overuse L<C<defined>|/defined EXPR> and are
1550then surprised to discover that the number C<0> and C<""> (the
1551zero-length string) are, in fact, defined values. For example, if you
1552say
a5f75d66
AD
1553
1554 "ab" =~ /a(.*)b/;
1555
80d38338 1556The pattern match succeeds and C<$1> is defined, although it
cf264981 1557matched "nothing". It didn't really fail to match anything. Rather, it
2b5ab1e7 1558matched something that happened to be zero characters long. This is all
a5f75d66 1559very above-board and honest. When a function returns an undefined value,
2f9daede 1560it's an admission that it couldn't give you an honest answer. So you
2263ed23
LM
1561should use L<C<defined>|/defined EXPR> only when questioning the
1562integrity of what you're trying to do. At other times, a simple
1563comparison to C<0> or C<""> is what you want.
2f9daede 1564
2263ed23
LM
1565See also L<C<undef>|/undef EXPR>, L<C<exists>|/exists EXPR>,
1566L<C<ref>|/ref EXPR>.
2f9daede 1567
a0d0e21e 1568=item delete EXPR
d74e8afc 1569X<delete>
a0d0e21e 1570
c17cdb72
NC
1571=for Pod::Functions deletes a value from a hash
1572
2263ed23
LM
1573Given an expression that specifies an element or slice of a hash,
1574L<C<delete>|/delete EXPR> deletes the specified elements from that hash
1575so that L<C<exists>|/exists EXPR> on that element no longer returns
1576true. Setting a hash element to the undefined value does not remove its
1577key, but deleting it does; see L<C<exists>|/exists EXPR>.
80d38338 1578
8f1da26d 1579In list context, returns the value or values deleted, or the last such
80d38338 1580element in scalar context. The return list's length always matches that of
d0a76353
RS
1581the argument list: deleting non-existent elements returns the undefined value
1582in their corresponding positions.
80d38338 1583
2263ed23
LM
1584L<C<delete>|/delete EXPR> may also be used on arrays and array slices,
1585but its behavior is less straightforward. Although
1586L<C<exists>|/exists EXPR> will return false for deleted entries,
1587deleting array elements never changes indices of existing values; use
1588L<C<shift>|/shift ARRAY> or L<C<splice>|/splice
1589ARRAY,OFFSET,LENGTH,LIST> for that. However, if any deleted elements
1590fall at the end of an array, the array's size shrinks to the position of
1591the highest element that still tests true for L<C<exists>|/exists EXPR>,
1592or to 0 if none do. In other words, an array won't have trailing
1593nonexistent elements after a delete.
1594
1595B<WARNING:> Calling L<C<delete>|/delete EXPR> on array values is
1596strongly discouraged. The
2fbadc08
RS
1597notion of deleting or checking the existence of Perl array elements is not
1598conceptually coherent, and can lead to surprising behavior.
80d38338 1599
2263ed23
LM
1600Deleting from L<C<%ENV>|perlvar/%ENV> modifies the environment.
1601Deleting from a hash tied to a DBM file deletes the entry from the DBM
1602file. Deleting from a L<C<tied>|/tied VARIABLE> hash or array may not
1603necessarily return anything; it depends on the implementation of the
1604L<C<tied>|/tied VARIABLE> package's DELETE method, which may do whatever
1605it pleases.
a0d0e21e 1606
80d38338
TC
1607The C<delete local EXPR> construct localizes the deletion to the current
1608block at run time. Until the block exits, elements locally deleted
1609temporarily no longer exist. See L<perlsub/"Localized deletion of elements
1610of composite types">.
eba0920a 1611
2263ed23
LM
1612 my %hash = (foo => 11, bar => 22, baz => 33);
1613 my $scalar = delete $hash{foo}; # $scalar is 11
f7051f2c 1614 $scalar = delete @hash{qw(foo bar)}; # $scalar is 22
2263ed23 1615 my @array = delete @hash{qw(foo baz)}; # @array is (undef,33)
eba0920a 1616
01020589 1617The following (inefficiently) deletes all the values of %HASH and @ARRAY:
a0d0e21e 1618
2263ed23 1619 foreach my $key (keys %HASH) {
a9a5a0dc 1620 delete $HASH{$key};
a0d0e21e
LW
1621 }
1622
2263ed23 1623 foreach my $index (0 .. $#ARRAY) {
a9a5a0dc 1624 delete $ARRAY[$index];
01020589
GS
1625 }
1626
1627And so do these:
5f05dabc 1628
01020589
GS
1629 delete @HASH{keys %HASH};
1630
9740c838 1631 delete @ARRAY[0 .. $#ARRAY];
5f05dabc 1632
80d38338 1633But both are slower than assigning the empty list
2263ed23 1634or undefining %HASH or @ARRAY, which is the customary
80d38338 1635way to empty out an aggregate:
01020589 1636
5ed4f2ec 1637 %HASH = (); # completely empty %HASH
1638 undef %HASH; # forget %HASH ever existed
2b5ab1e7 1639
5ed4f2ec 1640 @ARRAY = (); # completely empty @ARRAY
1641 undef @ARRAY; # forget @ARRAY ever existed
2b5ab1e7 1642
80d38338
TC
1643The EXPR can be arbitrarily complicated provided its
1644final operation is an element or slice of an aggregate:
a0d0e21e
LW
1645
1646 delete $ref->[$x][$y]{$key};
5f05dabc 1647 delete @{$ref->[$x][$y]}{$key1, $key2, @morekeys};
a0d0e21e 1648
01020589
GS
1649 delete $ref->[$x][$y][$index];
1650 delete @{$ref->[$x][$y]}[$index1, $index2, @moreindices];
1651
a0d0e21e 1652=item die LIST
d74e8afc 1653X<die> X<throw> X<exception> X<raise> X<$@> X<abort>
a0d0e21e 1654
c17cdb72
NC
1655=for Pod::Functions raise an exception or bail out
1656
52e58e76
Z
1657L<C<die>|/die LIST> raises an exception. Inside an L<C<eval>|/eval EXPR>
1658the exception is stuffed into L<C<$@>|perlvar/$@> and the L<C<eval>|/eval
1659EXPR> is terminated with the undefined value. If the exception is
1660outside of all enclosing L<C<eval>|/eval EXPR>s, then the uncaught
1661exception is printed to C<STDERR> and perl exits with an exit code
1662indicating failure. If you need to exit the process with a specific
1663exit code, see L<C<exit>|/exit EXPR>.
a0d0e21e
LW
1664
1665Equivalent examples:
1666
1667 die "Can't cd to spool: $!\n" unless chdir '/usr/spool/news';
54310121 1668 chdir '/usr/spool/news' or die "Can't cd to spool: $!\n"
a0d0e21e 1669
52e58e76
Z
1670Most of the time, C<die> is called with a string to use as the exception.
1671You may either give a single non-reference operand to serve as the
1672exception, or a list of two or more items, which will be stringified
1673and concatenated to make the exception.
1674
1675If the string exception does not end in a newline, the current
1676script line number and input line number (if any) and a newline
1677are appended to it. Note that the "input line number" (also
df37ec69
WW
1678known as "chunk") is subject to whatever notion of "line" happens to
1679be currently in effect, and is also available as the special variable
2263ed23 1680L<C<$.>|perlvar/$.>. See L<perlvar/"$/"> and L<perlvar/"$.">.
df37ec69
WW
1681
1682Hint: sometimes appending C<", stopped"> to your message will cause it
1683to make better sense when the string C<"at foo line 123"> is appended.
1684Suppose you are running script "canasta".
a0d0e21e
LW
1685
1686 die "/etc/games is no good";
1687 die "/etc/games is no good, stopped";
1688
1689produce, respectively
1690
1691 /etc/games is no good at canasta line 123.
1692 /etc/games is no good, stopped at canasta line 123.
1693
52e58e76
Z
1694If LIST was empty or made an empty string, and L<C<$@>|perlvar/$@>
1695already contains an exception value (typically from a previous
1696L<C<eval>|/eval EXPR>), then that value is reused after
177f0db9 1697appending C<"\t...propagated">. This is useful for propagating exceptions:
fb73857a
PP
1698
1699 eval { ... };
1700 die unless $@ =~ /Expected exception/;
1701
52e58e76
Z
1702If LIST was empty or made an empty string,
1703and L<C<$@>|perlvar/$@> contains an object
2263ed23
LM
1704reference that has a C<PROPAGATE> method, that method will be called
1705with additional file and line number parameters. The return value
1706replaces the value in L<C<$@>|perlvar/$@>; i.e., as if
1707C<< $@ = eval { $@->PROPAGATE(__FILE__, __LINE__) }; >> were called.
ad216e65 1708
52e58e76
Z
1709If LIST was empty or made an empty string, and L<C<$@>|perlvar/$@>
1710is also empty, then the string C<"Died"> is used.
4c050ad5 1711
2263ed23
LM
1712You can also call L<C<die>|/die LIST> with a reference argument, and if
1713this is trapped within an L<C<eval>|/eval EXPR>, L<C<$@>|perlvar/$@>
1714contains that reference. This permits more elaborate exception handling
1715using objects that maintain arbitrary state about the exception. Such a
1716scheme is sometimes preferable to matching particular string values of
52e58e76
Z
1717L<C<$@>|perlvar/$@> with regular expressions.
1718
1719Because Perl stringifies uncaught exception messages before display,
1720you'll probably want to overload stringification operations on
1721exception objects. See L<overload> for details about that.
1722The stringified message should be non-empty, and should end in a newline,
1723in order to fit in with the treatment of string exceptions.
1724Also, because an exception object reference cannot be stringified
6f0a679a 1725without destroying it, Perl doesn't attempt to append location or other
52e58e76
Z
1726information to a reference exception. If you want location information
1727with a complex exception object, you'll have to arrange to put the
1728location information into the object yourself.
1729
1730Because L<C<$@>|perlvar/$@> is a global variable, be careful that
1731analyzing an exception caught by C<eval> doesn't replace the reference
1732in the global variable. It's
2263ed23
LM
1733easiest to make a local copy of the reference before any manipulations.
1734Here's an example:
52531d10 1735
80d38338 1736 use Scalar::Util "blessed";
da279afe 1737
52531d10 1738 eval { ... ; die Some::Module::Exception->new( FOO => "bar" ) };
746d7dd7 1739 if (my $ev_err = $@) {
f7051f2c
FC
1740 if (blessed($ev_err)
1741 && $ev_err->isa("Some::Module::Exception")) {
52531d10
GS
1742 # handle Some::Module::Exception
1743 }
1744 else {
1745 # handle all other possible exceptions
1746 }
1747 }
1748
52e58e76
Z
1749If an uncaught exception results in interpreter exit, the exit code is
1750determined from the values of L<C<$!>|perlvar/$!> and
1751L<C<$?>|perlvar/$?> with this pseudocode:
1752
1753 exit $! if $!; # errno
1754 exit $? >> 8 if $? >> 8; # child exit status
1755 exit 255; # last resort
1756
1757As with L<C<exit>|/exit EXPR>, L<C<$?>|perlvar/$?> is set prior to
1758unwinding the call stack; any C<DESTROY> or C<END> handlers can then
1759alter this value, and thus Perl's exit code.
1760
1761The intent is to squeeze as much possible information about the likely cause
1762into the limited space of the system exit code. However, as
1763L<C<$!>|perlvar/$!> is the value of C's C<errno>, which can be set by
1764any system call, this means that the value of the exit code used by
1765L<C<die>|/die LIST> can be non-predictable, so should not be relied
1766upon, other than to be non-zero.
52531d10 1767
2263ed23
LM
1768You can arrange for a callback to be run just before the
1769L<C<die>|/die LIST> does its deed, by setting the
1770L<C<$SIG{__DIE__}>|perlvar/%SIG> hook. The associated handler is called
52e58e76
Z
1771with the exception as an argument, and can change the exception,
1772if it sees fit, by
2263ed23
LM
1773calling L<C<die>|/die LIST> again. See L<perlvar/%SIG> for details on
1774setting L<C<%SIG>|perlvar/%SIG> entries, and L<C<eval>|/eval EXPR> for some
1775examples. Although this feature was to be run only right before your
1776program was to exit, this is not currently so: the
1777L<C<$SIG{__DIE__}>|perlvar/%SIG> hook is currently called even inside
1778L<C<eval>|/eval EXPR>ed blocks/strings! If one wants the hook to do
19799a22 1779nothing in such situations, put
fb73857a 1780
5ed4f2ec 1781 die @_ if $^S;
fb73857a 1782
19799a22
GS
1783as the first line of the handler (see L<perlvar/$^S>). Because
1784this promotes strange action at a distance, this counterintuitive
b76cc8ba 1785behavior may be fixed in a future release.
774d564b 1786
2263ed23
LM
1787See also L<C<exit>|/exit EXPR>, L<C<warn>|/warn LIST>, and the L<Carp>
1788module.
4c050ad5 1789
a0d0e21e 1790=item do BLOCK
d74e8afc 1791X<do> X<block>
a0d0e21e 1792
c17cdb72
NC
1793=for Pod::Functions turn a BLOCK into a TERM
1794
a0d0e21e 1795Not really a function. Returns the value of the last command in the
6b275a1f
RGS
1796sequence of commands indicated by BLOCK. When modified by the C<while> or
1797C<until> loop modifier, executes the BLOCK once before testing the loop
391b733c 1798condition. (On other statements the loop modifiers test the conditional
6b275a1f 1799first.)
a0d0e21e 1800
4968c1e4 1801C<do BLOCK> does I<not> count as a loop, so the loop control statements
2263ed23
LM
1802L<C<next>|/next LABEL>, L<C<last>|/last LABEL>, or
1803L<C<redo>|/redo LABEL> cannot be used to leave or restart the block.
2b5ab1e7 1804See L<perlsyn> for alternative strategies.
4968c1e4 1805
a0d0e21e 1806=item do EXPR
d74e8afc 1807X<do>
a0d0e21e
LW
1808
1809Uses the value of EXPR as a filename and executes the contents of the
5fc38956 1810file as a Perl script:
a0d0e21e 1811
cfe4f7b6
DM
1812 # load the exact specified file (./ and ../ special-cased)
1813 do '/foo/stat.pl';
1814 do './stat.pl';
1815 do '../foo/stat.pl';
a0d0e21e 1816
cfe4f7b6
DM
1817 # search for the named file within @INC
1818 do 'stat.pl';
1819 do 'foo/stat.pl';
5fc38956
DM
1820
1821C<do './stat.pl'> is largely like
a0d0e21e 1822
986b19de 1823 eval `cat stat.pl`;
a0d0e21e 1824
a03e9f8a
DH
1825except that it's more concise, runs no external processes, and keeps
1826track of the current filename for error messages. It also differs in that
1827code evaluated with C<do FILE> cannot see lexicals in the enclosing
1828scope; C<eval STRING> does. It's the same, however, in that it does
1829reparse the file every time you call it, so you probably don't want
1830to do this inside a loop.
1831
cfe4f7b6 1832Using C<do> with a relative path (except for F<./> and F<../>), like
a03e9f8a 1833
cfe4f7b6 1834 do 'foo/stat.pl';
a03e9f8a
DH
1835
1836will search the L<C<@INC>|perlvar/@INC> directories, and update
1837L<C<%INC>|perlvar/%INC> if the file is found. See L<perlvar/@INC>
1838and L<perlvar/%INC> for these variables. In particular, note that
1839whilst historically L<C<@INC>|perlvar/@INC> contained '.' (the
1840current directory) making these two cases equivalent, that is no
1c99110e
DM
1841longer necessarily the case, as '.' is not included in C<@INC> by default
1842in perl versions 5.26.0 onwards. Instead, perl will now warn:
1843
1844 do "stat.pl" failed, '.' is no longer in @INC;
1845 did you mean do "./stat.pl"?
2263ed23
LM
1846
1847If L<C<do>|/do EXPR> can read the file but cannot compile it, it
1848returns L<C<undef>|/undef EXPR> and sets an error message in
1849L<C<$@>|perlvar/$@>. If L<C<do>|/do EXPR> cannot read the file, it
1850returns undef and sets L<C<$!>|perlvar/$!> to the error. Always check
1851L<C<$@>|perlvar/$@> first, as compilation could fail in a way that also
1852sets L<C<$!>|perlvar/$!>. If the file is successfully compiled,
1853L<C<do>|/do EXPR> returns the value of the last expression evaluated.
8e30cc93 1854
80d38338 1855Inclusion of library modules is better done with the
2263ed23
LM
1856L<C<use>|/use Module VERSION LIST> and L<C<require>|/require VERSION>
1857operators, which also do automatic error checking and raise an exception
1858if there's a problem.
a0d0e21e 1859
2263ed23
LM
1860You might like to use L<C<do>|/do EXPR> to read in a program
1861configuration file. Manual error checking can be done this way:
5a964f20 1862
cfe4f7b6
DM
1863 # Read in config files: system first, then user.
1864 # Beware of using relative pathnames here.
f86cebdf 1865 for $file ("/share/prog/defaults.rc",
b76cc8ba 1866 "$ENV{HOME}/.someprogrc")
a9a5a0dc
VP
1867 {
1868 unless ($return = do $file) {
1869 warn "couldn't parse $file: $@" if $@;
1870 warn "couldn't do $file: $!" unless defined $return;
1871 warn "couldn't run $file" unless $return;
1872 }
5a964f20
TC
1873 }
1874
a0d0e21e 1875=item dump LABEL
d74e8afc 1876X<dump> X<core> X<undump>
a0d0e21e 1877
8a7e748e
FC
1878=item dump EXPR
1879
1614b0e3
JD
1880=item dump
1881
c17cdb72
NC
1882=for Pod::Functions create an immediate core dump
1883
19799a22
GS
1884This function causes an immediate core dump. See also the B<-u>
1885command-line switch in L<perlrun>, which does the same thing.
1886Primarily this is so that you can use the B<undump> program (not
1887supplied) to turn your core dump into an executable binary after
1888having initialized all your variables at the beginning of the
1889program. When the new binary is executed it will begin by executing
2263ed23
LM
1890a C<goto LABEL> (with all the restrictions that L<C<goto>|/goto LABEL>
1891suffers).
19799a22 1892Think of it as a goto with an intervening core dump and reincarnation.
8a7e748e
FC
1893If C<LABEL> is omitted, restarts the program from the top. The
1894C<dump EXPR> form, available starting in Perl 5.18.0, allows a name to be
1895computed at run time, being otherwise identical to C<dump LABEL>.
19799a22
GS
1896
1897B<WARNING>: Any files opened at the time of the dump will I<not>
1898be open any more when the program is reincarnated, with possible
80d38338 1899resulting confusion by Perl.
19799a22 1900
59f521f4 1901This function is now largely obsolete, mostly because it's very hard to
391b733c 1902convert a core file into an executable. That's why you should now invoke
2263ed23 1903it as C<CORE::dump()> if you don't want to be warned against a possible
ac206dc8 1904typo.
19799a22 1905
2ba1f20a
FC
1906Unlike most named operators, this has the same precedence as assignment.
1907It is also exempt from the looks-like-a-function rule, so
1908C<dump ("foo")."bar"> will cause "bar" to be part of the argument to
2263ed23 1909L<C<dump>|/dump LABEL>.
2ba1f20a 1910
ea9eb35a 1911Portability issues: L<perlport/dump>.
1912
532eee96 1913=item each HASH
d74e8afc 1914X<each> X<hash, iterator>
aa689395 1915
532eee96 1916=item each ARRAY
aeedbbed
NC
1917X<array, iterator>
1918
c17cdb72
NC
1919=for Pod::Functions retrieve the next key/value pair from a hash
1920
bade7fbc
TC
1921When called on a hash in list context, returns a 2-element list
1922consisting of the key and value for the next element of a hash. In Perl
19235.12 and later only, it will also return the index and value for the next
1924element of an array so that you can iterate over it; older Perls consider
1925this a syntax error. When called in scalar context, returns only the key
1926(not the value) in a hash, or the index in an array.
2f9daede 1927
aeedbbed 1928Hash entries are returned in an apparently random order. The actual random
7bf59113 1929order is specific to a given hash; the exact same series of operations
7161e5c2 1930on two hashes may result in a different order for each hash. Any insertion
7bf59113 1931into the hash may change the order, as will any deletion, with the exception
2263ed23
LM
1932that the most recent key returned by L<C<each>|/each HASH> or
1933L<C<keys>|/keys HASH> may be deleted without changing the order. So
1934long as a given hash is unmodified you may rely on
1935L<C<keys>|/keys HASH>, L<C<values>|/values HASH> and
1936L<C<each>|/each HASH> to repeatedly return the same order
7161e5c2
FC
1937as each other. See L<perlsec/"Algorithmic Complexity Attacks"> for
1938details on why hash order is randomized. Aside from the guarantees
7bf59113
YO
1939provided here the exact details of Perl's hash algorithm and the hash
1940traversal order are subject to change in any release of Perl.
ab192400 1941
2263ed23
LM
1942After L<C<each>|/each HASH> has returned all entries from the hash or
1943array, the next call to L<C<each>|/each HASH> returns the empty list in
1944list context and L<C<undef>|/undef EXPR> in scalar context; the next
1945call following I<that> one restarts iteration. Each hash or array has
1946its own internal iterator, accessed by L<C<each>|/each HASH>,
1947L<C<keys>|/keys HASH>, and L<C<values>|/values HASH>. The iterator is
1948implicitly reset when L<C<each>|/each HASH> has reached the end as just
1949described; it can be explicitly reset by calling L<C<keys>|/keys HASH>
1950or L<C<values>|/values HASH> on the hash or array. If you add or delete
1951a hash's elements while iterating over it, the effect on the iterator is
49daec89 1952unspecified; for example, entries may be skipped or duplicated--so don't
d8021140 1953do that. Exception: It is always safe to delete the item most recently
2263ed23 1954returned by L<C<each>|/each HASH>, so the following code works properly:
74fc8b5f 1955
2263ed23
LM
1956 while (my ($key, $value) = each %hash) {
1957 print $key, "\n";
1958 delete $hash{$key}; # This is safe
1959 }
aa689395 1960
883f220b
TC
1961Tied hashes may have a different ordering behaviour to perl's hash
1962implementation.
1963
2263ed23 1964This prints out your environment like the L<printenv(1)> program,
3b10bc60 1965but in a different order:
a0d0e21e 1966
2263ed23 1967 while (my ($key,$value) = each %ENV) {
a9a5a0dc 1968 print "$key=$value\n";
a0d0e21e
LW
1969 }
1970
2263ed23
LM
1971Starting with Perl 5.14, an experimental feature allowed
1972L<C<each>|/each HASH> to take a scalar expression. This experiment has
1973been deemed unsuccessful, and was removed as of Perl 5.24.
cba5a3b0 1974
2263ed23
LM
1975As of Perl 5.18 you can use a bare L<C<each>|/each HASH> in a C<while>
1976loop, which will set L<C<$_>|perlvar/$_> on every iteration.
e6a0db3e 1977
2263ed23 1978 while (each %ENV) {
e6a0db3e
FC
1979 print "$_=$ENV{$_}\n";
1980 }
1981
bade7fbc
TC
1982To avoid confusing would-be users of your code who are running earlier
1983versions of Perl with mysterious syntax errors, put this sort of thing at
1984the top of your file to signal that your code will work I<only> on Perls of
1985a recent vintage:
1986
1987 use 5.012; # so keys/values/each work on arrays
e6a0db3e 1988 use 5.018; # so each assigns to $_ in a lone while test
bade7fbc 1989
2263ed23
LM
1990See also L<C<keys>|/keys HASH>, L<C<values>|/values HASH>, and
1991L<C<sort>|/sort SUBNAME LIST>.
a0d0e21e
LW
1992
1993=item eof FILEHANDLE
d74e8afc
ITB
1994X<eof>
1995X<end of file>
1996X<end-of-file>
a0d0e21e 1997
4633a7c4
LW
1998=item eof ()
1999
a0d0e21e
LW
2000=item eof
2001
c17cdb72
NC
2002=for Pod::Functions test a filehandle for its end
2003
8f1da26d 2004Returns 1 if the next read on FILEHANDLE will return end of file I<or> if
a0d0e21e 2005FILEHANDLE is not open. FILEHANDLE may be an expression whose value
5a964f20 2006gives the real filehandle. (Note that this function actually
80d38338 2007reads a character and then C<ungetc>s it, so isn't useful in an
748a9306 2008interactive context.) Do not read from a terminal file (or call
19799a22 2009C<eof(FILEHANDLE)> on it) after end-of-file is reached. File types such
748a9306
LW
2010as terminals may lose the end-of-file condition if you do.
2011
2263ed23
LM
2012An L<C<eof>|/eof FILEHANDLE> without an argument uses the last file
2013read. Using L<C<eof()>|/eof FILEHANDLE> with empty parentheses is
2014different. It refers to the pseudo file formed from the files listed on
2015the command line and accessed via the C<< <> >> operator. Since
2016C<< <> >> isn't explicitly opened, as a normal filehandle is, an
2017L<C<eof()>|/eof FILEHANDLE> before C<< <> >> has been used will cause
2018L<C<@ARGV>|perlvar/@ARGV> to be examined to determine if input is
2019available. Similarly, an L<C<eof()>|/eof FILEHANDLE> after C<< <> >>
2020has returned end-of-file will assume you are processing another
2021L<C<@ARGV>|perlvar/@ARGV> list, and if you haven't set
2022L<C<@ARGV>|perlvar/@ARGV>, will read input from C<STDIN>; see
2023L<perlop/"I/O Operators">.
2024
2025In a C<< while (<>) >> loop, L<C<eof>|/eof FILEHANDLE> or C<eof(ARGV)>
2026can be used to detect the end of each file, whereas
2027L<C<eof()>|/eof FILEHANDLE> will detect the end of the very last file
2028only. Examples:
a0d0e21e 2029
748a9306
LW
2030 # reset line numbering on each input file
2031 while (<>) {
a9a5a0dc
VP
2032 next if /^\s*#/; # skip comments
2033 print "$.\t$_";
5a964f20 2034 } continue {
a9a5a0dc 2035 close ARGV if eof; # Not eof()!
748a9306
LW
2036 }
2037
a0d0e21e
LW
2038 # insert dashes just before last line of last file
2039 while (<>) {
a9a5a0dc
VP
2040 if (eof()) { # check for end of last file
2041 print "--------------\n";
2042 }
2043 print;
f7051f2c 2044 last if eof(); # needed if we're reading from a terminal
a0d0e21e
LW
2045 }
2046
2263ed23
LM
2047Practical hint: you almost never need to use L<C<eof>|/eof FILEHANDLE>
2048in Perl, because the input operators typically return L<C<undef>|/undef
2049EXPR> when they run out of data or encounter an error.
a0d0e21e
LW
2050
2051=item eval EXPR
d74e8afc 2052X<eval> X<try> X<catch> X<evaluate> X<parse> X<execute>
f723aae1 2053X<error, handling> X<exception, handling>
a0d0e21e
LW
2054
2055=item eval BLOCK
2056
ce2984c3
PF
2057=item eval
2058
c17cdb72
NC
2059=for Pod::Functions catch exceptions or compile and run code
2060
9891e9b7
KW
2061C<eval> in all its forms is used to execute a little Perl program,
2062trapping any errors encountered so they don't crash the calling program.
2063
2064Plain C<eval> with no argument is just C<eval EXPR>, where the
2065expression is understood to be contained in L<C<$_>|perlvar/$_>. Thus
2066there are only two real C<eval> forms; the one with an EXPR is often
2067called "string eval". In a string eval, the value of the expression
2068(which is itself determined within scalar context) is first parsed, and
2069if there were no errors, executed as a block within the lexical context
2070of the current Perl program. This form is typically used to delay
2071parsing and subsequent execution of the text of EXPR until run time.
2072Note that the value is parsed every time the C<eval> executes.
2073
2074The other form is called "block eval". It is less general than string
2075eval, but the code within the BLOCK is parsed only once (at the same
2076time the code surrounding the C<eval> itself was parsed) and executed
c7cc6f1c 2077within the context of the current Perl program. This form is typically
9891e9b7
KW
2078used to trap exceptions more efficiently than the first, while also
2079providing the benefit of checking the code within BLOCK at compile time.
2080BLOCK is parsed and compiled just once. Since errors are trapped, it
2081often is used to check if a given feature is available.
c7cc6f1c
GS
2082
2083In both forms, the value returned is the value of the last expression
9891e9b7 2084evaluated inside the mini-program; a return statement may also be used, just
c7cc6f1c 2085as with subroutines. The expression providing the return value is evaluated
2263ed23 2086in void, scalar, or list context, depending on the context of the
9891e9b7 2087C<eval> itself. See L<C<wantarray>|/wantarray> for more
2263ed23
LM
2088on how the evaluation context can be determined.
2089
2090If there is a syntax error or runtime error, or a L<C<die>|/die LIST>
9891e9b7
KW
2091statement is executed, C<eval> returns
2092L<C<undef>|/undef EXPR> in scalar context, or an empty list in list
2263ed23
LM
2093context, and L<C<$@>|perlvar/$@> is set to the error message. (Prior to
20945.16, a bug caused L<C<undef>|/undef EXPR> to be returned in list
2095context for syntax errors, but not for runtime errors.) If there was no
2096error, L<C<$@>|perlvar/$@> is set to the empty string. A control flow
2097operator like L<C<last>|/last LABEL> or L<C<goto>|/goto LABEL> can
2098bypass the setting of L<C<$@>|perlvar/$@>. Beware that using
9891e9b7 2099C<eval> neither silences Perl from printing warnings to
2263ed23
LM
2100STDERR, nor does it stuff the text of warning messages into
2101L<C<$@>|perlvar/$@>. To do either of those, you have to use the
2102L<C<$SIG{__WARN__}>|perlvar/%SIG> facility, or turn off warnings inside
2103the BLOCK or EXPR using S<C<no warnings 'all'>>. See
2104L<C<warn>|/warn LIST>, L<perlvar>, and L<warnings>.
2105
9891e9b7 2106Note that, because C<eval> traps otherwise-fatal errors,
2263ed23
LM
2107it is useful for determining whether a particular feature (such as
2108L<C<socket>|/socket SOCKET,DOMAIN,TYPE,PROTOCOL> or
2109L<C<symlink>|/symlink OLDFILE,NEWFILE>) is implemented. It is also
2110Perl's exception-trapping mechanism, where the L<C<die>|/die LIST>
2111operator is used to raise exceptions.
a0d0e21e 2112
9891e9b7
KW
2113Before Perl 5.14, the assignment to L<C<$@>|perlvar/$@> occurred before
2114restoration
2115of localized variables, which means that for your code to run on older
2116versions, a temporary is required if you want to mask some, but not all
2117errors:
2118
2119 # alter $@ on nefarious repugnancy only
2120 {
2121 my $e;
2122 {
2123 local $@; # protect existing $@
2124 eval { test_repugnancy() };
2125 # $@ =~ /nefarious/ and die $@; # Perl 5.14 and higher only
2126 $@ =~ /nefarious/ and $e = $@;
2127 }
2128 die $e if defined $e
2129 }
2130
2131There are some different considerations for each form:
2132
2133=over 4
2134
2135=item String eval
2136
2137Since the return value of EXPR is executed as a block within the lexical
2138context of the current Perl program, any outer lexical variables are
2139visible to it, and any package variable settings or subroutine and
2140format definitions remain afterwards.
2141
2142=over 4
2143
2144=item Under the L<C<"unicode_eval"> feature|feature/The 'unicode_eval' and 'evalbytes' features>
2145
2146If this feature is enabled (which is the default under a C<use 5.16> or
2147higher declaration), EXPR is considered to be
2148in the same encoding as the surrounding program. Thus if
2149S<L<C<use utf8>|utf8>> is in effect, the string will be treated as being
2150UTF-8 encoded. Otherwise, the string is considered to be a sequence of
2151independent bytes. Bytes that correspond to ASCII-range code points
2152will have their normal meanings for operators in the string. The
2153treatment of the other bytes depends on if the
2154L<C<'unicode_strings"> feature|feature/The 'unicode_strings' feature> is
2155in effect.
2156
2157In a plain C<eval> without an EXPR argument, being in S<C<use utf8>> or
2158not is irrelevant; the UTF-8ness of C<$_> itself determines the
2159behavior.
2160
2161Any S<C<use utf8>> or S<C<no utf8>> declarations within the string have
2162no effect, and source filters are forbidden. (C<unicode_strings>,
66a17892 2163however, can appear within the string.) See also the
9891e9b7
KW
2164L<C<evalbytes>|/evalbytes EXPR> operator, which works properly with
2165source filters.
2166
2167Variables defined outside the C<eval> and used inside it retain their
2168original UTF-8ness. Everything inside the string follows the normal
2169rules for a Perl program with the given state of S<C<use utf8>>.
2170
2171=item Outside the C<"unicode_eval"> feature
2172
2173In this case, the behavior is problematic and is not so easily
2174described. Here are two bugs that cannot easily be fixed without
2175breaking existing programs:
2176
2177=over 4
2178
2179=item *
2180
2181It can lose track of whether something should be encoded as UTF-8 or
2182not.
2183
2184=item *
2185
2186Source filters activated within C<eval> leak out into whichever file
2187scope is currently being compiled. To give an example with the CPAN module
2188L<Semi::Semicolons>:
2189
2190 BEGIN { eval "use Semi::Semicolons; # not filtered" }
2191 # filtered here!
2192
2193L<C<evalbytes>|/evalbytes EXPR> fixes that to work the way one would
2194expect:
2195
2196 use feature "evalbytes";
2197 BEGIN { evalbytes "use Semi::Semicolons; # filtered" }
2198 # not filtered
2199
2200=back
2201
2202=back
2203
2204Problems can arise if the string expands a scalar containing a floating
2205point number. That scalar can expand to letters, such as C<"NaN"> or
2206C<"Infinity">; or, within the scope of a L<C<use locale>|locale>, the
2207decimal point character may be something other than a dot (such as a
2208comma). None of these are likely to parse as you are likely expecting.
2209
2210You should be especially careful to remember what's being looked at
2211when:
2212
2213 eval $x; # CASE 1
2214 eval "$x"; # CASE 2
2215
2216 eval '$x'; # CASE 3
2217 eval { $x }; # CASE 4
2218
2219 eval "\$$x++"; # CASE 5
2220 $$x++; # CASE 6
2221
2222Cases 1 and 2 above behave identically: they run the code contained in
2223the variable $x. (Although case 2 has misleading double quotes making
2224the reader wonder what else might be happening (nothing is).) Cases 3
2225and 4 likewise behave in the same way: they run the code C<'$x'>, which
2226does nothing but return the value of $x. (Case 4 is preferred for
2227purely visual reasons, but it also has the advantage of compiling at
2228compile-time instead of at run-time.) Case 5 is a place where
2229normally you I<would> like to use double quotes, except that in this
2230particular situation, you can just use symbolic references instead, as
2231in case 6.
2232
2233An C<eval ''> executed within a subroutine defined
2234in the C<DB> package doesn't see the usual
2235surrounding lexical scope, but rather the scope of the first non-DB piece
2236of code that called it. You don't normally need to worry about this unless
2237you are writing a Perl debugger.
2238
2239The final semicolon, if any, may be omitted from the value of EXPR.
2240
2241=item Block eval
5f1da31c 2242
a0d0e21e
LW
2243If the code to be executed doesn't vary, you may use the eval-BLOCK
2244form to trap run-time errors without incurring the penalty of
2263ed23
LM
2245recompiling each time. The error, if any, is still returned in
2246L<C<$@>|perlvar/$@>.
a0d0e21e
LW
2247Examples:
2248
54310121 2249 # make divide-by-zero nonfatal
a0d0e21e
LW
2250 eval { $answer = $a / $b; }; warn $@ if $@;
2251
2252 # same thing, but less efficient
2253 eval '$answer = $a / $b'; warn $@ if $@;
2254
2255 # a compile-time error
5ed4f2ec 2256 eval { $answer = }; # WRONG
a0d0e21e
LW
2257
2258 # a run-time error
5ed4f2ec 2259 eval '$answer ='; # sets $@
a0d0e21e 2260
9891e9b7
KW
2261If you want to trap errors when loading an XS module, some problems with
2262the binary interface (such as Perl version skew) may be fatal even with
2263C<eval> unless C<$ENV{PERL_DL_NONLAZY}> is set. See
2264L<perlrun>.
2265
2263ed23 2266Using the C<eval {}> form as an exception trap in libraries does have some
cf264981
SP
2267issues. Due to the current arguably broken state of C<__DIE__> hooks, you
2268may wish not to trigger any C<__DIE__> hooks that user code may have installed.
2b5ab1e7 2269You can use the C<local $SIG{__DIE__}> construct for this purpose,
80d38338 2270as this example shows:
774d564b 2271
80d38338 2272 # a private exception trap for divide-by-zero
f86cebdf
GS
2273 eval { local $SIG{'__DIE__'}; $answer = $a / $b; };
2274 warn $@ if $@;
774d564b
PP
2275
2276This is especially significant, given that C<__DIE__> hooks can call
2263ed23
LM
2277L<C<die>|/die LIST> again, which has the effect of changing their error
2278messages:
774d564b
PP
2279
2280 # __DIE__ hooks may modify error messages
2281 {
f86cebdf
GS
2282 local $SIG{'__DIE__'} =
2283 sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x };
c7cc6f1c
GS
2284 eval { die "foo lives here" };
2285 print $@ if $@; # prints "bar lives here"
774d564b
PP
2286 }
2287
19799a22 2288Because this promotes action at a distance, this counterintuitive behavior
2b5ab1e7
TC
2289may be fixed in a future release.
2290
4968c1e4 2291C<eval BLOCK> does I<not> count as a loop, so the loop control statements
2263ed23
LM
2292L<C<next>|/next LABEL>, L<C<last>|/last LABEL>, or
2293L<C<redo>|/redo LABEL> cannot be used to leave or restart the block.
4968c1e4 2294
9891e9b7
KW
2295The final semicolon, if any, may be omitted from within the BLOCK.
2296
2297=back
d819b83a 2298
7289c5e6
FC
2299=item evalbytes EXPR
2300X<evalbytes>
2301
2302=item evalbytes
2303
d9b04284 2304=for Pod::Functions +evalbytes similar to string eval, but intend to parse a bytestream
c17cdb72 2305
9891e9b7
KW
2306This function is similar to a L<string eval|/eval EXPR>, except it
2307always parses its argument (or L<C<$_>|perlvar/$_> if EXPR is omitted)
2308as a string of independent bytes.
7289c5e6 2309
9891e9b7 2310If called when S<C<use utf8>> is in effect, the string will be assumed
83c3106b
KW
2311to be encoded in UTF-8, and C<evalbytes> will make a temporary copy to
2312work from, downgraded to non-UTF-8. If this is not possible
9891e9b7
KW
2313(because one or more characters in it require UTF-8), the C<evalbytes>
2314will fail with the error stored in C<$@>.
2315
2316Bytes that correspond to ASCII-range code points will have their normal
2317meanings for operators in the string. The treatment of the other bytes
2318depends on if the L<C<'unicode_strings"> feature|feature/The
2319'unicode_strings' feature> is in effect.
2320
2321Of course, variables that are UTF-8 and are referred to in the string
2322retain that:
2323
2324 my $a = "\x{100}";
2325 evalbytes 'print ord $a, "\n"';
2326
2327prints
2328
2329 256
2330
2331and C<$@> is empty.
2332
2333Source filters activated within the evaluated code apply to the code
2334itself.
2335
2336L<C<evalbytes>|/evalbytes EXPR> is available starting in Perl v5.16. To
2337access it, you must say C<CORE::evalbytes>, but you can omit the
2338C<CORE::> if the
2263ed23 2339L<C<"evalbytes"> feature|feature/The 'unicode_eval' and 'evalbytes' features>
9891e9b7
KW
2340is enabled. This is enabled automatically with a C<use v5.16> (or
2341higher) declaration in the current scope.
7289c5e6 2342
a0d0e21e 2343=item exec LIST
d74e8afc 2344X<exec> X<execute>
a0d0e21e 2345
8bf3b016
GS
2346=item exec PROGRAM LIST
2347
c17cdb72
NC
2348=for Pod::Functions abandon this program to run another
2349
2263ed23
LM
2350The L<C<exec>|/exec LIST> function executes a system command I<and never
2351returns>; use L<C<system>|/system LIST> instead of L<C<exec>|/exec LIST>
2352if you want it to return. It fails and
19799a22 2353returns false only if the command does not exist I<and> it is executed
fb73857a 2354directly instead of via your system's command shell (see below).
a0d0e21e 2355
2263ed23
LM
2356Since it's a common mistake to use L<C<exec>|/exec LIST> instead of
2357L<C<system>|/system LIST>, Perl warns you if L<C<exec>|/exec LIST> is
2358called in void context and if there is a following statement that isn't
2359L<C<die>|/die LIST>, L<C<warn>|/warn LIST>, or L<C<exit>|/exit EXPR> (if
2360L<warnings> are enabled--but you always do that, right?). If you
2361I<really> want to follow an L<C<exec>|/exec LIST> with some other
2362statement, you can use one of these styles to avoid the warning:
55d729e4 2363
5a964f20
TC
2364 exec ('foo') or print STDERR "couldn't exec foo: $!";
2365 { exec ('foo') }; print STDERR "couldn't exec foo: $!";
55d729e4 2366
2263ed23 2367If there is more than one argument in LIST, this calls L<execvp(3)> with the
667eac0c
RS
2368arguments in LIST. If there is only one element in LIST, the argument is
2369checked for shell metacharacters, and if there are any, the entire
2370argument is passed to the system's command shell for parsing (this is
2371C</bin/sh -c> on Unix platforms, but varies on other platforms). If
2372there are no shell metacharacters in the argument, it is split into words
2373and passed directly to C<execvp>, which is more efficient. Examples:
a0d0e21e 2374
19799a22
GS
2375 exec '/bin/echo', 'Your arguments are: ', @ARGV;
2376 exec "sort $outfile | uniq";
a0d0e21e
LW
2377
2378If you don't really want to execute the first argument, but want to lie
2379to the program you are executing about its own name, you can specify
2380the program you actually want to run as an "indirect object" (without a
94d4006a
TS
2381comma) in front of the LIST, as in C<exec PROGRAM LIST>. (This always
2382forces interpretation of the LIST as a multivalued list, even if there
2383is only a single scalar in the list.) Example:
a0d0e21e 2384
2263ed23 2385 my $shell = '/bin/csh';
5ed4f2ec 2386 exec $shell '-sh'; # pretend it's a login shell
a0d0e21e
LW
2387
2388or, more directly,
2389
5ed4f2ec 2390 exec {'/bin/csh'} '-sh'; # pretend it's a login shell
a0d0e21e 2391
3b10bc60 2392When the arguments get executed via the system shell, results are
2393subject to its quirks and capabilities. See L<perlop/"`STRING`">
bb32b41a
GS
2394for details.
2395
2263ed23
LM
2396Using an indirect object with L<C<exec>|/exec LIST> or
2397L<C<system>|/system LIST> is also more secure. This usage (which also
2398works fine with L<C<system>|/system LIST>) forces
19799a22
GS
2399interpretation of the arguments as a multivalued list, even if the
2400list had just one argument. That way you're safe from the shell
2401expanding wildcards or splitting up words with whitespace in them.
5a964f20 2402
2263ed23 2403 my @args = ( "echo surprise" );
5a964f20 2404
2b5ab1e7 2405 exec @args; # subject to shell escapes
f86cebdf 2406 # if @args == 1
2b5ab1e7 2407 exec { $args[0] } @args; # safe even with one-arg list
5a964f20
TC
2408
2409The first version, the one without the indirect object, ran the I<echo>
80d38338
TC
2410program, passing it C<"surprise"> an argument. The second version didn't;
2411it tried to run a program named I<"echo surprise">, didn't find it, and set
2263ed23 2412L<C<$?>|perlvar/$?> to a non-zero value indicating failure.
5a964f20 2413
94d4006a
TS
2414On Windows, only the C<exec PROGRAM LIST> indirect object syntax will
2415reliably avoid using the shell; C<exec LIST>, even with more than one
2416element, will fall back to the shell if the first spawn fails.
2417
e9fa405d
BF
2418Perl attempts to flush all files opened for output before the exec,
2419but this may not be supported on some platforms (see L<perlport>).
2263ed23
LM
2420To be safe, you may need to set L<C<$E<verbar>>|perlvar/$E<verbar>>
2421(C<$AUTOFLUSH> in L<English>) or call the C<autoflush> method of
2422L<C<IO::Handle>|IO::Handle/METHODS> on any open handles to avoid lost
2423output.
0f897271 2424
2263ed23
LM
2425Note that L<C<exec>|/exec LIST> will not call your C<END> blocks, nor
2426will it invoke C<DESTROY> methods on your objects.
7660c0ab 2427
ea9eb35a 2428Portability issues: L<perlport/exec>.
2429
a0d0e21e 2430=item exists EXPR
d74e8afc 2431X<exists> X<autovivification>
a0d0e21e 2432
c17cdb72
NC
2433=for Pod::Functions test whether a hash key is present
2434
d0a76353
RS
2435Given an expression that specifies an element of a hash, returns true if the
2436specified element in the hash has ever been initialized, even if the
2437corresponding value is undefined.
a0d0e21e 2438
5ed4f2ec 2439 print "Exists\n" if exists $hash{$key};
2440 print "Defined\n" if defined $hash{$key};
01020589
GS
2441 print "True\n" if $hash{$key};
2442
d0a76353 2443exists may also be called on array elements, but its behavior is much less
2263ed23
LM
2444obvious and is strongly tied to the use of L<C<delete>|/delete EXPR> on
2445arrays.
2fbadc08 2446
2263ed23
LM
2447B<WARNING:> Calling L<C<exists>|/exists EXPR> on array values is
2448strongly discouraged. The
2fbadc08
RS
2449notion of deleting or checking the existence of Perl array elements is not
2450conceptually coherent, and can lead to surprising behavior.
d0a76353 2451
5ed4f2ec 2452 print "Exists\n" if exists $array[$index];
2453 print "Defined\n" if defined $array[$index];
01020589 2454 print "True\n" if $array[$index];
a0d0e21e 2455
8f1da26d 2456A hash or array element can be true only if it's defined and defined only if
a0d0e21e
LW
2457it exists, but the reverse doesn't necessarily hold true.
2458
afebc493
GS
2459Given an expression that specifies the name of a subroutine,
2460returns true if the specified subroutine has ever been declared, even
2461if it is undefined. Mentioning a subroutine name for exists or defined
80d38338 2462does not count as declaring it. Note that a subroutine that does not
847c7ebe
DD
2463exist may still be callable: its package may have an C<AUTOLOAD>
2464method that makes it spring into existence the first time that it is
3b10bc60 2465called; see L<perlsub>.
afebc493 2466
5ed4f2ec 2467 print "Exists\n" if exists &subroutine;
2468 print "Defined\n" if defined &subroutine;
afebc493 2469
a0d0e21e 2470Note that the EXPR can be arbitrarily complicated as long as the final
afebc493 2471operation is a hash or array key lookup or subroutine name:
a0d0e21e 2472
5ed4f2ec 2473 if (exists $ref->{A}->{B}->{$key}) { }
2474 if (exists $hash{A}{B}{$key}) { }
2b5ab1e7 2475
5ed4f2ec 2476 if (exists $ref->{A}->{B}->[$ix]) { }
2477 if (exists $hash{A}{B}[$ix]) { }
01020589 2478
afebc493
GS
2479 if (exists &{$ref->{A}{B}{$key}}) { }
2480
9590a7cd 2481Although the most deeply nested array or hash element will not spring into
3b10bc60 2482existence just because its existence was tested, any intervening ones will.
61eff3bc 2483Thus C<< $ref->{"A"} >> and C<< $ref->{"A"}->{"B"} >> will spring
2263ed23 2484into existence due to the existence test for the C<$key> element above.
3b10bc60 2485This happens anywhere the arrow operator is used, including even here:
5a964f20 2486
2b5ab1e7 2487 undef $ref;
5ed4f2ec 2488 if (exists $ref->{"Some key"}) { }
2489 print $ref; # prints HASH(0x80d3d5c)
2b5ab1e7 2490
afebc493 2491Use of a subroutine call, rather than a subroutine name, as an argument
2263ed23 2492to L<C<exists>|/exists EXPR> is an error.
afebc493 2493
5ed4f2ec 2494 exists &sub; # OK
2495 exists &sub(); # Error
afebc493 2496
a0d0e21e 2497=item exit EXPR
d74e8afc 2498X<exit> X<terminate> X<abort>
a0d0e21e 2499
ce2984c3
PF
2500=item exit
2501
c17cdb72
NC
2502=for Pod::Functions terminate this program
2503
2b5ab1e7 2504Evaluates EXPR and exits immediately with that value. Example:
a0d0e21e 2505
2263ed23 2506 my $ans = <STDIN>;
a0d0e21e
LW
2507 exit 0 if $ans =~ /^[Xx]/;
2508
2263ed23
LM
2509See also L<C<die>|/die LIST>. If EXPR is omitted, exits with C<0>
2510status. The only
2b5ab1e7
TC
2511universally recognized values for EXPR are C<0> for success and C<1>
2512for error; other values are subject to interpretation depending on the
2513environment in which the Perl program is running. For example, exiting
251469 (EX_UNAVAILABLE) from a I<sendmail> incoming-mail filter will cause
2515the mailer to return the item undelivered, but that's not true everywhere.
a0d0e21e 2516
2263ed23
LM
2517Don't use L<C<exit>|/exit EXPR> to abort a subroutine if there's any
2518chance that someone might want to trap whatever error happened. Use
2519L<C<die>|/die LIST> instead, which can be trapped by an
2520L<C<eval>|/eval EXPR>.
28757baa 2521
2263ed23
LM
2522The L<C<exit>|/exit EXPR> function does not always exit immediately. It
2523calls any defined C<END> routines first, but these C<END> routines may
2524not themselves abort the exit. Likewise any object destructors that
2525need to be called are called before the real exit. C<END> routines and
2526destructors can change the exit status by modifying L<C<$?>|perlvar/$?>.
2527If this is a problem, you can call
2528L<C<POSIX::_exit($status)>|POSIX/C<_exit>> to avoid C<END> and destructor
2529processing. See L<perlmod> for details.
5a964f20 2530
ea9eb35a 2531Portability issues: L<perlport/exit>.
2532
a0d0e21e 2533=item exp EXPR
d74e8afc 2534X<exp> X<exponential> X<antilog> X<antilogarithm> X<e>
a0d0e21e 2535
54310121 2536=item exp
bbce6d69 2537
c17cdb72
NC
2538=for Pod::Functions raise I<e> to a power
2539
b76cc8ba 2540Returns I<e> (the natural logarithm base) to the power of EXPR.
a0d0e21e
LW
2541If EXPR is omitted, gives C<exp($_)>.
2542
628253b8
BF
2543=item fc EXPR
2544X<fc> X<foldcase> X<casefold> X<fold-case> X<case-fold>
2545
2546=item fc
2547
d9b04284 2548=for Pod::Functions +fc return casefolded version of a string
c17cdb72 2549
628253b8
BF
2550Returns the casefolded version of EXPR. This is the internal function
2551implementing the C<\F> escape in double-quoted strings.
2552
2553Casefolding is the process of mapping strings to a form where case
2554differences are erased; comparing two strings in their casefolded
2555form is effectively a way of asking if two strings are equal,
2556regardless of case.
2557
2558Roughly, if you ever found yourself writing this
2559
f6c6dcb6 2560 lc($this) eq lc($that) # Wrong!
628253b8 2561 # or
f6c6dcb6 2562 uc($this) eq uc($that) # Also wrong!
628253b8 2563 # or
f6c6dcb6 2564 $this =~ /^\Q$that\E\z/i # Right!
628253b8
BF
2565
2566Now you can write
2567
2568 fc($this) eq fc($that)
2569
2570And get the correct results.
2571
2263ed23
LM
2572Perl only implements the full form of casefolding, but you can access
2573the simple folds using L<Unicode::UCD/B<casefold()>> and
2574L<Unicode::UCD/B<prop_invmap()>>.
628253b8
BF
2575For further information on casefolding, refer to
2576the Unicode Standard, specifically sections 3.13 C<Default Case Operations>,
25774.2 C<Case-Normative>, and 5.18 C<Case Mappings>,
2578available at L<http://www.unicode.org/versions/latest/>, as well as the
2579Case Charts available at L<http://www.unicode.org/charts/case/>.
2580
2263ed23 2581If EXPR is omitted, uses L<C<$_>|perlvar/$_>.
628253b8 2582
2263ed23
LM
2583This function behaves the same way under various pragmas, such as within
2584L<S<C<"use feature 'unicode_strings">>|feature/The 'unicode_strings' feature>,
2585as L<C<lc>|/lc EXPR> does, with the single exception of
2586L<C<fc>|/fc EXPR> of I<LATIN CAPITAL LETTER SHARP S> (U+1E9E) within the
2587scope of L<S<C<use locale>>|locale>. The foldcase of this character
2588would normally be C<"ss">, but as explained in the L<C<lc>|/lc EXPR>
2589section, case
1ca267a5
KW
2590changes that cross the 255/256 boundary are problematic under locales,
2591and are hence prohibited. Therefore, this function under locale returns
2263ed23
LM
2592instead the string C<"\x{17F}\x{17F}">, which is the I<LATIN SMALL LETTER
2593LONG S>. Since that character itself folds to C<"s">, the string of two
1ca267a5 2594of them together should be equivalent to a single U+1E9E when foldcased.
628253b8
BF
2595
2596While the Unicode Standard defines two additional forms of casefolding,
2597one for Turkic languages and one that never maps one character into multiple
2263ed23
LM
2598characters, these are not provided by the Perl core. However, the CPAN module
2599L<C<Unicode::Casing>|Unicode::Casing> may be used to provide an implementation.
628253b8 2600
2263ed23
LM
2601L<C<fc>|/fc EXPR> is available only if the
2602L<C<"fc"> feature|feature/The 'fc' feature> is enabled or if it is
2603prefixed with C<CORE::>. The
2604L<C<"fc"> feature|feature/The 'fc' feature> is enabled automatically
2605with a C<use v5.16> (or higher) declaration in the current scope.
628253b8 2606
a0d0e21e 2607=item fcntl FILEHANDLE,FUNCTION,SCALAR
d74e8afc 2608X<fcntl>
a0d0e21e 2609
c17cdb72
NC
2610=for Pod::Functions file control system call
2611
2263ed23 2612Implements the L<fcntl(2)> function. You'll probably have to say
a0d0e21e
LW
2613
2614 use Fcntl;
2615
0ade1984 2616first to get the correct constant definitions. Argument processing and
2263ed23
LM
2617value returned work just like L<C<ioctl>|/ioctl
2618FILEHANDLE,FUNCTION,SCALAR> below. For example:
a0d0e21e
LW
2619
2620 use Fcntl;
d5eedefe 2621 my $flags = fcntl($filehandle, F_GETFL, 0)
2263ed23
LM
2622 or die "Can't fcntl F_GETFL: $!";
2623
2624You don't have to check for L<C<defined>|/defined EXPR> on the return
2625from L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR>. Like
2626L<C<ioctl>|/ioctl FILEHANDLE,FUNCTION,SCALAR>, it maps a C<0> return
2627from the system call into C<"0 but true"> in Perl. This string is true
2628in boolean context and C<0> in numeric context. It is also exempt from
2629the normal
2630L<C<Argument "..." isn't numeric>|perldiag/Argument "%s" isn't numeric%s>
2631L<warnings> on improper numeric conversions.
2632
2633Note that L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR> raises an
2634exception if used on a machine that doesn't implement L<fcntl(2)>. See
2635the L<Fcntl> module or your L<fcntl(2)> manpage to learn what functions
2636are available on your system.
2637
2638Here's an example of setting a filehandle named C<$REMOTE> to be
2639non-blocking at the system level. You'll have to negotiate
2640L<C<$E<verbar>>|perlvar/$E<verbar>> on your own, though.
be2f7487 2641
2642 use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
2643
2263ed23
LM
2644 my $flags = fcntl($REMOTE, F_GETFL, 0)
2645 or die "Can't get flags for the socket: $!\n";
be2f7487 2646
2263ed23
LM
2647 fcntl($REMOTE, F_SETFL, $flags | O_NONBLOCK)
2648 or die "Can't set flags for the socket: $!\n";
be2f7487 2649
ea9eb35a 2650Portability issues: L<perlport/fcntl>.
2651
cfa52385
FC
2652=item __FILE__
2653X<__FILE__>
2654
c17cdb72
NC
2655=for Pod::Functions the name of the current source file
2656
cfa52385
FC
2657A special token that returns the name of the file in which it occurs.
2658
a0d0e21e 2659=item fileno FILEHANDLE
d74e8afc 2660X<fileno>
a0d0e21e 2661
f1f71a00
Z
2662=item fileno DIRHANDLE
2663
c17cdb72
NC
2664=for Pod::Functions return file descriptor from filehandle
2665
f1f71a00
Z
2666Returns the file descriptor for a filehandle or directory handle,
2667or undefined if the
a7c1632d
FC
2668filehandle is not open. If there is no real file descriptor at the OS
2669level, as can happen with filehandles connected to memory objects via
2263ed23
LM
2670L<C<open>|/open FILEHANDLE,EXPR> with a reference for the third
2671argument, -1 is returned.
a7c1632d 2672
2263ed23
LM
2673This is mainly useful for constructing bitmaps for
2674L<C<select>|/select RBITS,WBITS,EBITS,TIMEOUT> and low-level POSIX
2675tty-handling operations.
2b5ab1e7
TC
2676If FILEHANDLE is an expression, the value is taken as an indirect
2677filehandle, generally its name.
5a964f20 2678
b76cc8ba 2679You can use this to find out whether two handles refer to the
5a964f20
TC
2680same underlying descriptor:
2681
2263ed23
LM
2682 if (fileno($this) != -1 && fileno($this) == fileno($that)) {
2683 print "\$this and \$that are dups\n";
2684 } elsif (fileno($this) != -1 && fileno($that) != -1) {
2685 print "\$this and \$that have different " .
555bd962 2686 "underlying file descriptors\n";
3231d257 2687 } else {
2263ed23 2688 print "At least one of \$this and \$that does " .
555bd962 2689 "not have a real file descriptor\n";
b76cc8ba
NIS
2690 }
2691
2263ed23
LM
2692The behavior of L<C<fileno>|/fileno FILEHANDLE> on a directory handle
2693depends on the operating system. On a system with L<dirfd(3)> or
2694similar, L<C<fileno>|/fileno FILEHANDLE> on a directory
67f2cc75
AC
2695handle returns the underlying file descriptor associated with the
2696handle; on systems with no such support, it returns the undefined value,
2263ed23 2697and sets L<C<$!>|perlvar/$!> (errno).
67f2cc75 2698
a0d0e21e 2699=item flock FILEHANDLE,OPERATION
d74e8afc 2700X<flock> X<lock> X<locking>
a0d0e21e 2701
c17cdb72
NC
2702=for Pod::Functions lock an entire file with an advisory lock
2703
2263ed23 2704Calls L<flock(2)>, or an emulation of it, on FILEHANDLE. Returns true
19799a22 2705for success, false on failure. Produces a fatal error if used on a
2263ed23
LM
2706machine that doesn't implement L<flock(2)>, L<fcntl(2)> locking, or
2707L<lockf(3)>. L<C<flock>|/flock FILEHANDLE,OPERATION> is Perl's portable
2708file-locking interface, although it locks entire files only, not
2709records.
2b5ab1e7 2710
2263ed23
LM
2711Two potentially non-obvious but traditional L<C<flock>|/flock
2712FILEHANDLE,OPERATION> semantics are
2b5ab1e7 2713that it waits indefinitely until the lock is granted, and that its locks
dbfe1e81
FC
2714are B<merely advisory>. Such discretionary locks are more flexible, but
2715offer fewer guarantees. This means that programs that do not also use
2263ed23
LM
2716L<C<flock>|/flock FILEHANDLE,OPERATION> may modify files locked with
2717L<C<flock>|/flock FILEHANDLE,OPERATION>. See L<perlport>,
8f1da26d 2718your port's specific documentation, and your system-specific local manpages
2b5ab1e7
TC
2719for details. It's best to assume traditional behavior if you're writing
2720portable programs. (But if you're not, you should as always feel perfectly
2721free to write for your own system's idiosyncrasies (sometimes called
2722"features"). Slavish adherence to portability concerns shouldn't get
2723in the way of your getting your job done.)
a3cb178b 2724
8ebc5c01
PP
2725OPERATION is one of LOCK_SH, LOCK_EX, or LOCK_UN, possibly combined with
2726LOCK_NB. These constants are traditionally valued 1, 2, 8 and 4, but
8f1da26d
TC
2727you can use the symbolic names if you import them from the L<Fcntl> module,
2728either individually, or as a group using the C<:flock> tag. LOCK_SH
68dc0745 2729requests a shared lock, LOCK_EX requests an exclusive lock, and LOCK_UN
ea3105be 2730releases a previously requested lock. If LOCK_NB is bitwise-or'ed with
2263ed23
LM
2731LOCK_SH or LOCK_EX, then L<C<flock>|/flock FILEHANDLE,OPERATION> returns
2732immediately rather than blocking waiting for the lock; check the return
2733status to see if you got it.
68dc0745 2734
2b5ab1e7
TC
2735To avoid the possibility of miscoordination, Perl now flushes FILEHANDLE
2736before locking or unlocking it.
8ebc5c01 2737
2263ed23 2738Note that the emulation built with L<lockf(3)> doesn't provide shared
8ebc5c01 2739locks, and it requires that FILEHANDLE be open with write intent. These
2263ed23
LM
2740are the semantics that L<lockf(3)> implements. Most if not all systems
2741implement L<lockf(3)> in terms of L<fcntl(2)> locking, though, so the
8ebc5c01
PP
2742differing semantics shouldn't bite too many people.
2743
2263ed23 2744Note that the L<fcntl(2)> emulation of L<flock(3)> requires that FILEHANDLE
becacb53
TM
2745be open with read intent to use LOCK_SH and requires that it be open
2746with write intent to use LOCK_EX.
2747
2263ed23
LM
2748Note also that some versions of L<C<flock>|/flock FILEHANDLE,OPERATION>
2749cannot lock things over the network; you would need to use the more
2750system-specific L<C<fcntl>|/fcntl FILEHANDLE,FUNCTION,SCALAR> for
2751that. If you like you can force Perl to ignore your system's L<flock(2)>
2752function, and so provide its own L<fcntl(2)>-based emulation, by passing
8ebc5c01 2753the switch C<-Ud_flock> to the F<Configure> program when you configure
8f1da26d 2754and build a new Perl.
4633a7c4
LW
2755
2756Here's a mailbox appender for BSD systems.
a0d0e21e 2757
f7051f2c
FC
2758 # import LOCK_* and SEEK_END constants
2759 use Fcntl qw(:flock SEEK_END);
a0d0e21e
LW
2760
2761 sub lock {
a9a5a0dc
VP
2762 my ($fh) = @_;
2763 flock($fh, LOCK_EX) or die "Cannot lock mailbox - $!\n";
5c3085ee
DC
2764 # and, in case we're running on a very old UNIX
2765 # variant without the modern O_APPEND semantics...
a9a5a0dc 2766 seek($fh, 0, SEEK_END) or die "Cannot seek - $!\n";
a0d0e21e
LW
2767 }
2768
2769 sub unlock {
a9a5a0dc
VP
2770 my ($fh) = @_;
2771 flock($fh, LOCK_UN) or die "Cannot unlock mailbox - $!\n";
a0d0e21e
LW
2772 }
2773
b0169937 2774 open(my $mbox, ">>", "/usr/spool/mail/$ENV{'USER'}")
5ed4f2ec 2775 or die "Can't open mailbox: $!";
a0d0e21e 2776
7ed5353d 2777 lock($mbox);
b0169937 2778 print $mbox $msg,"\n\n";
7ed5353d 2779 unlock($mbox);
a0d0e21e 2780
2263ed23
LM
2781On systems that support a real L<flock(2)>, locks are inherited across
2782L<C<fork>|/fork> calls, whereas those that must resort to the more
2783capricious L<fcntl(2)> function lose their locks, making it seriously
2784harder to write servers.
2b5ab1e7 2785
2263ed23
LM
2786See also L<DB_File> for other L<C<flock>|/flock FILEHANDLE,OPERATION>
2787examples.
a0d0e21e 2788
ea9eb35a 2789Portability issues: L<perlport/flock>.
2790
a0d0e21e 2791=item fork
d74e8afc 2792X<fork> X<child> X<parent>
a0d0e21e 2793
c17cdb72
NC
2794=for Pod::Functions create a new process just like this one
2795
2263ed23 2796Does a L<fork(2)> system call to create a new process running the
2b5ab1e7 2797same program at the same point. It returns the child pid to the
2263ed23
LM
2798parent process, C<0> to the child process, or L<C<undef>|/undef EXPR> if
2799the fork is
2b5ab1e7
TC
2800unsuccessful. File descriptors (and sometimes locks on those descriptors)
2801are shared, while everything else is copied. On most systems supporting
2263ed23 2802L<fork(2)>, great care has gone into making it extremely efficient (for
2b5ab1e7
TC
2803example, using copy-on-write technology on data pages), making it the
2804dominant paradigm for multitasking over the last few decades.
5a964f20 2805
2263ed23
LM
2806Perl attempts to flush all files opened for output before forking the
2807child process, but this may not be supported on some platforms (see
2808L<perlport>). To be safe, you may need to set
2809L<C<$E<verbar>>|perlvar/$E<verbar>> (C<$AUTOFLUSH> in L<English>) or
2810call the C<autoflush> method of L<C<IO::Handle>|IO::Handle/METHODS> on
2811any open handles to avoid duplicate output.
a0d0e21e 2812
2263ed23 2813If you L<C<fork>|/fork> without ever waiting on your children, you will
2b5ab1e7 2814accumulate zombies. On some systems, you can avoid this by setting
2263ed23
LM
2815L<C<$SIG{CHLD}>|perlvar/%SIG> to C<"IGNORE">. See also L<perlipc> for
2816more examples of forking and reaping moribund children.
cb1a09d0 2817
28757baa
PP
2818Note that if your forked child inherits system file descriptors like
2819STDIN and STDOUT that are actually connected by a pipe or socket, even
2b5ab1e7 2820if you exit, then the remote server (such as, say, a CGI script or a
19799a22 2821backgrounded job launched from a remote shell) won't think you're done.
2b5ab1e7 2822You should reopen those to F</dev/null> if it's any issue.
28757baa 2823
2263ed23
LM
2824On some platforms such as Windows, where the L<fork(2)> system call is
2825not available, Perl can be built to emulate L<C<fork>|/fork> in the Perl
2826interpreter. The emulation is designed, at the level of the Perl
2827program, to be as compatible as possible with the "Unix" L<fork(2)>.
2828However it has limitations that have to be considered in code intended
2829to be portable. See L<perlfork> for more details.
ea9eb35a 2830
2831Portability issues: L<perlport/fork>.
2832
cb1a09d0 2833=item format
d74e8afc 2834X<format>
cb1a09d0 2835
c17cdb72
NC
2836=for Pod::Functions declare a picture format with use by the write() function
2837
2263ed23
LM
2838Declare a picture format for use by the L<C<write>|/write FILEHANDLE>
2839function. For example:
cb1a09d0 2840
54310121 2841 format Something =
a9a5a0dc
VP
2842 Test: @<<<<<<<< @||||| @>>>>>
2843 $str, $%, '$' . int($num)
cb1a09d0
AD
2844 .
2845
2846 $str = "widget";
184e9718 2847 $num = $cost/$quantity;
cb1a09d0
AD
2848 $~ = 'Something';
2849 write;
2850
2851See L<perlform> for many details and examples.
2852
8903cb82 2853=item formline PICTURE,LIST
d74e8afc 2854X<formline>
a0d0e21e 2855
c17cdb72
NC
2856=for Pod::Functions internal function used for formats
2857
2263ed23
LM
2858This is an internal function used by L<C<format>|/format>s, though you
2859may call it, too. It formats (see L<perlform>) a list of values
2860according to the contents of PICTURE, placing the output into the format
2861output accumulator, L<C<$^A>|perlvar/$^A> (or C<$ACCUMULATOR> in
2862L<English>). Eventually, when a L<C<write>|/write FILEHANDLE> is done,
2863the contents of L<C<$^A>|perlvar/$^A> are written to some filehandle.
2864You could also read L<C<$^A>|perlvar/$^A> and then set
2865L<C<$^A>|perlvar/$^A> back to C<"">. Note that a format typically does
2866one L<C<formline>|/formline PICTURE,LIST> per line of form, but the
2867L<C<formline>|/formline PICTURE,LIST> function itself doesn't care how
2868many newlines are embedded in the PICTURE. This means that the C<~> and
2869C<~~> tokens treat the entire PICTURE as a single line. You may
2870therefore need to use multiple formlines to implement a single record
2871format, just like the L<C<format>|/format> compiler.
748a9306 2872
19799a22 2873Be careful if you put double quotes around the picture, because an C<@>
748a9306 2874character may be taken to mean the beginning of an array name.
2263ed23
LM
2875L<C<formline>|/formline PICTURE,LIST> always returns true. See
2876L<perlform> for other examples.
a0d0e21e 2877
2263ed23
LM
2878If you are trying to use this instead of L<C<write>|/write FILEHANDLE>
2879to capture the output, you may find it easier to open a filehandle to a
2880scalar (C<< open my $fh, ">", \$output >>) and write to that instead.
445b09e5 2881
a0d0e21e 2882=item getc FILEHANDLE
f723aae1 2883X<getc> X<getchar> X<character> X<file, read>
a0d0e21e
LW
2884
2885=item getc
2886
c17cdb72
NC
2887=for Pod::Functions get the next character from the filehandle
2888
a0d0e21e 2889Returns the next character from the input file attached to FILEHANDLE,
3b10bc60 2890or the undefined value at end of file or if there was an error (in
2263ed23
LM
2891the latter case L<C<$!>|perlvar/$!> is set). If FILEHANDLE is omitted,
2892reads from
b5fe5ca2
SR
2893STDIN. This is not particularly efficient. However, it cannot be
2894used by itself to fetch single characters without waiting for the user
2895to hit enter. For that, try something more like:
4633a7c4
LW
2896
2897 if ($BSD_STYLE) {
a9a5a0dc 2898 system "stty cbreak </dev/tty >/dev/tty 2>&1";
4633a7c4
LW
2899 }
2900 else {
a9a5a0dc 2901 system "stty", '-icanon', 'eol', "\001";
4633a7c4
LW
2902 }
2903
2263ed23 2904 my $key = getc(STDIN);
4633a7c4
LW
2905
2906 if ($BSD_STYLE) {
a9a5a0dc 2907 system "stty -cbreak </dev/tty >/dev/tty 2>&1";
4633a7c4
LW
2908 }
2909 else {
3b10bc60 2910 system 'stty', 'icanon', 'eol', '^@'; # ASCII NUL
4633a7c4
LW
2911 }
2912 print "\n";
2913
2263ed23
LM
2914Determination of whether C<$BSD_STYLE> should be set is left as an
2915exercise to the reader.
cb1a09d0 2916
2263ed23
LM
2917The L<C<POSIX::getattr>|POSIX/C<getattr>> function can do this more
2918portably on systems purporting POSIX compliance. See also the
2919L<C<Term::ReadKey>|Term::ReadKey> module on CPAN.
a0d0e21e
LW
2920
2921=item getlogin
d74e8afc 2922X<getlogin> X<login>
a0d0e21e 2923
c17cdb72
NC
2924=for Pod::Functions return who logged in at this tty
2925
cf264981 2926This implements the C library function of the same name, which on most
3b10bc60 2927systems returns the current login from F</etc/utmp>, if any. If it
2263ed23 2928returns the empty string, use L<C<getpwuid>|/getpwuid UID>.
a0d0e21e 2929
2263ed23 2930 my $login = getlogin || getpwuid($<) || "Kilroy";
a0d0e21e 2931
2263ed23
LM
2932Do not consider L<C<getlogin>|/getlogin> for authentication: it is not
2933as secure as L<C<getpwuid>|/getpwuid UID>.
4633a7c4 2934
ea9eb35a 2935Portability issues: L<perlport/getlogin>.
2936
a0d0e21e 2937=item getpeername SOCKET
d74e8afc 2938X<getpeername> X<peer>
a0d0e21e 2939
c17cdb72
NC
2940=for Pod::Functions find the other end of a socket connection
2941
a3390c9f
FC
2942Returns the packed sockaddr address of the other end of the SOCKET
2943connection.
a0d0e21e 2944
4633a7c4 2945 use Socket;
2263ed23
LM
2946 my $hersockaddr = getpeername($sock);
2947 my ($port, $iaddr) = sockaddr_in($hersockaddr);
2948 my $herhostname = gethostbyaddr($iaddr, AF_INET);
2949 my $herstraddr = inet_ntoa($iaddr);
a0d0e21e
LW
2950
2951=item getpgrp PID
d74e8afc 2952X<getpgrp> X<group>
a0d0e21e 2953
c17cdb72
NC
2954=for Pod::Functions get process group
2955
47e29363 2956Returns the current process group for the specified PID. Use
7660c0ab 2957a PID of C<0> to get the current process group for the
4633a7c4 2958current process. Will raise an exception if used on a machine that
2263ed23
LM
2959doesn't implement L<getpgrp(2)>. If PID is omitted, returns the process
2960group of the current process. Note that the POSIX version of
2961L<C<getpgrp>|/getpgrp PID> does not accept a PID argument, so only
2962C<PID==0> is truly portable.
a0d0e21e 2963
ea9eb35a 2964Portability issues: L<perlport/getpgrp>.
2965
a0d0e21e 2966=item getppid
d74e8afc 2967X<getppid> X<parent> X<pid>
a0d0e21e 2968
c17cdb72
NC
2969=for Pod::Functions get parent process ID
2970
a0d0e21e
LW
2971Returns the process id of the parent process.
2972
d7c042c9
AB
2973Note for Linux users: Between v5.8.1 and v5.16.0 Perl would work
2974around non-POSIX thread semantics the minority of Linux systems (and
2975Debian GNU/kFreeBSD systems) that used LinuxThreads, this emulation
7161e5c2 2976has since been removed. See the documentation for L<$$|perlvar/$$> for
d7c042c9 2977details.
4d76a344 2978
ea9eb35a 2979Portability issues: L<perlport/getppid>.
2980
a0d0e21e 2981=item getpriority WHICH,WHO
d74e8afc 2982X<getpriority> X<priority> X<nice>
a0d0e21e 2983
c17cdb72
NC
2984=for Pod::Functions get current nice value
2985
4633a7c4 2986Returns the current priority for a process, a process group, or a user.
01aa884e 2987(See L<getpriority(2)>.) Will raise a fatal exception if used on a
2263ed23 2988machine that doesn't implement L<getpriority(2)>.
a0d0e21e 2989
7596fda6
TC
2990C<WHICH> can be any of C<PRIO_PROCESS>, C<PRIO_PGRP> or C<PRIO_USER>
2991imported from L<POSIX/RESOURCE CONSTANTS>.
2992
ea9eb35a 2993Portability issues: L<perlport/getpriority>.
2994
a0d0e21e 2995=item getpwnam NAME
d74e8afc
ITB
2996X<getpwnam> X<getgrnam> X<gethostbyname> X<getnetbyname> X<getprotobyname>
2997X<getpwuid> X<getgrgid> X<getservbyname> X<gethostbyaddr> X<getnetbyaddr>
2998X<getprotobynumber> X<getservbyport> X<getpwent> X<getgrent> X<gethostent>
2999X<getnetent> X<getprotoent> X<getservent> X<setpwent> X<setgrent> X<sethostent>
3000X<setnetent> X<setprotoent> X<setservent> X<endpwent> X<endgrent> X<endhostent>
2263ed23 3001X<endnetent> X<endprotoent> X<endservent>
a0d0e21e 3002
c17cdb72
NC
3003=for Pod::Functions get passwd record given user login name
3004
a0d0e21e
LW
3005=item getgrnam NAME
3006
c17cdb72
NC
3007=for Pod::Functions get group record given group name
3008
a0d0e21e
LW
3009=item gethostbyname NAME
3010
c17cdb72
NC
3011=for Pod::Functions get host record given name
3012
a0d0e21e
LW
3013=item getnetbyname NAME
3014
c17cdb72
NC
3015=for Pod::Functions get networks record given name
3016
a0d0e21e
LW
3017=item getprotobyname NAME
3018
c17cdb72
NC
3019=for Pod::Functions get protocol record given name
3020
a0d0e21e
LW
3021=item getpwuid UID
3022
c17cdb72
NC
3023=for Pod::Functions get passwd record given user ID
3024
a0d0e21e
LW
3025=item getgrgid GID
3026
c17cdb72
NC
3027=for Pod::Functions get group record given group user ID
3028
a0d0e21e
LW
3029=item getservbyname NAME,PROTO
3030
c17cdb72
NC
3031=for Pod::Functions get services record given its name
3032
a0d0e21e
LW
3033=item gethostbyaddr ADDR,ADDRTYPE
3034
c17cdb72
NC
3035=for Pod::Functions get host record given its address
3036
a0d0e21e
LW
3037=item getnetbyaddr ADDR,ADDRTYPE
3038
c17cdb72
NC
3039=for Pod::Functions get network record given its address
3040
a0d0e21e
LW
3041=item getprotobynumber NUMBER
3042
c17cdb72
NC
3043=for Pod::Functions get protocol record numeric protocol
3044
a0d0e21e
LW
3045=item getservbyport PORT,PROTO
3046
c17cdb72
NC
3047=for Pod::Functions get services record given numeric port
3048
a0d0e21e
LW
3049=item getpwent
3050
c17cdb72
NC
3051=for Pod::Functions get next passwd record
3052
a0d0e21e
LW
3053=item getgrent
3054
c17cdb72
NC
3055=for Pod::Functions get next group record
3056
a0d0e21e
LW
3057=item gethostent
3058
c17cdb72
NC
3059=for Pod::Functions get next hosts record
3060
a0d0e21e
LW
3061=item getnetent
3062
c17cdb72
NC
3063=for Pod::Functions get next networks record
3064
a0d0e21e
LW
3065=item getprotoent
3066
c17cdb72
NC
3067=for Pod::Functions get next protocols record
3068
a0d0e21e
LW
3069=item getservent
3070
c17cdb72
NC
3071=for Pod::Functions get next services record
3072
a0d0e21e
LW
3073=item setpwent
3074
c17cdb72
NC
3075=for Pod::Functions prepare passwd file for use
3076
a0d0e21e
LW
3077=item setgrent
3078
c17cdb72
NC
3079=for Pod::Functions prepare group file for use
3080
a0d0e21e
LW
3081=item sethostent STAYOPEN
3082
c17cdb72
NC
3083=for Pod::Functions prepare hosts file for use
3084
a0d0e21e
LW
3085=item setnetent STAYOPEN
3086
c17cdb72
NC
3087=for Pod::Functions prepare networks file for use
3088
a0d0e21e
LW
3089=item setprotoent STAYOPEN
3090
c17cdb72
NC
3091=for Pod::Functions prepare protocols file for use
3092
a0d0e21e
LW
3093=item setservent STAYOPEN
3094
c17cdb72
NC
3095=for Pod::Functions prepare services file for use
3096
a0d0e21e
LW
3097=item endpwent
3098
c17cdb72
NC
3099=for Pod::Functions be done using passwd file
3100
a0d0e21e
LW
3101=item endgrent
3102
c17cdb72
NC
3103=for Pod::Functions be done using group file
3104
a0d0e21e
LW
3105=item endhostent
3106
c17cdb72
NC
3107=for Pod::Functions be done using hosts file
3108
a0d0e21e
LW
3109=item endnetent
3110
c17cdb72
NC
3111=for Pod::Functions be done using networks file
3112
a0d0e21e
LW
3113=item endprotoent
3114
c17cdb72
NC
3115=for Pod::Functions be done using protocols file
3116
a0d0e21e
LW
3117=item endservent
3118
c17cdb72
NC
3119=for Pod::Functions be done using services file
3120
80d38338
TC
3121These routines are the same as their counterparts in the
3122system C library. In list context, the return values from the
a0d0e21e
LW
3123various get routines are as follows:
3124
2263ed23
LM
3125 # 0 1 2 3 4
3126 my ( $name, $passwd, $gid, $members ) = getgr*
3127 my ( $name, $aliases, $addrtype, $net ) = getnet*
3128 my ( $name, $aliases, $port, $proto ) = getserv*
3129 my ( $name, $aliases, $proto ) = getproto*
3130 my ( $name, $aliases, $addrtype, $length, @addrs ) = gethost*
3131 my ( $name, $passwd, $uid, $gid, $quota,
3132 $comment, $gcos, $dir, $shell, $expire ) = getpw*
3133 # 5 6 7 8 9
a0d0e21e 3134
75f7c783
FC
3135(If the entry doesn't exist, the return value is a single meaningless true
3136value.)
a0d0e21e 3137
4602f195
JH
3138The exact meaning of the $gcos field varies but it usually contains
3139the real name of the user (as opposed to the login name) and other
3140information pertaining to the user. Beware, however, that in many
3141system users are able to change this information and therefore it
106325ad 3142cannot be trusted and therefore the $gcos is tainted (see
2959b6e3 3143L<perlsec>). The $passwd and $shell, user's encrypted password and
a3390c9f 3144login shell, are also tainted, for the same reason.
4602f195 3145
5a964f20 3146In scalar context, you get the name, unless the function was a
a0d0e21e
LW
3147lookup by name, in which case you get the other thing, whatever it is.
3148(If the entry doesn't exist you get the undefined value.) For example:
3149
2263ed23
LM
3150 my $uid = getpwnam($name);
3151 my $name = getpwuid($num);
3152 my $name = getpwent();
3153 my $gid = getgrnam($name);
3154 my $name = getgrgid($num);
3155 my $name = getgrent();
3156 # etc.
a0d0e21e 3157
4602f195 3158In I<getpw*()> the fields $quota, $comment, and $expire are special
80d38338 3159in that they are unsupported on many systems. If the
4602f195
JH
3160$quota is unsupported, it is an empty scalar. If it is supported, it
3161usually encodes the disk quota. If the $comment field is unsupported,
3162it is an empty scalar. If it is supported it usually encodes some
3163administrative comment about the user. In some systems the $quota
3164field may be $change or $age, fields that have to do with password
3165aging. In some systems the $comment field may be $class. The $expire
3166field, if present, encodes the expiration period of the account or the
3167password. For the availability and the exact meaning of these fields
2263ed23 3168in your system, please consult L<getpwnam(3)> and your system's
4602f195
JH
3169F<pwd.h> file. You can also find out from within Perl what your
3170$quota and $comment fields mean and whether you have the $expire field
2263ed23 3171by using the L<C<Config>|Config> module and the values C<d_pwquota>, C<d_pwage>,
4602f195 3172C<d_pwchange>, C<d_pwcomment>, and C<d_pwexpire>. Shadow password
3b10bc60 3173files are supported only if your vendor has implemented them in the
4602f195 3174intuitive fashion that calling the regular C library routines gets the
5d3a0a3b 3175shadow versions if you're running under privilege or if there exists
2263ed23 3176the L<shadow(3)> functions as found in System V (this includes Solaris
a3390c9f 3177and Linux). Those systems that implement a proprietary shadow password
5d3a0a3b 3178facility are unlikely to be supported.
6ee623d5 3179
a3390c9f 3180The $members value returned by I<getgr*()> is a space-separated list of
a0d0e21e
LW
3181the login names of the members of the group.
3182
3183For the I<gethost*()> functions, if the C<h_errno> variable is supported in
2263ed23
LM
3184C, it will be returned to you via L<C<$?>|perlvar/$?> if the function
3185call fails. The
3b10bc60 3186C<@addrs> value returned by a successful call is a list of raw
3187addresses returned by the corresponding library call. In the
3188Internet domain, each address is four bytes long; you can unpack it
a0d0e21e
LW
3189by saying something like:
3190
2263ed23 3191 my ($w,$x,$y,$z) = unpack('W4',$addr[0]);
a0d0e21e 3192
2b5ab1e7
TC
3193The Socket library makes this slightly easier:
3194
3195 use Socket;
2263ed23
LM
3196 my $iaddr = inet_aton("127.1"); # or whatever address
3197 my $name = gethostbyaddr($iaddr, AF_INET);
2b5ab1e7
TC
3198
3199 # or going the other way
2263ed23 3200 my $straddr = inet_ntoa($iaddr);
2b5ab1e7 3201
d760c846
GS
3202In the opposite way, to resolve a hostname to the IP address
3203you can write this:
3204
3205 use Socket;
2263ed23
LM
3206 my $packed_ip = gethostbyname("www.perl.org");
3207 my $ip_address;
d760c846
GS