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