| 1 |
.\" -*- mode: troff; coding: utf-8 -*- |
| 2 |
.\" Automatically generated by Pod::Man 5.0102 (Pod::Simple 3.45) |
| 3 |
.\" |
| 4 |
.\" Standard preamble: |
| 5 |
.\" ======================================================================== |
| 6 |
.de Sp \" Vertical space (when we can't use .PP) |
| 7 |
.if t .sp .5v |
| 8 |
.if n .sp |
| 9 |
.. |
| 10 |
.de Vb \" Begin verbatim text |
| 11 |
.ft CW |
| 12 |
.nf |
| 13 |
.ne \\$1 |
| 14 |
.. |
| 15 |
.de Ve \" End verbatim text |
| 16 |
.ft R |
| 17 |
.fi |
| 18 |
.. |
| 19 |
.\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. |
| 20 |
.ie n \{\ |
| 21 |
. ds C` "" |
| 22 |
. ds C' "" |
| 23 |
'br\} |
| 24 |
.el\{\ |
| 25 |
. ds C` |
| 26 |
. ds C' |
| 27 |
'br\} |
| 28 |
.\" |
| 29 |
.\" Escape single quotes in literal strings from groff's Unicode transform. |
| 30 |
.ie \n(.g .ds Aq \(aq |
| 31 |
.el .ds Aq ' |
| 32 |
.\" |
| 33 |
.\" If the F register is >0, we'll generate index entries on stderr for |
| 34 |
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index |
| 35 |
.\" entries marked with X<> in POD. Of course, you'll have to process the |
| 36 |
.\" output yourself in some meaningful fashion. |
| 37 |
.\" |
| 38 |
.\" Avoid warning from groff about undefined register 'F'. |
| 39 |
.de IX |
| 40 |
.. |
| 41 |
.nr rF 0 |
| 42 |
.if \n(.g .if rF .nr rF 1 |
| 43 |
.if (\n(rF:(\n(.g==0)) \{\ |
| 44 |
. if \nF \{\ |
| 45 |
. de IX |
| 46 |
. tm Index:\\$1\t\\n%\t"\\$2" |
| 47 |
.. |
| 48 |
. if !\nF==2 \{\ |
| 49 |
. nr % 0 |
| 50 |
. nr F 2 |
| 51 |
. \} |
| 52 |
. \} |
| 53 |
.\} |
| 54 |
.rr rF |
| 55 |
.\" ======================================================================== |
| 56 |
.\" |
| 57 |
.IX Title "PERLGLOSSARY 1" |
| 58 |
.TH PERLGLOSSARY 1 2025-11-16 "perl v5.40.1" "Perl Programmers Reference Guide" |
| 59 |
.\" For nroff, turn off justification. Always turn off hyphenation; it makes |
| 60 |
.\" way too many mistakes in technical documents. |
| 61 |
.if n .ad l |
| 62 |
.nh |
| 63 |
.SH NAME |
| 64 |
perlglossary \- Perl Glossary |
| 65 |
.SH VERSION |
| 66 |
.IX Header "VERSION" |
| 67 |
version 5.20240218 |
| 68 |
.SH DESCRIPTION |
| 69 |
.IX Header "DESCRIPTION" |
| 70 |
A glossary of terms (technical and otherwise) used in the Perl |
| 71 |
documentation, derived from the Glossary of \fIProgramming |
| 72 |
Perl\fR, Fourth Edition. Words or phrases in bold are defined elsewhere in |
| 73 |
this glossary. |
| 74 |
.PP |
| 75 |
Other useful sources include the Unicode Glossary <http://unicode.org/glossary/>, |
| 76 |
the Free On-Line Dictionary of Computing <http://foldoc.org/>, |
| 77 |
the Jargon File <http://catb.org/~esr/jargon/>, |
| 78 |
and Wikipedia <http://www.wikipedia.org/>. |
| 79 |
.SS A |
| 80 |
.IX Subsection "A" |
| 81 |
.IP "accessor methods" 4 |
| 82 |
.IX Item "accessor methods" |
| 83 |
A \fBmethod\fR used to |
| 84 |
indirectly inspect or update an \fBobject\fR’s state (its \fBinstance |
| 85 |
variables\fR). |
| 86 |
.IX Xref "accessor methods, defined methods, accessor" |
| 87 |
.IP "actual arguments" 4 |
| 88 |
.IX Item "actual arguments" |
| 89 |
The \fBscalar values\fR that you supply |
| 90 |
to a \fBfunction\fR or \fBsubroutine\fR when you call it. For instance, when you |
| 91 |
call \f(CWpower("puff")\fR, the string \f(CW"puff"\fR is the actual argument. See also |
| 92 |
\&\fBargument\fR and \fBformal arguments\fR. |
| 93 |
.IX Xref "actual arguments arguments, actual" |
| 94 |
.IP "address operator" 4 |
| 95 |
.IX Item "address operator" |
| 96 |
Some languages work directly with the memory addresses of |
| 97 |
values, but this can be like playing with fire. Perl provides a set of |
| 98 |
asbestos gloves for handling all memory management. The closest to an |
| 99 |
address operator in Perl is the backslash operator, but it gives you a |
| 100 |
\&\fBhard reference\fR, which is much safer than a memory address. |
| 101 |
.IX Xref "address operator" |
| 102 |
.IP algorithm 4 |
| 103 |
.IX Item "algorithm" |
| 104 |
A well-defined sequence of steps, explained clearly |
| 105 |
enough that even a computer could do them. |
| 106 |
.IX Xref "algorithms (term)" |
| 107 |
.IP alias 4 |
| 108 |
.IX Item "alias" |
| 109 |
A nickname for something, which behaves in all ways as |
| 110 |
though you’d used the original name instead of the nickname. Temporary |
| 111 |
aliases are implicitly created in the loop variable for \f(CW\*(C`foreach\*(C'\fR loops, in |
| 112 |
the \f(CW$_\fR variable for \f(CW\*(C`map\*(C'\fR or \f(CW\*(C`grep\*(C'\fR operators, in \f(CW$a\fR and \f(CW$b\fR |
| 113 |
during \f(CW\*(C`sort\*(C'\fR’s comparison function, and in each element of \f(CW@_\fR for the |
| 114 |
\&\fBactual arguments\fR of a subroutine call. Permanent aliases are explicitly |
| 115 |
created in \fBpackages\fR by \fBimporting\fR symbols or by assignment to |
| 116 |
\&\fBtypeglobs\fR. Lexically scoped aliases for package variables are explicitly |
| 117 |
created by the \f(CW\*(C`our\*(C'\fR declaration. |
| 118 |
.IX Xref "aliases, defined" |
| 119 |
.IP alphabetic 4 |
| 120 |
.IX Item "alphabetic" |
| 121 |
The sort of characters we put into words. In Unicode, this |
| 122 |
is all letters including all ideographs and certain diacritics, letter |
| 123 |
numbers like Roman numerals, and various combining marks. |
| 124 |
.IX Xref "alphabetic sort" |
| 125 |
.IP alternatives 4 |
| 126 |
.IX Item "alternatives" |
| 127 |
A list of possible choices from which you may |
| 128 |
select only one, as in, “Would you like door A, B, or C?” Alternatives in |
| 129 |
regular expressions are separated with a single vertical bar: \f(CW\*(C`|\*(C'\fR. |
| 130 |
Alternatives in normal Perl expressions are separated with a double vertical |
| 131 |
bar: \f(CW\*(C`||\*(C'\fR. Logical alternatives in \fBBoolean\fR expressions are separated |
| 132 |
with either \f(CW\*(C`||\*(C'\fR or \f(CW\*(C`or\*(C'\fR. |
| 133 |
.IX Xref "alternative characters" |
| 134 |
.IP anonymous 4 |
| 135 |
.IX Item "anonymous" |
| 136 |
Used to describe a \fBreferent\fR |
| 137 |
that is not directly accessible through a named \fBvariable\fR. Such a referent |
| 138 |
must be indirectly accessible through at least one \fBhard reference\fR. When |
| 139 |
the last hard reference goes away, the anonymous referent is destroyed |
| 140 |
without pity. |
| 141 |
.IX Xref "anonymous referents referents, anonymous" |
| 142 |
.IP application 4 |
| 143 |
.IX Item "application" |
| 144 |
A bigger, fancier sort of \fBprogram\fR with a fancier |
| 145 |
name so people don’t realize they are using a program. |
| 146 |
.IX Xref "applications (term)" |
| 147 |
.IP architecture 4 |
| 148 |
.IX Item "architecture" |
| 149 |
The kind of computer you’re working on, where one “kind of |
| 150 |
computer” means all those computers sharing a compatible machine language. |
| 151 |
Since Perl programs are (typically) simple text files, not executable |
| 152 |
images, a Perl program is much less sensitive to the architecture it’s |
| 153 |
running on than programs in other languages, such as C, that are \fBcompiled\fR |
| 154 |
into machine code. See also \fBplatform\fR and \fBoperating system\fR. |
| 155 |
.IX Xref "architecture" |
| 156 |
.IP argument 4 |
| 157 |
.IX Item "argument" |
| 158 |
A piece of data supplied to a \fBprogram\fR, |
| 159 |
\&\fBsubroutine\fR, \fBfunction\fR, or \fBmethod\fR to tell it what it’s supposed to |
| 160 |
do. Also called a “parameter”. |
| 161 |
.IX Xref "arguments, defined" |
| 162 |
.IP ARGV 4 |
| 163 |
.IX Item "ARGV" |
| 164 |
The name of the array containing the \fBargument\fR \fBvector\fR |
| 165 |
from the command line. If you use the empty \f(CW\*(C`<>\*(C'\fR operator, \f(CW\*(C`ARGV\*(C'\fR |
| 166 |
is the name of both the \fBfilehandle\fR used to traverse the arguments and the |
| 167 |
\&\fBscalar\fR containing the name of the current input file. |
| 168 |
.IX Xref "ARGV filehandle" |
| 169 |
.IP "arithmetical operator" 4 |
| 170 |
.IX Item "arithmetical operator" |
| 171 |
A \fBsymbol\fR such as \f(CW\*(C`+\*(C'\fR or \f(CW\*(C`/\*(C'\fR that tells |
| 172 |
Perl to do the arithmetic you were supposed to learn in grade school. |
| 173 |
.IX Xref "arithmetic operators, about" |
| 174 |
.IP array 4 |
| 175 |
.IX Item "array" |
| 176 |
An ordered sequence of \fBvalues\fR, stored such that you can |
| 177 |
easily access any of the values using an \fIinteger subscript\fR that specifies |
| 178 |
the value’s \fBoffset\fR in the sequence. |
| 179 |
.IX Xref "arrays, defined" |
| 180 |
.IP "array context" 4 |
| 181 |
.IX Item "array context" |
| 182 |
An archaic expression for what is more correctly referred to |
| 183 |
as \fBlist context\fR. |
| 184 |
.IX Xref "array context" |
| 185 |
.IP "Artistic License" 4 |
| 186 |
.IX Item "Artistic License" |
| 187 |
The open source license that Larry Wall |
| 188 |
created for Perl, maximizing Perl’s usefulness, availability, and |
| 189 |
modifiability. The current version is 2. (<http://www.opensource.org/licenses/artistic\-license.php>). |
| 190 |
.IX Xref "Artistic License Wall, Larry" |
| 191 |
.IP ASCII 4 |
| 192 |
.IX Item "ASCII" |
| 193 |
The American Standard Code for |
| 194 |
Information Interchange (a 7\-bit character set adequate only for poorly |
| 195 |
representing English text). Often used loosely to describe the lowest 128 |
| 196 |
values of the various ISO\-8859\-X character sets, a bunch of mutually |
| 197 |
incompatible 8\-bit codes best described as half ASCII. See also \fBUnicode\fR. |
| 198 |
.IX Xref "ASCII (American Standard Code for Information Interchange) American Standard Code for Information Interchange (ASCII)" |
| 199 |
.IP assertion 4 |
| 200 |
.IX Item "assertion" |
| 201 |
A component of a \fBregular expression\fR that must be true for the pattern to |
| 202 |
match but does not necessarily match any characters itself. Often used |
| 203 |
specifically to mean a \fBzero-width\fR assertion. |
| 204 |
.IX Xref "assertions (in regexes), defined regular expressions, assertions in" |
| 205 |
.IP assignment 4 |
| 206 |
.IX Item "assignment" |
| 207 |
An \fBoperator\fR whose assigned mission in life is to |
| 208 |
change the value of a \fBvariable\fR. |
| 209 |
.IX Xref "assignments, defined" |
| 210 |
.IP "assignment operator" 4 |
| 211 |
.IX Item "assignment operator" |
| 212 |
Either a regular \fBassignment\fR or a compound |
| 213 |
\&\fBoperator\fR composed of an ordinary assignment and some other operator, that |
| 214 |
changes the value of a variable in place; that is, relative to its old |
| 215 |
value. For example, \f(CW\*(C`$a += 2\*(C'\fR adds \f(CW2\fR to \f(CW$a\fR. |
| 216 |
.IX Xref "assignment operators, about" |
| 217 |
.IP "associative array" 4 |
| 218 |
.IX Item "associative array" |
| 219 |
See \fBhash\fR. Please. The term associative array is the |
| 220 |
old Perl 4 term for a \fBhash\fR. Some languages call it a dictionary. |
| 221 |
.IX Xref "associative arrays" |
| 222 |
.IP associativity 4 |
| 223 |
.IX Item "associativity" |
| 224 |
Determines whether you do the left \fBoperator\fR first or the |
| 225 |
right \fBoperator\fR first when you have “A \fBoperator\fR B \fBoperator\fR C”, and |
| 226 |
the two operators are of the same precedence. Operators like \f(CW\*(C`+\*(C'\fR are left |
| 227 |
associative, while operators like \f(CW\*(C`**\*(C'\fR are right associative. See Camel |
| 228 |
chapter 3, “Unary and Binary Operators” for a list of operators and their |
| 229 |
associativity. |
| 230 |
.IX Xref "associativity" |
| 231 |
.IP asynchronous 4 |
| 232 |
.IX Item "asynchronous" |
| 233 |
Said of events or activities whose relative |
| 234 |
temporal ordering is indeterminate because too many things are going on at |
| 235 |
once. Hence, an asynchronous event is one you didn’t know when to expect. |
| 236 |
.IX Xref "asynchronous event processing" |
| 237 |
.IP atom 4 |
| 238 |
.IX Item "atom" |
| 239 |
A \fBregular expression\fR component potentially matching a |
| 240 |
\&\fBsubstring\fR containing one or more characters and treated as an indivisible |
| 241 |
syntactic unit by any following \fBquantifier\fR. (Contrast with an |
| 242 |
\&\fBassertion\fR that matches something of \fBzero width\fR and may not be quantified.) |
| 243 |
.IX Xref "atoms" |
| 244 |
.IP "atomic operation" 4 |
| 245 |
.IX Item "atomic operation" |
| 246 |
When Democritus gave the word “atom” to the indivisible |
| 247 |
bits of matter, he meant literally something that could not be cut: \fIἀ\-\fR |
| 248 |
(not) + \fI\-τομος\fR (cuttable). An atomic operation is an action that can’t be |
| 249 |
interrupted, not one forbidden in a nuclear-free zone. |
| 250 |
.IX Xref "atomic operation" |
| 251 |
.IP attribute 4 |
| 252 |
.IX Item "attribute" |
| 253 |
A new feature that allows the declaration of |
| 254 |
\&\fBvariables\fR and \fBsubroutines\fR with modifiers, as in \f(CW\*(C`sub foo : locked |
| 255 |
method\*(C'\fR. Also another name for an \fBinstance variable\fR of an \fBobject\fR. |
| 256 |
.IX Xref "attribute feature" |
| 257 |
.IP autogeneration 4 |
| 258 |
.IX Item "autogeneration" |
| 259 |
A feature of \fBoperator overloading\fR of \fBobjects\fR, |
| 260 |
whereby the behavior of certain \fBoperators\fR can be reasonably deduced using |
| 261 |
more fundamental operators. This assumes that the overloaded operators will |
| 262 |
often have the same relationships as the regular operators. See Camel |
| 263 |
chapter 13, “Overloading”. |
| 264 |
.IX Xref "autogeneration, about" |
| 265 |
.IP autoincrement 4 |
| 266 |
.IX Item "autoincrement" |
| 267 |
To add one to something automatically, hence the name |
| 268 |
of the \f(CW\*(C`++\*(C'\fR operator. To instead subtract one from something automatically |
| 269 |
is known as an “autodecrement”. |
| 270 |
.IX Xref "autoincrement (term)" |
| 271 |
.IP autoload 4 |
| 272 |
.IX Item "autoload" |
| 273 |
To load on demand. (Also called “lazy” loading.) |
| 274 |
Specifically, to call an \f(CW\*(C`AUTOLOAD\*(C'\fR subroutine on behalf of an undefined |
| 275 |
subroutine. |
| 276 |
.IX Xref "autoloading, defined" |
| 277 |
.IP autosplit 4 |
| 278 |
.IX Item "autosplit" |
| 279 |
To split a string automatically, as the \fI–a\fR \fBswitch\fR |
| 280 |
does when running under \fI–p\fR or \fI–n\fR in order to emulate \fBawk\fR. (See also |
| 281 |
the \f(CW\*(C`AutoSplit\*(C'\fR module, which has nothing to do with the |
| 282 |
\&\f(CW\*(C`–a\*(C'\fR switch but a lot to do with autoloading.) |
| 283 |
.IX Xref "autosplit (term) AutoSplit module" |
| 284 |
.IP autovivification 4 |
| 285 |
.IX Item "autovivification" |
| 286 |
A Graeco-Roman word meaning “to bring oneself to life”. |
| 287 |
In Perl, storage locations (\fBlvalues\fR) spontaneously generate themselves as |
| 288 |
needed, including the creation of any \fBhard reference\fR values to point to |
| 289 |
the next level of storage. The assignment \f(CW\*(C`$a[5][5][5][5][5] = "quintet"\*(C'\fR |
| 290 |
potentially creates five scalar storage locations, plus four references (in |
| 291 |
the first four scalar locations) pointing to four new anonymous arrays (to |
| 292 |
hold the last four scalar locations). But the point of autovivification is |
| 293 |
that you don’t have to worry about it. |
| 294 |
.IX Xref "autovivification" |
| 295 |
.IP AV 4 |
| 296 |
.IX Item "AV" |
| 297 |
Short for “array |
| 298 |
value”, which refers to one of Perl’s internal data types that holds an |
| 299 |
\&\fBarray\fR. The \f(CW\*(C`AV\*(C'\fR type is a subclass of \fBSV\fR. |
| 300 |
.IX Xref "AV (array value) array value (AV) values, array" |
| 301 |
.IP awk 4 |
| 302 |
.IX Item "awk" |
| 303 |
Descriptive editing term—short for “awkward”. Also |
| 304 |
coincidentally refers to a venerable text-processing language from which |
| 305 |
Perl derived some of its high-level ideas. |
| 306 |
.IX Xref "awk (editing term)" |
| 307 |
.SS B |
| 308 |
.IX Subsection "B" |
| 309 |
.IP backreference 4 |
| 310 |
.IX Item "backreference" |
| 311 |
A substring \fBcaptured\fR |
| 312 |
by a subpattern within unadorned parentheses in a \fBregex\fR. Backslashed |
| 313 |
decimal numbers (\f(CW\*(C`\e1\*(C'\fR, \f(CW\*(C`\e2\*(C'\fR, etc.) later in the same pattern refer back to |
| 314 |
the corresponding subpattern in the current match. Outside the pattern, the |
| 315 |
numbered variables (\f(CW$1\fR, \f(CW$2\fR, etc.) continue to refer to these same |
| 316 |
values, as long as the pattern was the last successful match of the current |
| 317 |
\&\fBdynamic scope\fR. |
| 318 |
.IX Xref "backreferences, about references, backreferences" |
| 319 |
.IP backtracking 4 |
| 320 |
.IX Item "backtracking" |
| 321 |
The practice of saying, “If I had to do it all over, I’d do |
| 322 |
it differently,” and then actually going back and doing it all over |
| 323 |
differently. Mathematically speaking, it’s returning from an unsuccessful |
| 324 |
recursion on a tree of possibilities. Perl backtracks when it attempts to |
| 325 |
match patterns with a \fBregular expression\fR, and its earlier attempts don’t |
| 326 |
pan out. See the section “The Little Engine That /Couldn(n’t)” in Camel |
| 327 |
chapter 5, “Pattern Matching”. |
| 328 |
.IX Xref "backtracking" |
| 329 |
.IP "backward compatibility" 4 |
| 330 |
.IX Item "backward compatibility" |
| 331 |
Means you can still run your old program |
| 332 |
because we didn’t break any of the features or bugs it was relying on. |
| 333 |
.IX Xref "backward compatibility, defined" |
| 334 |
.IP bareword 4 |
| 335 |
.IX Item "bareword" |
| 336 |
A word sufficiently ambiguous to be deemed illegal under |
| 337 |
\&\f(CW\*(C`use strict \*(Aqsubs\*(Aq\*(C'\fR. In the absence of that stricture, a bareword is |
| 338 |
treated as if quotes were around it. |
| 339 |
.IX Xref "barewords, about" |
| 340 |
.IP "base class" 4 |
| 341 |
.IX Item "base class" |
| 342 |
A generic \fBobject\fR type; that is, a \fBclass\fR |
| 343 |
from which other, more specific classes are derived genetically by |
| 344 |
\&\fBinheritance\fR. Also called a |
| 345 |
“superclass” by people who respect their ancestors. |
| 346 |
.IX Xref "base classes classes, base superclasses classes, superclasses" |
| 347 |
.IP big-endian 4 |
| 348 |
.IX Item "big-endian" |
| 349 |
From Swift: someone who |
| 350 |
eats eggs big end first. Also used of computers that store the most |
| 351 |
significant \fBbyte\fR of a word at a lower byte address than the least |
| 352 |
significant byte. Often considered superior to little-endian machines. See |
| 353 |
also \fBlittle-endian\fR. |
| 354 |
.IX Xref "big–endian, defined endianness, big–endian" |
| 355 |
.IP binary 4 |
| 356 |
.IX Item "binary" |
| 357 |
Having to do with numbers represented in base 2. That means |
| 358 |
there’s basically two numbers: 0 and 1. Also used to describe a file of |
| 359 |
“nontext”, presumably because such a file makes full use of all the binary |
| 360 |
bits in its bytes. With the advent of \fBUnicode\fR, this distinction, already |
| 361 |
suspect, loses even more of its meaning. |
| 362 |
.IX Xref "binary (term)" |
| 363 |
.IP "binary operator" 4 |
| 364 |
.IX Item "binary operator" |
| 365 |
An \fBoperator\fR that takes two \fBoperands\fR. |
| 366 |
.IX Xref "binary operators, about" |
| 367 |
.IP bind 4 |
| 368 |
.IX Item "bind" |
| 369 |
To assign a specific \fBnetwork address\fR to a \fBsocket\fR. |
| 370 |
.IX Xref "bind (term)" |
| 371 |
.IP bit 4 |
| 372 |
.IX Item "bit" |
| 373 |
An integer in the range from 0 to 1, inclusive. The smallest |
| 374 |
possible unit of information storage. An eighth of a \fBbyte\fR or of a dollar. |
| 375 |
(The term “Pieces of Eight” comes from being able to split the old Spanish |
| 376 |
dollar into 8 bits, each of which still counted for money. That’s why a 25\- |
| 377 |
cent piece today is still “two bits”.) |
| 378 |
.IX Xref "bits, defined" |
| 379 |
.IP "bit shift" 4 |
| 380 |
.IX Item "bit shift" |
| 381 |
The movement of bits left or right in a |
| 382 |
computer word, which has the effect of multiplying or dividing by a |
| 383 |
power of 2. |
| 384 |
.IX Xref "bit–shift operators, defined" |
| 385 |
.IP "bit string" 4 |
| 386 |
.IX Item "bit string" |
| 387 |
A sequence of \fBbits\fR that is actually being thought of as a |
| 388 |
sequence of bits, for once. |
| 389 |
.IX Xref "bit string" |
| 390 |
.IP bless 4 |
| 391 |
.IX Item "bless" |
| 392 |
In corporate life, to grant official |
| 393 |
approval to a thing, as in, “The VP of Engineering has blessed our |
| 394 |
WebCruncher project.” Similarly, in Perl, to grant official approval to a |
| 395 |
\&\fBreferent\fR so that it can function as an \fBobject\fR, such as a WebCruncher |
| 396 |
object. See the \f(CW\*(C`bless\*(C'\fR function in Camel chapter 27, “Functions”. |
| 397 |
.IX Xref "bless function, about bless (term)" |
| 398 |
.IP block 4 |
| 399 |
.IX Item "block" |
| 400 |
What a \fBprocess\fR does when it has to wait for something: |
| 401 |
“My process blocked waiting for the disk.” As an unrelated noun, it refers |
| 402 |
to a large chunk of data, of a size that the \fBoperating system\fR likes to |
| 403 |
deal with (normally a power of 2 such as 512 or 8192). Typically refers to |
| 404 |
a chunk of data that’s coming from or going to a disk file. |
| 405 |
.IX Xref "blocks, defined" |
| 406 |
.IP BLOCK 4 |
| 407 |
.IX Item "BLOCK" |
| 408 |
A syntactic construct |
| 409 |
consisting of a sequence of Perl \fBstatements\fR that is delimited by braces. |
| 410 |
The \f(CW\*(C`if\*(C'\fR and \f(CW\*(C`while\*(C'\fR statements are defined in terms of \fR\f(CI\*(C`BLOCK\*(C'\fR\fI\fRs, for |
| 411 |
instance. Sometimes we also say “block” to mean a lexical scope; that is, a |
| 412 |
sequence of statements that acts like a \fI\fR\f(CI\*(C`BLOCK\*(C'\fR\fI\fR, such as within an |
| 413 |
\&\f(CW\*(C`eval\*(C'\fR or a file, even though the statements aren’t delimited by braces. |
| 414 |
.IX Xref "BLOCK construct, about constructs, BLOCK" |
| 415 |
.IP "block buffering" 4 |
| 416 |
.IX Item "block buffering" |
| 417 |
A method of making input and output |
| 418 |
efficient by passing one \fBblock\fR at a time. By default, Perl does block |
| 419 |
buffering to disk files. See \fBbuffer\fR and \fBcommand buffering\fR. |
| 420 |
.IX Xref "block buffering buffering, block" |
| 421 |
.IP Boolean 4 |
| 422 |
.IX Item "Boolean" |
| 423 |
A value that is either \fBtrue\fR or |
| 424 |
\&\fBfalse\fR. |
| 425 |
.IX Xref "Boolean values values, Boolean" |
| 426 |
.IP "Boolean context" 4 |
| 427 |
.IX Item "Boolean context" |
| 428 |
A special kind of \fBscalar |
| 429 |
context\fR used in conditionals to decide whether the \fBscalar value\fR returned |
| 430 |
by an expression is \fBtrue\fR or \fBfalse\fR. Does not evaluate as either a |
| 431 |
string or a number. See \fBcontext\fR. |
| 432 |
.IX Xref "Boolean context, about context, Boolean" |
| 433 |
.IP breakpoint 4 |
| 434 |
.IX Item "breakpoint" |
| 435 |
A spot in your program where you’ve told the debugger |
| 436 |
to stop \fBexecution\fR so you can poke around and see whether anything is |
| 437 |
wrong yet. |
| 438 |
.IX Xref "breakpoints, defined" |
| 439 |
.IP broadcast 4 |
| 440 |
.IX Item "broadcast" |
| 441 |
To send a \fBdatagram\fR to multiple destinations |
| 442 |
simultaneously. |
| 443 |
.IX Xref "broadcast (networking term)" |
| 444 |
.IP BSD 4 |
| 445 |
.IX Item "BSD" |
| 446 |
A psychoactive drug, popular in the ’80s, probably developed at UC |
| 447 |
Berkeley or thereabouts. Similar in many ways to the prescription-only |
| 448 |
medication called “System V”, but infinitely more useful. (Or, at least, |
| 449 |
more fun.) The full chemical name is “Berkeley Standard Distribution”. |
| 450 |
.IX Xref "BSD (Berkeley Standard Distribution) Berkeley Standard Distribution (BSD)" |
| 451 |
.IP bucket 4 |
| 452 |
.IX Item "bucket" |
| 453 |
A location in a \fBhash table\fR containing (potentially) |
| 454 |
multiple entries whose keys “hash” to the same hash value according to its |
| 455 |
hash function. (As internal policy, you don’t have to worry about it unless |
| 456 |
you’re into internals, or policy.) |
| 457 |
.IX Xref "buckets (term)" |
| 458 |
.IP buffer 4 |
| 459 |
.IX Item "buffer" |
| 460 |
A temporary holding location for data. Data that are |
| 461 |
\&\fBBlock buffering\fR means that the data is passed on to its destination |
| 462 |
whenever the buffer is full. \fBLine buffering\fR means that it’s passed on |
| 463 |
whenever a complete line is received. \fBCommand buffering\fR means that it’s |
| 464 |
passed every time you do a \f(CW\*(C`print\*(C'\fR command (or equivalent). If your output |
| 465 |
is unbuffered, the system processes it one byte at a time without the use of |
| 466 |
a holding area. This can be rather inefficient. |
| 467 |
.IX Xref "buffers, defined" |
| 468 |
.IP built-in 4 |
| 469 |
.IX Item "built-in" |
| 470 |
A \fBfunction\fR that is predefined in the |
| 471 |
language. Even when hidden by \fBoverriding\fR, you can always get at a built\- |
| 472 |
in function by \fBqualifying\fR its name with the \f(CW\*(C`CORE::\*(C'\fR pseudopackage. |
| 473 |
.IX Xref "built–in functions, about" |
| 474 |
.IP bundle 4 |
| 475 |
.IX Item "bundle" |
| 476 |
A group of related modules on \fBCPAN\fR. (Also sometimes |
| 477 |
refers to a group of command-line switches grouped into one \fBswitch |
| 478 |
cluster\fR.) |
| 479 |
.IX Xref "bundles (term)" |
| 480 |
.IP byte 4 |
| 481 |
.IX Item "byte" |
| 482 |
A piece of data worth eight \fBbits\fR in most places. |
| 483 |
.IX Xref "bytes (term)" |
| 484 |
.IP bytecode 4 |
| 485 |
.IX Item "bytecode" |
| 486 |
A pidgin-like lingo spoken among ’droids when they don’t wish to reveal |
| 487 |
their orientation (see \fBendian\fR). Named after some similar languages spoken |
| 488 |
(for similar reasons) between compilers and interpreters in the late 20ᵗʰ |
| 489 |
century. These languages are characterized by representing everything as a |
| 490 |
nonarchitecture-dependent sequence of bytes. |
| 491 |
.SS C |
| 492 |
.IX Subsection "C" |
| 493 |
.IP C 4 |
| 494 |
.IX Item "C" |
| 495 |
A language beloved by many for its inside-out \fBtype\fR |
| 496 |
definitions, inscrutable \fBprecedence\fR rules, and heavy \fBoverloading\fR of |
| 497 |
the function-call mechanism. (Well, actually, people first switched to C |
| 498 |
because they found lowercase identifiers easier to read than upper.) Perl is |
| 499 |
written in C, so it’s not surprising that Perl borrowed a few ideas from it. |
| 500 |
.IX Xref "C language, about" |
| 501 |
.IP cache 4 |
| 502 |
.IX Item "cache" |
| 503 |
A data repository. Instead of computing expensive answers |
| 504 |
several times, compute it once and save the result. |
| 505 |
.IX Xref "cache (term)" |
| 506 |
.IP callback 4 |
| 507 |
.IX Item "callback" |
| 508 |
A \fBhandler\fR that you register with some other part of your |
| 509 |
program in the hope that the other part of your program will \fBtrigger\fR your |
| 510 |
handler when some event of interest transpires. |
| 511 |
.IX Xref "callbacks" |
| 512 |
.IP "call by reference" 4 |
| 513 |
.IX Item "call by reference" |
| 514 |
An \fBargument\fR\-passing mechanism in which the \fBformal arguments\fR refer directly to the |
| 515 |
\&\fBactual arguments\fR, and the \fBsubroutine\fR can change the actual arguments |
| 516 |
by changing the formal arguments. That is, the formal argument is an |
| 517 |
\&\fBalias\fR for the actual argument. See also \fBcall by value\fR. |
| 518 |
.IX Xref "call by reference references, call by reference mechanism" |
| 519 |
.IP "call by value" 4 |
| 520 |
.IX Item "call by value" |
| 521 |
An \fBargument\fR\-passing mechanism in which the \fBformal |
| 522 |
arguments\fR refer to a copy of the \fBactual arguments\fR, and the |
| 523 |
\&\fBsubroutine\fR cannot change the actual arguments by changing the formal |
| 524 |
arguments. See also \fBcall by reference\fR. |
| 525 |
.IX Xref "call by value" |
| 526 |
.IP canonical 4 |
| 527 |
.IX Item "canonical" |
| 528 |
Reduced to a standard form to facilitate comparison. |
| 529 |
.IX Xref "canonical (term)" |
| 530 |
.IP "capture variables" 4 |
| 531 |
.IX Item "capture variables" |
| 532 |
The variables—such as \f(CW$1\fR and |
| 533 |
\&\f(CW$2\fR, and \f(CW\*(C`%+\*(C'\fR and \f(CW\*(C`%– \*(C'\fR—that hold the text remembered in a pattern |
| 534 |
match. See Camel chapter 5, “Pattern Matching”. |
| 535 |
.IX Xref "capture variables variables, capture" |
| 536 |
.IP capturing 4 |
| 537 |
.IX Item "capturing" |
| 538 |
The use of parentheses around a \fBsubpattern\fR in a |
| 539 |
\&\fBregular expression\fR to store the matched \fBsubstring\fR as a |
| 540 |
\&\fBbackreference\fR. (Captured strings are also returned as a list in \fBlist |
| 541 |
context\fR.) See Camel chapter 5, “Pattern Matching”. |
| 542 |
.IX Xref "capturing in pattern matching subpatterns, capturing pattern matching, capturing in" |
| 543 |
.IP "cargo cult" 4 |
| 544 |
.IX Item "cargo cult" |
| 545 |
Copying and pasting code without understanding it, while |
| 546 |
superstitiously believing in its value. This term originated from |
| 547 |
preindustrial cultures dealing with the detritus of explorers and colonizers |
| 548 |
of technologically advanced cultures. See \fIThe Gods Must Be Crazy\fR. |
| 549 |
.IX Xref "cargo cult" |
| 550 |
.IP case 4 |
| 551 |
.IX Item "case" |
| 552 |
A property of certain |
| 553 |
characters. Originally, typesetter stored capital letters in the upper of |
| 554 |
two cases and small letters in the lower one. Unicode recognizes three |
| 555 |
cases: \fBlowercase\fR (\fBcharacter property\fR \f(CW\*(C`\ep{lower}\*(C'\fR), \fBtitlecase\fR |
| 556 |
(\f(CW\*(C`\ep{title}\*(C'\fR), and \fBuppercase\fR (\f(CW\*(C`\ep{upper}\*(C'\fR). A fourth casemapping called |
| 557 |
\&\fBfoldcase\fR is not itself a distinct case, but it is used internally to |
| 558 |
implement \fBcasefolding\fR. Not all letters have case, and some nonletters |
| 559 |
have case. |
| 560 |
.IX Xref "case (character) characters, case considerations" |
| 561 |
.IP casefolding 4 |
| 562 |
.IX Item "casefolding" |
| 563 |
Comparing or matching a string case-insensitively. In Perl, it |
| 564 |
is implemented with the \f(CW\*(C`/i\*(C'\fR pattern modifier, the \f(CW\*(C`fc\*(C'\fR function, and the |
| 565 |
\&\f(CW\*(C`\eF\*(C'\fR double-quote translation escape. |
| 566 |
.IX Xref "casefolding" |
| 567 |
.IP casemapping 4 |
| 568 |
.IX Item "casemapping" |
| 569 |
The process of converting a string to one of the four Unicode |
| 570 |
\&\fBcasemaps\fR; in Perl, it is implemented with the \f(CW\*(C`fc\*(C'\fR, \f(CW\*(C`lc\*(C'\fR, \f(CW\*(C`ucfirst\*(C'\fR, |
| 571 |
and \f(CW\*(C`uc\*(C'\fR functions. |
| 572 |
.IX Xref "casemapping" |
| 573 |
.IP character 4 |
| 574 |
.IX Item "character" |
| 575 |
The smallest individual element of a string. Computers |
| 576 |
store characters as integers, but Perl lets you operate on them as text. The |
| 577 |
integer used to represent a particular character is called that character’s |
| 578 |
\&\fBcodepoint\fR. |
| 579 |
.IX Xref "characters, defined" |
| 580 |
.IP "character class" 4 |
| 581 |
.IX Item "character class" |
| 582 |
A square-bracketed list of |
| 583 |
characters used in a \fBregular expression\fR to indicate that any character |
| 584 |
of the set may occur at a given point. Loosely, any predefined set of |
| 585 |
characters so used. |
| 586 |
.IX Xref "character classes, about classes, character" |
| 587 |
.IP "character property" 4 |
| 588 |
.IX Item "character property" |
| 589 |
A predefined \fBcharacter class\fR matchable by the \f(CW\*(C`\ep\*(C'\fR |
| 590 |
or \f(CW\*(C`\eP\*(C'\fR \fBmetasymbol\fR. \fBUnicode\fR defines hundreds of standard properties |
| 591 |
for every possible codepoint, and Perl defines a few of its own, too. |
| 592 |
.IX Xref "character property" |
| 593 |
.IP "circumfix operator" 4 |
| 594 |
.IX Item "circumfix operator" |
| 595 |
An \fBoperator\fR that surrounds its \fBoperand\fR, like the |
| 596 |
angle operator, or parentheses, or a hug. |
| 597 |
.IX Xref "circumfix operator" |
| 598 |
.IP class 4 |
| 599 |
.IX Item "class" |
| 600 |
A user-defined \fBtype\fR, implemented in Perl via a |
| 601 |
\&\fBpackage\fR that provides (either directly or by inheritance) \fBmethods\fR |
| 602 |
(that is, \fBsubroutines\fR) to handle \fBinstances\fR of the class (its |
| 603 |
\&\fBobjects\fR). See also \fBinheritance\fR. |
| 604 |
.IX Xref "classes, defined" |
| 605 |
.IP "class method" 4 |
| 606 |
.IX Item "class method" |
| 607 |
A \fBmethod\fR whose \fBinvocant\fR is a |
| 608 |
\&\fBpackage\fR name, not an \fBobject\fR reference. A method associated with the |
| 609 |
class as a whole. Also see \fBinstance method\fR. |
| 610 |
.IX Xref "class methods methods, class" |
| 611 |
.IP client 4 |
| 612 |
.IX Item "client" |
| 613 |
In networking, a \fBprocess\fR that |
| 614 |
initiates contact with a \fBserver\fR process in order to exchange data and |
| 615 |
perhaps receive a service. |
| 616 |
.IX Xref "clients, defined processes, client" |
| 617 |
.IP closure 4 |
| 618 |
.IX Item "closure" |
| 619 |
An \fBanonymous\fR subroutine |
| 620 |
that, when a reference to it is generated at runtime, keeps track of the |
| 621 |
identities of externally visible \fBlexical variables\fR, even after those |
| 622 |
lexical variables have supposedly gone out of \fBscope\fR. They’re called |
| 623 |
“closures” because this sort of behavior gives mathematicians a sense of |
| 624 |
closure. |
| 625 |
.IX Xref "closure subroutines subroutines, closure" |
| 626 |
.IP cluster 4 |
| 627 |
.IX Item "cluster" |
| 628 |
A parenthesized \fBsubpattern\fR |
| 629 |
used to group parts of a \fBregular expression\fR into a single \fBatom\fR. |
| 630 |
.IX Xref "clusters, defined subpatterns, cluster" |
| 631 |
.IP CODE 4 |
| 632 |
.IX Item "CODE" |
| 633 |
The word returned by the \f(CW\*(C`ref\*(C'\fR |
| 634 |
function when you apply it to a reference to a subroutine. See also \fBCV\fR. |
| 635 |
.IX Xref "CODE (ref function) ref function, about" |
| 636 |
.IP "code generator" 4 |
| 637 |
.IX Item "code generator" |
| 638 |
A system that writes code for you in a low-level |
| 639 |
language, such as code to implement the backend of a compiler. See \fBprogram |
| 640 |
generator\fR. |
| 641 |
.IX Xref "code generators, defined" |
| 642 |
.IP codepoint 4 |
| 643 |
.IX Item "codepoint" |
| 644 |
The integer a computer uses to represent a given |
| 645 |
character. ASCII codepoints are in the range 0 to 127; Unicode codepoints |
| 646 |
are in the range 0 to 0x10_FFFF; and Perl codepoints are in the range 0 to |
| 647 |
2³²−1 or 0 to 2⁶⁴−1, depending on your native integer size. In Perl Culture, |
| 648 |
sometimes called \fBordinals\fR. |
| 649 |
.IX Xref "codepoints, about" |
| 650 |
.IP "code subpattern" 4 |
| 651 |
.IX Item "code subpattern" |
| 652 |
A \fBregular expression\fR subpattern |
| 653 |
whose real purpose is to execute some Perl code—for example, the \f(CW\*(C`(?{...})\*(C'\fR |
| 654 |
and \f(CW\*(C`(??{...})\*(C'\fR subpatterns. |
| 655 |
.IX Xref "code subpatterns subpatterns, code" |
| 656 |
.IP "collating sequence" 4 |
| 657 |
.IX Item "collating sequence" |
| 658 |
The order into which \fBcharacters\fR |
| 659 |
sort. This is used by \fBstring\fR comparison routines to decide, for example, |
| 660 |
where in this glossary to put “collating sequence”. |
| 661 |
.IX Xref "collating sequence collating sequence" |
| 662 |
.IP co-maintainer 4 |
| 663 |
.IX Item "co-maintainer" |
| 664 |
A person with permissions to index a \fBnamespace\fR in |
| 665 |
\&\fBPAUSE\fR. Anyone can upload any namespace, but only primary and |
| 666 |
co-maintainers get their contributions indexed. |
| 667 |
.IX Xref "co–maintainers" |
| 668 |
.IP "combining character" 4 |
| 669 |
.IX Item "combining character" |
| 670 |
Any character with the |
| 671 |
General Category of Combining Mark (\f(CW\*(C`\ep{GC=M}\*(C'\fR), which may be spacing or |
| 672 |
nonspacing. Some are even invisible. A sequence of combining characters |
| 673 |
following a grapheme base character together make up a single user-visible |
| 674 |
character called a \fBgrapheme\fR. Most but not all diacritics are combining |
| 675 |
characters, and vice versa. |
| 676 |
.IX Xref "combining characters characters, combining" |
| 677 |
.IP command 4 |
| 678 |
.IX Item "command" |
| 679 |
In \fBshell\fR programming, the syntactic combination of a |
| 680 |
program name and its arguments. More loosely, anything you type to a shell |
| 681 |
(a command interpreter) that starts it doing something. Even more loosely, a |
| 682 |
Perl \fBstatement\fR, which might start with a \fBlabel\fR and typically ends with |
| 683 |
a semicolon. |
| 684 |
.IX Xref "commands, defined" |
| 685 |
.IP "command buffering" 4 |
| 686 |
.IX Item "command buffering" |
| 687 |
A mechanism in Perl that lets you |
| 688 |
store up the output of each Perl \fBcommand\fR and then flush it out as a |
| 689 |
single request to the \fBoperating system\fR. It’s enabled by setting the \f(CW$|\fR |
| 690 |
(\f(CW$AUTOFLUSH\fR) variable to a true value. It’s used when you don’t want data |
| 691 |
sitting around, not going where it’s supposed to, which may happen because |
| 692 |
the default on a \fBfile\fR or \fBpipe\fR is to use \fBblock buffering\fR. |
| 693 |
.IX Xref "command buffering buffering, command" |
| 694 |
.IP "command-line arguments" 4 |
| 695 |
.IX Item "command-line arguments" |
| 696 |
The \fBvalues\fR you supply |
| 697 |
along with a program name when you tell a \fBshell\fR to execute a \fBcommand\fR. |
| 698 |
These values are passed to a Perl program through \f(CW@ARGV\fR. |
| 699 |
.IX Xref "command–line arguments arguments, command–line" |
| 700 |
.IP "command name" 4 |
| 701 |
.IX Item "command name" |
| 702 |
The name of the program currently executing, as typed on the |
| 703 |
command line. In C, the \fBcommand\fR name is passed to the program as the |
| 704 |
first command-line argument. In Perl, it comes in separately as \f(CW$0\fR. |
| 705 |
.IX Xref "command names" |
| 706 |
.IP comment 4 |
| 707 |
.IX Item "comment" |
| 708 |
A remark that doesn’t affect the meaning of the program. |
| 709 |
In Perl, a comment is introduced by a \f(CW\*(C`#\*(C'\fR character and continues to the |
| 710 |
end of the line. |
| 711 |
.IX Xref "comments, defined" |
| 712 |
.IP "compilation unit" 4 |
| 713 |
.IX Item "compilation unit" |
| 714 |
The \fBfile\fR (or \fBstring\fR, in the case of \f(CW\*(C`eval\*(C'\fR) that |
| 715 |
is currently being \fBcompiled\fR. |
| 716 |
.IX Xref "compilation units" |
| 717 |
.IP compile 4 |
| 718 |
.IX Item "compile" |
| 719 |
The process of turning source code into a machine-usable form. See \fBcompile |
| 720 |
phase\fR. |
| 721 |
.IP "compile phase" 4 |
| 722 |
.IX Item "compile phase" |
| 723 |
Any time before Perl starts running your main |
| 724 |
program. See also \fBrun phase\fR. Compile phase is mostly spent in \fBcompile |
| 725 |
time\fR, but may also be spent in \fBruntime\fR when \f(CW\*(C`BEGIN\*(C'\fR blocks, \f(CW\*(C`use\*(C'\fR or |
| 726 |
\&\f(CW\*(C`no\*(C'\fR declarations, or constant subexpressions are being evaluated. The |
| 727 |
startup and import code of any \f(CW\*(C`use\*(C'\fR declaration is also run during |
| 728 |
compile phase. |
| 729 |
.IX Xref "compile phase, defined" |
| 730 |
.IP compiler 4 |
| 731 |
.IX Item "compiler" |
| 732 |
Strictly speaking, a program that munches |
| 733 |
up another program and spits out yet another file containing the program in |
| 734 |
a “more executable” form, typically containing native machine instructions. |
| 735 |
The \fIperl\fR program is not a compiler by this definition, but it does |
| 736 |
contain a kind of compiler that takes a program and turns it into a more |
| 737 |
executable form (\fBsyntax trees\fR) within the \fIperl\fR process itself, which |
| 738 |
the \fBinterpreter\fR then interprets. There are, however, extension \fBmodules\fR |
| 739 |
to get Perl to act more like a “real” compiler. See Camel chapter 16, |
| 740 |
“Compiling”. |
| 741 |
.IX Xref "compilers and compiling, about" |
| 742 |
.IP "compile time" 4 |
| 743 |
.IX Item "compile time" |
| 744 |
The time when Perl is trying to make sense of your |
| 745 |
code, as opposed to when it thinks it knows what your code means and is |
| 746 |
merely trying to do what it thinks your code says to do, which is \fBruntime\fR. |
| 747 |
.IX Xref "compile time, defined" |
| 748 |
.IP composer 4 |
| 749 |
.IX Item "composer" |
| 750 |
A “constructor” for a \fBreferent\fR that isn’t really an |
| 751 |
\&\fBobject\fR, like an anonymous array or a hash (or a sonata, for that matter). |
| 752 |
For example, a pair of braces acts as a composer for a hash, and a pair of |
| 753 |
brackets acts as a composer for an array. See the section “Creating |
| 754 |
References” in Camel chapter 8, “References”. |
| 755 |
.IX Xref "composers, about" |
| 756 |
.IP concatenation 4 |
| 757 |
.IX Item "concatenation" |
| 758 |
The process of gluing one |
| 759 |
cat’s nose to another cat’s tail. Also a similar operation on two |
| 760 |
\&\fBstrings\fR. |
| 761 |
.IX Xref "concatenating strings strings, concatenating" |
| 762 |
.IP conditional 4 |
| 763 |
.IX Item "conditional" |
| 764 |
Something “iffy”. See \fBBoolean context\fR. |
| 765 |
.IX Xref "conditional (term)" |
| 766 |
.IP connection 4 |
| 767 |
.IX Item "connection" |
| 768 |
In telephony, the temporary electrical circuit between |
| 769 |
the caller’s and the callee’s phone. In networking, the same kind of |
| 770 |
temporary circuit between a \fBclient\fR and a \fBserver\fR. |
| 771 |
.IX Xref "connections (term)" |
| 772 |
.IP construct 4 |
| 773 |
.IX Item "construct" |
| 774 |
As a noun, a piece of syntax made up of smaller |
| 775 |
pieces. As a transitive verb, to create an \fBobject\fR using a \fBconstructor\fR. |
| 776 |
.IX Xref "constructs, defined" |
| 777 |
.IP constructor 4 |
| 778 |
.IX Item "constructor" |
| 779 |
Any \fBclass method\fR, \fBinstance\fR, or \fBsubroutine\fR |
| 780 |
that composes, initializes, blesses, and returns an \fBobject\fR. Sometimes we |
| 781 |
use the term loosely to mean a \fBcomposer\fR. |
| 782 |
.IX Xref "constructors, defined" |
| 783 |
.IP context 4 |
| 784 |
.IX Item "context" |
| 785 |
The surroundings or environment. The context given by the |
| 786 |
surrounding code determines what kind of data a particular \fBexpression\fR is |
| 787 |
expected to return. The three primary contexts are \fBlist context\fR, |
| 788 |
\&\fBscalar\fR, and \fBvoid context\fR. Scalar context is sometimes subdivided into |
| 789 |
\&\fBBoolean context\fR, \fBnumeric context\fR, \fBstring context\fR, and \fBvoid |
| 790 |
context\fR. There’s also a “don’t care” context (which is dealt with in Camel |
| 791 |
chapter 2, “Bits and Pieces”, if you care). |
| 792 |
.IX Xref "context, about" |
| 793 |
.IP continuation 4 |
| 794 |
.IX Item "continuation" |
| 795 |
The treatment of more than one physical \fBline\fR as a |
| 796 |
single logical line. \fBMakefile\fR lines are continued by putting a backslash |
| 797 |
before the \fBnewline\fR. Mail headers, as defined by RFC 822, are |
| 798 |
continued by putting a space or tab \fIafter\fR the newline. In general, lines |
| 799 |
in Perl do not need any form of continuation mark, because \fBwhitespace\fR |
| 800 |
(including newlines) is gleefully ignored. Usually. |
| 801 |
.IX Xref "continuation lines RFC 822" |
| 802 |
.IP "core dump" 4 |
| 803 |
.IX Item "core dump" |
| 804 |
The corpse of a \fBprocess\fR, in the form of a file left in the |
| 805 |
\&\fBworking directory\fR of the process, usually as a result of certain kinds |
| 806 |
of fatal errors. |
| 807 |
.IX Xref "core dump" |
| 808 |
.IP CPAN 4 |
| 809 |
.IX Item "CPAN" |
| 810 |
The Comprehensive Perl Archive Network. (See the Camel Preface |
| 811 |
and Camel chapter 19, “CPAN” for details.) |
| 812 |
.IX Xref "Comprehensive Perl Archive Network CPAN (Comprehensive Perl Archive Network), about" |
| 813 |
.IP "C preprocessor" 4 |
| 814 |
.IX Item "C preprocessor" |
| 815 |
The typical C compiler’s first pass, which processes lines |
| 816 |
beginning with \f(CW\*(C`#\*(C'\fR for conditional compilation and macro definition, and |
| 817 |
does various manipulations of the program text based on the current |
| 818 |
definitions. Also known as \fIcpp\fR(1). |
| 819 |
.IX Xref "C preprocessor" |
| 820 |
.IP cracker 4 |
| 821 |
.IX Item "cracker" |
| 822 |
Someone who breaks security on computer systems. A cracker may |
| 823 |
be a true \fBhacker\fR or only a \fBscript kiddie\fR. |
| 824 |
.IX Xref "crackers" |
| 825 |
.IP "currently selected output channel" 4 |
| 826 |
.IX Item "currently selected output channel" |
| 827 |
The last \fBfilehandle\fR that was |
| 828 |
designated with \f(CWselect(FILEHANDLE)\fR; \f(CW\*(C`STDOUT\*(C'\fR, if no filehandle has |
| 829 |
been selected. |
| 830 |
.IX Xref "currently selected output channel" |
| 831 |
.IP "current package" 4 |
| 832 |
.IX Item "current package" |
| 833 |
The \fBpackage\fR in which the current statement is |
| 834 |
\&\fBcompiled\fR. Scan backward in the text of your program through the current |
| 835 |
\&\fBlexical scope\fR or any enclosing lexical scopes until you find a package |
| 836 |
declaration. That’s your current package name. |
| 837 |
.IX Xref "current package" |
| 838 |
.IP "current working directory" 4 |
| 839 |
.IX Item "current working directory" |
| 840 |
See \fBworking directory\fR. |
| 841 |
.IX Xref "current working directory" |
| 842 |
.IP CV 4 |
| 843 |
.IX Item "CV" |
| 844 |
In academia, a curriculum vitæ, a fancy kind of résumé. In Perl, an internal “code value” typedef holding a |
| 845 |
\&\fBsubroutine\fR. The \f(CW\*(C`CV\*(C'\fR type is a subclass of \fBSV\fR. |
| 846 |
.IX Xref "CV (code value) code value (CV)" |
| 847 |
.SS D |
| 848 |
.IX Subsection "D" |
| 849 |
.IP "dangling statement" 4 |
| 850 |
.IX Item "dangling statement" |
| 851 |
A bare, single \fBstatement\fR, |
| 852 |
without any braces, hanging off an \f(CW\*(C`if\*(C'\fR or \f(CW\*(C`while\*(C'\fR conditional. C allows |
| 853 |
them. Perl doesn’t. |
| 854 |
.IX Xref "dangling statements statements, dangling" |
| 855 |
.IP datagram 4 |
| 856 |
.IX Item "datagram" |
| 857 |
A packet of data, such as a \fBUDP\fR message, that (from |
| 858 |
the viewpoint of the programs involved) can be sent independently over the |
| 859 |
network. (In fact, all packets are sent independently at the \fBIP\fR level, |
| 860 |
but \fBstream\fR protocols such as \fBTCP\fR hide this from your program.) |
| 861 |
.IX Xref "datagrams, defined" |
| 862 |
.IP "data structure" 4 |
| 863 |
.IX Item "data structure" |
| 864 |
How your various pieces of data relate to each |
| 865 |
other and what shape they make when you put them all together, as in a |
| 866 |
rectangular table or a triangular tree. |
| 867 |
.IX Xref "data structures, defined" |
| 868 |
.IP "data type" 4 |
| 869 |
.IX Item "data type" |
| 870 |
A set of possible values, together with all the |
| 871 |
operations that know how to deal with those values. For example, a numeric |
| 872 |
data type has a certain set of numbers that you can work with, as well as |
| 873 |
various mathematical operations that you can do on the numbers, but would |
| 874 |
make little sense on, say, a string such as \f(CW"Kilroy"\fR. Strings have their |
| 875 |
own operations, such as \fBconcatenation\fR. Compound types made of a number of |
| 876 |
smaller pieces generally have operations to compose and decompose them, and |
| 877 |
perhaps to rearrange them. \fBObjects\fR that model things in the real world |
| 878 |
often have operations that correspond to real activities. For instance, if |
| 879 |
you model an elevator, your elevator object might have an \f(CW\*(C`open_door\*(C'\fR |
| 880 |
\&\fBmethod\fR. |
| 881 |
.IX Xref "data types, defined" |
| 882 |
.IP DBM 4 |
| 883 |
.IX Item "DBM" |
| 884 |
Stands for “Database Management” routines, a set of routines that emulate an |
| 885 |
\&\fBassociative array\fR using disk files. The routines use a dynamic hashing |
| 886 |
scheme to locate any entry with only two disk accesses. DBM files allow a |
| 887 |
Perl program to keep a persistent \fBhash\fR across multiple invocations. You |
| 888 |
can \f(CW\*(C`tie\*(C'\fR your hash variables to various DBM implementations. |
| 889 |
.IX Xref "DBM (Database Management) routines Database Management (DBM) routines" |
| 890 |
.IP declaration 4 |
| 891 |
.IX Item "declaration" |
| 892 |
An \fBassertion\fR that states something exists and |
| 893 |
perhaps describes what it’s like, without giving any commitment as to how |
| 894 |
or where you’ll use it. A declaration is like the part of your recipe that |
| 895 |
says, “two cups flour, one large egg, four or five tadpoles…” See |
| 896 |
\&\fBstatement\fR for its opposite. Note that some declarations also function |
| 897 |
as statements. Subroutine declarations also act as definitions if a body |
| 898 |
is supplied. |
| 899 |
.IX Xref "declarations, defined" |
| 900 |
.IP declarator 4 |
| 901 |
.IX Item "declarator" |
| 902 |
Something that tells your program what sort of variable |
| 903 |
you’d like. Perl doesn’t require you to declare variables, but you can use |
| 904 |
\&\f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, or \f(CW\*(C`state\*(C'\fR to denote that you want something other than |
| 905 |
the default. |
| 906 |
.IX Xref "declarators" |
| 907 |
.IP decrement 4 |
| 908 |
.IX Item "decrement" |
| 909 |
To subtract a value from a |
| 910 |
variable, as in “decrement \f(CW$x\fR” (meaning to remove 1 from its value) or |
| 911 |
“decrement \f(CW$x\fR by 3”. |
| 912 |
.IX Xref "decrementing values values, decrementing" |
| 913 |
.IP default 4 |
| 914 |
.IX Item "default" |
| 915 |
A \fBvalue\fR chosen for you if you don’t |
| 916 |
supply a value of your own. |
| 917 |
.IX Xref "default values values, default" |
| 918 |
.IP defined 4 |
| 919 |
.IX Item "defined" |
| 920 |
Having a meaning. Perl thinks that some of the things |
| 921 |
people try to do are devoid of meaning; in particular, making use of |
| 922 |
variables that have never been given a \fBvalue\fR and performing certain |
| 923 |
operations on data that isn’t there. For example, if you try to read data |
| 924 |
past the end of a file, Perl will hand you back an undefined value. See also |
| 925 |
\&\fBfalse\fR and the \f(CW\*(C`defined\*(C'\fR entry in Camel chapter 27, “Functions”. |
| 926 |
.IX Xref "defined (term)" |
| 927 |
.IP delimiter 4 |
| 928 |
.IX Item "delimiter" |
| 929 |
A \fBcharacter\fR or \fBstring\fR that sets bounds to an |
| 930 |
arbitrarily sized textual object, not to be confused with a \fBseparator\fR or |
| 931 |
\&\fBterminator\fR. “To delimit” really just means “to surround” or “to enclose” |
| 932 |
(like these parentheses are doing). |
| 933 |
.IX Xref "delimiters (term)" |
| 934 |
.IP dereference 4 |
| 935 |
.IX Item "dereference" |
| 936 |
A fancy computer science term |
| 937 |
meaning “to follow a \fBreference\fR to what it points to”. The “de” part of it |
| 938 |
refers to the fact that you’re taking away one level of \fBindirection\fR. |
| 939 |
.IX Xref "dereference (term) references, dereference" |
| 940 |
.IP "derived class" 4 |
| 941 |
.IX Item "derived class" |
| 942 |
A \fBclass\fR that defines some of its \fBmethods\fR in terms of a more generic class, |
| 943 |
called a \fBbase class\fR. Note that classes aren’t classified exclusively into |
| 944 |
base classes or derived classes: a class can function as both a derived |
| 945 |
class and a base class simultaneously, which is kind of classy. |
| 946 |
.IX Xref "derived classes classes, derived subclasses classes, subclasses" |
| 947 |
.IP descriptor 4 |
| 948 |
.IX Item "descriptor" |
| 949 |
See \fBfile descriptor\fR. |
| 950 |
.IP destroy 4 |
| 951 |
.IX Item "destroy" |
| 952 |
To deallocate the memory of a \fBreferent\fR (first triggering |
| 953 |
its \f(CW\*(C`DESTROY\*(C'\fR method, if it has one). |
| 954 |
.IX Xref "destroy (term)" |
| 955 |
.IP destructor 4 |
| 956 |
.IX Item "destructor" |
| 957 |
A special \fBmethod\fR that is called |
| 958 |
when an \fBobject\fR is thinking about \fBdestroying\fR itself. A Perl program’s |
| 959 |
\&\f(CW\*(C`DESTROY\*(C'\fR method doesn’t do the actual destruction; Perl just \fBtriggers\fR |
| 960 |
the method in case the \fBclass\fR wants to do any associated cleanup. |
| 961 |
.IX Xref "destructor method methods, destructor" |
| 962 |
.IP device 4 |
| 963 |
.IX Item "device" |
| 964 |
A whiz-bang hardware gizmo (like a disk or tape drive or a |
| 965 |
modem or a joystick or a mouse) attached to your computer, which the |
| 966 |
\&\fBoperating system\fR tries to make look like a \fBfile\fR (or a bunch of files). |
| 967 |
Under Unix, these fake files tend to live in the \fI/dev\fR directory. |
| 968 |
.IX Xref "devices (term)" |
| 969 |
.IP directive 4 |
| 970 |
.IX Item "directive" |
| 971 |
A \fBpod\fR directive. See Camel chapter 23, “Plain Old |
| 972 |
Documentation”. |
| 973 |
.IX Xref "directives, defined" |
| 974 |
.IP directory 4 |
| 975 |
.IX Item "directory" |
| 976 |
A special file that contains other files. Some |
| 977 |
\&\fBoperating systems\fR call these “folders”, “drawers”, “catalogues”, or |
| 978 |
“catalogs”. |
| 979 |
.IX Xref "directories, defined" |
| 980 |
.IP "directory handle" 4 |
| 981 |
.IX Item "directory handle" |
| 982 |
A name that represents a particular instance of opening a |
| 983 |
directory to read it, until you close it. See the \f(CW\*(C`opendir\*(C'\fR function. |
| 984 |
.IX Xref "directory handle" |
| 985 |
.IP discipline 4 |
| 986 |
.IX Item "discipline" |
| 987 |
Some people need this and some people avoid it. |
| 988 |
For Perl, it’s an old way to say \fBI/O layer\fR. |
| 989 |
.IX Xref "discipline (I O layer)" |
| 990 |
.IP dispatch 4 |
| 991 |
.IX Item "dispatch" |
| 992 |
To send something to its correct destination. Often used |
| 993 |
metaphorically to indicate a transfer of programmatic control to a |
| 994 |
destination selected algorithmically, often by lookup in a table of function |
| 995 |
\&\fBreferences\fR or, in the case of object \fBmethods\fR, by traversing the |
| 996 |
inheritance tree looking for the most specific definition for the method. |
| 997 |
.IX Xref "dispatching" |
| 998 |
.IP distribution 4 |
| 999 |
.IX Item "distribution" |
| 1000 |
A standard, bundled release of a system of |
| 1001 |
software. The default usage implies source code is included. If that is not |
| 1002 |
the case, it will be called a “binary\-only” distribution. |
| 1003 |
.IX Xref "distributions, defined" |
| 1004 |
.IP dual-lived 4 |
| 1005 |
.IX Item "dual-lived" |
| 1006 |
Some modules live both in the |
| 1007 |
\&\fBStandard Library\fR and on \fBCPAN\fR. These modules might be developed on two |
| 1008 |
tracks as people modify either version. The trend currently is to untangle |
| 1009 |
these situations. |
| 1010 |
.IX Xref "dual–lived modules modules, dual–lived" |
| 1011 |
.IP dweomer 4 |
| 1012 |
.IX Item "dweomer" |
| 1013 |
An enchantment, illusion, phantasm, or jugglery. Said when Perl’s |
| 1014 |
magical \fBdwimmer\fR effects don’t do what you expect, but rather seem to be |
| 1015 |
the product of arcane \fIdweomercraft\fR, sorcery, or wonder working. [From |
| 1016 |
Middle English.] |
| 1017 |
.IX Xref "dweomer" |
| 1018 |
.IP dwimmer 4 |
| 1019 |
.IX Item "dwimmer" |
| 1020 |
DWIM is |
| 1021 |
an acronym for “Do What I Mean”, the principle that something |
| 1022 |
should just do what you want it to do without an undue amount of fuss. A bit |
| 1023 |
of code that does “dwimming” is a “dwimmer”. Dwimming can require a great |
| 1024 |
deal of behind-the-scenes magic, which (if it doesn’t stay properly behind |
| 1025 |
the scenes) is called a \fBdweomer\fR instead. |
| 1026 |
.IX Xref "DWIM (Do What I Mean) principle Do What I Mean (DWIM) principle dwimming" |
| 1027 |
.IP "dynamic scoping" 4 |
| 1028 |
.IX Item "dynamic scoping" |
| 1029 |
Dynamic scoping works over a \fBdynamic |
| 1030 |
scope\fR, making variables visible throughout the rest of the \fBblock\fR in |
| 1031 |
which they are first used and in any \fBsubroutines\fR that are called by the |
| 1032 |
rest of the block. Dynamically scoped variables can have their values |
| 1033 |
temporarily changed (and implicitly restored later) by a \f(CW\*(C`local\*(C'\fR operator. |
| 1034 |
(Compare \fBlexical scoping\fR.) Used more loosely to mean how a subroutine |
| 1035 |
that is in the middle of calling another subroutine “contains” that |
| 1036 |
subroutine at \fBruntime\fR. |
| 1037 |
.IX Xref "dynamic scope scopes, dynamic" |
| 1038 |
.SS E |
| 1039 |
.IX Subsection "E" |
| 1040 |
.IP eclectic 4 |
| 1041 |
.IX Item "eclectic" |
| 1042 |
Derived from many sources. Some would say \fItoo\fR many. |
| 1043 |
.IX Xref "eclectic (term)" |
| 1044 |
.IP element 4 |
| 1045 |
.IX Item "element" |
| 1046 |
A basic building block. When you’re talking about an |
| 1047 |
\&\fBarray\fR, it’s one of the items that make up the array. |
| 1048 |
.IX Xref "elements, about" |
| 1049 |
.IP embedding 4 |
| 1050 |
.IX Item "embedding" |
| 1051 |
When something is contained in something else, |
| 1052 |
particularly when that might be considered surprising: “I’ve embedded a |
| 1053 |
complete Perl interpreter in my editor!” |
| 1054 |
.IX Xref "embedding (term)" |
| 1055 |
.IP "empty subclass test" 4 |
| 1056 |
.IX Item "empty subclass test" |
| 1057 |
The notion that an empty \fBderived class\fR should |
| 1058 |
behave exactly like its \fBbase class\fR. |
| 1059 |
.IX Xref "empty subclass test" |
| 1060 |
.IP encapsulation 4 |
| 1061 |
.IX Item "encapsulation" |
| 1062 |
The veil of abstraction separating the \fBinterface\fR |
| 1063 |
from the \fBimplementation\fR (whether enforced or not), which mandates that |
| 1064 |
all access to an \fBobject\fR’s state be through \fBmethods\fR alone. |
| 1065 |
.IX Xref "encapsulation (term)" |
| 1066 |
.IP endian 4 |
| 1067 |
.IX Item "endian" |
| 1068 |
See \fBlittle-endian\fR and \fBbig-endian\fR. |
| 1069 |
.IP "en passant" 4 |
| 1070 |
.IX Item "en passant" |
| 1071 |
When you change a \fBvalue\fR as it is being copied. [From |
| 1072 |
French “in passing”, as in the exotic pawn-capturing maneuver in chess.] |
| 1073 |
.IX Xref "en passant (term)" |
| 1074 |
.IP environment 4 |
| 1075 |
.IX Item "environment" |
| 1076 |
The collective set of \fBenvironment variables\fR your |
| 1077 |
\&\fBprocess\fR inherits from its parent. Accessed via \f(CW%ENV\fR. |
| 1078 |
.IX Xref "environment (term)" |
| 1079 |
.IP "environment variable" 4 |
| 1080 |
.IX Item "environment variable" |
| 1081 |
A mechanism by which some high-level agent such as a user can pass its |
| 1082 |
preferences down to its future offspring (child \fBprocesses\fR, grandchild |
| 1083 |
processes, great-grandchild processes, and so on). Each environment |
| 1084 |
variable is a \fBkey\fR/\fBvalue\fR pair, like one entry in a \fBhash\fR. |
| 1085 |
.IX Xref "environment variables variables, environment environment variables" |
| 1086 |
.IP EOF 4 |
| 1087 |
.IX Item "EOF" |
| 1088 |
End of File. Sometimes used |
| 1089 |
metaphorically as the terminating string of a \fBhere document\fR. |
| 1090 |
.IX Xref "End of File (EOF) EOF (End of File)" |
| 1091 |
.IP errno 4 |
| 1092 |
.IX Item "errno" |
| 1093 |
The error number returned by a |
| 1094 |
\&\fBsyscall\fR when it fails. Perl refers to the error by the name \f(CW$!\fR (or |
| 1095 |
\&\f(CW$OS_ERROR\fR if you use the English module). |
| 1096 |
.IX Xref "errno (error number) error number (errno)" |
| 1097 |
.IP error 4 |
| 1098 |
.IX Item "error" |
| 1099 |
See \fBexception\fR or \fBfatal error\fR. |
| 1100 |
.IP "escape sequence" 4 |
| 1101 |
.IX Item "escape sequence" |
| 1102 |
See \fBmetasymbol\fR. |
| 1103 |
.IP exception 4 |
| 1104 |
.IX Item "exception" |
| 1105 |
A fancy term for an error. See \fBfatal error\fR. |
| 1106 |
.IP "exception handling" 4 |
| 1107 |
.IX Item "exception handling" |
| 1108 |
The way a program responds to an error. The |
| 1109 |
exception-handling mechanism in Perl is the \f(CW\*(C`eval\*(C'\fR operator. |
| 1110 |
.IX Xref "exception handling, defined" |
| 1111 |
.IP exec 4 |
| 1112 |
.IX Item "exec" |
| 1113 |
To throw away the current \fBprocess\fR’s program and replace |
| 1114 |
it with another, without exiting the process or relinquishing any resources |
| 1115 |
held (apart from the old memory image). |
| 1116 |
.IX Xref "exec function" |
| 1117 |
.IP "executable file" 4 |
| 1118 |
.IX Item "executable file" |
| 1119 |
A \fBfile\fR that is specially marked to |
| 1120 |
tell the \fBoperating system\fR that it’s okay to run this file as a program. |
| 1121 |
Usually shortened to “executable”. |
| 1122 |
.IX Xref "executable files files, executable" |
| 1123 |
.IP execute 4 |
| 1124 |
.IX Item "execute" |
| 1125 |
To run a \fBprogram\fR or \fBsubroutine\fR. (Has nothing to do |
| 1126 |
with the \f(CW\*(C`kill\*(C'\fR built-in, unless you’re trying to run a \fBsignal handler\fR.) |
| 1127 |
.IX Xref "execute (term)" |
| 1128 |
.IP "execute bit" 4 |
| 1129 |
.IX Item "execute bit" |
| 1130 |
The special mark that tells the operating system it can run |
| 1131 |
this program. There are actually three execute bits under Unix, and which |
| 1132 |
bit gets used depends on whether you own the file singularly, collectively, |
| 1133 |
or not at all. |
| 1134 |
.IX Xref "execute bit" |
| 1135 |
.IP "exit status" 4 |
| 1136 |
.IX Item "exit status" |
| 1137 |
See \fBstatus\fR. |
| 1138 |
.IP exploit 4 |
| 1139 |
.IX Item "exploit" |
| 1140 |
Used as a noun in this case, this refers to a known way |
| 1141 |
to compromise a program to get it to do something the author didn’t intend. |
| 1142 |
Your task is to write unexploitable programs. |
| 1143 |
.IX Xref "exploits, security" |
| 1144 |
.IP export 4 |
| 1145 |
.IX Item "export" |
| 1146 |
To make symbols from a \fBmodule\fR available for |
| 1147 |
\&\fBimport\fR by other modules. |
| 1148 |
.IX Xref "exporting, defined" |
| 1149 |
.IP expression 4 |
| 1150 |
.IX Item "expression" |
| 1151 |
Anything you can legally say in a spot |
| 1152 |
where a \fBvalue\fR is required. Typically composed of \fBliterals\fR, |
| 1153 |
\&\fBvariables\fR, \fBoperators\fR, \fBfunctions\fR, and \fBsubroutine\fR calls, not |
| 1154 |
necessarily in that order. |
| 1155 |
.IX Xref "expressions, defined expressions" |
| 1156 |
.IP extension 4 |
| 1157 |
.IX Item "extension" |
| 1158 |
A Perl module that also pulls in \fBcompiled\fR C or C++ |
| 1159 |
code. More generally, any experimental option that can be \fBcompiled\fR into |
| 1160 |
Perl, such as multithreading. |
| 1161 |
.IX Xref "extensions, defined" |
| 1162 |
.SS F |
| 1163 |
.IX Subsection "F" |
| 1164 |
.IP false 4 |
| 1165 |
.IX Item "false" |
| 1166 |
In Perl, any value that would look like \f(CW""\fR |
| 1167 |
or \f(CW"0"\fR if evaluated in a string context. Since undefined values evaluate |
| 1168 |
to \f(CW""\fR, all undefined values are false, but not all false values are |
| 1169 |
undefined. |
| 1170 |
.IX Xref "false values values, false" |
| 1171 |
.IP FAQ 4 |
| 1172 |
.IX Item "FAQ" |
| 1173 |
Frequently Asked Question (although not necessarily |
| 1174 |
frequently answered, especially if the answer appears in the Perl FAQ |
| 1175 |
shipped standard with Perl). |
| 1176 |
.IX Xref "FAQ (Frequently Asked Question) Frequently Asked Question (FAQ)" |
| 1177 |
.IP "fatal error" 4 |
| 1178 |
.IX Item "fatal error" |
| 1179 |
An uncaught \fBexception\fR, which causes termination of the |
| 1180 |
\&\fBprocess\fR after printing a message on your \fBstandard error\fR stream. Errors |
| 1181 |
that happen inside an \f(CW\*(C`eval\*(C'\fR are not fatal. Instead, the \f(CW\*(C`eval\*(C'\fR terminates |
| 1182 |
after placing the exception message in the \f(CW$@\fR (\f(CW$EVAL_ERROR\fR) variable. |
| 1183 |
You can try to provoke a fatal error with the \f(CW\*(C`die\*(C'\fR operator (known as |
| 1184 |
throwing or raising an exception), but this may be caught by a dynamically |
| 1185 |
enclosing \f(CW\*(C`eval\*(C'\fR. If not caught, the \f(CW\*(C`die\*(C'\fR becomes a fatal error. |
| 1186 |
.IX Xref "fatal errors" |
| 1187 |
.IP "feeping creaturism" 4 |
| 1188 |
.IX Item "feeping creaturism" |
| 1189 |
A spoonerism of “creeping |
| 1190 |
featurism”, noting the biological urge to add just one more feature to |
| 1191 |
a program. |
| 1192 |
.IX Xref "feeping creaturism creeping featurism" |
| 1193 |
.IP field 4 |
| 1194 |
.IX Item "field" |
| 1195 |
A single piece of numeric or string data that is part of a |
| 1196 |
longer \fBstring\fR, \fBrecord\fR, or \fBline\fR. Variable-width fields are usually |
| 1197 |
split up by \fBseparators\fR (so use \f(CW\*(C`split\*(C'\fR to extract the fields), while |
| 1198 |
fixed-width fields are usually at fixed positions (so use \f(CW\*(C`unpack\*(C'\fR). |
| 1199 |
\&\fBInstance variables\fR are also known as “fields”. |
| 1200 |
.IX Xref "fields (term)" |
| 1201 |
.IP FIFO 4 |
| 1202 |
.IX Item "FIFO" |
| 1203 |
First In, First Out. See also \fBLIFO\fR. Also a nickname for a \fBnamed pipe\fR. |
| 1204 |
.IX Xref "First In, First Out (FIFO) FIFO (First In, First Out)" |
| 1205 |
.IP file 4 |
| 1206 |
.IX Item "file" |
| 1207 |
A named collection of data, usually stored on disk in a |
| 1208 |
\&\fBdirectory\fR in a \fBfilesystem\fR. Roughly like a document, if you’re into |
| 1209 |
office metaphors. In modern filesystems, you can actually give a file more |
| 1210 |
than one name. Some files have special properties, like directories and |
| 1211 |
devices. |
| 1212 |
.IX Xref "files, defined" |
| 1213 |
.IP "file descriptor" 4 |
| 1214 |
.IX Item "file descriptor" |
| 1215 |
The little number the \fBoperating |
| 1216 |
system\fR uses to keep track of which opened \fBfile\fR you’re talking about. |
| 1217 |
Perl hides the file descriptor inside a \fBstandard I/O\fR stream and then |
| 1218 |
attaches the stream to a \fBfilehandle\fR. |
| 1219 |
.IX Xref "file descriptors descriptors, file" |
| 1220 |
.IP fileglob 4 |
| 1221 |
.IX Item "fileglob" |
| 1222 |
A “wildcard” match on \fBfilenames\fR. See the \f(CW\*(C`glob\*(C'\fR function. |
| 1223 |
.IX Xref "fileglobs" |
| 1224 |
.IP filehandle 4 |
| 1225 |
.IX Item "filehandle" |
| 1226 |
An identifier (not necessarily related to the real |
| 1227 |
name of a file) that represents a particular instance of opening a file, |
| 1228 |
until you close it. If you’re going to open and close several different |
| 1229 |
files in succession, it’s fine to open each of them with the same |
| 1230 |
filehandle, so you don’t have to write out separate code to process each |
| 1231 |
file. |
| 1232 |
.IX Xref "filehandles, about" |
| 1233 |
.IP filename 4 |
| 1234 |
.IX Item "filename" |
| 1235 |
One name for a file. This name is listed in a |
| 1236 |
\&\fBdirectory\fR. You can use it in an \f(CW\*(C`open\*(C'\fR to tell the \fBoperating system\fR |
| 1237 |
exactly which file you want to open, and associate the file with a |
| 1238 |
\&\fBfilehandle\fR, which will carry the subsequent identity of that file in |
| 1239 |
your program, until you close it. |
| 1240 |
.IX Xref "filenames, about" |
| 1241 |
.IP filesystem 4 |
| 1242 |
.IX Item "filesystem" |
| 1243 |
A set of \fBdirectories\fR and \fBfiles\fR residing on a |
| 1244 |
partition of the disk. Sometimes known as a “partition”. You can change the |
| 1245 |
file’s name or even move a file around from directory to directory within a |
| 1246 |
filesystem without actually moving the file itself, at least under Unix. |
| 1247 |
.IX Xref "filesystems, defined" |
| 1248 |
.IP "file test operator" 4 |
| 1249 |
.IX Item "file test operator" |
| 1250 |
A built-in unary operator that you use to |
| 1251 |
determine whether something is \fBtrue\fR about a file, such as \f(CW–o |
| 1252 |
$filename\fR to test whether you’re the owner of the file. |
| 1253 |
.IX Xref "file test operators, about" |
| 1254 |
.IP filter 4 |
| 1255 |
.IX Item "filter" |
| 1256 |
A program designed to take a \fBstream\fR of input and |
| 1257 |
transform it into a stream of output. |
| 1258 |
.IX Xref "filters, defined" |
| 1259 |
.IP first-come 4 |
| 1260 |
.IX Item "first-come" |
| 1261 |
The first \fBPAUSE\fR |
| 1262 |
author to upload a \fBnamespace\fR automatically becomes the \fBprimary |
| 1263 |
maintainer\fR for that namespace. The “first come” permissions distinguish a |
| 1264 |
\&\fBprimary maintainer\fR who was assigned that role from one who received it |
| 1265 |
automatically. |
| 1266 |
.IX Xref "first–come permissions permissions, first–come" |
| 1267 |
.IP flag 4 |
| 1268 |
.IX Item "flag" |
| 1269 |
We tend to avoid this term because it means so many things. |
| 1270 |
It may mean a command-line \fBswitch\fR that takes no argument itself (such as |
| 1271 |
Perl’s \f(CW\*(C`–n\*(C'\fR and \f(CW\*(C`–p\*(C'\fR flags) or, less frequently, a single-bit indicator |
| 1272 |
(such as the \f(CW\*(C`O_CREAT\*(C'\fR and \f(CW\*(C`O_EXCL\*(C'\fR flags used in \f(CW\*(C`sysopen\*(C'\fR). Sometimes |
| 1273 |
informally used to refer to certain regex modifiers. |
| 1274 |
.IX Xref "flags (term)" |
| 1275 |
.IP "floating point" 4 |
| 1276 |
.IX Item "floating point" |
| 1277 |
A method of storing |
| 1278 |
numbers in “scientific notation”, such that the precision of the number is |
| 1279 |
independent of its magnitude (the decimal point “floats”). Perl does its |
| 1280 |
numeric work with floating-point numbers (sometimes called “floats”) when |
| 1281 |
it can’t get away with using \fBintegers\fR. Floating-point numbers are mere |
| 1282 |
approximations of real numbers. |
| 1283 |
.IX Xref "floating point methods methods, floating point" |
| 1284 |
.IP flush 4 |
| 1285 |
.IX Item "flush" |
| 1286 |
The act of emptying a \fBbuffer\fR, |
| 1287 |
often before it’s full. |
| 1288 |
.IX Xref "flushing buffers buffers, flushing" |
| 1289 |
.IP FMTEYEWTK 4 |
| 1290 |
.IX Item "FMTEYEWTK" |
| 1291 |
Far More Than Everything You Ever Wanted To Know. An |
| 1292 |
exhaustive treatise on one narrow topic, something of a super\-\fBFAQ\fR. See |
| 1293 |
Tom for far more. |
| 1294 |
.IX Xref "FMTEYEWTK acronym" |
| 1295 |
.IP foldcase 4 |
| 1296 |
.IX Item "foldcase" |
| 1297 |
The casemap used in Unicode when comparing or matching |
| 1298 |
without regard to case. Comparing lower\-, title\-, or uppercase are all |
| 1299 |
unreliable due to Unicode’s complex, one-to-many case mappings. Foldcase is |
| 1300 |
a \fBlowercase\fR variant (using a partially decomposed \fBnormalization\fR form |
| 1301 |
for certain codepoints) created specifically to resolve this. |
| 1302 |
.IX Xref "foldcase (term)" |
| 1303 |
.IP fork 4 |
| 1304 |
.IX Item "fork" |
| 1305 |
To create a child \fBprocess\fR |
| 1306 |
identical to the parent process at its moment of conception, at least until |
| 1307 |
it gets ideas of its own. A thread with protected memory. |
| 1308 |
.IX Xref "forking processes processes, forking" |
| 1309 |
.IP "formal arguments" 4 |
| 1310 |
.IX Item "formal arguments" |
| 1311 |
The generic names by which a |
| 1312 |
\&\fBsubroutine\fR knows its \fBarguments\fR. In many languages, formal arguments |
| 1313 |
are always given individual names; in Perl, the formal arguments are just |
| 1314 |
the elements of an array. The formal arguments to a Perl program are |
| 1315 |
\&\f(CW$ARGV[0]\fR, \f(CW$ARGV[1]\fR, and so on. Similarly, the formal arguments to a |
| 1316 |
Perl subroutine are \f(CW$_[0]\fR, \f(CW$_[1]\fR, and so on. You may give the |
| 1317 |
arguments individual names by assigning the values to a \f(CW\*(C`my\*(C'\fR list. See |
| 1318 |
also \fBactual arguments\fR. |
| 1319 |
.IX Xref "formal arguments arguments, formal" |
| 1320 |
.IP format 4 |
| 1321 |
.IX Item "format" |
| 1322 |
A specification of how many spaces and digits and things |
| 1323 |
to put somewhere so that whatever you’re printing comes out nice and |
| 1324 |
pretty. |
| 1325 |
.IX Xref "formats, defined" |
| 1326 |
.IP "freely available" 4 |
| 1327 |
.IX Item "freely available" |
| 1328 |
Means you don’t have to pay money to get it, but |
| 1329 |
the copyright on it may still belong to someone else (like Larry). |
| 1330 |
.IX Xref "freely available (term)" |
| 1331 |
.IP "freely redistributable" 4 |
| 1332 |
.IX Item "freely redistributable" |
| 1333 |
Means you’re not in legal trouble if you |
| 1334 |
give a bootleg copy of it to your friends and we find out about it. In |
| 1335 |
fact, we’d rather you gave a copy to all your friends. |
| 1336 |
.IX Xref "freely redistributable (term)" |
| 1337 |
.IP freeware 4 |
| 1338 |
.IX Item "freeware" |
| 1339 |
Historically, any software that you give away, |
| 1340 |
particularly if you make the source code available as well. Now often |
| 1341 |
called \fBopen source software\fR. Recently there has been a trend to use the |
| 1342 |
term in contradistinction to \fBopen source software\fR, to refer only to free |
| 1343 |
software released under the Free Software |
| 1344 |
Foundation’s GPL (General Public License), but this is difficult to justify |
| 1345 |
etymologically. |
| 1346 |
.IX Xref "freeware (term) Free Software Foundation" |
| 1347 |
.IP function 4 |
| 1348 |
.IX Item "function" |
| 1349 |
Mathematically, a mapping of each of a set of input |
| 1350 |
values to a particular output value. In computers, refers to a |
| 1351 |
\&\fBsubroutine\fR or \fBoperator\fR that returns a \fBvalue\fR. It may or may not |
| 1352 |
have input values (called \fBarguments\fR). |
| 1353 |
.IX Xref "functions, about" |
| 1354 |
.IP "funny character" 4 |
| 1355 |
.IX Item "funny character" |
| 1356 |
Someone like Larry, or one of his |
| 1357 |
peculiar friends. Also refers to the strange prefixes that Perl requires as |
| 1358 |
noun markers on its variables. |
| 1359 |
.IX Xref "funny characters characters, funny" |
| 1360 |
.SS G |
| 1361 |
.IX Subsection "G" |
| 1362 |
.IP "garbage collection" 4 |
| 1363 |
.IX Item "garbage collection" |
| 1364 |
A misnamed feature—it should be called, |
| 1365 |
“expecting your mother to pick up after you”. Strictly speaking, Perl |
| 1366 |
doesn’t do this, but it relies on a reference-counting mechanism to keep |
| 1367 |
things tidy. However, we rarely speak strictly and will often refer to the |
| 1368 |
reference-counting scheme as a form of garbage collection. (If it’s any |
| 1369 |
comfort, when your interpreter exits, a “real” garbage collector runs to |
| 1370 |
make sure everything is cleaned up if you’ve been messy with circular |
| 1371 |
references and such.) |
| 1372 |
.IX Xref "garbage collection, defined" |
| 1373 |
.IP GID 4 |
| 1374 |
.IX Item "GID" |
| 1375 |
Group ID—in Unix, the numeric group ID |
| 1376 |
that the \fBoperating system\fR uses to identify you and members of your |
| 1377 |
\&\fBgroup\fR. |
| 1378 |
.IX Xref "GID (Group ID) Group ID (GID)" |
| 1379 |
.IP glob 4 |
| 1380 |
.IX Item "glob" |
| 1381 |
Strictly, the shell’s \f(CW\*(C`*\*(C'\fR character, which will match |
| 1382 |
a “glob” of characters when you’re trying to generate a list of filenames. |
| 1383 |
Loosely, the act of using globs and similar symbols to do pattern matching. |
| 1384 |
See also \fBfileglob\fR and \fBtypeglob\fR. |
| 1385 |
.IX Xref "glob (* character)" |
| 1386 |
.IP global 4 |
| 1387 |
.IX Item "global" |
| 1388 |
Something you can see from anywhere, usually used of |
| 1389 |
\&\fBvariables\fR and \fBsubroutines\fR that are visible everywhere in your |
| 1390 |
program. In Perl, only certain special variables are truly global—most |
| 1391 |
variables (and all subroutines) exist only in the current \fBpackage\fR. |
| 1392 |
Global variables can be declared with \f(CW\*(C`our\*(C'\fR. See “Global Declarations” in |
| 1393 |
Camel chapter 4, “Statements and Declarations”. |
| 1394 |
.IX Xref "global (term)" |
| 1395 |
.IP "global destruction" 4 |
| 1396 |
.IX Item "global destruction" |
| 1397 |
The \fBgarbage collection\fR of globals (and the running |
| 1398 |
of any associated object destructors) that takes place when a Perl |
| 1399 |
\&\fBinterpreter\fR is being shut down. Global destruction should not be |
| 1400 |
confused with the Apocalypse, except perhaps when it should. |
| 1401 |
.IX Xref "global destruction" |
| 1402 |
.IP "glue language" 4 |
| 1403 |
.IX Item "glue language" |
| 1404 |
A language such as Perl that is good at hooking things |
| 1405 |
together that weren’t intended to be hooked together. |
| 1406 |
.IX Xref "glue language" |
| 1407 |
.IP granularity 4 |
| 1408 |
.IX Item "granularity" |
| 1409 |
The size of the pieces you’re dealing with, mentally |
| 1410 |
speaking. |
| 1411 |
.IX Xref "granularity" |
| 1412 |
.IP grapheme 4 |
| 1413 |
.IX Item "grapheme" |
| 1414 |
A graphene is an allotrope of carbon arranged in a |
| 1415 |
hexagonal crystal lattice one atom thick. A \fBgrapheme\fR, or more fully, a |
| 1416 |
\&\fIgrapheme cluster string\fR is a single user-visible \fBcharacter\fR, which may |
| 1417 |
in turn be several characters (\fBcodepoints\fR) long. For example, a carriage |
| 1418 |
return plus a line feed is a single grapheme but two characters, while a |
| 1419 |
“ȫ” is a single grapheme but one, two, or even three characters, depending |
| 1420 |
on \fBnormalization\fR. |
| 1421 |
.IX Xref "graphemes, defined" |
| 1422 |
.IP greedy 4 |
| 1423 |
.IX Item "greedy" |
| 1424 |
A \fBsubpattern\fR whose |
| 1425 |
\&\fBquantifier\fR wants to match as many things as possible. |
| 1426 |
.IX Xref "greedy subpatterns subpatterns, greedy" |
| 1427 |
.IP grep 4 |
| 1428 |
.IX Item "grep" |
| 1429 |
Originally from the old Unix editor command for “Globally |
| 1430 |
search for a Regular Expression and Print it”, now used in the general |
| 1431 |
sense of any kind of search, especially text searches. Perl has a built-in |
| 1432 |
\&\f(CW\*(C`grep\*(C'\fR function that searches a list for elements matching any given |
| 1433 |
criterion, whereas the \fBgrep\fR(1) program searches for lines matching a |
| 1434 |
\&\fBregular expression\fR in one or more files. |
| 1435 |
.IX Xref "grep function" |
| 1436 |
.IP group 4 |
| 1437 |
.IX Item "group" |
| 1438 |
A set of users of which you are a member. In some |
| 1439 |
operating systems (like Unix), you can give certain file access permissions |
| 1440 |
to other members of your group. |
| 1441 |
.IX Xref "groups, defined" |
| 1442 |
.IP GV 4 |
| 1443 |
.IX Item "GV" |
| 1444 |
An internal “glob value” typedef, |
| 1445 |
holding a \fBtypeglob\fR. The \f(CW\*(C`GV\*(C'\fR type is a subclass of \fBSV\fR. |
| 1446 |
.IX Xref "GV (glob value) glob value (GV)" |
| 1447 |
.SS H |
| 1448 |
.IX Subsection "H" |
| 1449 |
.IP hacker 4 |
| 1450 |
.IX Item "hacker" |
| 1451 |
Someone who is brilliantly persistent in solving technical |
| 1452 |
problems, whether these involve golfing, fighting orcs, or programming. |
| 1453 |
Hacker is a neutral term, morally speaking. Good hackers are not to be |
| 1454 |
confused with evil \fBcrackers\fR or clueless \fBscript kiddies\fR. If you |
| 1455 |
confuse them, we will presume that you are either evil or clueless. |
| 1456 |
.IX Xref "hackers" |
| 1457 |
.IP handler 4 |
| 1458 |
.IX Item "handler" |
| 1459 |
A \fBsubroutine\fR or \fBmethod\fR that Perl calls when your |
| 1460 |
program needs to respond to some internal event, such as a \fBsignal\fR, or an |
| 1461 |
encounter with an operator subject to \fBoperator overloading\fR. See also |
| 1462 |
\&\fBcallback\fR. |
| 1463 |
.IX Xref "handlers, defined" |
| 1464 |
.IP "hard reference" 4 |
| 1465 |
.IX Item "hard reference" |
| 1466 |
A \fBscalar\fR \fBvalue\fR containing |
| 1467 |
the actual address of a \fBreferent\fR, such that the referent’s \fBreference\fR |
| 1468 |
count accounts for it. (Some hard references are held internally, such as |
| 1469 |
the implicit reference from one of a \fBtypeglob\fR’s variable slots to its |
| 1470 |
corresponding referent.) A hard reference is different from a \fBsymbolic |
| 1471 |
reference\fR. |
| 1472 |
.IX Xref "hard references, about references, hard" |
| 1473 |
.IP hash 4 |
| 1474 |
.IX Item "hash" |
| 1475 |
An unordered association of \fBkey\fR/\fBvalue\fR pairs, stored such that you can easily use a string \fBkey\fR to |
| 1476 |
look up its associated data \fBvalue\fR. This glossary is like a hash, where |
| 1477 |
the word to be defined is the key and the definition is the value. A hash |
| 1478 |
is also sometimes septisyllabically called an “associative array”, which is |
| 1479 |
a pretty good reason for simply calling it a “hash” instead. |
| 1480 |
.IX Xref "hashes, about key value pairs, about" |
| 1481 |
.IP "hash table" 4 |
| 1482 |
.IX Item "hash table" |
| 1483 |
A data structure used internally by Perl for implementing |
| 1484 |
associative arrays (hashes) efficiently. See also \fBbucket\fR. |
| 1485 |
.IX Xref "hash tables" |
| 1486 |
.IP "header file" 4 |
| 1487 |
.IX Item "header file" |
| 1488 |
A file containing certain required |
| 1489 |
definitions that you must include “ahead” of the rest of your program to do |
| 1490 |
certain obscure operations. A C header file has a \fI.h\fR extension. Perl |
| 1491 |
doesn’t really have header files, though historically Perl has sometimes |
| 1492 |
used translated \fI.h\fR files with a \fI.ph\fR extension. See \f(CW\*(C`require\*(C'\fR in |
| 1493 |
Camel chapter 27, “Functions”. (Header files have been superseded by the |
| 1494 |
\&\fBmodule\fR mechanism.) |
| 1495 |
.IX Xref "header files files, header" |
| 1496 |
.IP "here document" 4 |
| 1497 |
.IX Item "here document" |
| 1498 |
So called because of a similar construct in \fBshells\fR that |
| 1499 |
pretends that the \fBlines\fR following the \fBcommand\fR are a separate \fBfile\fR |
| 1500 |
to be fed to the command, up to some terminating string. In Perl, however, |
| 1501 |
it’s just a fancy form of quoting. |
| 1502 |
.IX Xref "here documents" |
| 1503 |
.IP hexadecimal 4 |
| 1504 |
.IX Item "hexadecimal" |
| 1505 |
A number in base 16, “hex” for short. The digits for 10 |
| 1506 |
through 15 are customarily represented by the letters \f(CW\*(C`a\*(C'\fR through \f(CW\*(C`f\*(C'\fR. |
| 1507 |
Hexadecimal constants in Perl start with \f(CW\*(C`0x\*(C'\fR. See also the \f(CW\*(C`hex\*(C'\fR |
| 1508 |
function in Camel chapter 27, “Functions”. |
| 1509 |
.IX Xref "hexadecimals" |
| 1510 |
.IP "home directory" 4 |
| 1511 |
.IX Item "home directory" |
| 1512 |
The directory you are put into when |
| 1513 |
you log in. On a Unix system, the name is often placed into \f(CW$ENV{HOME}\fR |
| 1514 |
or \f(CW$ENV{LOGDIR}\fR by \fIlogin\fR, but you can also find it with |
| 1515 |
\&\f(CW\*(C`(get\*(C'\fR\f(CW\*(C`pwuid($<))[7]\*(C'\fR. (Some platforms do not have a concept of a |
| 1516 |
home directory.) |
| 1517 |
.IX Xref "home directory directories, home" |
| 1518 |
.IP host 4 |
| 1519 |
.IX Item "host" |
| 1520 |
The computer on which a program or other data resides. |
| 1521 |
.IX Xref "host computers" |
| 1522 |
.IP hubris 4 |
| 1523 |
.IX Item "hubris" |
| 1524 |
Excessive pride, the sort of thing for which Zeus zaps |
| 1525 |
you. Also the quality that makes you write (and maintain) programs that |
| 1526 |
other people won’t want to say bad things about. Hence, the third great |
| 1527 |
virtue of a programmer. See also \fBlaziness\fR and \fBimpatience\fR. |
| 1528 |
.IX Xref "hubris quality" |
| 1529 |
.IP HV 4 |
| 1530 |
.IX Item "HV" |
| 1531 |
Short for a “hash value” typedef, which |
| 1532 |
holds Perl’s internal representation of a hash. The \f(CW\*(C`HV\*(C'\fR type is a |
| 1533 |
subclass of \fBSV\fR. |
| 1534 |
.IX Xref "HV (hash value) hash value (HV)" |
| 1535 |
.SS I |
| 1536 |
.IX Subsection "I" |
| 1537 |
.IP identifier 4 |
| 1538 |
.IX Item "identifier" |
| 1539 |
A legally formed name for most anything in which a |
| 1540 |
computer program might be interested. Many languages (including Perl) allow |
| 1541 |
identifiers to start with an alphabetic character, and then contain |
| 1542 |
alphabetics and digits. Perl also allows connector punctuation like the |
| 1543 |
underscore character wherever it allows alphabetics. (Perl also has more |
| 1544 |
complicated names, like \fBqualified\fR names.) |
| 1545 |
.IX Xref "identifiers, defined" |
| 1546 |
.IP impatience 4 |
| 1547 |
.IX Item "impatience" |
| 1548 |
The anger you feel when the computer is being lazy. |
| 1549 |
This makes you write programs that don’t just react to your needs, but |
| 1550 |
actually anticipate them. Or at least that pretend to. Hence, the second |
| 1551 |
great virtue of a programmer. See also \fBlaziness\fR and \fBhubris\fR. |
| 1552 |
.IX Xref "impatience quality" |
| 1553 |
.IP implementation 4 |
| 1554 |
.IX Item "implementation" |
| 1555 |
How a piece of code actually goes about doing its |
| 1556 |
job. Users of the code should not count on implementation details staying |
| 1557 |
the same unless they are part of the published \fBinterface\fR. |
| 1558 |
.IX Xref "implementation (term)" |
| 1559 |
.IP import 4 |
| 1560 |
.IX Item "import" |
| 1561 |
To gain access to symbols that are exported from another |
| 1562 |
module. See \f(CW\*(C`use\*(C'\fR in Camel chapter 27, “Functions”. |
| 1563 |
.IX Xref "import (term)" |
| 1564 |
.IP increment 4 |
| 1565 |
.IX Item "increment" |
| 1566 |
To increase the value of |
| 1567 |
something by 1 (or by some other number, if so specified). |
| 1568 |
.IX Xref "incrementing values values, incrementing" |
| 1569 |
.IP indexing 4 |
| 1570 |
.IX Item "indexing" |
| 1571 |
In olden days, the act of looking up a \fBkey\fR in an |
| 1572 |
actual index (such as a phone book). But now it's merely the act of using |
| 1573 |
any kind of key or position to find the corresponding \fBvalue\fR, even if no |
| 1574 |
index is involved. Things have degenerated to the point that Perl’s |
| 1575 |
\&\f(CW\*(C`index\*(C'\fR function merely locates the position (index) of one string in |
| 1576 |
another. |
| 1577 |
.IX Xref "indexing (term)" |
| 1578 |
.IP "indirect filehandle" 4 |
| 1579 |
.IX Item "indirect filehandle" |
| 1580 |
An \fBexpression\fR that |
| 1581 |
evaluates to something that can be used as a \fBfilehandle\fR: a \fBstring\fR |
| 1582 |
(filehandle name), a \fBtypeglob\fR, a typeglob \fBreference\fR, or a low-level |
| 1583 |
\&\fBIO\fR object. |
| 1584 |
.IX Xref "indirect filehandles filehandles, indirect" |
| 1585 |
.IP indirection 4 |
| 1586 |
.IX Item "indirection" |
| 1587 |
If something in a program isn’t the value you’re |
| 1588 |
looking for but indicates where the value is, that’s indirection. This can |
| 1589 |
be done with either \fBsymbolic references\fR or \fBhard\fR. |
| 1590 |
.IX Xref "indirection (term)" |
| 1591 |
.IP "indirect object" 4 |
| 1592 |
.IX Item "indirect object" |
| 1593 |
In English grammar, a short |
| 1594 |
noun phrase between a verb and its direct object indicating the beneficiary |
| 1595 |
or recipient of the action. In Perl, \f(CW\*(C`print STDOUT "$foo\en";\*(C'\fR can be |
| 1596 |
understood as “verb indirect-object object”, where \f(CW\*(C`STDOUT\*(C'\fR is the |
| 1597 |
recipient of the \f(CW\*(C`print\*(C'\fR action, and \f(CW"$foo"\fR is the object being |
| 1598 |
printed. Similarly, when invoking a \fBmethod\fR, you might place the |
| 1599 |
invocant in the dative slot between the method and its arguments: |
| 1600 |
.IX Xref "indirect objects, defined objects, indirect" |
| 1601 |
.Sp |
| 1602 |
.Vb 3 |
| 1603 |
\& $gollum = new Pathetic::Creature "Sméagol"; |
| 1604 |
\& give $gollum "Fisssssh!"; |
| 1605 |
\& give $gollum "Precious!"; |
| 1606 |
.Ve |
| 1607 |
.IP "indirect object slot" 4 |
| 1608 |
.IX Item "indirect object slot" |
| 1609 |
The syntactic position falling between a method call |
| 1610 |
and its arguments when using the indirect object invocation syntax. (The |
| 1611 |
slot is distinguished by the absence of a comma between it and the next |
| 1612 |
argument.) \f(CW\*(C`STDERR\*(C'\fR is in the indirect object slot here: |
| 1613 |
.IX Xref "indirect object slot" |
| 1614 |
.Sp |
| 1615 |
.Vb 1 |
| 1616 |
\& print STDERR "Awake! Awake! Fear, Fire, Foes! Awake!\en"; |
| 1617 |
.Ve |
| 1618 |
.IP infix 4 |
| 1619 |
.IX Item "infix" |
| 1620 |
An \fBoperator\fR that comes in between its \fBoperands\fR, |
| 1621 |
such as multiplication in \f(CW\*(C`24 * 7\*(C'\fR. |
| 1622 |
.IX Xref "infix operators" |
| 1623 |
.IP inheritance 4 |
| 1624 |
.IX Item "inheritance" |
| 1625 |
What you get from your ancestors, genetically or |
| 1626 |
otherwise. If you happen to be a \fBclass\fR, your ancestors are called \fBbase |
| 1627 |
classes\fR and your descendants are called \fBderived classes\fR. See \fBsingle |
| 1628 |
inheritance\fR and \fBmultiple inheritance\fR. |
| 1629 |
.IX Xref "inheritance, defined" |
| 1630 |
.IP instance 4 |
| 1631 |
.IX Item "instance" |
| 1632 |
Short for “an instance of a class”, meaning an \fBobject\fR |
| 1633 |
of that \fBclass\fR. |
| 1634 |
.IX Xref "instances (term)" |
| 1635 |
.IP "instance data" 4 |
| 1636 |
.IX Item "instance data" |
| 1637 |
See \fBinstance variable\fR. |
| 1638 |
.IX Xref "instance data" |
| 1639 |
.IP "instance method" 4 |
| 1640 |
.IX Item "instance method" |
| 1641 |
A \fBmethod\fR of an \fBobject\fR, as |
| 1642 |
opposed to a \fBclass method\fR. |
| 1643 |
.IX Xref "instance methods methods, instance" |
| 1644 |
.Sp |
| 1645 |
A \fBmethod\fR whose \fBinvocant\fR is an \fBobject\fR, not a \fBpackage\fR name. Every |
| 1646 |
object of a class shares all the methods of that class, so an instance |
| 1647 |
method applies to all instances of the class, rather than applying to a |
| 1648 |
particular instance. Also see \fBclass method\fR. |
| 1649 |
.IP "instance variable" 4 |
| 1650 |
.IX Item "instance variable" |
| 1651 |
An \fBattribute\fR of an \fBobject\fR; data stored with the particular object rather than with the class |
| 1652 |
as a whole. |
| 1653 |
.IX Xref "instance variables, defined variables, instance" |
| 1654 |
.IP integer 4 |
| 1655 |
.IX Item "integer" |
| 1656 |
A number with no fractional (decimal) part. A counting |
| 1657 |
number, like 1, 2, 3, and so on, but including 0 and the negatives. |
| 1658 |
.IX Xref "integers (term)" |
| 1659 |
.IP interface 4 |
| 1660 |
.IX Item "interface" |
| 1661 |
The services a piece of code promises to provide |
| 1662 |
forever, in contrast to its \fBimplementation\fR, which it should feel free to |
| 1663 |
change whenever it likes. |
| 1664 |
.IX Xref "interfaces (term)" |
| 1665 |
.IP interpolation 4 |
| 1666 |
.IX Item "interpolation" |
| 1667 |
The insertion of a scalar or list value somewhere |
| 1668 |
in the middle of another value, such that it appears to have been there all |
| 1669 |
along. In Perl, variable interpolation happens in double-quoted strings and |
| 1670 |
patterns, and list interpolation occurs when constructing the list of |
| 1671 |
values to pass to a list operator or other such construct that takes a |
| 1672 |
\&\fR\f(CI\*(C`LIST\*(C'\fR\fI\fR. |
| 1673 |
.IX Xref "interpolation, defined" |
| 1674 |
.IP interpreter 4 |
| 1675 |
.IX Item "interpreter" |
| 1676 |
Strictly speaking, a program that reads a second |
| 1677 |
program and does what the second program says directly without turning the |
| 1678 |
program into a different form first, which is what \fBcompilers\fR do. Perl is |
| 1679 |
not an interpreter by this definition, because it contains a kind of |
| 1680 |
compiler that takes a program and turns it into a more executable form |
| 1681 |
(\fBsyntax trees\fR) within the \fIperl\fR process itself, which the Perl |
| 1682 |
\&\fBruntime\fR system then interprets. |
| 1683 |
.IX Xref "interpreters, defined" |
| 1684 |
.IP invocant 4 |
| 1685 |
.IX Item "invocant" |
| 1686 |
The agent on whose behalf a \fBmethod\fR is invoked. In a |
| 1687 |
\&\fBclass\fR method, the invocant is a package name. In an \fBinstance\fR method, |
| 1688 |
the invocant is an object reference. |
| 1689 |
.IX Xref "invocants, defined" |
| 1690 |
.IP invocation 4 |
| 1691 |
.IX Item "invocation" |
| 1692 |
The act of calling up a deity, daemon, program, |
| 1693 |
method, subroutine, or function to get it to do what you think it’s |
| 1694 |
supposed to do. We usually “call” subroutines but “invoke” methods, since |
| 1695 |
it sounds cooler. |
| 1696 |
.IX Xref "invocation, method" |
| 1697 |
.IP I/O 4 |
| 1698 |
.IX Item "I/O" |
| 1699 |
Input from, or output to, a \fBfile\fR or \fBdevice\fR. |
| 1700 |
.IX Xref "I O (Input Output), defined Input Output (I O), defined" |
| 1701 |
.IP IO 4 |
| 1702 |
.IX Item "IO" |
| 1703 |
An internal I/O object. Can also mean \fBindirect object\fR. |
| 1704 |
.IP "I/O layer" 4 |
| 1705 |
.IX Item "I/O layer" |
| 1706 |
One of the filters between the data and what you get as input |
| 1707 |
or what you end up with as output. |
| 1708 |
.IX Xref "I O layer" |
| 1709 |
.IP IPA 4 |
| 1710 |
.IX Item "IPA" |
| 1711 |
India Pale Ale. Also the International Phonetic Alphabet, the |
| 1712 |
standard alphabet used for phonetic notation worldwide. Draws heavily on |
| 1713 |
Unicode, including many combining characters. |
| 1714 |
.IX Xref "International Phonetic Alphabet (IPA) IPA (International Phonetic Alphabet)" |
| 1715 |
.IP IP 4 |
| 1716 |
.IX Item "IP" |
| 1717 |
Internet Protocol, or |
| 1718 |
Intellectual |
| 1719 |
Property. |
| 1720 |
.IX Xref "Internet Protocol (IP) IP (Internet Protocol) IP (Intellectual Property) Intellectual Property (IP)" |
| 1721 |
.IP IPC 4 |
| 1722 |
.IX Item "IPC" |
| 1723 |
Interprocess Communication. |
| 1724 |
.IX Xref "Interprocess Communication IPC (Interprocess Communication), about communication" |
| 1725 |
.IP is-a 4 |
| 1726 |
.IX Item "is-a" |
| 1727 |
A relationship between two \fBobjects\fR in which one |
| 1728 |
object is considered to be a more specific version of the other, generic |
| 1729 |
object: “A camel is a mammal.” Since the generic object really only exists |
| 1730 |
in a Platonic sense, we usually add a little abstraction to the notion of |
| 1731 |
objects and think of the relationship as being between a generic \fBbase |
| 1732 |
class\fR and a specific \fBderived class\fR. Oddly enough, Platonic classes |
| 1733 |
don’t always have Platonic relationships—see \fBinheritance\fR. |
| 1734 |
.IX Xref "is–a relationship" |
| 1735 |
.IP iteration 4 |
| 1736 |
.IX Item "iteration" |
| 1737 |
Doing something repeatedly. |
| 1738 |
.IX Xref "iteration" |
| 1739 |
.IP iterator 4 |
| 1740 |
.IX Item "iterator" |
| 1741 |
A special programming gizmo that keeps track of where you are |
| 1742 |
in something that you’re trying to iterate over. The \f(CW\*(C`foreach\*(C'\fR loop in |
| 1743 |
Perl contains an iterator; so does a hash, allowing you to \f(CW\*(C`each\*(C'\fR through |
| 1744 |
it. |
| 1745 |
.IX Xref "iterators" |
| 1746 |
.IP IV 4 |
| 1747 |
.IX Item "IV" |
| 1748 |
The integer four, not to be |
| 1749 |
confused with six, Tom’s favorite editor. IV also means an internal Integer |
| 1750 |
Value of the type a \fBscalar\fR can hold, not to be confused with an \fBNV\fR. |
| 1751 |
.IX Xref "IV (Integer Value) Integer Value (IV)" |
| 1752 |
.SS J |
| 1753 |
.IX Subsection "J" |
| 1754 |
.IP JAPH 4 |
| 1755 |
.IX Item "JAPH" |
| 1756 |
“Just Another Perl Hacker”, a clever but cryptic bit of Perl |
| 1757 |
code that, when executed, evaluates to that string. Often used to |
| 1758 |
illustrate a particular Perl feature, and something of an ongoing |
| 1759 |
Obfuscated Perl Contest seen in USENET signatures. |
| 1760 |
.IX Xref "JAPH acronym" |
| 1761 |
.SS K |
| 1762 |
.IX Subsection "K" |
| 1763 |
.IP key 4 |
| 1764 |
.IX Item "key" |
| 1765 |
The string index to a \fBhash\fR, used to look up the \fBvalue\fR |
| 1766 |
associated with that key. |
| 1767 |
.IX Xref "keys, defined" |
| 1768 |
.IP keyword 4 |
| 1769 |
.IX Item "keyword" |
| 1770 |
See \fBreserved words\fR. |
| 1771 |
.SS L |
| 1772 |
.IX Subsection "L" |
| 1773 |
.IP label 4 |
| 1774 |
.IX Item "label" |
| 1775 |
A name you give to a \fBstatement\fR so that you can talk |
| 1776 |
about that statement elsewhere in the program. |
| 1777 |
.IX Xref "labels, defined" |
| 1778 |
.IP laziness 4 |
| 1779 |
.IX Item "laziness" |
| 1780 |
The quality that makes you go to great effort to reduce |
| 1781 |
overall energy expenditure. It makes you write labor-saving programs that |
| 1782 |
other people will find useful, and then document what you wrote so you |
| 1783 |
don’t have to answer so many questions about it. Hence, the first great |
| 1784 |
virtue of a programmer. Also hence, this book. See also \fBimpatience\fR and |
| 1785 |
\&\fBhubris\fR. |
| 1786 |
.IX Xref "laziness quality" |
| 1787 |
.IP "leftmost longest" 4 |
| 1788 |
.IX Item "leftmost longest" |
| 1789 |
The preference of the \fBregular expression\fR engine to match the |
| 1790 |
leftmost occurrence of a \fBpattern\fR, then given a position at which a match |
| 1791 |
will occur, the preference for the longest match (presuming the use of a |
| 1792 |
\&\fBgreedy\fR quantifier). See Camel chapter 5, “Pattern Matching” for \fImuch\fR |
| 1793 |
more on this subject. |
| 1794 |
.IX Xref "leftmost longest preference regular expressions, leftmost longest preference" |
| 1795 |
.IP "left shift" 4 |
| 1796 |
.IX Item "left shift" |
| 1797 |
A \fBbit shift\fR that multiplies the |
| 1798 |
number by some power of 2. |
| 1799 |
.IX Xref "left shift (<<) bit operator bit–shift operators, left shift << (left shift) bit operator" |
| 1800 |
.IP lexeme 4 |
| 1801 |
.IX Item "lexeme" |
| 1802 |
Fancy term for a \fBtoken\fR. |
| 1803 |
.IX Xref "lexeme (token)" |
| 1804 |
.IP lexer 4 |
| 1805 |
.IX Item "lexer" |
| 1806 |
Fancy term for a \fBtokener\fR. |
| 1807 |
.IX Xref "lexer (tokener)" |
| 1808 |
.IP "lexical analysis" 4 |
| 1809 |
.IX Item "lexical analysis" |
| 1810 |
Fancy term for \fBtokenizing\fR. |
| 1811 |
.IX Xref "lexical analysis" |
| 1812 |
.IP "lexical scoping" 4 |
| 1813 |
.IX Item "lexical scoping" |
| 1814 |
Looking at your \fIOxford English |
| 1815 |
Dictionary\fR through a microscope. (Also known as \fBstatic scoping\fR, because |
| 1816 |
dictionaries don’t change very fast.) Similarly, looking at variables |
| 1817 |
stored in a private dictionary (namespace) for each scope, which are |
| 1818 |
visible only from their point of declaration down to the end of the lexical scope in which they are declared. —Syn. |
| 1819 |
\&\fBstatic scoping\fR. —Ant. \fBdynamic scoping\fR. |
| 1820 |
.IX Xref "lexical scopes, defined scopes static scopes scopes, static" |
| 1821 |
.IP "lexical variable" 4 |
| 1822 |
.IX Item "lexical variable" |
| 1823 |
A \fBvariable\fR subject to |
| 1824 |
\&\fBlexical scoping\fR, declared by \f(CW\*(C`my\*(C'\fR. Often just called a “lexical”. (The |
| 1825 |
\&\f(CW\*(C`our\*(C'\fR declaration declares a lexically scoped name for a global variable, |
| 1826 |
which is not itself a lexical variable.) |
| 1827 |
.IX Xref "lexical variables, about variables, lexical" |
| 1828 |
.IP library 4 |
| 1829 |
.IX Item "library" |
| 1830 |
Generally, a collection of procedures. In ancient |
| 1831 |
days, referred to a collection of subroutines in a \fI.pl\fR file. In modern |
| 1832 |
times, refers more often to the entire collection of Perl \fBmodules\fR on |
| 1833 |
your system. |
| 1834 |
.IX Xref "libraries, defined" |
| 1835 |
.IP LIFO 4 |
| 1836 |
.IX Item "LIFO" |
| 1837 |
Last In, First Out. See also \fBFIFO\fR. A LIFO is usually called a |
| 1838 |
\&\fBstack\fR. |
| 1839 |
.IX Xref "Last In, First Out (LIFO) LIFO (Last In, First Out) stacks, defined" |
| 1840 |
.IP line 4 |
| 1841 |
.IX Item "line" |
| 1842 |
In Unix, a sequence of zero or more nonnewline characters |
| 1843 |
terminated with a \fBnewline\fR character. On non-Unix machines, this is |
| 1844 |
emulated by the C library even if the underlying \fBoperating system\fR has |
| 1845 |
different ideas. |
| 1846 |
.IX Xref "line (term)" |
| 1847 |
.IP linebreak 4 |
| 1848 |
.IX Item "linebreak" |
| 1849 |
A \fBgrapheme\fR consisting of either a carriage return followed |
| 1850 |
by a line feed or any character with the Unicode Vertical Space \fBcharacter |
| 1851 |
property\fR. |
| 1852 |
.IX Xref "linebreaks" |
| 1853 |
.IP "line buffering" 4 |
| 1854 |
.IX Item "line buffering" |
| 1855 |
Used by a \fBstandard I/O\fR output stream that |
| 1856 |
flushes its \fBbuffer\fR after every \fBnewline\fR. Many standard I/O libraries |
| 1857 |
automatically set up line buffering on output that is going to the terminal. |
| 1858 |
.IX Xref "line buffering buffering, line" |
| 1859 |
.IP "line number" 4 |
| 1860 |
.IX Item "line number" |
| 1861 |
The number of lines read previous to this one, plus 1. Perl |
| 1862 |
keeps a separate line number for each source or input file it opens. The |
| 1863 |
current source file’s line number is represented by \f(CW\*(C`_\|_LINE_\|_\*(C'\fR. The |
| 1864 |
current input line number (for the file that was most recently read via |
| 1865 |
\&\f(CW\*(C`<FH>\*(C'\fR) is represented by the \f(CW$.\fR (\f(CW$INPUT_LINE_NUMBER\fR) |
| 1866 |
variable. Many error messages report both values, if available. |
| 1867 |
.IX Xref "line number" |
| 1868 |
.IP link 4 |
| 1869 |
.IX Item "link" |
| 1870 |
Used as a noun, a name in a \fBdirectory\fR that represents a |
| 1871 |
\&\fBfile\fR. A given file can have multiple links to it. It’s like having the |
| 1872 |
same phone number listed in the phone directory under different names. As a |
| 1873 |
verb, to resolve a partially \fBcompiled\fR file’s unresolved symbols into a |
| 1874 |
(nearly) executable image. Linking can generally be static or dynamic, |
| 1875 |
which has nothing to do with static or dynamic scoping. |
| 1876 |
.IX Xref "links, defined" |
| 1877 |
.IP LIST 4 |
| 1878 |
.IX Item "LIST" |
| 1879 |
A syntactic construct representing a |
| 1880 |
comma\- separated list of expressions, evaluated to produce a \fBlist value\fR. |
| 1881 |
Each \fBexpression\fR in a \fR\f(CI\*(C`LIST\*(C'\fR\fI\fR is evaluated in \fBlist context\fR and |
| 1882 |
interpolated into the list value. |
| 1883 |
.IX Xref "LIST construct constructs, LIST" |
| 1884 |
.IP list 4 |
| 1885 |
.IX Item "list" |
| 1886 |
An ordered set of scalar values. |
| 1887 |
.IX Xref "lists, defined" |
| 1888 |
.IP "list context" 4 |
| 1889 |
.IX Item "list context" |
| 1890 |
The situation in which an \fBexpression\fR is |
| 1891 |
expected by its surroundings (the code calling it) to return a list of |
| 1892 |
values rather than a single value. Functions that want a \fR\f(CI\*(C`LIST\*(C'\fR\fI\fR of |
| 1893 |
arguments tell those arguments that they should produce a list value. See |
| 1894 |
also \fBcontext\fR. |
| 1895 |
.IX Xref "list context context, list" |
| 1896 |
.IP "list operator" 4 |
| 1897 |
.IX Item "list operator" |
| 1898 |
An \fBoperator\fR that does something with a list of |
| 1899 |
values, such as \f(CW\*(C`join\*(C'\fR or \f(CW\*(C`grep\*(C'\fR. Usually used for named built-in |
| 1900 |
operators (such as \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`unlink\*(C'\fR, and \f(CW\*(C`system\*(C'\fR) that do not require |
| 1901 |
parentheses around their \fBargument\fR list. |
| 1902 |
.IX Xref "list operators, about" |
| 1903 |
.IP "list value" 4 |
| 1904 |
.IX Item "list value" |
| 1905 |
An unnamed list of temporary scalar |
| 1906 |
values that may be passed around within a program from any list-generating |
| 1907 |
function to any function or construct that provides a \fBlist context\fR. |
| 1908 |
.IX Xref "list values, about values, list" |
| 1909 |
.IP literal 4 |
| 1910 |
.IX Item "literal" |
| 1911 |
A token in a programming language, such as a number or |
| 1912 |
\&\fBstring\fR, that gives you an actual \fBvalue\fR instead of merely representing |
| 1913 |
possible values as a \fBvariable\fR does. |
| 1914 |
.IX Xref "literals, defined" |
| 1915 |
.IP little-endian 4 |
| 1916 |
.IX Item "little-endian" |
| 1917 |
From Swift: someone |
| 1918 |
who eats eggs little end first. Also used of computers that store the least |
| 1919 |
significant \fBbyte\fR of a word at a lower byte address than the most |
| 1920 |
significant byte. Often considered superior to big-endian machines. See |
| 1921 |
also \fBbig-endian\fR. |
| 1922 |
.IX Xref "little–endian, defined endianness, little–endian" |
| 1923 |
.IP local 4 |
| 1924 |
.IX Item "local" |
| 1925 |
Not meaning the same thing everywhere. A global |
| 1926 |
variable in Perl can be localized inside a \fBdynamic scope\fR via the |
| 1927 |
\&\f(CW\*(C`local\*(C'\fR operator. |
| 1928 |
.IX Xref "local operator, about" |
| 1929 |
.IP "logical operator" 4 |
| 1930 |
.IX Item "logical operator" |
| 1931 |
Symbols representing the concepts “and”, “or”, |
| 1932 |
“xor”, and “not”. |
| 1933 |
.IX Xref "logical operators, about" |
| 1934 |
.IP lookahead 4 |
| 1935 |
.IX Item "lookahead" |
| 1936 |
An \fBassertion\fR that peeks at the string to the right of the current match location. |
| 1937 |
.IX Xref "lookahead assertions assertions (in regexes), lookahead" |
| 1938 |
.IP lookbehind 4 |
| 1939 |
.IX Item "lookbehind" |
| 1940 |
An \fBassertion\fR that peeks at the string to the left of the current match |
| 1941 |
location. |
| 1942 |
.IX Xref "lookbehind assertions assertions (in regexes), lookbehind" |
| 1943 |
.IP loop 4 |
| 1944 |
.IX Item "loop" |
| 1945 |
A construct that |
| 1946 |
performs something repeatedly, like a roller coaster. |
| 1947 |
.IX Xref "loop constructs and statements, about constructs, loop" |
| 1948 |
.IP "loop control statement" 4 |
| 1949 |
.IX Item "loop control statement" |
| 1950 |
Any statement within the body of a loop that can |
| 1951 |
make a loop prematurely stop looping or skip an \fBiteration\fR. Generally, |
| 1952 |
you shouldn’t try this on roller coasters. |
| 1953 |
.IX Xref "statements, loop control" |
| 1954 |
.IP "loop label" 4 |
| 1955 |
.IX Item "loop label" |
| 1956 |
A kind of key or name attached to a loop (or |
| 1957 |
roller coaster) so that loop control statements can talk about which loop |
| 1958 |
they want to control. |
| 1959 |
.IX Xref "loop labels labels, loop" |
| 1960 |
.IP lowercase 4 |
| 1961 |
.IX Item "lowercase" |
| 1962 |
In Unicode, not just |
| 1963 |
characters with the General Category of Lowercase Letter, but any character |
| 1964 |
with the Lowercase property, including Modifier Letters, Letter Numbers, |
| 1965 |
some Other Symbols, and one Combining Mark. |
| 1966 |
.IX Xref "lowercase characters characters, lowercase" |
| 1967 |
.IP lvaluable 4 |
| 1968 |
.IX Item "lvaluable" |
| 1969 |
Able to serve as an \fBlvalue\fR. |
| 1970 |
.IX Xref "lvaluable function functions, lvaluable" |
| 1971 |
.IP lvalue 4 |
| 1972 |
.IX Item "lvalue" |
| 1973 |
Term used by language lawyers for a |
| 1974 |
storage location you can assign a new \fBvalue\fR to, such as a \fBvariable\fR or |
| 1975 |
an element of an \fBarray\fR. The “l” is short for “left”, as in the left side |
| 1976 |
of an assignment, a typical place for lvalues. An \fBlvaluable\fR function or |
| 1977 |
expression is one to which a value may be assigned, as in \f(CW\*(C`pos($x) = 10\*(C'\fR. |
| 1978 |
.IX Xref "lvalue (term) values, lvalue" |
| 1979 |
.IP "lvalue modifier" 4 |
| 1980 |
.IX Item "lvalue modifier" |
| 1981 |
An adjectival pseudofunction that |
| 1982 |
warps the meaning of an \fBlvalue\fR in some declarative fashion. Currently |
| 1983 |
there are three lvalue modifiers: \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, and \f(CW\*(C`local\*(C'\fR. |
| 1984 |
.IX Xref "lvalue modifier modifiers, lvalue" |
| 1985 |
.SS M |
| 1986 |
.IX Subsection "M" |
| 1987 |
.IP magic 4 |
| 1988 |
.IX Item "magic" |
| 1989 |
Technically speaking, any extra semantics attached to a |
| 1990 |
variable such as \f(CW$!\fR, \f(CW$0\fR, \f(CW%ENV\fR, or \f(CW%SIG\fR, or to any tied |
| 1991 |
variable. Magical things happen when you diddle those variables. |
| 1992 |
.IX Xref "magic (term)" |
| 1993 |
.IP "magical increment" 4 |
| 1994 |
.IX Item "magical increment" |
| 1995 |
An \fBincrement\fR operator that knows how to |
| 1996 |
bump up ASCII alphabetics as well as numbers. |
| 1997 |
.IX Xref "magical increment operator" |
| 1998 |
.IP "magical variables" 4 |
| 1999 |
.IX Item "magical variables" |
| 2000 |
Special variables that have side |
| 2001 |
effects when you access them or assign to them. For example, in Perl, |
| 2002 |
changing elements of the \f(CW%ENV\fR array also changes the corresponding |
| 2003 |
environment variables that subprocesses will use. Reading the \f(CW$!\fR |
| 2004 |
variable gives you the current system error number or message. |
| 2005 |
.IX Xref "magical variables variables, magical" |
| 2006 |
.IP Makefile 4 |
| 2007 |
.IX Item "Makefile" |
| 2008 |
A file that controls the compilation of a program. Perl programs |
| 2009 |
don’t usually need a \fBMakefile\fR because the Perl compiler has plenty of |
| 2010 |
self-control. |
| 2011 |
.IX Xref "Makefile" |
| 2012 |
.IP man 4 |
| 2013 |
.IX Item "man" |
| 2014 |
The Unix program that displays online documentation |
| 2015 |
(manual pages) for you. |
| 2016 |
.IX Xref "man program (Unix)" |
| 2017 |
.IP manpage 4 |
| 2018 |
.IX Item "manpage" |
| 2019 |
A “page” from the manuals, typically accessed via the |
| 2020 |
\&\fIman\fR(1) command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of |
| 2021 |
BUGS, and so on, and is typically longer than a page. There are manpages |
| 2022 |
documenting \fBcommands\fR, \fBsyscalls\fR, \fBlibrary\fR \fBfunctions\fR, \fBdevices\fR, |
| 2023 |
\&\fBprotocols\fR, \fBfiles\fR, and such. In this book, we call any piece of |
| 2024 |
standard Perl documentation (like perlop or perldelta) a manpage, no |
| 2025 |
matter what format it’s installed in on your system. |
| 2026 |
.IX Xref "manpages, defined" |
| 2027 |
.IP matching 4 |
| 2028 |
.IX Item "matching" |
| 2029 |
See \fBpattern matching\fR. |
| 2030 |
.IX Xref "matching" |
| 2031 |
.IP "member data" 4 |
| 2032 |
.IX Item "member data" |
| 2033 |
See \fBinstance variable\fR. |
| 2034 |
.IX Xref "member data" |
| 2035 |
.IP memory 4 |
| 2036 |
.IX Item "memory" |
| 2037 |
This always means your main memory, not your disk. |
| 2038 |
Clouding the issue is the fact that your machine may implement |
| 2039 |
\&\fBvirtual\fR memory; that is, it will pretend that it has more memory than |
| 2040 |
it really does, and it’ll use disk space to hold inactive bits. This can |
| 2041 |
make it seem like you have a little more memory than you really do, but |
| 2042 |
it’s not a substitute for real memory. The best thing that can be said |
| 2043 |
about virtual memory is that it lets your performance degrade gradually |
| 2044 |
rather than suddenly when you run out of real memory. But your program |
| 2045 |
can die when you run out of virtual memory, too—if you haven’t thrashed |
| 2046 |
your disk to death first. |
| 2047 |
.IX Xref "memory, defined" |
| 2048 |
.IP metacharacter 4 |
| 2049 |
.IX Item "metacharacter" |
| 2050 |
A \fBcharacter\fR that is \fInot\fR supposed to be treated normally. Which characters |
| 2051 |
are to be treated specially as metacharacters varies greatly from context to |
| 2052 |
context. Your \fBshell\fR will have certain metacharacters, double-quoted Perl |
| 2053 |
\&\fBstrings\fR have other metacharacters, |
| 2054 |
and \fBregular expression\fR patterns have all the double-quote metacharacters plus |
| 2055 |
some extra ones of their own. |
| 2056 |
.IX Xref "metacharacters, about characters, regex metacharacters regular expressions, metacharacters and" |
| 2057 |
.IP metasymbol 4 |
| 2058 |
.IX Item "metasymbol" |
| 2059 |
Something we’d call a |
| 2060 |
\&\fBmetacharacter\fR except that it’s a sequence of more than one character. |
| 2061 |
Generally, the first character in the sequence must be a true metacharacter |
| 2062 |
to get the other characters in the metasymbol to misbehave along with it. |
| 2063 |
.IX Xref "metasymbols, about escape sequences" |
| 2064 |
.IP method 4 |
| 2065 |
.IX Item "method" |
| 2066 |
A kind of action that an \fBobject\fR can take if you tell |
| 2067 |
it to. See Camel chapter 12, “Objects”. |
| 2068 |
.IX Xref "methods, defined" |
| 2069 |
.IP "method resolution order" 4 |
| 2070 |
.IX Item "method resolution order" |
| 2071 |
The path Perl takes through \f(CW@INC\fR. By default, this is a double depth first |
| 2072 |
search, once looking for defined methods and once for \f(CW\*(C`AUTOLOAD\*(C'\fR. However, |
| 2073 |
Perl lets you configure this with \f(CW\*(C`mro\*(C'\fR. |
| 2074 |
.IX Xref "method resolution order (mro) mro (method resolution order)" |
| 2075 |
.IP minicpan 4 |
| 2076 |
.IX Item "minicpan" |
| 2077 |
A CPAN mirror that includes just the latest versions for each |
| 2078 |
distribution, probably created with \f(CW\*(C`CPAN::Mini\*(C'\fR. See |
| 2079 |
Camel chapter 19, “CPAN”. |
| 2080 |
.IX Xref "minicpan, defined CPAN (Comprehensive Perl Archive Network), minicpan and CPAN::Mini module" |
| 2081 |
.IP minimalism 4 |
| 2082 |
.IX Item "minimalism" |
| 2083 |
The belief that “small is beautiful”. Paradoxically, if you |
| 2084 |
say something in a small language, it turns out big, and if you say it in a |
| 2085 |
big language, it turns out small. Go figure. |
| 2086 |
.IX Xref "minimalism" |
| 2087 |
.IP mode 4 |
| 2088 |
.IX Item "mode" |
| 2089 |
In the context of the \fIstat\fR(2) syscall, refers to the field |
| 2090 |
holding the \fBpermission bits\fR and the type of the \fBfile\fR. |
| 2091 |
.IX Xref "mode" |
| 2092 |
.IP modifier 4 |
| 2093 |
.IX Item "modifier" |
| 2094 |
See \fBstatement modifier\fR, \fBregular expression\fR, and |
| 2095 |
\&\fBlvalue\fR, not necessarily in that order. |
| 2096 |
.IX Xref "modifiers, defined" |
| 2097 |
.IP module 4 |
| 2098 |
.IX Item "module" |
| 2099 |
A \fBfile\fR that defines a \fBpackage\fR of (almost) the same |
| 2100 |
name, which can either \fBexport\fR symbols or function as an \fBobject\fR class. |
| 2101 |
(A module’s main \fI.pm\fR file may also load in other files in support of the |
| 2102 |
module.) See the \f(CW\*(C`use\*(C'\fR built-in. |
| 2103 |
.IX Xref "modules, defined" |
| 2104 |
.IP modulus 4 |
| 2105 |
.IX Item "modulus" |
| 2106 |
An integer divisor when |
| 2107 |
you’re interested in the remainder instead of the quotient. |
| 2108 |
.IX Xref "modulus (%) operator % (modulus) operator" |
| 2109 |
.IP mojibake 4 |
| 2110 |
.IX Item "mojibake" |
| 2111 |
When you speak one language and the computer thinks you’re |
| 2112 |
speaking another. You’ll see odd translations when you send UTF‑8, for |
| 2113 |
instance, but the computer thinks you sent Latin\-1, showing all sorts of |
| 2114 |
weird characters instead. The term is written 「文字化け」in Japanese and |
| 2115 |
means “character rot”, an apt description. Pronounced [\f(CW\*(C`modʑibake\*(C'\fR] in |
| 2116 |
standard \fBIPA\fR phonetics, or approximately “moh\-jee\-bah\-keh”. |
| 2117 |
.IX Xref "mojibake" |
| 2118 |
.IP monger 4 |
| 2119 |
.IX Item "monger" |
| 2120 |
Short for one member of \fBPerl mongers\fR, a |
| 2121 |
purveyor of Perl. |
| 2122 |
.IX Xref "mongers, Perl Perl mongers" |
| 2123 |
.IP mortal 4 |
| 2124 |
.IX Item "mortal" |
| 2125 |
A temporary value scheduled to die when the |
| 2126 |
current statement finishes. |
| 2127 |
.IX Xref "mortal value values, mortal" |
| 2128 |
.IP mro 4 |
| 2129 |
.IX Item "mro" |
| 2130 |
See \fBmethod resolution order\fR. |
| 2131 |
.IP "multidimensional array" 4 |
| 2132 |
.IX Item "multidimensional array" |
| 2133 |
An array with multiple |
| 2134 |
subscripts for finding a single element. Perl implements these using |
| 2135 |
\&\fBreferences\fR—see Camel chapter 9, “Data Structures”. |
| 2136 |
.IX Xref "multidimensional arrays arrays, multidimensional" |
| 2137 |
.IP "multiple inheritance" 4 |
| 2138 |
.IX Item "multiple inheritance" |
| 2139 |
The features you got from |
| 2140 |
your mother and father, mixed together unpredictably. (See also |
| 2141 |
\&\fBinheritance\fR and \fBsingle inheritance\fR.) In computer languages (including |
| 2142 |
Perl), it is the notion that a given class may have multiple direct |
| 2143 |
ancestors or \fBbase classes\fR. |
| 2144 |
.IX Xref "multiple inheritance inheritance, multiple" |
| 2145 |
.SS N |
| 2146 |
.IX Subsection "N" |
| 2147 |
.IP "named pipe" 4 |
| 2148 |
.IX Item "named pipe" |
| 2149 |
A \fBpipe\fR with a name embedded in the |
| 2150 |
\&\fBfilesystem\fR so that it can be accessed by two unrelated \fBprocesses\fR. |
| 2151 |
.IX Xref "named pipes pipes, names" |
| 2152 |
.IP namespace 4 |
| 2153 |
.IX Item "namespace" |
| 2154 |
A domain of names. You needn’t worry about whether the |
| 2155 |
names in one such domain have been used in another. See \fBpackage\fR. |
| 2156 |
.IX Xref "namespaces, about" |
| 2157 |
.IP NaN 4 |
| 2158 |
.IX Item "NaN" |
| 2159 |
Not a number. The value Perl uses |
| 2160 |
for certain invalid or inexpressible floating-point operations. |
| 2161 |
.IX Xref "NaN (not a number) not a number (NaN)" |
| 2162 |
.IP "network address" 4 |
| 2163 |
.IX Item "network address" |
| 2164 |
The most important attribute of a socket, like your |
| 2165 |
telephone’s telephone number. Typically an IP address. See also \fBport\fR. |
| 2166 |
.IX Xref "network address" |
| 2167 |
.IP newline 4 |
| 2168 |
.IX Item "newline" |
| 2169 |
A single character that |
| 2170 |
represents the end of a line, with the ASCII value of 012 octal under Unix |
| 2171 |
(but 015 on a Mac), and represented by \f(CW\*(C`\en\*(C'\fR in Perl strings. For Windows |
| 2172 |
machines writing text files, and for certain physical devices like |
| 2173 |
terminals, the single newline gets automatically translated by your C |
| 2174 |
library into a line feed and a carriage return, but normally, no |
| 2175 |
translation is done. |
| 2176 |
.IX Xref "newline character characters, newline" |
| 2177 |
.IP NFS 4 |
| 2178 |
.IX Item "NFS" |
| 2179 |
Network File System, which allows you to mount a remote filesystem as if it were local. |
| 2180 |
.IX Xref "NFS (Network File System) Network File System (NFS)" |
| 2181 |
.IP normalization 4 |
| 2182 |
.IX Item "normalization" |
| 2183 |
Converting a text string into an alternate but equivalent |
| 2184 |
\&\fBcanonical\fR (or compatible) representation that can then be compared for |
| 2185 |
equivalence. Unicode recognizes four different normalization forms: NFD, |
| 2186 |
NFC, NFKD, and NFKC. |
| 2187 |
.IX Xref "normalization" |
| 2188 |
.IP "null character" 4 |
| 2189 |
.IX Item "null character" |
| 2190 |
A character with the numeric value of |
| 2191 |
zero. It’s used by C to terminate strings, but Perl allows strings to |
| 2192 |
contain a null. |
| 2193 |
.IX Xref "null character characters, null" |
| 2194 |
.IP "null list" 4 |
| 2195 |
.IX Item "null list" |
| 2196 |
A \fBlist value\fR with zero elements, represented |
| 2197 |
in Perl by \f(CW\*(C`()\*(C'\fR. |
| 2198 |
.IX Xref "null lists lists, null" |
| 2199 |
.IP "null string" 4 |
| 2200 |
.IX Item "null string" |
| 2201 |
A \fBstring\fR containing no characters, not to |
| 2202 |
be confused with a string containing a \fBnull character\fR, which has a |
| 2203 |
positive length and is \fBtrue\fR. |
| 2204 |
.IX Xref "null strings strings, null" |
| 2205 |
.IP "numeric context" 4 |
| 2206 |
.IX Item "numeric context" |
| 2207 |
The situation in which an expression |
| 2208 |
is expected by its surroundings (the code calling it) to return a number. |
| 2209 |
See also \fBcontext\fR and \fBstring context\fR. |
| 2210 |
.IX Xref "numeric context context, numeric" |
| 2211 |
.IP numification 4 |
| 2212 |
.IX Item "numification" |
| 2213 |
(Sometimes spelled \fInummification\fR and \fInummify\fR.) Perl lingo |
| 2214 |
for implicit conversion into a number; the related verb is \fInumify\fR. |
| 2215 |
\&\fINumification\fR is intended to rhyme with \fImummification\fR, and \fInumify\fR with |
| 2216 |
\&\fImummify\fR. It is unrelated to English \fInumen\fR, \fInumina\fR, \fInuminous\fR. We |
| 2217 |
originally forgot the extra \fIm\fR a long time ago, and some people got used to |
| 2218 |
our funny spelling, and so just as with \f(CW\*(C`HTTP_REFERER\*(C'\fR’s own missing letter, |
| 2219 |
our weird spelling has stuck around. |
| 2220 |
.IX Xref "numification" |
| 2221 |
.IP NV 4 |
| 2222 |
.IX Item "NV" |
| 2223 |
Short for Nevada, no part of |
| 2224 |
which will ever be confused with civilization. NV also means an internal |
| 2225 |
floating\- point Numeric Value of the type a \fBscalar\fR can hold, not to be |
| 2226 |
confused with an \fBIV\fR. |
| 2227 |
.IX Xref "Numeric Value (NV) NV (Numeric Value)" |
| 2228 |
.IP nybble 4 |
| 2229 |
.IX Item "nybble" |
| 2230 |
Half a \fBbyte\fR, equivalent to one \fBhexadecimal\fR digit, and worth |
| 2231 |
four \fBbits\fR. |
| 2232 |
.IX Xref "nybble" |
| 2233 |
.SS O |
| 2234 |
.IX Subsection "O" |
| 2235 |
.IP object 4 |
| 2236 |
.IX Item "object" |
| 2237 |
An \fBinstance\fR of a \fBclass\fR. Something that “knows” |
| 2238 |
what user-defined type (class) it is, and what it can do because of what |
| 2239 |
class it is. Your program can request an object to do things, but the |
| 2240 |
object gets to decide whether it wants to do them or not. Some objects are |
| 2241 |
more accommodating than others. |
| 2242 |
.IX Xref "objects, defined" |
| 2243 |
.IP octal 4 |
| 2244 |
.IX Item "octal" |
| 2245 |
A number in base 8. Only the digits 0 through 7 are allowed. Octal |
| 2246 |
constants in Perl start with 0, as in 013. See also the \f(CW\*(C`oct\*(C'\fR function. |
| 2247 |
.IX Xref "octals" |
| 2248 |
.IP offset 4 |
| 2249 |
.IX Item "offset" |
| 2250 |
How many things you have to skip |
| 2251 |
over when moving from the beginning of a string or array to a specific |
| 2252 |
position within it. Thus, the minimum offset is zero, not one, because you |
| 2253 |
don’t skip anything to get to the first item. |
| 2254 |
.IX Xref "offsets in strings strings, offsets in" |
| 2255 |
.IP one-liner 4 |
| 2256 |
.IX Item "one-liner" |
| 2257 |
An entire computer program crammed into one line of |
| 2258 |
text. |
| 2259 |
.IX Xref "one–liner programs" |
| 2260 |
.IP "open source software" 4 |
| 2261 |
.IX Item "open source software" |
| 2262 |
Programs for which the source code is freely |
| 2263 |
available and freely redistributable, with no commercial strings attached. |
| 2264 |
For a more detailed definition, see <http://www.opensource.org/osd.html>. |
| 2265 |
.IX Xref "open source software" |
| 2266 |
.IP operand 4 |
| 2267 |
.IX Item "operand" |
| 2268 |
An \fBexpression\fR that yields a \fBvalue\fR that an |
| 2269 |
\&\fBoperator\fR operates on. See also \fBprecedence\fR. |
| 2270 |
.IX Xref "operands (term)" |
| 2271 |
.IP "operating system" 4 |
| 2272 |
.IX Item "operating system" |
| 2273 |
A special program that runs on the bare |
| 2274 |
machine and hides the gory details of managing \fBprocesses\fR and \fBdevices\fR. |
| 2275 |
Usually used in a looser sense to indicate a particular culture of |
| 2276 |
programming. The loose sense can be used at varying levels of specificity. |
| 2277 |
At one extreme, you might say that all versions of Unix and Unix-lookalikes |
| 2278 |
are the same operating system (upsetting many people, especially lawyers |
| 2279 |
and other advocates). At the other extreme, you could say this particular |
| 2280 |
version of this particular vendor’s operating system is different from any |
| 2281 |
other version of this or any other vendor’s operating system. Perl is much |
| 2282 |
more portable across operating systems than many other languages. See also |
| 2283 |
\&\fBarchitecture\fR and \fBplatform\fR. |
| 2284 |
.IX Xref "operating systems, defined" |
| 2285 |
.IP operator 4 |
| 2286 |
.IX Item "operator" |
| 2287 |
A gizmo that transforms some number of input values to |
| 2288 |
some number of output values, often built into a language with a special |
| 2289 |
syntax or symbol. A given operator may have specific expectations about |
| 2290 |
what \fBtypes\fR of data you give as its arguments (\fBoperands\fR) and what type |
| 2291 |
of data you want back from it. |
| 2292 |
.IX Xref "operators, about" |
| 2293 |
.IP "operator overloading" 4 |
| 2294 |
.IX Item "operator overloading" |
| 2295 |
A kind of |
| 2296 |
\&\fBoverloading\fR that you can do on built-in \fBoperators\fR to make them work |
| 2297 |
on \fBobjects\fR as if the objects were ordinary scalar values, but with the |
| 2298 |
actual semantics supplied by the object class. This is set up with the |
| 2299 |
overload \fBpragma\fR—see Camel chapter 13, “Overloading”. |
| 2300 |
.IX Xref "operator overloading, about overloading, operator" |
| 2301 |
.IP options 4 |
| 2302 |
.IX Item "options" |
| 2303 |
See either \fBswitches\fR or \fBregular expression modifiers\fR. |
| 2304 |
.IX Xref "options" |
| 2305 |
.IP ordinal 4 |
| 2306 |
.IX Item "ordinal" |
| 2307 |
An abstract character’s integer value. Same thing as |
| 2308 |
\&\fBcodepoint\fR. |
| 2309 |
.IX Xref "ordinals (term)" |
| 2310 |
.IP overloading 4 |
| 2311 |
.IX Item "overloading" |
| 2312 |
Giving additional meanings to a symbol or construct. |
| 2313 |
Actually, all languages do overloading to one extent or another, since |
| 2314 |
people are good at figuring out things from \fBcontext\fR. |
| 2315 |
.IX Xref "overloading, defined" |
| 2316 |
.IP overriding 4 |
| 2317 |
.IX Item "overriding" |
| 2318 |
Hiding or invalidating some other definition of the |
| 2319 |
same name. (Not to be confused with \fBoverloading\fR, which adds definitions |
| 2320 |
that must be disambiguated some other way.) To confuse the issue further, |
| 2321 |
we use the word with two overloaded definitions: to describe how you can |
| 2322 |
define your own \fBsubroutine\fR to hide a built-in \fBfunction\fR of the same |
| 2323 |
name (see the section “Overriding Built-in Functions” in Camel chapter 11, |
| 2324 |
“Modules”), and to describe how you can define a replacement \fBmethod\fR in a |
| 2325 |
\&\fBderived class\fR to hide a \fBbase class\fR’s method of the same name (see |
| 2326 |
Camel chapter 12, “Objects”). |
| 2327 |
.IX Xref "overriding, defined" |
| 2328 |
.IP owner 4 |
| 2329 |
.IX Item "owner" |
| 2330 |
The one user (apart from the |
| 2331 |
superuser) who has absolute control over a \fBfile\fR. A file may also have a |
| 2332 |
\&\fBgroup\fR of users who may exercise joint ownership if the real owner |
| 2333 |
permits it. See \fBpermission bits\fR. |
| 2334 |
.IX Xref "ownership, file files, ownership of" |
| 2335 |
.SS P |
| 2336 |
.IX Subsection "P" |
| 2337 |
.IP package 4 |
| 2338 |
.IX Item "package" |
| 2339 |
A \fBnamespace\fR for global \fBvariables\fR, \fBsubroutines\fR, |
| 2340 |
and the like, such that they can be kept separate from like-named |
| 2341 |
\&\fBsymbols\fR in other namespaces. In a sense, only the package is global, |
| 2342 |
since the symbols in the package’s symbol table are only accessible from |
| 2343 |
code \fBcompiled\fR outside the package by naming the package. But in another |
| 2344 |
sense, all package symbols are also globals—they’re just well-organized |
| 2345 |
globals. |
| 2346 |
.IX Xref "packages, defined" |
| 2347 |
.IP pad 4 |
| 2348 |
.IX Item "pad" |
| 2349 |
Short for \fBscratchpad\fR. |
| 2350 |
.IX Xref "pads (scratchpads)" |
| 2351 |
.IP parameter 4 |
| 2352 |
.IX Item "parameter" |
| 2353 |
See \fBargument\fR. |
| 2354 |
.IX Xref "parameters" |
| 2355 |
.IP "parent class" 4 |
| 2356 |
.IX Item "parent class" |
| 2357 |
See \fBbase class\fR. |
| 2358 |
.IX Xref "parent classes classes, parent" |
| 2359 |
.IP "parse tree" 4 |
| 2360 |
.IX Item "parse tree" |
| 2361 |
See \fBsyntax tree\fR. |
| 2362 |
.IX Xref "parse tree" |
| 2363 |
.IP parsing 4 |
| 2364 |
.IX Item "parsing" |
| 2365 |
The subtle but sometimes brutal art of attempting to turn |
| 2366 |
your possibly malformed program into a valid \fBsyntax tree\fR. |
| 2367 |
.IX Xref "parsing, about" |
| 2368 |
.IP patch 4 |
| 2369 |
.IX Item "patch" |
| 2370 |
To fix by applying one, as it were. In the realm of hackerdom, a |
| 2371 |
listing of the differences between two versions of a program as might be |
| 2372 |
applied by the \fBpatch\fR(1) program when you want to fix a bug or upgrade |
| 2373 |
your old version. |
| 2374 |
.IX Xref "patches" |
| 2375 |
.IP PATH 4 |
| 2376 |
.IX Item "PATH" |
| 2377 |
The list of |
| 2378 |
\&\fBdirectories\fR the system searches to find a program you want to |
| 2379 |
\&\fBexecute\fR. The list is stored as one of your \fBenvironment variables\fR, |
| 2380 |
accessible in Perl as \f(CW$ENV{PATH}\fR. |
| 2381 |
.IX Xref "PATH environment variable variables, environment" |
| 2382 |
.IP pathname 4 |
| 2383 |
.IX Item "pathname" |
| 2384 |
A fully qualified filename such as \fI/usr/bin/perl\fR. Sometimes |
| 2385 |
confused with \f(CW\*(C`PATH\*(C'\fR. |
| 2386 |
.IX Xref "pathname" |
| 2387 |
.IP pattern 4 |
| 2388 |
.IX Item "pattern" |
| 2389 |
A template used in \fBpattern matching\fR. |
| 2390 |
.IX Xref "patterns, defined" |
| 2391 |
.IP "pattern matching" 4 |
| 2392 |
.IX Item "pattern matching" |
| 2393 |
Taking a pattern, usually a \fBregular |
| 2394 |
expression\fR, and trying the pattern various ways on a string to see whether |
| 2395 |
there’s any way to make it fit. Often used to pick interesting tidbits out |
| 2396 |
of a file. |
| 2397 |
.IX Xref "pattern matching, about" |
| 2398 |
.IP PAUSE 4 |
| 2399 |
.IX Item "PAUSE" |
| 2400 |
The Perl Authors Upload SErver (<http://pause.perl.org>), the gateway |
| 2401 |
for \fBmodules\fR on their way to \fBCPAN\fR. |
| 2402 |
.IX Xref "Perl Authors Upload SErver (PAUSE) PAUSE (Perl Authors Upload SErver)" |
| 2403 |
.IP "Perl mongers" 4 |
| 2404 |
.IX Item "Perl mongers" |
| 2405 |
A Perl user group, taking the form of its |
| 2406 |
name from the New York Perl mongers, the first Perl user group. Find one |
| 2407 |
near you at <http://www.pm.org>. |
| 2408 |
.IX Xref "Perl mongers mongers, Perl" |
| 2409 |
.IP "permission bits" 4 |
| 2410 |
.IX Item "permission bits" |
| 2411 |
Bits that the \fBowner\fR of a file sets |
| 2412 |
or unsets to allow or disallow access to other people. These flag bits are |
| 2413 |
part of the \fBmode\fR word returned by the \f(CW\*(C`stat\*(C'\fR built-in when you ask |
| 2414 |
about a file. On Unix systems, you can check the \fIls\fR(1) manpage for more |
| 2415 |
information. |
| 2416 |
.IX Xref "permission bits bits, permission" |
| 2417 |
.IP Pern 4 |
| 2418 |
.IX Item "Pern" |
| 2419 |
What you get when you do \f(CW\*(C`Perl++\*(C'\fR twice. Doing it only once |
| 2420 |
will curl your hair. You have to increment it eight times to shampoo your |
| 2421 |
hair. Lather, rinse, iterate. |
| 2422 |
.IX Xref "Pern (term)" |
| 2423 |
.IP pipe 4 |
| 2424 |
.IX Item "pipe" |
| 2425 |
A direct \fBconnection\fR that carries the output of one |
| 2426 |
\&\fBprocess\fR to the input of another without an intermediate temporary file. |
| 2427 |
Once the pipe is set up, the two processes in question can read and write |
| 2428 |
as if they were talking to a normal file, with some caveats. |
| 2429 |
.IX Xref "pipes, defined" |
| 2430 |
.IP pipeline 4 |
| 2431 |
.IX Item "pipeline" |
| 2432 |
A series of \fBprocesses\fR all in a row, linked by \fBpipes\fR, where |
| 2433 |
each passes its output stream to the next. |
| 2434 |
.IX Xref "pipeline" |
| 2435 |
.IP platform 4 |
| 2436 |
.IX Item "platform" |
| 2437 |
The entire hardware and software context in which a |
| 2438 |
program runs. A program written in a platform-dependent language might |
| 2439 |
break if you change any of the following: machine, operating system, |
| 2440 |
libraries, compiler, or system configuration. The \fIperl\fR interpreter has |
| 2441 |
to be \fBcompiled\fR differently for each platform because it is implemented |
| 2442 |
in C, but programs written in the Perl language are largely platform |
| 2443 |
independent. |
| 2444 |
.IX Xref "platforms, defined" |
| 2445 |
.IP pod 4 |
| 2446 |
.IX Item "pod" |
| 2447 |
The markup |
| 2448 |
used to embed documentation into your Perl code. Pod stands for “Plain old |
| 2449 |
documentation”. See Camel chapter 23, “Plain Old Documentation”. |
| 2450 |
.IX Xref "pod (plain old documentation), about plain old documentation" |
| 2451 |
.IP "pod command" 4 |
| 2452 |
.IX Item "pod command" |
| 2453 |
A sequence, such as \f(CW\*(C`=head1\*(C'\fR, that denotes |
| 2454 |
the start of a \fBpod\fR section. |
| 2455 |
.IX Xref "pod commands commands, pod" |
| 2456 |
.IP pointer 4 |
| 2457 |
.IX Item "pointer" |
| 2458 |
A \fBvariable\fR in a language like C that contains the exact |
| 2459 |
memory location of some other item. Perl handles pointers internally so you |
| 2460 |
don’t have to worry about them. Instead, you just use symbolic pointers in |
| 2461 |
the form of \fBkeys\fR and \fBvariable\fR names, or \fBhard references\fR, which |
| 2462 |
aren’t pointers (but act like pointers and do in fact contain pointers). |
| 2463 |
.IX Xref "pointers" |
| 2464 |
.IP polymorphism 4 |
| 2465 |
.IX Item "polymorphism" |
| 2466 |
The notion that you can tell an \fBobject\fR to do something |
| 2467 |
generic, and the object will interpret the command in different ways |
| 2468 |
depending on its type. [< Greek πολυ\- + μορϕή, many forms.] |
| 2469 |
.IX Xref "polymorphism" |
| 2470 |
.IP port 4 |
| 2471 |
.IX Item "port" |
| 2472 |
The part of the address of a TCP or UDP socket that directs |
| 2473 |
packets to the correct process after finding the right machine, something |
| 2474 |
like the phone extension you give when you reach the company operator. Also |
| 2475 |
the result of converting code to run on a different platform than |
| 2476 |
originally intended, or the verb denoting this conversion. |
| 2477 |
.IX Xref "ports (term)" |
| 2478 |
.IP portable 4 |
| 2479 |
.IX Item "portable" |
| 2480 |
Once upon a time, C code compilable under both BSD and |
| 2481 |
SysV. In general, code that can be easily converted to run on another |
| 2482 |
\&\fBplatform\fR, where “easily” can be defined however you like, and usually |
| 2483 |
is. Anything may be considered portable if you try hard enough, such as a |
| 2484 |
mobile home or London Bridge. |
| 2485 |
.IX Xref "portability, about" |
| 2486 |
.IP porter 4 |
| 2487 |
.IX Item "porter" |
| 2488 |
Someone who “carries” software from one \fBplatform\fR to another. |
| 2489 |
Porting programs written in platform-dependent languages such as C can be |
| 2490 |
difficult work, but porting programs like Perl is very much worth the |
| 2491 |
agony. |
| 2492 |
.IX Xref "porters" |
| 2493 |
.IP possessive 4 |
| 2494 |
.IX Item "possessive" |
| 2495 |
Said of quantifiers and groups in patterns that refuse |
| 2496 |
to give up anything once they’ve gotten their mitts on it. Catchier and |
| 2497 |
easier to say than the even more formal \fInonbacktrackable\fR. |
| 2498 |
.IX Xref "possessive (term)" |
| 2499 |
.IP POSIX 4 |
| 2500 |
.IX Item "POSIX" |
| 2501 |
The Portable Operating System Interface |
| 2502 |
specification. |
| 2503 |
.IX Xref "Portable Operating System Interface (POSIX), about POSIX (Portable Operating System Interface), about" |
| 2504 |
.IP postfix 4 |
| 2505 |
.IX Item "postfix" |
| 2506 |
An \fBoperator\fR that follows its \fBoperand\fR, as in |
| 2507 |
\&\f(CW\*(C`$x++\*(C'\fR. |
| 2508 |
.IX Xref "postfix operator" |
| 2509 |
.IP pp 4 |
| 2510 |
.IX Item "pp" |
| 2511 |
An internal shorthand for a |
| 2512 |
“push\- pop” code; that is, C code implementing Perl’s stack machine. |
| 2513 |
.IX Xref "pp (push–pop) code push–pop (pp) code" |
| 2514 |
.IP pragma 4 |
| 2515 |
.IX Item "pragma" |
| 2516 |
A standard module whose practical hints and |
| 2517 |
suggestions are received (and possibly ignored) at compile time. Pragmas |
| 2518 |
are named in all lowercase. |
| 2519 |
.IX Xref "pragmas, about modules" |
| 2520 |
.IP precedence 4 |
| 2521 |
.IX Item "precedence" |
| 2522 |
The rules of |
| 2523 |
conduct that, in the absence of other guidance, determine what should |
| 2524 |
happen first. For example, in the absence of parentheses, you always do |
| 2525 |
multiplication before addition. |
| 2526 |
.IX Xref "precedence rules, about operators, precedence rules" |
| 2527 |
.IP prefix 4 |
| 2528 |
.IX Item "prefix" |
| 2529 |
An \fBoperator\fR that precedes its \fBoperand\fR, as in |
| 2530 |
\&\f(CW\*(C`++$x\*(C'\fR. |
| 2531 |
.IX Xref "prefix operators" |
| 2532 |
.IP preprocessing 4 |
| 2533 |
.IX Item "preprocessing" |
| 2534 |
What some helper \fBprocess\fR did to transform the incoming |
| 2535 |
data into a form more suitable for the current process. Often done with an |
| 2536 |
incoming \fBpipe\fR. See also \fBC preprocessor\fR. |
| 2537 |
.IX Xref "preprocessing" |
| 2538 |
.IP "primary maintainer" 4 |
| 2539 |
.IX Item "primary maintainer" |
| 2540 |
The author that PAUSE allows to assign \fBco-maintainer\fR |
| 2541 |
permissions to a \fBnamespace\fR. A primary maintainer can give up this |
| 2542 |
distinction by assigning it to another PAUSE author. See Camel chapter 19, |
| 2543 |
“CPAN”. |
| 2544 |
.IX Xref "primary maintainer" |
| 2545 |
.IP procedure 4 |
| 2546 |
.IX Item "procedure" |
| 2547 |
A \fBsubroutine\fR. |
| 2548 |
.IX Xref "procedures, defined" |
| 2549 |
.IP process 4 |
| 2550 |
.IX Item "process" |
| 2551 |
An instance of a running program. Under multitasking |
| 2552 |
systems like Unix, two or more separate processes could be running the same |
| 2553 |
program independently at the same time—in fact, the \f(CW\*(C`fork\*(C'\fR function is |
| 2554 |
designed to bring about this happy state of affairs. Under other operating |
| 2555 |
systems, processes are sometimes called “threads”, “tasks”, or “jobs”, |
| 2556 |
often with slight nuances in meaning. |
| 2557 |
.IX Xref "processes, defined" |
| 2558 |
.IP program 4 |
| 2559 |
.IX Item "program" |
| 2560 |
See \fBscript\fR. |
| 2561 |
.IP "program generator" 4 |
| 2562 |
.IX Item "program generator" |
| 2563 |
A system that algorithmically writes code for you in a |
| 2564 |
high-level language. See also \fBcode generator\fR. |
| 2565 |
.IX Xref "program generators" |
| 2566 |
.IP "progressive matching" 4 |
| 2567 |
.IX Item "progressive matching" |
| 2568 |
\&\fBPattern matching\fR matching>that picks up where it left off before. |
| 2569 |
.IX Xref "progressive matching pattern matching, progressive matching" |
| 2570 |
.IP property 4 |
| 2571 |
.IX Item "property" |
| 2572 |
See either \fBinstance variable\fR or \fBcharacter property\fR. |
| 2573 |
.IX Xref "property" |
| 2574 |
.IP protocol 4 |
| 2575 |
.IX Item "protocol" |
| 2576 |
In networking, an agreed-upon way of sending messages |
| 2577 |
back and forth so that neither correspondent will get too confused. |
| 2578 |
.IX Xref "protocols (term)" |
| 2579 |
.IP prototype 4 |
| 2580 |
.IX Item "prototype" |
| 2581 |
An optional part of a \fBsubroutine\fR declaration telling |
| 2582 |
the Perl compiler how many and what flavor of arguments may be passed as |
| 2583 |
\&\fBactual arguments\fR, so you can write subroutine calls that parse much like |
| 2584 |
built-in functions. (Or don’t parse, as the case may be.) |
| 2585 |
.IX Xref "prototypes, about" |
| 2586 |
.IP pseudofunction 4 |
| 2587 |
.IX Item "pseudofunction" |
| 2588 |
A construct that sometimes looks like a function but really |
| 2589 |
isn’t. Usually reserved for \fBlvalue\fR modifiers like \f(CW\*(C`my\*(C'\fR, for \fBcontext\fR |
| 2590 |
modifiers like \f(CW\*(C`scalar\*(C'\fR, and for the pick-your-own-quotes constructs, |
| 2591 |
\&\f(CW\*(C`q//\*(C'\fR, \f(CW\*(C`qq//\*(C'\fR, \f(CW\*(C`qx//\*(C'\fR, \f(CW\*(C`qw//\*(C'\fR, \f(CW\*(C`qr//\*(C'\fR, \f(CW\*(C`m//\*(C'\fR, \f(CW\*(C`s///\*(C'\fR, \f(CW\*(C`y///\*(C'\fR, and |
| 2592 |
\&\f(CW\*(C`tr///\*(C'\fR. |
| 2593 |
.IX Xref "pseudofunctions constructs, pseudofunctions functions, pseudofunctions" |
| 2594 |
.IP pseudohash 4 |
| 2595 |
.IX Item "pseudohash" |
| 2596 |
Formerly, a reference to an array |
| 2597 |
whose initial element happens to hold a reference to a hash. You used to be |
| 2598 |
able to treat a pseudohash reference as either an array reference or a hash |
| 2599 |
reference. Pseudohashes are no longer supported. |
| 2600 |
.IX Xref "pseudohashes hashes, pseudohashes" |
| 2601 |
.IP pseudoliteral 4 |
| 2602 |
.IX Item "pseudoliteral" |
| 2603 |
An \fBoperator\fR X\f(CW\*(C`that looks something like a \fR\f(CBliteral\fR\f(CW, |
| 2604 |
such as the output\-grabbing operator, <literal |
| 2605 |
moreinfo="none"\*(C'\fR`>\fR\f(CI\*(C`command\*(C'\fR\fI\fR\f(CW\*(C`\`\*(C'\fR. |
| 2606 |
.IX Xref "pseudoliterals" |
| 2607 |
.IP "public domain" 4 |
| 2608 |
.IX Item "public domain" |
| 2609 |
Something not owned by anybody. Perl is copyrighted and is |
| 2610 |
thus \fInot\fR in the public domain—it’s just \fBfreely available\fR and \fBfreely |
| 2611 |
redistributable\fR. |
| 2612 |
.IX Xref "public domain" |
| 2613 |
.IP pumpkin 4 |
| 2614 |
.IX Item "pumpkin" |
| 2615 |
A notional “baton” handed around the Perl community |
| 2616 |
indicating who is the lead integrator in some arena of development. |
| 2617 |
.IX Xref "pumpkin (term)" |
| 2618 |
.IP pumpking 4 |
| 2619 |
.IX Item "pumpking" |
| 2620 |
A \fBpumpkin\fR holder, the person in charge of pumping the pump, |
| 2621 |
or at least priming it. Must be willing to play the part of the Great |
| 2622 |
Pumpkin now and then. |
| 2623 |
.IX Xref "pumpking" |
| 2624 |
.IP PV 4 |
| 2625 |
.IX Item "PV" |
| 2626 |
A “pointer value”, which is Perl |
| 2627 |
Internals Talk for a \f(CW\*(C`char*\*(C'\fR. |
| 2628 |
.IX Xref "PV (pointer value) pointer value (PV)" |
| 2629 |
.SS Q |
| 2630 |
.IX Subsection "Q" |
| 2631 |
.IP qualified 4 |
| 2632 |
.IX Item "qualified" |
| 2633 |
Possessing a complete name. The symbol \f(CW$Ent::moot\fR is |
| 2634 |
qualified; \f(CW$moot\fR is unqualified. A fully qualified filename is specified |
| 2635 |
from the top-level directory. |
| 2636 |
.IX Xref "qualified (term)" |
| 2637 |
.IP quantifier 4 |
| 2638 |
.IX Item "quantifier" |
| 2639 |
A component of a \fBregular expression\fR specifying how |
| 2640 |
many times the foregoing \fBatom\fR may occur. |
| 2641 |
.IX Xref "quantifiers, about" |
| 2642 |
.SS R |
| 2643 |
.IX Subsection "R" |
| 2644 |
.IP "race condition" 4 |
| 2645 |
.IX Item "race condition" |
| 2646 |
A race condition exists when the result of |
| 2647 |
several interrelated events depends on the ordering of those events, but |
| 2648 |
that order cannot be guaranteed due to nondeterministic timing effects. If |
| 2649 |
two or more programs, or parts of the same program, try to go through the |
| 2650 |
same series of events, one might interrupt the work of the other. This is a |
| 2651 |
good way to find an \fBexploit\fR. |
| 2652 |
.IX Xref "race conditions, defined" |
| 2653 |
.IP readable 4 |
| 2654 |
.IX Item "readable" |
| 2655 |
With respect to files, one that has the proper permission |
| 2656 |
bit set to let you access the file. With respect to computer programs, one |
| 2657 |
that’s written well enough that someone has a chance of figuring out what |
| 2658 |
it’s trying to do. |
| 2659 |
.IX Xref "readable (term)" |
| 2660 |
.IP reaping 4 |
| 2661 |
.IX Item "reaping" |
| 2662 |
The last rites performed by a parent \fBprocess\fR |
| 2663 |
on behalf of a deceased child process so that it doesn’t remain a |
| 2664 |
\&\fBzombie\fR. See the \f(CW\*(C`wait\*(C'\fR and \f(CW\*(C`waitpid\*(C'\fR function calls. |
| 2665 |
.IX Xref "reaping zombie processes" |
| 2666 |
.IP record 4 |
| 2667 |
.IX Item "record" |
| 2668 |
A set of related data values in a \fBfile\fR or \fBstream\fR, |
| 2669 |
often associated with a unique \fBkey\fR field. In Unix, often commensurate |
| 2670 |
with a \fBline\fR, or a blank\-line–terminated set of lines (a “paragraph”). |
| 2671 |
Each line of the \fI/etc/passwd\fR file is a record, keyed on login name, |
| 2672 |
containing information about that user. |
| 2673 |
.IX Xref "records, defined" |
| 2674 |
.IP recursion 4 |
| 2675 |
.IX Item "recursion" |
| 2676 |
The art of defining something (at least partly) in |
| 2677 |
terms of itself, which is a naughty no-no in dictionaries but often works |
| 2678 |
out okay in computer programs if you’re careful not to recurse forever |
| 2679 |
(which is like an infinite loop with more spectacular failure modes). |
| 2680 |
.IX Xref "recursion, defined" |
| 2681 |
.IP reference 4 |
| 2682 |
.IX Item "reference" |
| 2683 |
Where you look to find a pointer to information |
| 2684 |
somewhere else. (See \fBindirection\fR.) References come in two flavors: |
| 2685 |
\&\fBsymbolic references\fR and \fBhard references\fR. |
| 2686 |
.IX Xref "references, about" |
| 2687 |
.IP referent 4 |
| 2688 |
.IX Item "referent" |
| 2689 |
Whatever a reference refers to, which may or may not |
| 2690 |
have a name. Common types of referents include scalars, arrays, hashes, and |
| 2691 |
subroutines. |
| 2692 |
.IX Xref "referents, defined" |
| 2693 |
.IP regex 4 |
| 2694 |
.IX Item "regex" |
| 2695 |
See \fBregular expression\fR. |
| 2696 |
.IP "regular expression" 4 |
| 2697 |
.IX Item "regular expression" |
| 2698 |
A single entity with various |
| 2699 |
interpretations, like an elephant. To a computer scientist, it’s a grammar |
| 2700 |
for a little language in which some strings are legal and others aren’t. To |
| 2701 |
normal people, it’s a pattern you can use to find what you’re looking for |
| 2702 |
when it varies from case to case. Perl’s regular expressions are far from |
| 2703 |
regular in the theoretical sense, but in regular use they work quite well. |
| 2704 |
Here’s a regular expression: \f(CW\*(C`/Oh s.*t./\*(C'\fR. This will match strings like |
| 2705 |
“\f(CW\*(C`Oh say can you see by the dawn\*(Aqs early light\*(C'\fR” and “\f(CW\*(C`Oh sit!\*(C'\fR”. See |
| 2706 |
Camel chapter 5, “Pattern Matching”. |
| 2707 |
.IX Xref "regular expressions, defined" |
| 2708 |
.IP "regular expression modifier" 4 |
| 2709 |
.IX Item "regular expression modifier" |
| 2710 |
An option on a pattern or substitution, such as \f(CW\*(C`/i\*(C'\fR to render the pattern |
| 2711 |
case\- insensitive. |
| 2712 |
.IX Xref "regular expression modifiers modifiers, regular expression" |
| 2713 |
.IP "regular file" 4 |
| 2714 |
.IX Item "regular file" |
| 2715 |
A \fBfile\fR that’s not a \fBdirectory\fR, a |
| 2716 |
\&\fBdevice\fR, a named \fBpipe\fR or \fBsocket\fR, or a \fBsymbolic link\fR. Perl uses |
| 2717 |
the \f(CW\*(C`–f\*(C'\fR file test operator to identify regular files. Sometimes called a |
| 2718 |
“plain” file. |
| 2719 |
.IX Xref "regular files files, regular" |
| 2720 |
.IP "relational operator" 4 |
| 2721 |
.IX Item "relational operator" |
| 2722 |
An \fBoperator\fR that says whether a particular |
| 2723 |
ordering relationship is \fBtrue\fR about a pair of \fBoperands\fR. Perl has both |
| 2724 |
numeric and string relational operators. See \fBcollating sequence\fR. |
| 2725 |
.IX Xref "relational operators" |
| 2726 |
.IP "reserved words" 4 |
| 2727 |
.IX Item "reserved words" |
| 2728 |
A word with a specific, built-in meaning |
| 2729 |
to a \fBcompiler\fR, such as \f(CW\*(C`if\*(C'\fR or \f(CW\*(C`delete\*(C'\fR. In many languages (not Perl), |
| 2730 |
it’s illegal to use reserved words to name anything else. (Which is why |
| 2731 |
they’re reserved, after all.) In Perl, you just can’t use them to name |
| 2732 |
\&\fBlabels\fR or \fBfilehandles\fR. Also called “keywords”. |
| 2733 |
.IX Xref "reserved words keywords (term)" |
| 2734 |
.IP "return value" 4 |
| 2735 |
.IX Item "return value" |
| 2736 |
The \fBvalue\fR produced by a \fBsubroutine\fR |
| 2737 |
or \fBexpression\fR when evaluated. In Perl, a return value may be either a |
| 2738 |
\&\fBlist\fR or a \fBscalar\fR. |
| 2739 |
.IX Xref "return values values, return" |
| 2740 |
.IP RFC 4 |
| 2741 |
.IX Item "RFC" |
| 2742 |
Request For Comment, which despite the timid connotations is the name of a series of |
| 2743 |
important standards documents. |
| 2744 |
.IX Xref "Request For Comment (RFC) RFC (Request For Comment)" |
| 2745 |
.IP "right shift" 4 |
| 2746 |
.IX Item "right shift" |
| 2747 |
A \fBbit shift\fR that divides |
| 2748 |
a number by some power of 2. |
| 2749 |
.IX Xref "right shift (>>) bit operator bit–shift operators, right shift >> (right shift) bit operator" |
| 2750 |
.IP role 4 |
| 2751 |
.IX Item "role" |
| 2752 |
A name for a concrete set of behaviors. A role is a way to |
| 2753 |
add behavior to a class without inheritance. |
| 2754 |
.IX Xref "roles (term)" |
| 2755 |
.IP root 4 |
| 2756 |
.IX Item "root" |
| 2757 |
The superuser (\f(CW\*(C`UID\*(C'\fR == 0). Also the top-level directory of |
| 2758 |
the filesystem. |
| 2759 |
.IX Xref "root (term)" |
| 2760 |
.IP RTFM 4 |
| 2761 |
.IX Item "RTFM" |
| 2762 |
What you are told when someone thinks you should Read The |
| 2763 |
Fine Manual. |
| 2764 |
.IX Xref "RTFM acronym" |
| 2765 |
.IP "run phase" 4 |
| 2766 |
.IX Item "run phase" |
| 2767 |
Any time after Perl starts running your main program. |
| 2768 |
See also \fBcompile phase\fR. Run phase is mostly spent in \fBruntime\fR but may |
| 2769 |
also be spent in \fBcompile time\fR when \f(CW\*(C`require\*(C'\fR, \f(CW\*(C`do\*(C'\fR \fR\f(CI\*(C`FILE\*(C'\fR\fI\fR, or |
| 2770 |
\&\f(CW\*(C`eval\*(C'\fR \fI\fR\f(CI\*(C`STRING\*(C'\fR\fI\fR operators are executed, or when a substitution uses |
| 2771 |
the \f(CW\*(C`/ee\*(C'\fR modifier. |
| 2772 |
.IX Xref "run phase, defined" |
| 2773 |
.IP runtime 4 |
| 2774 |
.IX Item "runtime" |
| 2775 |
The time when Perl is actually doing what your |
| 2776 |
code says to do, as opposed to the earlier period of time when it was |
| 2777 |
trying to figure out whether what you said made any sense whatsoever, which |
| 2778 |
is \fBcompile time\fR. |
| 2779 |
.IX Xref "runtime (term), defined" |
| 2780 |
.IP "runtime pattern" 4 |
| 2781 |
.IX Item "runtime pattern" |
| 2782 |
A pattern that contains one or more |
| 2783 |
variables to be interpolated before parsing the pattern as a \fBregular |
| 2784 |
expression\fR, and that therefore cannot be analyzed at compile time, but |
| 2785 |
must be reanalyzed each time the pattern match operator is evaluated. |
| 2786 |
Runtime patterns are useful but expensive. |
| 2787 |
.IX Xref "runtime patterns patterns, runtime" |
| 2788 |
.IP RV 4 |
| 2789 |
.IX Item "RV" |
| 2790 |
A recreational vehicle, not |
| 2791 |
to be confused with vehicular recreation. RV also means an internal |
| 2792 |
Reference Value of the type a \fBscalar\fR can hold. See also \fBIV\fR and \fBNV\fR |
| 2793 |
if you’re not confused yet. |
| 2794 |
.IX Xref "Reference Value (RV) RV (Reference Value)" |
| 2795 |
.IP rvalue 4 |
| 2796 |
.IX Item "rvalue" |
| 2797 |
A \fBvalue\fR that you might find on the |
| 2798 |
right side of an \fBassignment\fR. See also \fBlvalue\fR. |
| 2799 |
.IX Xref "rvalue (term) values, rvalue" |
| 2800 |
.SS S |
| 2801 |
.IX Subsection "S" |
| 2802 |
.IP sandbox 4 |
| 2803 |
.IX Item "sandbox" |
| 2804 |
A walled off area that’s not supposed to affect beyond |
| 2805 |
its walls. You let kids play in the sandbox instead of running in the road. |
| 2806 |
See Camel chapter 20, “Security”. |
| 2807 |
.IX Xref "sandbox, defined" |
| 2808 |
.IP scalar 4 |
| 2809 |
.IX Item "scalar" |
| 2810 |
A simple, singular value; a number, \fBstring\fR, or |
| 2811 |
\&\fBreference\fR. |
| 2812 |
.IX Xref "scalars, defined" |
| 2813 |
.IP "scalar context" 4 |
| 2814 |
.IX Item "scalar context" |
| 2815 |
The situation in which an |
| 2816 |
\&\fBexpression\fR is expected by its surroundings (the code calling it) to |
| 2817 |
return a single \fBvalue\fR rather than a \fBlist\fR of values. See also |
| 2818 |
\&\fBcontext\fR and \fBlist context\fR. A scalar context sometimes imposes |
| 2819 |
additional constraints on the return value—see \fBstring context\fR and |
| 2820 |
\&\fBnumeric context\fR. Sometimes we talk about a \fBBoolean context\fR inside |
| 2821 |
conditionals, but this imposes no additional constraints, since any scalar |
| 2822 |
value, whether numeric or \fBstring\fR, is already true or false. |
| 2823 |
.IX Xref "scalar context, about context, scalar" |
| 2824 |
.IP "scalar literal" 4 |
| 2825 |
.IX Item "scalar literal" |
| 2826 |
A number or quoted \fBstring\fR—an actual |
| 2827 |
\&\fBvalue\fR in the text of your program, as opposed to a \fBvariable\fR. |
| 2828 |
.IX Xref "scalar literals literals, scalar" |
| 2829 |
.IP "scalar value" 4 |
| 2830 |
.IX Item "scalar value" |
| 2831 |
A value that happens to be a |
| 2832 |
\&\fBscalar\fR as opposed to a \fBlist\fR. |
| 2833 |
.IX Xref "scalar values, about values, scalar SV" |
| 2834 |
.IP "scalar variable" 4 |
| 2835 |
.IX Item "scalar variable" |
| 2836 |
A \fBvariable\fR prefixed with |
| 2837 |
\&\f(CW\*(C`$\*(C'\fR that holds a single value. |
| 2838 |
.IX Xref "scalar variables, defined variables, scalar" |
| 2839 |
.IP scope 4 |
| 2840 |
.IX Item "scope" |
| 2841 |
From how far away you can see a variable, looking through |
| 2842 |
one. Perl has two visibility mechanisms. It does \fBdynamic scoping\fR of |
| 2843 |
\&\f(CW\*(C`local\*(C'\fR \fBvariables\fR, meaning that the rest of the \fBblock\fR, and any |
| 2844 |
\&\fBsubroutines\fR that are called by the rest of the block, can see the |
| 2845 |
variables that are local to the block. Perl does \fBlexical scoping\fR of |
| 2846 |
\&\f(CW\*(C`my\*(C'\fR variables, meaning that the rest of the block can see the variable, |
| 2847 |
but other subroutines called by the block \fIcannot\fR see the variable. |
| 2848 |
.IX Xref "scopes, defined" |
| 2849 |
.IP scratchpad 4 |
| 2850 |
.IX Item "scratchpad" |
| 2851 |
The area in which a particular invocation of a particular |
| 2852 |
file or subroutine keeps some of its temporary values, including any |
| 2853 |
lexically scoped variables. |
| 2854 |
.IX Xref "scratchpads" |
| 2855 |
.IP script 4 |
| 2856 |
.IX Item "script" |
| 2857 |
A text \fBfile\fR that is a program |
| 2858 |
intended to be \fBexecuted\fR directly rather than \fBcompiled\fR to another form |
| 2859 |
of file before \fBexecution\fR. |
| 2860 |
.IX Xref "scripts (term) programs, defined" |
| 2861 |
.Sp |
| 2862 |
Also, in the context of \fBUnicode\fR, a writing system for a particular |
| 2863 |
language or group of languages, such as Greek, Bengali, or Tengwar. |
| 2864 |
.IP "script kiddie" 4 |
| 2865 |
.IX Item "script kiddie" |
| 2866 |
A \fBcracker\fR who is not a \fBhacker\fR but knows just enough |
| 2867 |
to run canned scripts. A \fBcargo-cult\fR programmer. |
| 2868 |
.IX Xref "script kiddie" |
| 2869 |
.IP sed 4 |
| 2870 |
.IX Item "sed" |
| 2871 |
A venerable Stream EDitor from |
| 2872 |
which Perl derives some of its ideas. |
| 2873 |
.IX Xref "sed (Stream EDitor) Stream EDitor (sed)" |
| 2874 |
.IP semaphore 4 |
| 2875 |
.IX Item "semaphore" |
| 2876 |
A fancy kind of interlock that prevents multiple \fBthreads\fR or |
| 2877 |
\&\fBprocesses\fR from using up the same resources simultaneously. |
| 2878 |
.IX Xref "semaphore" |
| 2879 |
.IP separator 4 |
| 2880 |
.IX Item "separator" |
| 2881 |
A \fBcharacter\fR or \fBstring\fR that keeps two surrounding strings from being |
| 2882 |
confused with each other. The \f(CW\*(C`split\*(C'\fR function works on separators. Not to be confused with \fBdelimiters\fR |
| 2883 |
or \fBterminators\fR. The “or” in the previous sentence separated the two |
| 2884 |
alternatives. |
| 2885 |
.IX Xref "separators characters, separators strings, separators split function, separators and" |
| 2886 |
.IP serialization 4 |
| 2887 |
.IX Item "serialization" |
| 2888 |
Putting a fancy \fBdata structure\fR into |
| 2889 |
linear order so that it can be stored as a \fBstring\fR in a disk file or |
| 2890 |
database, or sent through a \fBpipe\fR. Also called marshalling. |
| 2891 |
.IX Xref "serialization marshalling (term)" |
| 2892 |
.IP server 4 |
| 2893 |
.IX Item "server" |
| 2894 |
In networking, a \fBprocess\fR that |
| 2895 |
either advertises a \fBservice\fR or just hangs around at a known location and |
| 2896 |
waits for \fBclients\fR who need service to get in touch with it. |
| 2897 |
.IX Xref "servers, defined processes, server" |
| 2898 |
.IP service 4 |
| 2899 |
.IX Item "service" |
| 2900 |
Something you do for someone else to make them happy, |
| 2901 |
like giving them the time of day (or of their life). On some machines, |
| 2902 |
well-known services are listed by the \f(CW\*(C`getservent\*(C'\fR |
| 2903 |
function. |
| 2904 |
.IX Xref "services (term) getservent function" |
| 2905 |
.IP setgid 4 |
| 2906 |
.IX Item "setgid" |
| 2907 |
Same as \fBsetuid\fR, only having to do with giving |
| 2908 |
away \fBgroup\fR privileges. |
| 2909 |
.IX Xref "setgid program, about" |
| 2910 |
.IP setuid 4 |
| 2911 |
.IX Item "setuid" |
| 2912 |
Said of a program that runs with the privileges of |
| 2913 |
its \fBowner\fR rather than (as is usually the case) the privileges of whoever |
| 2914 |
is running it. Also describes the bit in the mode word (\fBpermission bits\fR) |
| 2915 |
that controls the feature. This bit must be explicitly set by the owner to |
| 2916 |
enable this feature, and the program must be carefully written not to give |
| 2917 |
away more privileges than it ought to. |
| 2918 |
.IX Xref "setuid program, about" |
| 2919 |
.IP "shared memory" 4 |
| 2920 |
.IX Item "shared memory" |
| 2921 |
A piece of \fBmemory\fR accessible by two |
| 2922 |
different \fBprocesses\fR who otherwise would not see each other’s memory. |
| 2923 |
.IX Xref "shared memory memory, shared" |
| 2924 |
.IP shebang 4 |
| 2925 |
.IX Item "shebang" |
| 2926 |
Irish for the whole McGillicuddy. In Perl culture, a |
| 2927 |
portmanteau of “sharp” and “bang”, meaning the \f(CW\*(C`#!\*(C'\fR sequence that tells |
| 2928 |
the system where to find the interpreter. |
| 2929 |
.IX Xref "shebang (term)" |
| 2930 |
.IP shell 4 |
| 2931 |
.IX Item "shell" |
| 2932 |
A \fBcommand\fR\-line \fBinterpreter\fR. The program that |
| 2933 |
interactively gives you a prompt, accepts one or more \fBlines\fR of input, |
| 2934 |
and executes the programs you mentioned, feeding each of them their proper |
| 2935 |
\&\fBarguments\fR and input data. Shells can also execute scripts containing |
| 2936 |
such commands. Under Unix, typical shells include the Bourne shell |
| 2937 |
(\fI/bin/sh\fR), the C shell (\fI/bin/csh\fR), and the Korn shell (\fI/bin/ksh\fR). |
| 2938 |
Perl is not strictly a shell because it’s not interactive (although Perl |
| 2939 |
programs can be interactive). |
| 2940 |
.IX Xref "shell program, defined" |
| 2941 |
.IP "side effects" 4 |
| 2942 |
.IX Item "side effects" |
| 2943 |
Something extra that happens when you evaluate an |
| 2944 |
\&\fBexpression\fR. Nowadays it can refer to almost anything. For example, |
| 2945 |
evaluating a simple assignment statement typically has the “side effect” of |
| 2946 |
assigning a value to a variable. (And you thought assigning the value was |
| 2947 |
your primary intent in the first place!) Likewise, assigning a value to the |
| 2948 |
special variable \f(CW$|\fR (\f(CW$AUTOFLUSH\fR) has the side effect of forcing a |
| 2949 |
flush after every \f(CW\*(C`write\*(C'\fR or \f(CW\*(C`print\*(C'\fR on the currently selected |
| 2950 |
filehandle. |
| 2951 |
.IX Xref "side effects" |
| 2952 |
.IP sigil 4 |
| 2953 |
.IX Item "sigil" |
| 2954 |
A glyph used in magic. Or, for Perl, the symbol in front |
| 2955 |
of a variable name, such as \f(CW\*(C`$\*(C'\fR, \f(CW\*(C`@\*(C'\fR, and \f(CW\*(C`%\*(C'\fR. |
| 2956 |
.IX Xref "sigils, defined" |
| 2957 |
.IP signal 4 |
| 2958 |
.IX Item "signal" |
| 2959 |
A bolt out of the blue; that is, an |
| 2960 |
event triggered by the \fBoperating system\fR, probably when you’re least |
| 2961 |
expecting it. |
| 2962 |
.IX Xref "signals and signal handling, about" |
| 2963 |
.IP "signal handler" 4 |
| 2964 |
.IX Item "signal handler" |
| 2965 |
A \fBsubroutine\fR that, instead of being content to be |
| 2966 |
called in the normal fashion, sits around waiting for a bolt out of the |
| 2967 |
blue before it will deign to \fBexecute\fR. Under Perl, bolts out of the blue |
| 2968 |
are called signals, and you send them with the \f(CW\*(C`kill\*(C'\fR built-in. See the |
| 2969 |
\&\f(CW%SIG\fR hash in Camel chapter 25, “Special Names” and the section “Signals” |
| 2970 |
in Camel chapter 15, “Interprocess Communication”. |
| 2971 |
.IX Xref "handlers, signal" |
| 2972 |
.IP "single inheritance" 4 |
| 2973 |
.IX Item "single inheritance" |
| 2974 |
The features you got from your |
| 2975 |
mother, if she told you that you don’t have a father. (See also |
| 2976 |
\&\fBinheritance\fR and \fBmultiple inheritance\fR.) In computer languages, the |
| 2977 |
idea that \fBclasses\fR reproduce asexually so that a given class can only |
| 2978 |
have one direct ancestor or \fBbase class\fR. Perl supplies no such |
| 2979 |
restriction, though you may certainly program Perl that way if you like. |
| 2980 |
.IX Xref "single inheritance inheritance, single" |
| 2981 |
.IP slice 4 |
| 2982 |
.IX Item "slice" |
| 2983 |
A selection of any number of |
| 2984 |
\&\fBelements\fR from a \fBlist\fR, \fBarray\fR, or \fBhash\fR. |
| 2985 |
.IX Xref "slices of elements elements, slices of" |
| 2986 |
.IP slurp 4 |
| 2987 |
.IX Item "slurp" |
| 2988 |
To read an entire \fBfile\fR into a \fBstring\fR in one operation. |
| 2989 |
.IX Xref "slurp (term)" |
| 2990 |
.IP socket 4 |
| 2991 |
.IX Item "socket" |
| 2992 |
An endpoint for network communication among multiple |
| 2993 |
\&\fBprocesses\fR that works much like a telephone or a post office box. The |
| 2994 |
most important thing about a socket is its \fBnetwork address\fR (like a phone |
| 2995 |
number). Different kinds of sockets have different kinds of addresses—some |
| 2996 |
look like filenames, and some don’t. |
| 2997 |
.IX Xref "sockets, defined" |
| 2998 |
.IP "soft reference" 4 |
| 2999 |
.IX Item "soft reference" |
| 3000 |
See \fBsymbolic reference\fR. |
| 3001 |
.IX Xref "soft references references, soft" |
| 3002 |
.IP "source filter" 4 |
| 3003 |
.IX Item "source filter" |
| 3004 |
A special kind of \fBmodule\fR that does |
| 3005 |
\&\fBpreprocessing\fR on your script just before it gets to the \fBtokener\fR. |
| 3006 |
.IX Xref "source filters filters, source" |
| 3007 |
.IP stack 4 |
| 3008 |
.IX Item "stack" |
| 3009 |
A device you can put things on the top of, and later take |
| 3010 |
them back off in the opposite order in which you put them on. See \fBLIFO\fR. |
| 3011 |
.IX Xref "stacks, defined" |
| 3012 |
.IP standard 4 |
| 3013 |
.IX Item "standard" |
| 3014 |
Included in the official Perl distribution, as in a |
| 3015 |
standard module, a standard tool, or a standard Perl \fBmanpage\fR. |
| 3016 |
.IX Xref "standard (term)" |
| 3017 |
.IP "standard error" 4 |
| 3018 |
.IX Item "standard error" |
| 3019 |
The default output \fBstream\fR for nasty remarks that don’t belong in |
| 3020 |
\&\fBstandard output\fR. Represented within a Perl program by the output> \fBfilehandle\fR \f(CW\*(C`STDERR\*(C'\fR. You can use this |
| 3021 |
stream explicitly, but the \f(CW\*(C`die\*(C'\fR and \f(CW\*(C`warn\*(C'\fR built-ins write to your |
| 3022 |
standard error stream automatically (unless trapped or otherwise |
| 3023 |
intercepted). |
| 3024 |
.IX Xref "STDERR filehandle, about" |
| 3025 |
.IP "standard input" 4 |
| 3026 |
.IX Item "standard input" |
| 3027 |
The default input \fBstream\fR for your program, |
| 3028 |
which if possible shouldn’t care where its data is coming from. Represented |
| 3029 |
within a Perl program by the \fBfilehandle\fR \f(CW\*(C`STDIN\*(C'\fR. |
| 3030 |
.IX Xref "STDIN filehandle, about" |
| 3031 |
.IP "standard I/O" 4 |
| 3032 |
.IX Item "standard I/O" |
| 3033 |
A standard C library for doing \fBbuffered\fR input |
| 3034 |
and output to the \fBoperating system\fR. (The “standard” of standard I/O is |
| 3035 |
at most marginally related to the “standard” of standard input and output.) |
| 3036 |
In general, Perl relies on whatever implementation of standard I/O a given |
| 3037 |
operating system supplies, so the buffering characteristics of a Perl |
| 3038 |
program on one machine may not exactly match those on another machine. |
| 3039 |
Normally this only influences efficiency, not semantics. If your standard |
| 3040 |
I/O package is doing block buffering and you want it to \fBflush\fR the buffer |
| 3041 |
more often, just set the \f(CW$|\fR variable to a true value. |
| 3042 |
.IX Xref "standard I O I O (Input Output), standard Input Output (I O), standard STDIO filehandle" |
| 3043 |
.IP "Standard Library" 4 |
| 3044 |
.IX Item "Standard Library" |
| 3045 |
Everything that comes with the official |
| 3046 |
\&\fIperl\fR distribution. Some vendor versions of \fIperl\fR change their |
| 3047 |
distributions, leaving out some parts or including extras. See also |
| 3048 |
\&\fBdual-lived\fR. |
| 3049 |
.IX Xref "Standard Perl Library, about" |
| 3050 |
.IP "standard output" 4 |
| 3051 |
.IX Item "standard output" |
| 3052 |
The default output \fBstream\fR for your program, |
| 3053 |
which if possible shouldn’t care where its data is going. Represented |
| 3054 |
within a Perl program by the \fBfilehandle\fR \f(CW\*(C`STDOUT\*(C'\fR. |
| 3055 |
.IX Xref "STDOUT filehandle, about" |
| 3056 |
.IP statement 4 |
| 3057 |
.IX Item "statement" |
| 3058 |
A \fBcommand\fR to the computer about what to do next, |
| 3059 |
like a step in a recipe: “Add marmalade to batter and mix until mixed.” A |
| 3060 |
statement is distinguished from a \fBdeclaration\fR, which doesn’t tell the |
| 3061 |
computer to do anything, but just to learn something. |
| 3062 |
.IX Xref "statements, about" |
| 3063 |
.IP "statement modifier" 4 |
| 3064 |
.IX Item "statement modifier" |
| 3065 |
A \fBconditional\fR or |
| 3066 |
\&\fBloop\fR that you put after the \fBstatement\fR instead of before, if you know |
| 3067 |
what we mean. |
| 3068 |
.IX Xref "statement modifiers, about modifiers, statement" |
| 3069 |
.IP static 4 |
| 3070 |
.IX Item "static" |
| 3071 |
Varying slowly compared to something else. (Unfortunately, |
| 3072 |
everything is relatively stable compared to something else, except for |
| 3073 |
certain elementary particles, and we’re not so sure about them.) In |
| 3074 |
computers, where things are supposed to vary rapidly, “static” has a |
| 3075 |
derogatory connotation, indicating a slightly dysfunctional \fBvariable\fR, |
| 3076 |
\&\fBsubroutine\fR, or \fBmethod\fR. In Perl culture, the word is politely avoided. |
| 3077 |
.IX Xref "static (term)" |
| 3078 |
.Sp |
| 3079 |
If you’re a C or C++ programmer, you might be looking for Perl’s \f(CW\*(C`state\*(C'\fR |
| 3080 |
keyword. |
| 3081 |
.IP "static method" 4 |
| 3082 |
.IX Item "static method" |
| 3083 |
No such thing. See \fBclass method\fR. |
| 3084 |
.IX Xref "static methods methods, static" |
| 3085 |
.IP "static scoping" 4 |
| 3086 |
.IX Item "static scoping" |
| 3087 |
No such thing. See \fBlexical scoping\fR. |
| 3088 |
.IP "static variable" 4 |
| 3089 |
.IX Item "static variable" |
| 3090 |
No such thing. Just use a \fBlexical |
| 3091 |
variable\fR in a scope larger than your \fBsubroutine\fR, or declare it with |
| 3092 |
\&\f(CW\*(C`state\*(C'\fR instead of with \f(CW\*(C`my\*(C'\fR. |
| 3093 |
.IX Xref "static variables variables, static" |
| 3094 |
.IP "stat structure" 4 |
| 3095 |
.IX Item "stat structure" |
| 3096 |
A special internal spot |
| 3097 |
in which Perl keeps the information about the last \fBfile\fR on which you |
| 3098 |
requested information. |
| 3099 |
.IX Xref "stat structure data structures, stat structure" |
| 3100 |
.IP status 4 |
| 3101 |
.IX Item "status" |
| 3102 |
The \fBvalue\fR returned to the |
| 3103 |
parent \fBprocess\fR when one of its child processes dies. This value is |
| 3104 |
placed in the special variable \f(CW$?\fR. Its upper eight \fBbits\fR are the exit |
| 3105 |
status of the defunct process, and its lower eight bits identify the signal |
| 3106 |
(if any) that the process died from. On Unix systems, this status value is |
| 3107 |
the same as the status word returned by \fIwait\fR(2). See \f(CW\*(C`system\*(C'\fR in Camel |
| 3108 |
chapter 27, “Functions”. |
| 3109 |
.IX Xref "status value values, status exit status" |
| 3110 |
.IP STDERR 4 |
| 3111 |
.IX Item "STDERR" |
| 3112 |
See \fBstandard error\fR. |
| 3113 |
.IP STDIN 4 |
| 3114 |
.IX Item "STDIN" |
| 3115 |
See \fBstandard input\fR. |
| 3116 |
.IP STDIO 4 |
| 3117 |
.IX Item "STDIO" |
| 3118 |
See \fBstandard I/O\fR. |
| 3119 |
.IP STDOUT 4 |
| 3120 |
.IX Item "STDOUT" |
| 3121 |
See \fBstandard output\fR. |
| 3122 |
.IP stream 4 |
| 3123 |
.IX Item "stream" |
| 3124 |
A flow of data into or out of |
| 3125 |
a process as a steady sequence of bytes or characters, without the |
| 3126 |
appearance of being broken up into packets. This is a kind of |
| 3127 |
\&\fBinterface\fR—the underlying \fBimplementation\fR may well break your data up |
| 3128 |
into separate packets for delivery, but this is hidden from you. |
| 3129 |
.IX Xref "streaming data processes, streaming data" |
| 3130 |
.IP string 4 |
| 3131 |
.IX Item "string" |
| 3132 |
A sequence of characters such as “He said !@#*&%@#*?!”. |
| 3133 |
A string does not have to be entirely printable. |
| 3134 |
.IX Xref "strings, defined" |
| 3135 |
.IP "string context" 4 |
| 3136 |
.IX Item "string context" |
| 3137 |
The situation in which an expression is |
| 3138 |
expected by its surroundings (the code calling it) to return a \fBstring\fR. |
| 3139 |
See also \fBcontext\fR and \fBnumeric context\fR. |
| 3140 |
.IX Xref "string context context, string" |
| 3141 |
.IP stringification 4 |
| 3142 |
.IX Item "stringification" |
| 3143 |
The process of producing a \fBstring\fR representation of an |
| 3144 |
abstract object. |
| 3145 |
.IX Xref "stringification" |
| 3146 |
.IP struct 4 |
| 3147 |
.IX Item "struct" |
| 3148 |
C keyword introducing a structure definition or name. |
| 3149 |
.IX Xref "struct keyword" |
| 3150 |
.IP structure 4 |
| 3151 |
.IX Item "structure" |
| 3152 |
See \fBdata structure\fR. |
| 3153 |
.IX Xref "structures" |
| 3154 |
.IP subclass 4 |
| 3155 |
.IX Item "subclass" |
| 3156 |
See \fBderived class\fR. |
| 3157 |
.IP subpattern 4 |
| 3158 |
.IX Item "subpattern" |
| 3159 |
A component of a \fBregular expression\fR pattern. |
| 3160 |
.IX Xref "subpatterns, defined" |
| 3161 |
.IP subroutine 4 |
| 3162 |
.IX Item "subroutine" |
| 3163 |
A named or otherwise accessible piece of program |
| 3164 |
that can be invoked from elsewhere in the program in order to accomplish |
| 3165 |
some subgoal of the program. A subroutine is often parameterized to |
| 3166 |
accomplish different but related things depending on its input |
| 3167 |
\&\fBarguments\fR. If the subroutine returns a meaningful \fBvalue\fR, it is also |
| 3168 |
called a \fBfunction\fR. |
| 3169 |
.IX Xref "subroutines, defined" |
| 3170 |
.IP subscript 4 |
| 3171 |
.IX Item "subscript" |
| 3172 |
A \fBvalue\fR that indicates the position of a particular |
| 3173 |
\&\fBarray\fR \fBelement\fR in an array. |
| 3174 |
.IX Xref "subscripts" |
| 3175 |
.IP substitution 4 |
| 3176 |
.IX Item "substitution" |
| 3177 |
Changing parts of a string via the \f(CW\*(C`s///\*(C'\fR |
| 3178 |
operator. (We avoid use of this term to mean \fBvariable interpolation\fR.) |
| 3179 |
.IX Xref "substitution (s ) operator, about strings, substitution in s (substitution) operator, about" |
| 3180 |
.IP substring 4 |
| 3181 |
.IX Item "substring" |
| 3182 |
A portion of a \fBstring\fR, starting at a certain |
| 3183 |
\&\fBcharacter\fR position (\fBoffset\fR) and proceeding for a certain number of |
| 3184 |
characters. |
| 3185 |
.IX Xref "substrings (term)" |
| 3186 |
.IP superclass 4 |
| 3187 |
.IX Item "superclass" |
| 3188 |
See \fBbase class\fR. |
| 3189 |
.IP superuser 4 |
| 3190 |
.IX Item "superuser" |
| 3191 |
The person whom the \fBoperating system\fR will let do almost |
| 3192 |
anything. Typically your system administrator or someone pretending to be |
| 3193 |
your system administrator. On Unix systems, the \fBroot\fR user. On Windows |
| 3194 |
systems, usually the Administrator user. |
| 3195 |
.IX Xref "superusers" |
| 3196 |
.IP SV 4 |
| 3197 |
.IX Item "SV" |
| 3198 |
Short for “scalar value”. But |
| 3199 |
within the Perl interpreter, every \fBreferent\fR is treated as a member of a |
| 3200 |
class derived from SV, in an object-oriented sort of way. Every \fBvalue\fR |
| 3201 |
inside Perl is passed around as a C language \f(CW\*(C`SV*\*(C'\fR pointer. The SV |
| 3202 |
\&\fBstruct\fR knows its own “referent type”, and the code is smart enough (we |
| 3203 |
hope) not to try to call a \fBhash\fR function on a \fBsubroutine\fR. |
| 3204 |
.IX Xref "scalar values, about values, scalar" |
| 3205 |
.IP switch 4 |
| 3206 |
.IX Item "switch" |
| 3207 |
An option you give on a command line to |
| 3208 |
influence the way your program works, usually introduced with a minus sign. |
| 3209 |
The word is also used as a nickname for a \fBswitch statement\fR. |
| 3210 |
.IX Xref "switches, about switches" |
| 3211 |
.IP "switch cluster" 4 |
| 3212 |
.IX Item "switch cluster" |
| 3213 |
The combination of multiple command\- |
| 3214 |
line switches (\fIe.g.\fR, \f(CW\*(C`–a –b –c\*(C'\fR) into one switch (\fIe.g.\fR, \f(CW\*(C`–abc\*(C'\fR). |
| 3215 |
Any switch with an additional \fBargument\fR must be the last switch in a |
| 3216 |
cluster. |
| 3217 |
.IX Xref "switch clusters clusters, switch" |
| 3218 |
.IP "switch statement" 4 |
| 3219 |
.IX Item "switch statement" |
| 3220 |
A program technique that lets you |
| 3221 |
evaluate an \fBexpression\fR and then, based on the value of the expression, |
| 3222 |
do a multiway branch to the appropriate piece of code for that value. Also |
| 3223 |
called a “case structure”, named after the similar Pascal construct. Most |
| 3224 |
switch statements in Perl are spelled \f(CW\*(C`given\*(C'\fR. See “The \f(CW\*(C`given\*(C'\fR |
| 3225 |
statement” in Camel chapter 4, “Statements and Declarations”. |
| 3226 |
.IX Xref "switch statement statements, switch" |
| 3227 |
.Sp |
| 3228 |
The \f(CW\*(C`given\*(C'\fR, \f(CW\*(C`when\*(C'\fR keywords and the smartmatch (\f(CW\*(C`~~\*(C'\fR) operator will |
| 3229 |
be removed in Perl 5.42. |
| 3230 |
.IP symbol 4 |
| 3231 |
.IX Item "symbol" |
| 3232 |
Generally, any \fBtoken\fR or \fBmetasymbol\fR. Often used |
| 3233 |
more specifically to mean the sort of name you might find in a \fBsymbol |
| 3234 |
table\fR. |
| 3235 |
.IX Xref "symbols symbols" |
| 3236 |
.IP "symbolic debugger" 4 |
| 3237 |
.IX Item "symbolic debugger" |
| 3238 |
A program that lets you step through |
| 3239 |
the \fBexecution\fR of your program, stopping or printing things out here and |
| 3240 |
there to see whether anything has gone wrong, and, if so, what. The |
| 3241 |
“symbolic” part just means that you can talk to the debugger using the same |
| 3242 |
symbols with which your program is written. |
| 3243 |
.IX Xref "symbolic debugger debugger, about" |
| 3244 |
.IP "symbolic link" 4 |
| 3245 |
.IX Item "symbolic link" |
| 3246 |
An alternate filename that points to the |
| 3247 |
real \fBfilename\fR, which in turn points to the real \fBfile\fR. Whenever the |
| 3248 |
\&\fBoperating system\fR is trying to parse a \fBpathname\fR containing a symbolic |
| 3249 |
link, it merely substitutes the new name and continues parsing. |
| 3250 |
.IX Xref "symbolic links links, symbolic" |
| 3251 |
.IP "symbolic reference" 4 |
| 3252 |
.IX Item "symbolic reference" |
| 3253 |
A variable whose value is the |
| 3254 |
name of another variable or subroutine. By \fBdereferencing\fR the first |
| 3255 |
variable, you can get at the second one. Symbolic references are illegal |
| 3256 |
under \f(CW\*(C`use strict "refs"\*(C'\fR. |
| 3257 |
.IX Xref "symbolic references references, symbolic" |
| 3258 |
.IP "symbol table" 4 |
| 3259 |
.IX Item "symbol table" |
| 3260 |
Where a \fBcompiler\fR remembers symbols. A program |
| 3261 |
like Perl must somehow remember all the names of all the \fBvariables\fR, |
| 3262 |
\&\fBfilehandles\fR, and \fBsubroutines\fR you’ve used. It does this by placing the |
| 3263 |
names in a symbol table, which is implemented in Perl using a \fBhash |
| 3264 |
table\fR. There is a separate symbol table for each \fBpackage\fR to give each |
| 3265 |
package its own \fBnamespace\fR. |
| 3266 |
.IX Xref "symbol tables, about" |
| 3267 |
.IP synchronous 4 |
| 3268 |
.IX Item "synchronous" |
| 3269 |
Programming in which the orderly sequence of events |
| 3270 |
can be determined; that is, when things happen one after the other, not at |
| 3271 |
the same time. |
| 3272 |
.IX Xref "synchronous (term)" |
| 3273 |
.IP "syntactic sugar" 4 |
| 3274 |
.IX Item "syntactic sugar" |
| 3275 |
An alternative way of writing something more easily; a |
| 3276 |
shortcut. |
| 3277 |
.IX Xref "syntactic sugar" |
| 3278 |
.IP syntax 4 |
| 3279 |
.IX Item "syntax" |
| 3280 |
From Greek σύνταξις, “with\-arrangement”. How things |
| 3281 |
(particularly symbols) are put together with each other. |
| 3282 |
.IX Xref "syntax, about" |
| 3283 |
.IP "syntax tree" 4 |
| 3284 |
.IX Item "syntax tree" |
| 3285 |
An internal representation of your program wherein |
| 3286 |
lower-level \fBconstructs\fR dangle off the higher-level constructs enclosing |
| 3287 |
them. |
| 3288 |
.IX Xref "syntax tree" |
| 3289 |
.IP syscall 4 |
| 3290 |
.IX Item "syscall" |
| 3291 |
A \fBfunction\fR call directly to the \fBoperating |
| 3292 |
system\fR. Many of the important subroutines and functions you use aren’t |
| 3293 |
direct system calls, but are built up in one or more layers above the |
| 3294 |
system call level. In general, Perl programmers don’t need to worry about |
| 3295 |
the distinction. However, if you do happen to know which Perl functions are |
| 3296 |
really syscalls, you can predict which of these will set the \f(CW$!\fR |
| 3297 |
(\f(CW$ERRNO\fR) variable on failure. Unfortunately, beginning programmers often |
| 3298 |
confusingly employ the term “system call” to mean what happens when you |
| 3299 |
call the Perl \f(CW\*(C`system\*(C'\fR function, which actually involves many syscalls. To |
| 3300 |
avoid any confusion, we nearly always say “syscall” for something you could |
| 3301 |
call indirectly via Perl’s \f(CW\*(C`syscall\*(C'\fR function, and never for something you |
| 3302 |
would call with Perl’s \f(CW\*(C`system\*(C'\fR function. |
| 3303 |
.IX Xref "syscall function, about" |
| 3304 |
.SS T |
| 3305 |
.IX Subsection "T" |
| 3306 |
.IP "taint checks" 4 |
| 3307 |
.IX Item "taint checks" |
| 3308 |
The special bookkeeping Perl does to track the flow |
| 3309 |
of external data through your program and disallow their use in system |
| 3310 |
commands. |
| 3311 |
.IX Xref "taint checks, about" |
| 3312 |
.IP tainted 4 |
| 3313 |
.IX Item "tainted" |
| 3314 |
Said of data derived from the grubby hands of a user, |
| 3315 |
and thus unsafe for a secure program to rely on. Perl does taint checks if |
| 3316 |
you run a \fBsetuid\fR (or \fBsetgid\fR) program, or if you use the \f(CW\*(C`–T\*(C'\fR switch. |
| 3317 |
.IX Xref "tainted data, about" |
| 3318 |
.IP "taint mode" 4 |
| 3319 |
.IX Item "taint mode" |
| 3320 |
Running under the \f(CW\*(C`–T\*(C'\fR switch, marking all external data as |
| 3321 |
suspect and refusing to use it with system commands. See Camel chapter 20, |
| 3322 |
“Security”. |
| 3323 |
.IX Xref "taint mode" |
| 3324 |
.IP TCP 4 |
| 3325 |
.IX Item "TCP" |
| 3326 |
Short for Transmission Control Protocol. A protocol wrapped around the |
| 3327 |
Internet Protocol to make an unreliable packet transmission mechanism |
| 3328 |
appear to the application program to be a reliable \fBstream\fR of bytes. |
| 3329 |
(Usually.) |
| 3330 |
.IX Xref "TCP (Transmission Control Protocol) Transmission Control Protocol (TCP)" |
| 3331 |
.IP term 4 |
| 3332 |
.IX Item "term" |
| 3333 |
Short for a “terminal”—that is, a leaf node of a \fBsyntax |
| 3334 |
tree\fR. A thing that functions grammatically as an \fBoperand\fR for the |
| 3335 |
operators in an expression. |
| 3336 |
.IX Xref "terms, defined" |
| 3337 |
.IP terminator 4 |
| 3338 |
.IX Item "terminator" |
| 3339 |
A \fBcharacter\fR or \fBstring\fR that marks the end of another string. The \f(CW$/\fR |
| 3340 |
variable contains the string that terminates a \f(CW\*(C`readline\*(C'\fR operation, which |
| 3341 |
\&\f(CW\*(C`chomp\*(C'\fR deletes from the end. Not to be confused with \fBdelimiters\fR or |
| 3342 |
\&\fBseparators\fR. The period at the end of this sentence is a terminator. |
| 3343 |
.IX Xref "terminators (term) characters, terminators strings, terminators in" |
| 3344 |
.IP ternary 4 |
| 3345 |
.IX Item "ternary" |
| 3346 |
An \fBoperator\fR taking three \fBoperands\fR. Sometimes |
| 3347 |
pronounced \fBtrinary\fR. |
| 3348 |
.IX Xref "ternary operators" |
| 3349 |
.IP text 4 |
| 3350 |
.IX Item "text" |
| 3351 |
A \fBstring\fR or \fBfile\fR containing primarily printable characters. |
| 3352 |
.IX Xref "text, defined strings, text files, text text" |
| 3353 |
.IP thread 4 |
| 3354 |
.IX Item "thread" |
| 3355 |
Like a forked process, but without \fBfork\fR’s inherent |
| 3356 |
memory protection. A thread is lighter weight than a full process, in that |
| 3357 |
a process could have multiple threads running around in it, all fighting |
| 3358 |
over the same process’s memory space unless steps are taken to protect |
| 3359 |
threads from one another. |
| 3360 |
.IX Xref "threads (term)" |
| 3361 |
.IP tie 4 |
| 3362 |
.IX Item "tie" |
| 3363 |
The bond between a magical variable and its |
| 3364 |
implementation class. See the \f(CW\*(C`tie\*(C'\fR function in Camel chapter 27, |
| 3365 |
“Functions” and Camel chapter 14, “Tied Variables”. |
| 3366 |
.IX Xref "tied variables, about" |
| 3367 |
.IP titlecase 4 |
| 3368 |
.IX Item "titlecase" |
| 3369 |
The case used for capitals |
| 3370 |
that are followed by lowercase characters instead of by more capitals. |
| 3371 |
Sometimes called sentence case or headline case. English doesn’t use |
| 3372 |
Unicode titlecase, but casing rules for English titles are more complicated |
| 3373 |
than simply capitalizing each word’s first character. |
| 3374 |
.IX Xref "titlecase characters characters, titlecase" |
| 3375 |
.IP TMTOWTDI 4 |
| 3376 |
.IX Item "TMTOWTDI" |
| 3377 |
There’s More Than One Way To Do It, the Perl Motto. The |
| 3378 |
notion that there can be more than one valid path to solving a programming |
| 3379 |
problem in context. (This doesn’t mean that more ways are always better or |
| 3380 |
that all possible paths are equally desirable—just that there need not be |
| 3381 |
One True Way.) |
| 3382 |
.IX Xref "TMTOWTDI acronym" |
| 3383 |
.IP token 4 |
| 3384 |
.IX Item "token" |
| 3385 |
A morpheme in a programming language, the smallest unit |
| 3386 |
of text with semantic significance. |
| 3387 |
.IX Xref "tokens, defined" |
| 3388 |
.IP tokener 4 |
| 3389 |
.IX Item "tokener" |
| 3390 |
A module that breaks a program text into a sequence of |
| 3391 |
\&\fBtokens\fR for later analysis by a parser. |
| 3392 |
.IX Xref "tokeners, defined" |
| 3393 |
.IP tokenizing 4 |
| 3394 |
.IX Item "tokenizing" |
| 3395 |
Splitting up a program text into \fBtokens\fR. Also known as |
| 3396 |
“lexing”, in which case you get “lexemes” instead of tokens. |
| 3397 |
.IX Xref "tokenizing" |
| 3398 |
.IP "toolbox approach" 4 |
| 3399 |
.IX Item "toolbox approach" |
| 3400 |
The notion that, with a complete set of simple tools |
| 3401 |
that work well together, you can build almost anything you want. Which is |
| 3402 |
fine if you’re assembling a tricycle, but if you’re building a |
| 3403 |
defranishizing comboflux regurgalator, you really want your own machine |
| 3404 |
shop in which to build special tools. Perl is sort of a machine shop. |
| 3405 |
.IX Xref "toolbox approach" |
| 3406 |
.IP topic 4 |
| 3407 |
.IX Item "topic" |
| 3408 |
The thing you’re working on. Structures like |
| 3409 |
\&\f(CWwhile(<>)\fR, \f(CW\*(C`for\*(C'\fR, \f(CW\*(C`foreach\*(C'\fR, and \f(CW\*(C`given\*(C'\fR set the topic for |
| 3410 |
you by assigning to \f(CW$_\fR, the default (\fItopic\fR) variable. |
| 3411 |
.IX Xref "topics (term)" |
| 3412 |
.IP transliterate 4 |
| 3413 |
.IX Item "transliterate" |
| 3414 |
To turn one string |
| 3415 |
representation into another by mapping each character of the source string |
| 3416 |
to its corresponding character in the result string. Not to be confused |
| 3417 |
with translation: for example, Greek \fIπολύχρωμος\fR transliterates into |
| 3418 |
\&\fIpolychromos\fR but translates into \fImany-colored\fR. See the \f(CW\*(C`tr///\*(C'\fR |
| 3419 |
operator in Camel chapter 5, “Pattern Matching”. |
| 3420 |
.IX Xref "tr (transliteration) operator, about strings, transliteration of transliteration (tr ) operator, about" |
| 3421 |
.IP trigger 4 |
| 3422 |
.IX Item "trigger" |
| 3423 |
An event that causes a \fBhandler\fR to be run. |
| 3424 |
.IX Xref "triggers (term)" |
| 3425 |
.IP trinary 4 |
| 3426 |
.IX Item "trinary" |
| 3427 |
Not a stellar system with three stars, but an |
| 3428 |
\&\fBoperator\fR taking three \fBoperands\fR. Sometimes pronounced \fBternary\fR. |
| 3429 |
.IX Xref "trinary operators" |
| 3430 |
.IP troff 4 |
| 3431 |
.IX Item "troff" |
| 3432 |
A venerable typesetting language from which Perl derives |
| 3433 |
the name of its \f(CW$%\fR variable and which is secretly used in the production |
| 3434 |
of Camel books. |
| 3435 |
.IX Xref "troff language" |
| 3436 |
.IP true 4 |
| 3437 |
.IX Item "true" |
| 3438 |
Any scalar value that doesn’t evaluate to 0 or |
| 3439 |
\&\f(CW""\fR. |
| 3440 |
.IX Xref "true values values, true" |
| 3441 |
.IP truncating 4 |
| 3442 |
.IX Item "truncating" |
| 3443 |
Emptying a file of existing |
| 3444 |
contents, either automatically when opening a file for writing or |
| 3445 |
explicitly via the \f(CW\*(C`truncate\*(C'\fR function. |
| 3446 |
.IX Xref "truncate function files, truncating" |
| 3447 |
.IP type 4 |
| 3448 |
.IX Item "type" |
| 3449 |
See \fBdata type\fR and \fBclass\fR. |
| 3450 |
.IX Xref "type" |
| 3451 |
.IP "type casting" 4 |
| 3452 |
.IX Item "type casting" |
| 3453 |
Converting data from one type to another. C permits this. |
| 3454 |
Perl does not need it. Nor want it. |
| 3455 |
.IX Xref "type casting" |
| 3456 |
.IP typedef 4 |
| 3457 |
.IX Item "typedef" |
| 3458 |
A type definition in the C and C++ languages. |
| 3459 |
.IX Xref "typedef" |
| 3460 |
.IP "typed lexical" 4 |
| 3461 |
.IX Item "typed lexical" |
| 3462 |
A \fBlexical variable\fR lexical>that is declared with a \fBclass\fR |
| 3463 |
type: \f(CW\*(C`my Pony $bill\*(C'\fR. |
| 3464 |
.IX Xref "typed lexicals lexical variables, typed lexicals variables, variable" |
| 3465 |
.IP typeglob 4 |
| 3466 |
.IX Item "typeglob" |
| 3467 |
Use of a single identifier, prefixed with \f(CW\*(C`*\*(C'\fR. For |
| 3468 |
example, \f(CW*name\fR stands for any or all of \f(CW$name\fR, \f(CW@name\fR, \f(CW%name\fR, |
| 3469 |
\&\f(CW&name\fR, or just \f(CW\*(C`name\*(C'\fR. How you use it determines whether it is |
| 3470 |
interpreted as all or only one of them. See “Typeglobs and Filehandles” in |
| 3471 |
Camel chapter 2, “Bits and Pieces”. |
| 3472 |
.IX Xref "typeglobs, defined" |
| 3473 |
.IP typemap 4 |
| 3474 |
.IX Item "typemap" |
| 3475 |
A description of how C types may be transformed to and from Perl |
| 3476 |
types within an \fBextension\fR module written in \fBXS\fR. |
| 3477 |
.IX Xref "typemap" |
| 3478 |
.SS U |
| 3479 |
.IX Subsection "U" |
| 3480 |
.IP UDP 4 |
| 3481 |
.IX Item "UDP" |
| 3482 |
User Datagram Protocol, the typical way to send |
| 3483 |
\&\fBdatagrams\fR over the Internet. |
| 3484 |
.IX Xref "User Datagram Protocol (UDP) UDP (User Datagram Protocol) datagrams, UDP support" |
| 3485 |
.IP UID 4 |
| 3486 |
.IX Item "UID" |
| 3487 |
A user ID. Often used in the context of |
| 3488 |
\&\fBfile\fR or \fBprocess\fR ownership. |
| 3489 |
.IX Xref "UID (user ID) user ID (UID)" |
| 3490 |
.IP umask 4 |
| 3491 |
.IX Item "umask" |
| 3492 |
A mask of those \fBpermission bits\fR that should be forced |
| 3493 |
off when creating files or directories, in order to establish a policy of |
| 3494 |
whom you’ll ordinarily deny access to. See the \f(CW\*(C`umask\*(C'\fR function. |
| 3495 |
.IX Xref "umask function" |
| 3496 |
.IP "unary operator" 4 |
| 3497 |
.IX Item "unary operator" |
| 3498 |
An operator with only one \fBoperand\fR, like \f(CW\*(C`!\*(C'\fR or |
| 3499 |
\&\f(CW\*(C`chdir\*(C'\fR. Unary operators are usually prefix operators; that is, they |
| 3500 |
precede their operand. The \f(CW\*(C`++\*(C'\fR and \f(CW\*(C`––\*(C'\fR operators can be either prefix |
| 3501 |
or postfix. (Their position \fIdoes\fR change their meanings.) |
| 3502 |
.IX Xref "unary operators, about" |
| 3503 |
.IP Unicode 4 |
| 3504 |
.IX Item "Unicode" |
| 3505 |
A character set comprising all the major character sets of |
| 3506 |
the world, more or less. See <http://www.unicode.org>. |
| 3507 |
.IX Xref "Unicode, about" |
| 3508 |
.IP Unix 4 |
| 3509 |
.IX Item "Unix" |
| 3510 |
A very large and constantly evolving language with several |
| 3511 |
alternative and largely incompatible syntaxes, in which anyone can define |
| 3512 |
anything any way they choose, and usually do. Speakers of this language |
| 3513 |
think it’s easy to learn because it’s so easily twisted to one’s own ends, |
| 3514 |
but dialectical differences make tribal intercommunication nearly |
| 3515 |
impossible, and travelers are often reduced to a pidgin-like subset of the |
| 3516 |
language. To be universally understood, a Unix shell programmer must spend |
| 3517 |
years of study in the art. Many have abandoned this discipline and now |
| 3518 |
communicate via an Esperanto-like language called Perl. |
| 3519 |
.IX Xref "Unix language" |
| 3520 |
.Sp |
| 3521 |
In ancient times, Unix was also used to refer to some code that a couple of |
| 3522 |
people at Bell Labs wrote to make use of a PDP\-7 computer that wasn’t doing |
| 3523 |
much of anything else at the time. |
| 3524 |
.IP uppercase 4 |
| 3525 |
.IX Item "uppercase" |
| 3526 |
In Unicode, not just |
| 3527 |
characters with the General Category of Uppercase Letter, but any character |
| 3528 |
with the Uppercase property, including some Letter Numbers and Symbols. Not |
| 3529 |
to be confused with \fBtitlecase\fR. |
| 3530 |
.IX Xref "uppercase characters characters, uppercase" |
| 3531 |
.IP "UTF\-8 string" 4 |
| 3532 |
.IX Item "UTF-8 string" |
| 3533 |
A "string" whose ordinals represent a valid sequence of UTF\-8 bytes. |
| 3534 |
Sometimes called a "UTF\-8 encoded string". |
| 3535 |
.Sp |
| 3536 |
(\fBIMPORTANT:\fR This is unrelated to Perl’s internal |
| 3537 |
“UTF8 flag”, which only Perl itself |
| 3538 |
should usually care about. UTF\-8 strings may have that flag set or unset.) |
| 3539 |
.SS V |
| 3540 |
.IX Subsection "V" |
| 3541 |
.IP value 4 |
| 3542 |
.IX Item "value" |
| 3543 |
An actual piece of data, in contrast to all the |
| 3544 |
variables, references, keys, indices, operators, and whatnot that you need |
| 3545 |
to access the value. |
| 3546 |
.IX Xref "values, defined" |
| 3547 |
.IP variable 4 |
| 3548 |
.IX Item "variable" |
| 3549 |
A named storage location that can hold any |
| 3550 |
of various kinds of \fBvalue\fR, as your program sees fit. |
| 3551 |
.IX Xref "variables, defined variables" |
| 3552 |
.IP "variable interpolation" 4 |
| 3553 |
.IX Item "variable interpolation" |
| 3554 |
The \fBinterpolation\fR of |
| 3555 |
a scalar or array variable into a string. |
| 3556 |
.IX Xref "variable interpolation interpolation, variable" |
| 3557 |
.IP variadic 4 |
| 3558 |
.IX Item "variadic" |
| 3559 |
Said of a \fBfunction\fR that happily receives an |
| 3560 |
indeterminate number of \fBactual arguments\fR. |
| 3561 |
.IX Xref "variadic (term)" |
| 3562 |
.IP vector 4 |
| 3563 |
.IX Item "vector" |
| 3564 |
Mathematical jargon for a list of \fBscalar values\fR. |
| 3565 |
.IX Xref "vectors" |
| 3566 |
.IP virtual 4 |
| 3567 |
.IX Item "virtual" |
| 3568 |
Providing the appearance of something without the reality, |
| 3569 |
as in: virtual memory is not real memory. (See also \fBmemory\fR.) The |
| 3570 |
opposite of “virtual” is “transparent”, which means providing the reality |
| 3571 |
of something without the appearance, as in: Perl handles the |
| 3572 |
variable-length UTF‑8 character encoding transparently. |
| 3573 |
.IX Xref "virtual (term)" |
| 3574 |
.IP "void context" 4 |
| 3575 |
.IX Item "void context" |
| 3576 |
A form of \fBscalar context\fR in which an |
| 3577 |
\&\fBexpression\fR is not expected to return any \fBvalue\fR at all and is |
| 3578 |
evaluated for its \fBside effects\fR alone. |
| 3579 |
.IX Xref "void context context, void" |
| 3580 |
.IP v\-string 4 |
| 3581 |
.IX Item "v-string" |
| 3582 |
A “version” or “vector” \fBstring\fR |
| 3583 |
specified with a \f(CW\*(C`v\*(C'\fR followed by a series of decimal integers in dot |
| 3584 |
notation, for instance, \f(CW\*(C`v1.20.300.4000\*(C'\fR. Each number turns into a |
| 3585 |
\&\fBcharacter\fR with the specified ordinal value. (The \f(CW\*(C`v\*(C'\fR is optional when |
| 3586 |
there are at least three integers.) |
| 3587 |
.IX Xref "v–strings strings, v–strings" |
| 3588 |
.SS W |
| 3589 |
.IX Subsection "W" |
| 3590 |
.IP warning 4 |
| 3591 |
.IX Item "warning" |
| 3592 |
A message printed to the \f(CW\*(C`STDERR\*(C'\fR stream to the effect that something might be |
| 3593 |
wrong but isn’t worth blowing up over. See \f(CW\*(C`warn\*(C'\fR in Camel chapter 27, |
| 3594 |
“Functions” and the \f(CW\*(C`warnings\*(C'\fR pragma in Camel chapter 28, “Pragmantic |
| 3595 |
Modules”. |
| 3596 |
.IX Xref "warning messages STDERR filehandle, warning messages and" |
| 3597 |
.IP "watch expression" 4 |
| 3598 |
.IX Item "watch expression" |
| 3599 |
An expression which, when its value |
| 3600 |
changes, causes a breakpoint in the Perl debugger. |
| 3601 |
.IX Xref "watch expression expressions, watch" |
| 3602 |
.IP "weak reference" 4 |
| 3603 |
.IX Item "weak reference" |
| 3604 |
A reference that doesn’t get counted |
| 3605 |
normally. When all the normal references to data disappear, the data |
| 3606 |
disappears. These are useful for circular references that would never |
| 3607 |
disappear otherwise. |
| 3608 |
.IX Xref "weak references references, weak" |
| 3609 |
.IP whitespace 4 |
| 3610 |
.IX Item "whitespace" |
| 3611 |
A \fBcharacter\fR that moves |
| 3612 |
your cursor but doesn’t otherwise put anything on your screen. Typically |
| 3613 |
refers to any of: space, tab, line feed, carriage return, or form feed. In |
| 3614 |
Unicode, matches many other characters that Unicode considers whitespace, |
| 3615 |
including the ɴ\-ʙʀ . |
| 3616 |
.IX Xref "whitespace characters characters, whitespace" |
| 3617 |
.IP word 4 |
| 3618 |
.IX Item "word" |
| 3619 |
In normal “computerese”, the piece of data of the size most |
| 3620 |
efficiently handled by your computer, typically 32 bits or so, give or take a |
| 3621 |
few powers of 2. In Perl culture, it more often refers to an alphanumeric |
| 3622 |
\&\fBidentifier\fR (including underscores), or to a string of nonwhitespace |
| 3623 |
\&\fBcharacters\fR bounded by whitespace or string boundaries. |
| 3624 |
.IX Xref "words (term)" |
| 3625 |
.IP "working directory" 4 |
| 3626 |
.IX Item "working directory" |
| 3627 |
Your current \fBdirectory\fR, from |
| 3628 |
which relative pathnames are interpreted by the \fBoperating system\fR. The |
| 3629 |
operating system knows your current directory because you told it with a |
| 3630 |
\&\f(CW\*(C`chdir\*(C'\fR, or because you started out in the place where your parent |
| 3631 |
\&\fBprocess\fR was when you were born. |
| 3632 |
.IX Xref "working directory directories, working" |
| 3633 |
.IP wrapper 4 |
| 3634 |
.IX Item "wrapper" |
| 3635 |
A program or subroutine that runs some other program or |
| 3636 |
subroutine for you, modifying some of its input or output to better suit |
| 3637 |
your purposes. |
| 3638 |
.IX Xref "wrappers (term)" |
| 3639 |
.IP WYSIWYG 4 |
| 3640 |
.IX Item "WYSIWYG" |
| 3641 |
What You See Is What You Get. Usually used when something |
| 3642 |
that appears on the screen matches how it will eventually look, like Perl’s |
| 3643 |
\&\f(CW\*(C`format\*(C'\fR declarations. Also used to mean the opposite of magic because |
| 3644 |
everything works exactly as it appears, as in the three\- argument form of |
| 3645 |
\&\f(CW\*(C`open\*(C'\fR. |
| 3646 |
.IX Xref "WYSIWYG acronym" |
| 3647 |
.SS X |
| 3648 |
.IX Subsection "X" |
| 3649 |
.IP XS 4 |
| 3650 |
.IX Item "XS" |
| 3651 |
An extraordinarily |
| 3652 |
exported, expeditiously excellent, expressly eXternal Subroutine, executed |
| 3653 |
in existing C or C++ or in an exciting extension language called |
| 3654 |
(exasperatingly) XS. |
| 3655 |
.IX Xref "XS (eXternal Subroutine) eXternal Subroutine (XS)" |
| 3656 |
.IP XSUB 4 |
| 3657 |
.IX Item "XSUB" |
| 3658 |
An external \fBsubroutine\fR defined in \fBXS\fR. |
| 3659 |
.IX Xref "XSUB (term)" |
| 3660 |
.SS Y |
| 3661 |
.IX Subsection "Y" |
| 3662 |
.IP yacc 4 |
| 3663 |
.IX Item "yacc" |
| 3664 |
Yet Another Compiler Compiler. A parser generator without |
| 3665 |
which Perl probably would not have existed. See the file \fIperly.y\fR in the |
| 3666 |
Perl source distribution. |
| 3667 |
.IX Xref "yacc acronym" |
| 3668 |
.SS Z |
| 3669 |
.IX Subsection "Z" |
| 3670 |
.IP "zero width" 4 |
| 3671 |
.IX Item "zero width" |
| 3672 |
A subpattern \fBassertion\fR matching the \fBnull |
| 3673 |
string\fR between \fBcharacters\fR. |
| 3674 |
.IX Xref "zero–width assertions subpatterns, zero–width assertions assertions (in regexes), zero–width" |
| 3675 |
.IP zombie 4 |
| 3676 |
.IX Item "zombie" |
| 3677 |
A process that has died (exited) but |
| 3678 |
whose parent has not yet received proper notification of its demise by |
| 3679 |
virtue of having called \f(CW\*(C`wait\*(C'\fR or \f(CW\*(C`waitpid\*(C'\fR. If you \f(CW\*(C`fork\*(C'\fR, you must |
| 3680 |
clean up after your child processes when they exit; otherwise, the process |
| 3681 |
table will fill up and your system administrator will Not Be Happy with |
| 3682 |
you. |
| 3683 |
.IX Xref "zombie processes processes, zombie" |
| 3684 |
.SH "AUTHOR AND COPYRIGHT" |
| 3685 |
.IX Header "AUTHOR AND COPYRIGHT" |
| 3686 |
Based on the Glossary of \fIProgramming Perl\fR, Fourth Edition, |
| 3687 |
by Tom Christiansen, brian d foy, Larry Wall, & Jon Orwant. |
| 3688 |
Copyright (c) 2000, 1996, 1991, 2012 O'Reilly Media, Inc. |
| 3689 |
This document may be distributed under the same terms as Perl itself. |