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