| 1 | .\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.32 |
| 2 | .\" |
| 3 | .\" Standard preamble: |
| 4 | .\" ======================================================================== |
| 5 | .de Sh \" Subsection heading |
| 6 | .br |
| 7 | .if t .Sp |
| 8 | .ne 5 |
| 9 | .PP |
| 10 | \fB\\$1\fR |
| 11 | .PP |
| 12 | .. |
| 13 | .de Sp \" Vertical space (when we can't use .PP) |
| 14 | .if t .sp .5v |
| 15 | .if n .sp |
| 16 | .. |
| 17 | .de Vb \" Begin verbatim text |
| 18 | .ft CW |
| 19 | .nf |
| 20 | .ne \\$1 |
| 21 | .. |
| 22 | .de Ve \" End verbatim text |
| 23 | .ft R |
| 24 | .fi |
| 25 | .. |
| 26 | .\" Set up some character translations and predefined strings. \*(-- will |
| 27 | .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left |
| 28 | .\" double quote, and \*(R" will give a right double quote. | will give a |
| 29 | .\" real vertical bar. \*(C+ will give a nicer C++. Capital omega is used to |
| 30 | .\" do unbreakable dashes and therefore won't be available. \*(C` and \*(C' |
| 31 | .\" expand to `' in nroff, nothing in troff, for use with C<>. |
| 32 | .tr \(*W-|\(bv\*(Tr |
| 33 | .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' |
| 34 | .ie n \{\ |
| 35 | . ds -- \(*W- |
| 36 | . ds PI pi |
| 37 | . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch |
| 38 | . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch |
| 39 | . ds L" "" |
| 40 | . ds R" "" |
| 41 | . ds C` "" |
| 42 | . ds C' "" |
| 43 | 'br\} |
| 44 | .el\{\ |
| 45 | . ds -- \|\(em\| |
| 46 | . ds PI \(*p |
| 47 | . ds L" `` |
| 48 | . ds R" '' |
| 49 | 'br\} |
| 50 | .\" |
| 51 | .\" If the F register is turned on, we'll generate index entries on stderr for |
| 52 | .\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index |
| 53 | .\" entries marked with X<> in POD. Of course, you'll have to process the |
| 54 | .\" output yourself in some meaningful fashion. |
| 55 | .if \nF \{\ |
| 56 | . de IX |
| 57 | . tm Index:\\$1\t\\n%\t"\\$2" |
| 58 | .. |
| 59 | . nr % 0 |
| 60 | . rr F |
| 61 | .\} |
| 62 | .\" |
| 63 | .\" For nroff, turn off justification. Always turn off hyphenation; it makes |
| 64 | .\" way too many mistakes in technical documents. |
| 65 | .hy 0 |
| 66 | .if n .na |
| 67 | .\" |
| 68 | .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). |
| 69 | .\" Fear. Run. Save yourself. No user-serviceable parts. |
| 70 | . \" fudge factors for nroff and troff |
| 71 | .if n \{\ |
| 72 | . ds #H 0 |
| 73 | . ds #V .8m |
| 74 | . ds #F .3m |
| 75 | . ds #[ \f1 |
| 76 | . ds #] \fP |
| 77 | .\} |
| 78 | .if t \{\ |
| 79 | . ds #H ((1u-(\\\\n(.fu%2u))*.13m) |
| 80 | . ds #V .6m |
| 81 | . ds #F 0 |
| 82 | . ds #[ \& |
| 83 | . ds #] \& |
| 84 | .\} |
| 85 | . \" simple accents for nroff and troff |
| 86 | .if n \{\ |
| 87 | . ds ' \& |
| 88 | . ds ` \& |
| 89 | . ds ^ \& |
| 90 | . ds , \& |
| 91 | . ds ~ ~ |
| 92 | . ds / |
| 93 | .\} |
| 94 | .if t \{\ |
| 95 | . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" |
| 96 | . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' |
| 97 | . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' |
| 98 | . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' |
| 99 | . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' |
| 100 | . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' |
| 101 | .\} |
| 102 | . \" troff and (daisy-wheel) nroff accents |
| 103 | .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' |
| 104 | .ds 8 \h'\*(#H'\(*b\h'-\*(#H' |
| 105 | .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] |
| 106 | .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' |
| 107 | .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' |
| 108 | .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] |
| 109 | .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] |
| 110 | .ds ae a\h'-(\w'a'u*4/10)'e |
| 111 | .ds Ae A\h'-(\w'A'u*4/10)'E |
| 112 | . \" corrections for vroff |
| 113 | .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' |
| 114 | .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' |
| 115 | . \" for low resolution devices (crt and lpr) |
| 116 | .if \n(.H>23 .if \n(.V>19 \ |
| 117 | \{\ |
| 118 | . ds : e |
| 119 | . ds 8 ss |
| 120 | . ds o a |
| 121 | . ds d- d\h'-1'\(ga |
| 122 | . ds D- D\h'-1'\(hy |
| 123 | . ds th \o'bp' |
| 124 | . ds Th \o'LP' |
| 125 | . ds ae ae |
| 126 | . ds Ae AE |
| 127 | .\} |
| 128 | .rm #[ #] #H #V #F C |
| 129 | .\" ======================================================================== |
| 130 | .\" |
| 131 | .IX Title "PERLGLOSSARY 1" |
| 132 | .TH PERLGLOSSARY 1 "2006-01-07" "perl v5.8.8" "Perl Programmers Reference Guide" |
| 133 | .SH "NAME" |
| 134 | perlglossary \- Perl Glossary |
| 135 | .SH "DESCRIPTION" |
| 136 | .IX Header "DESCRIPTION" |
| 137 | A glossary of terms (technical and otherwise) used in the Perl documentation. |
| 138 | Other useful sources include the Free On-Line Dictionary of Computing |
| 139 | <http://foldoc.doc.ic.ac.uk/foldoc/index.html>, the Jargon File |
| 140 | <http://catb.org/~esr/jargon/>, and Wikipedia <http://www.wikipedia.org/>. |
| 141 | .Sh "A" |
| 142 | .IX Subsection "A" |
| 143 | .IP "accessor methods" 4 |
| 144 | .IX Item "accessor methods" |
| 145 | A \*(L"method\*(R" used to indirectly inspect or update an \*(L"object\*(R"'s |
| 146 | state (its instance variables). |
| 147 | .IP "actual arguments" 4 |
| 148 | .IX Item "actual arguments" |
| 149 | The scalar values that you supply to a \*(L"function\*(R" |
| 150 | or \*(L"subroutine\*(R" when you call it. For instance, when you call |
| 151 | \&\f(CW\*(C`power("puff")\*(C'\fR, the string \f(CW"puff"\fR is the actual argument. See |
| 152 | also \*(L"argument\*(R" and \*(L"formal arguments\*(R". |
| 153 | .IP "address operator" 4 |
| 154 | .IX Item "address operator" |
| 155 | Some languages work directly with the memory addresses of values, but |
| 156 | this can be like playing with fire. Perl provides a set of asbestos |
| 157 | gloves for handling all memory management. The closest to an address |
| 158 | operator in Perl is the backslash operator, but it gives you a \*(L"hard reference\*(R", which is much safer than a memory address. |
| 159 | .IP "algorithm" 4 |
| 160 | .IX Item "algorithm" |
| 161 | A well-defined sequence of steps, clearly enough explained that even a |
| 162 | computer could do them. |
| 163 | .IP "alias" 4 |
| 164 | .IX Item "alias" |
| 165 | A nickname for something, which behaves in all ways as though you'd |
| 166 | used the original name instead of the nickname. Temporary aliases are |
| 167 | implicitly created in the loop variable for \f(CW\*(C`foreach\*(C'\fR loops, in the |
| 168 | \&\f(CW$_\fR variable for map or grep |
| 169 | operators, in \f(CW$a\fR and \f(CW$b\fR during sort's |
| 170 | comparison function, and in each element of \f(CW@_\fR for the \*(L"actual arguments\*(R" of a subroutine call. Permanent aliases are explicitly |
| 171 | created in packages by importing symbols or by |
| 172 | assignment to typeglobs. Lexically scoped aliases for |
| 173 | package variables are explicitly created by the our |
| 174 | declaration. |
| 175 | .IP "alternatives" 4 |
| 176 | .IX Item "alternatives" |
| 177 | A list of possible choices from which you may select only one, as in |
| 178 | \&\*(L"Would you like door A, B, or C?\*(R" Alternatives in regular expressions |
| 179 | are separated with a single vertical bar: \f(CW\*(C`|\*(C'\fR. Alternatives in |
| 180 | normal Perl expressions are separated with a double vertical bar: |
| 181 | \&\f(CW\*(C`||\*(C'\fR. Logical alternatives in \*(L"Boolean\*(R" expressions are separated |
| 182 | with either \f(CW\*(C`||\*(C'\fR or \f(CW\*(C`or\*(C'\fR. |
| 183 | .IP "anonymous" 4 |
| 184 | .IX Item "anonymous" |
| 185 | Used to describe a \*(L"referent\*(R" that is not directly accessible |
| 186 | through a named \*(L"variable\*(R". Such a referent must be indirectly |
| 187 | accessible through at least one \*(L"hard reference\*(R". When the last |
| 188 | hard reference goes away, the anonymous referent is destroyed without |
| 189 | pity. |
| 190 | .IP "architecture" 4 |
| 191 | .IX Item "architecture" |
| 192 | The kind of computer you're working on, where one \*(L"kind\*(R" of computer |
| 193 | means all those computers sharing a compatible machine language. |
| 194 | Since Perl programs are (typically) simple text files, not executable |
| 195 | images, a Perl program is much less sensitive to the architecture it's |
| 196 | running on than programs in other languages, such as C, that are |
| 197 | compiled into machine code. See also \*(L"platform\*(R" and \*(L"operating system\*(R". |
| 198 | .IP "argument" 4 |
| 199 | .IX Item "argument" |
| 200 | A piece of data supplied to a program, |
| 201 | \&\*(L"subroutine\*(R", \*(L"function\*(R", or \*(L"method\*(R" to tell it what it's |
| 202 | supposed to do. Also called a \*(L"parameter\*(R". |
| 203 | .IP "\s-1ARGV\s0" 4 |
| 204 | .IX Item "ARGV" |
| 205 | The name of the array containing the \*(L"argument\*(R" \*(L"vector\*(R" from the |
| 206 | command line. If you use the empty \f(CW\*(C`<>\*(C'\fR operator, \*(L"\s-1ARGV\s0\*(R" is |
| 207 | the name of both the \*(L"filehandle\*(R" used to traverse the arguments and |
| 208 | the \*(L"scalar\*(R" containing the name of the current input file. |
| 209 | .IP "arithmetical operator" 4 |
| 210 | .IX Item "arithmetical operator" |
| 211 | A \*(L"symbol\*(R" such as \f(CW\*(C`+\*(C'\fR or \f(CW\*(C`/\*(C'\fR that tells Perl to do the arithmetic |
| 212 | you were supposed to learn in grade school. |
| 213 | .IP "array" 4 |
| 214 | .IX Item "array" |
| 215 | An ordered sequence of values, stored such that you can |
| 216 | easily access any of the values using an integer \*(L"subscript\*(R" |
| 217 | that specifies the value's \*(L"offset\*(R" in the sequence. |
| 218 | .IP "array context" 4 |
| 219 | .IX Item "array context" |
| 220 | An archaic expression for what is more correctly referred to as |
| 221 | \&\*(L"list context\*(R". |
| 222 | .IP "\s-1ASCII\s0" 4 |
| 223 | .IX Item "ASCII" |
| 224 | The American Standard Code for Information Interchange (a 7\-bit |
| 225 | character set adequate only for poorly representing English text). |
| 226 | Often used loosely to describe the lowest 128 values of the various |
| 227 | \&\s-1ISO\-8859\-X\s0 character sets, a bunch of mutually incompatible 8\-bit |
| 228 | codes best described as half \s-1ASCII\s0. See also \*(L"Unicode\*(R". |
| 229 | .IP "assertion" 4 |
| 230 | .IX Item "assertion" |
| 231 | A component of a \*(L"regular expression\*(R" that must be true for the |
| 232 | pattern to match but does not necessarily match any characters itself. |
| 233 | Often used specifically to mean a \*(L"zero width\*(R" assertion. |
| 234 | .IP "assignment" 4 |
| 235 | .IX Item "assignment" |
| 236 | An \*(L"operator\*(R" whose assigned mission in life is to change the value |
| 237 | of a \*(L"variable\*(R". |
| 238 | .IP "assignment operator" 4 |
| 239 | .IX Item "assignment operator" |
| 240 | Either a regular \*(L"assignment\*(R", or a compound \*(L"operator\*(R" composed |
| 241 | of an ordinary assignment and some other operator, that changes the |
| 242 | value of a variable in place, that is, relative to its old value. For |
| 243 | example, \f(CW\*(C`$a += 2\*(C'\fR adds \f(CW2\fR to \f(CW$a\fR. |
| 244 | .IP "associative array" 4 |
| 245 | .IX Item "associative array" |
| 246 | See \*(L"hash\*(R". Please. |
| 247 | .IP "associativity" 4 |
| 248 | .IX Item "associativity" |
| 249 | Determines whether you do the left \*(L"operator\*(R" first or the right |
| 250 | \&\*(L"operator\*(R" first when you have "A \*(L"operator\*(R" B \*(L"operator\*(R" C" and |
| 251 | the two operators are of the same precedence. Operators like \f(CW\*(C`+\*(C'\fR are |
| 252 | left associative, while operators like \f(CW\*(C`**\*(C'\fR are right associative. |
| 253 | See perlop for a list of operators and their associativity. |
| 254 | .IP "asynchronous" 4 |
| 255 | .IX Item "asynchronous" |
| 256 | Said of events or activities whose relative temporal ordering is |
| 257 | indeterminate because too many things are going on at once. Hence, an |
| 258 | asynchronous event is one you didn't know when to expect. |
| 259 | .IP "atom" 4 |
| 260 | .IX Item "atom" |
| 261 | A \*(L"regular expression\*(R" component potentially matching a |
| 262 | \&\*(L"substring\*(R" containing one or more characters and treated as an |
| 263 | indivisible syntactic unit by any following \*(L"quantifier\*(R". (Contrast |
| 264 | with an \*(L"assertion\*(R" that matches something of \*(L"zero width\*(R" and may |
| 265 | not be quantified.) |
| 266 | .IP "atomic operation" 4 |
| 267 | .IX Item "atomic operation" |
| 268 | When Democritus gave the word \*(L"atom\*(R" to the indivisible bits of |
| 269 | matter, he meant literally something that could not be cut: \fIa\-\fR |
| 270 | (not) + \fItomos\fR (cuttable). An atomic operation is an action that |
| 271 | can't be interrupted, not one forbidden in a nuclear-free zone. |
| 272 | .IP "attribute" 4 |
| 273 | .IX Item "attribute" |
| 274 | A new feature that allows the declaration of variables |
| 275 | and subroutines with modifiers as in \f(CW\*(C`sub foo : locked |
| 276 | method\*(C'\fR. Also, another name for an \*(L"instance variable\*(R" of an |
| 277 | \&\*(L"object\*(R". |
| 278 | .IP "autogeneration" 4 |
| 279 | .IX Item "autogeneration" |
| 280 | A feature of \*(L"operator overloading\*(R" of objects, whereby |
| 281 | the behavior of certain operators can be reasonably |
| 282 | deduced using more fundamental operators. This assumes that the |
| 283 | overloaded operators will often have the same relationships as the |
| 284 | regular operators. See perlop. |
| 285 | .IP "autoincrement" 4 |
| 286 | .IX Item "autoincrement" |
| 287 | To add one to something automatically, hence the name of the \f(CW\*(C`++\*(C'\fR |
| 288 | operator. To instead subtract one from something automatically is |
| 289 | known as an \*(L"autodecrement\*(R". |
| 290 | .IP "autoload" 4 |
| 291 | .IX Item "autoload" |
| 292 | To load on demand. (Also called \*(L"lazy\*(R" loading.) Specifically, to |
| 293 | call an \s-1AUTOLOAD\s0 subroutine on behalf of an |
| 294 | undefined subroutine. |
| 295 | .IP "autosplit" 4 |
| 296 | .IX Item "autosplit" |
| 297 | To split a string automatically, as the \fB\-a\fR \*(L"switch\*(R" does when |
| 298 | running under \fB\-p\fR or \fB\-n\fR in order to emulate \*(L"awk\*(R". (See also |
| 299 | the AutoSplit module, which has nothing to do with the \fB\-a\fR |
| 300 | switch, but a lot to do with autoloading.) |
| 301 | .IP "autovivification" 4 |
| 302 | .IX Item "autovivification" |
| 303 | A Greco-Roman word meaning \*(L"to bring oneself to life\*(R". In Perl, |
| 304 | storage locations (lvalues) spontaneously generate |
| 305 | themselves as needed, including the creation of any \*(L"hard reference\*(R" |
| 306 | values to point to the next level of storage. The assignment |
| 307 | \&\f(CW\*(C`$a[5][5][5][5][5] = "quintet"\*(C'\fR potentially creates five scalar |
| 308 | storage locations, plus four references (in the first four scalar |
| 309 | locations) pointing to four new anonymous arrays (to hold the last |
| 310 | four scalar locations). But the point of autovivification is that you |
| 311 | don't have to worry about it. |
| 312 | .IP "\s-1AV\s0" 4 |
| 313 | .IX Item "AV" |
| 314 | Short for \*(L"array value\*(R", which refers to one of Perl's internal data |
| 315 | types that holds an \*(L"array\*(R". The \*(L"\s-1AV\s0\*(R" type is a subclass of |
| 316 | \&\*(L"\s-1SV\s0\*(R". |
| 317 | .IP "awk" 4 |
| 318 | .IX Item "awk" |
| 319 | Descriptive editing term\*(--short for \*(L"awkward\*(R". Also coincidentally |
| 320 | refers to a venerable text-processing language from which Perl derived |
| 321 | some of its high-level ideas. |
| 322 | .Sh "B" |
| 323 | .IX Subsection "B" |
| 324 | .IP "backreference" 4 |
| 325 | .IX Item "backreference" |
| 326 | A substring captured by a subpattern within |
| 327 | unadorned parentheses in a \*(L"regex\*(R". Backslashed decimal numbers |
| 328 | (\f(CW\*(C`\e1\*(C'\fR, \f(CW\*(C`\e2\*(C'\fR, etc.) later in the same pattern refer back to the |
| 329 | corresponding subpattern in the current match. Outside the pattern, |
| 330 | the numbered variables (\f(CW$1\fR, \f(CW$2\fR, etc.) continue to refer to these |
| 331 | same values, as long as the pattern was the last successful match of |
| 332 | the current dynamic scope. |
| 333 | .IP "backtracking" 4 |
| 334 | .IX Item "backtracking" |
| 335 | The practice of saying, \*(L"If I had to do it all over, I'd do it |
| 336 | differently,\*(R" and then actually going back and doing it all over |
| 337 | differently. Mathematically speaking, it's returning from an |
| 338 | unsuccessful recursion on a tree of possibilities. Perl backtracks |
| 339 | when it attempts to match patterns with a \*(L"regular expression\*(R", and |
| 340 | its earlier attempts don't pan out. See \*(L"Backtracking\*(R" in perlre. |
| 341 | .IP "backward compatibility" 4 |
| 342 | .IX Item "backward compatibility" |
| 343 | Means you can still run your old program because we didn't break any |
| 344 | of the features or bugs it was relying on. |
| 345 | .IP "bareword" 4 |
| 346 | .IX Item "bareword" |
| 347 | A word sufficiently ambiguous to be deemed illegal under use strict 'subs'. In the absence of that stricture, a |
| 348 | bareword is treated as if quotes were around it. |
| 349 | .IP "base class" 4 |
| 350 | .IX Item "base class" |
| 351 | A generic \*(L"object\*(R" type; that is, a \*(L"class\*(R" from which other, more |
| 352 | specific classes are derived genetically by \*(L"inheritance\*(R". Also |
| 353 | called a \*(L"superclass\*(R" by people who respect their ancestors. |
| 354 | .IP "big-endian" 4 |
| 355 | .IX Item "big-endian" |
| 356 | From Swift: someone who eats eggs big end first. Also used of |
| 357 | computers that store the most significant \*(L"byte\*(R" of a word at a |
| 358 | lower byte address than the least significant byte. Often considered |
| 359 | superior to little-endian machines. See also \*(L"little\-endian\*(R". |
| 360 | .IP "binary" 4 |
| 361 | .IX Item "binary" |
| 362 | Having to do with numbers represented in base 2. That means there's |
| 363 | basically two numbers, 0 and 1. Also used to describe a \*(L"non\-text |
| 364 | file\*(R", presumably because such a file makes full use of all the binary |
| 365 | bits in its bytes. With the advent of \*(L"Unicode\*(R", this distinction, |
| 366 | already suspect, loses even more of its meaning. |
| 367 | .IP "binary operator" 4 |
| 368 | .IX Item "binary operator" |
| 369 | An \*(L"operator\*(R" that takes two operands. |
| 370 | .IP "bind" 4 |
| 371 | .IX Item "bind" |
| 372 | To assign a specific \*(L"network address\*(R" to a \*(L"socket\*(R". |
| 373 | .IP "bit" 4 |
| 374 | .IX Item "bit" |
| 375 | An integer in the range from 0 to 1, inclusive. The smallest possible |
| 376 | unit of information storage. An eighth of a \*(L"byte\*(R" or of a dollar. |
| 377 | (The term \*(L"Pieces of Eight\*(R" comes from being able to split the old |
| 378 | Spanish dollar into 8 bits, each of which still counted for money. |
| 379 | That's why a 25\-cent piece today is still \*(L"two bits\*(R".) |
| 380 | .IP "bit shift" 4 |
| 381 | .IX Item "bit shift" |
| 382 | The movement of bits left or right in a computer word, which has the |
| 383 | effect of multiplying or dividing by a power of 2. |
| 384 | .IP "bit string" 4 |
| 385 | .IX Item "bit string" |
| 386 | A sequence of bits that is actually being thought of as a |
| 387 | sequence of bits, for once. |
| 388 | .IP "bless" 4 |
| 389 | .IX Item "bless" |
| 390 | In corporate life, to grant official approval to a thing, as in, \*(L"The |
| 391 | \&\s-1VP\s0 of Engineering has blessed our WebCruncher project.\*(R" Similarly in |
| 392 | Perl, to grant official approval to a \*(L"referent\*(R" so that it can |
| 393 | function as an \*(L"object\*(R", such as a WebCruncher object. See |
| 394 | \&\*(L"bless\*(R" in perlfunc. |
| 395 | .IP "block" 4 |
| 396 | .IX Item "block" |
| 397 | What a \*(L"process\*(R" does when it has to wait for something: \*(L"My process |
| 398 | blocked waiting for the disk.\*(R" As an unrelated noun, it refers to a |
| 399 | large chunk of data, of a size that the \*(L"operating system\*(R" likes to |
| 400 | deal with (normally a power of two such as 512 or 8192). Typically |
| 401 | refers to a chunk of data that's coming from or going to a disk file. |
| 402 | .IP "\s-1BLOCK\s0" 4 |
| 403 | .IX Item "BLOCK" |
| 404 | A syntactic construct consisting of a sequence of Perl |
| 405 | statements that is delimited by braces. The \f(CW\*(C`if\*(C'\fR and |
| 406 | \&\f(CW\*(C`while\*(C'\fR statements are defined in terms of BLOCKs, for instance. |
| 407 | Sometimes we also say \*(L"block\*(R" to mean a lexical scope; that is, a |
| 408 | sequence of statements that act like a \*(L"\s-1BLOCK\s0\*(R", such as within an |
| 409 | eval or a file, even though the statements aren't |
| 410 | delimited by braces. |
| 411 | .IP "block buffering" 4 |
| 412 | .IX Item "block buffering" |
| 413 | A method of making input and output efficient by passing one \*(L"block\*(R" |
| 414 | at a time. By default, Perl does block buffering to disk files. See |
| 415 | \&\*(L"buffer\*(R" and \*(L"command buffering\*(R". |
| 416 | .IP "Boolean" 4 |
| 417 | .IX Item "Boolean" |
| 418 | A value that is either \*(L"true\*(R" or \*(L"false\*(R". |
| 419 | .IP "Boolean context" 4 |
| 420 | .IX Item "Boolean context" |
| 421 | A special kind of \*(L"scalar context\*(R" used in conditionals to decide |
| 422 | whether the \*(L"scalar value\*(R" returned by an expression is \*(L"true\*(R" or |
| 423 | \&\*(L"false\*(R". Does not evaluate as either a string or a number. See |
| 424 | \&\*(L"context\*(R". |
| 425 | .IP "breakpoint" 4 |
| 426 | .IX Item "breakpoint" |
| 427 | A spot in your program where you've told the debugger to stop |
| 428 | execution so you can poke around and see whether anything |
| 429 | is wrong yet. |
| 430 | .IP "broadcast" 4 |
| 431 | .IX Item "broadcast" |
| 432 | To send a \*(L"datagram\*(R" to multiple destinations simultaneously. |
| 433 | .IP "\s-1BSD\s0" 4 |
| 434 | .IX Item "BSD" |
| 435 | A psychoactive drug, popular in the 80s, probably developed at |
| 436 | U. C. Berkeley or thereabouts. Similar in many ways to the |
| 437 | prescription-only medication called \*(L"System V\*(R", but infinitely more |
| 438 | useful. (Or, at least, more fun.) The full chemical name is |
| 439 | \&\*(L"Berkeley Standard Distribution\*(R". |
| 440 | .IP "bucket" 4 |
| 441 | .IX Item "bucket" |
| 442 | A location in a \*(L"hash table\*(R" containing (potentially) multiple |
| 443 | entries whose keys \*(L"hash\*(R" to the same hash value according to its hash |
| 444 | function. (As internal policy, you don't have to worry about it, |
| 445 | unless you're into internals, or policy.) |
| 446 | .IP "buffer" 4 |
| 447 | .IX Item "buffer" |
| 448 | A temporary holding location for data. Block buffering means that the data is passed on to its destination |
| 449 | whenever the buffer is full. Line buffering means |
| 450 | that it's passed on whenever a complete line is received. Command buffering means that it's passed every time you do |
| 451 | a print command (or equivalent). If your output is |
| 452 | unbuffered, the system processes it one byte at a time without the use |
| 453 | of a holding area. This can be rather inefficient. |
| 454 | .IP "built-in" 4 |
| 455 | .IX Item "built-in" |
| 456 | A \*(L"function\*(R" that is predefined in the language. Even when hidden |
| 457 | by \*(L"overriding\*(R", you can always get at a built-in function by |
| 458 | qualifying its name with the \f(CW\*(C`CORE::\*(C'\fR pseudo\-package. |
| 459 | .IP "bundle" 4 |
| 460 | .IX Item "bundle" |
| 461 | A group of related modules on \*(L"\s-1CPAN\s0\*(R". (Also, sometimes refers to a |
| 462 | group of command-line switches grouped into one \*(L"switch cluster\*(R".) |
| 463 | .IP "byte" 4 |
| 464 | .IX Item "byte" |
| 465 | A piece of data worth eight bits in most places. |
| 466 | .IP "bytecode" 4 |
| 467 | .IX Item "bytecode" |
| 468 | A pidgin-like language spoken among 'droids when they don't wish to |
| 469 | reveal their orientation (see \*(L"endian\*(R"). Named after some similar |
| 470 | languages spoken (for similar reasons) between compilers and |
| 471 | interpreters in the late 20th century. These languages are |
| 472 | characterized by representing everything as a |
| 473 | non-architecture-dependent sequence of bytes. |
| 474 | .Sh "C" |
| 475 | .IX Subsection "C" |
| 476 | .IP "C" 4 |
| 477 | .IX Item "C" |
| 478 | A language beloved by many for its inside-out \*(L"type\*(R" definitions, |
| 479 | inscrutable \*(L"precedence\*(R" rules, and heavy \*(L"overloading\*(R" of the |
| 480 | function-call mechanism. (Well, actually, people first switched to C |
| 481 | because they found lowercase identifiers easier to read than upper.) |
| 482 | Perl is written in C, so it's not surprising that Perl borrowed a few |
| 483 | ideas from it. |
| 484 | .IP "C preprocessor" 4 |
| 485 | .IX Item "C preprocessor" |
| 486 | The typical C compiler's first pass, which processes lines beginning |
| 487 | with \f(CW\*(C`#\*(C'\fR for conditional compilation and macro definition and does |
| 488 | various manipulations of the program text based on the current |
| 489 | definitions. Also known as \fIcpp\fR(1). |
| 490 | .IP "call by reference" 4 |
| 491 | .IX Item "call by reference" |
| 492 | An \*(L"argument\*(R"\-passing mechanism in which the \*(L"formal arguments\*(R" |
| 493 | refer directly to the \*(L"actual arguments\*(R", and the \*(L"subroutine\*(R" can |
| 494 | change the actual arguments by changing the formal arguments. That |
| 495 | is, the formal argument is an \*(L"alias\*(R" for the actual argument. See |
| 496 | also \*(L"call by value\*(R". |
| 497 | .IP "call by value" 4 |
| 498 | .IX Item "call by value" |
| 499 | An \*(L"argument\*(R"\-passing mechanism in which the \*(L"formal arguments\*(R" |
| 500 | refer to a copy of the \*(L"actual arguments\*(R", and the \*(L"subroutine\*(R" |
| 501 | cannot change the actual arguments by changing the formal arguments. |
| 502 | See also \*(L"call by reference\*(R". |
| 503 | .IP "callback" 4 |
| 504 | .IX Item "callback" |
| 505 | A \*(L"handler\*(R" that you register with some other part of your program |
| 506 | in the hope that the other part of your program will \*(L"trigger\*(R" your |
| 507 | handler when some event of interest transpires. |
| 508 | .IP "canonical" 4 |
| 509 | .IX Item "canonical" |
| 510 | Reduced to a standard form to facilitate comparison. |
| 511 | .IP "capturing" 4 |
| 512 | .IX Item "capturing" |
| 513 | The use of parentheses around a \*(L"subpattern\*(R" in a \*(L"regular expression\*(R" to store the matched \*(L"substring\*(R" as a \*(L"backreference\*(R". |
| 514 | (Captured strings are also returned as a list in \*(L"list context\*(R".) |
| 515 | .IP "character" 4 |
| 516 | .IX Item "character" |
| 517 | A small integer representative of a unit of orthography. |
| 518 | Historically, characters were usually stored as fixed-width integers |
| 519 | (typically in a byte, or maybe two, depending on the character set), |
| 520 | but with the advent of \s-1UTF\-8\s0, characters are often stored in a |
| 521 | variable number of bytes depending on the size of the integer that |
| 522 | represents the character. Perl manages this transparently for you, |
| 523 | for the most part. |
| 524 | .IP "character class" 4 |
| 525 | .IX Item "character class" |
| 526 | A square-bracketed list of characters used in a \*(L"regular expression\*(R" |
| 527 | to indicate that any character of the set may occur at a given point. |
| 528 | Loosely, any predefined set of characters so used. |
| 529 | .IP "character property" 4 |
| 530 | .IX Item "character property" |
| 531 | A predefined \*(L"character class\*(R" matchable by the \f(CW\*(C`\ep\*(C'\fR |
| 532 | \&\*(L"metasymbol\*(R". Many standard properties are defined for \*(L"Unicode\*(R". |
| 533 | .IP "circumfix operator" 4 |
| 534 | .IX Item "circumfix operator" |
| 535 | An \*(L"operator\*(R" that surrounds its \*(L"operand\*(R", like the angle |
| 536 | operator, or parentheses, or a hug. |
| 537 | .IP "class" 4 |
| 538 | .IX Item "class" |
| 539 | A user-defined \*(L"type\*(R", implemented in Perl via a \*(L"package\*(R" that |
| 540 | provides (either directly or by inheritance) methods (that |
| 541 | is, subroutines) to handle instances of |
| 542 | the class (its objects). See also \*(L"inheritance\*(R". |
| 543 | .IP "class method" 4 |
| 544 | .IX Item "class method" |
| 545 | A \*(L"method\*(R" whose \*(L"invocant\*(R" is a \*(L"package\*(R" name, not an |
| 546 | \&\*(L"object\*(R" reference. A method associated with the class as a whole. |
| 547 | .IP "client" 4 |
| 548 | .IX Item "client" |
| 549 | In networking, a \*(L"process\*(R" that initiates contact with a \*(L"server\*(R" |
| 550 | process in order to exchange data and perhaps receive a service. |
| 551 | .IP "cloister" 4 |
| 552 | .IX Item "cloister" |
| 553 | A \*(L"cluster\*(R" used to restrict the scope of a \*(L"regular expression modifier\*(R". |
| 554 | .IP "closure" 4 |
| 555 | .IX Item "closure" |
| 556 | An \*(L"anonymous\*(R" subroutine that, when a reference to it is generated |
| 557 | at run time, keeps track of the identities of externally visible |
| 558 | lexical variables even after those lexical |
| 559 | variables have supposedly gone out of \*(L"scope\*(R". They're called |
| 560 | \&\*(L"closures\*(R" because this sort of behavior gives mathematicians a sense |
| 561 | of closure. |
| 562 | .IP "cluster" 4 |
| 563 | .IX Item "cluster" |
| 564 | A parenthesized \*(L"subpattern\*(R" used to group parts of a \*(L"regular expression\*(R" into a single \*(L"atom\*(R". |
| 565 | .IP "\s-1CODE\s0" 4 |
| 566 | .IX Item "CODE" |
| 567 | The word returned by the ref function when you apply |
| 568 | it to a reference to a subroutine. See also \*(L"\s-1CV\s0\*(R". |
| 569 | .IP "code generator" 4 |
| 570 | .IX Item "code generator" |
| 571 | A system that writes code for you in a low-level language, such as |
| 572 | code to implement the backend of a compiler. See \*(L"program generator\*(R". |
| 573 | .IP "code subpattern" 4 |
| 574 | .IX Item "code subpattern" |
| 575 | A \*(L"regular expression\*(R" subpattern whose real purpose is to execute |
| 576 | some Perl code, for example, the \f(CW\*(C`(?{...})\*(C'\fR and \f(CW\*(C`(??{...})\*(C'\fR |
| 577 | subpatterns. |
| 578 | .IP "collating sequence" 4 |
| 579 | .IX Item "collating sequence" |
| 580 | The order into which characters sort. This is used by |
| 581 | \&\*(L"string\*(R" comparison routines to decide, for example, where in this |
| 582 | glossary to put \*(L"collating sequence\*(R". |
| 583 | .IP "command" 4 |
| 584 | .IX Item "command" |
| 585 | In \*(L"shell\*(R" programming, the syntactic combination of a program name |
| 586 | and its arguments. More loosely, anything you type to a shell (a |
| 587 | command interpreter) that starts it doing something. Even more |
| 588 | loosely, a Perl \*(L"statement\*(R", which might start with a \*(L"label\*(R" and |
| 589 | typically ends with a semicolon. |
| 590 | .IP "command buffering" 4 |
| 591 | .IX Item "command buffering" |
| 592 | A mechanism in Perl that lets you store up the output of each Perl |
| 593 | \&\*(L"command\*(R" and then flush it out as a single request to the |
| 594 | \&\*(L"operating system\*(R". It's enabled by setting the \f(CW$|\fR |
| 595 | (\f(CW$AUTOFLUSH\fR) variable to a true value. It's used when you don't |
| 596 | want data sitting around not going where it's supposed to, which may |
| 597 | happen because the default on a \*(L"file\*(R" or \*(L"pipe\*(R" is to use |
| 598 | \&\*(L"block buffering\*(R". |
| 599 | .IP "command name" 4 |
| 600 | .IX Item "command name" |
| 601 | The name of the program currently executing, as typed on the command |
| 602 | line. In C, the \*(L"command\*(R" name is passed to the program as the |
| 603 | first command-line argument. In Perl, it comes in separately as |
| 604 | \&\f(CW$0\fR. |
| 605 | .IP "command-line arguments" 4 |
| 606 | .IX Item "command-line arguments" |
| 607 | The values you supply along with a program name when you |
| 608 | tell a \*(L"shell\*(R" to execute a \*(L"command\*(R". These values are passed to |
| 609 | a Perl program through \f(CW@ARGV\fR. |
| 610 | .IP "comment" 4 |
| 611 | .IX Item "comment" |
| 612 | A remark that doesn't affect the meaning of the program. In Perl, a |
| 613 | comment is introduced by a \f(CW\*(C`#\*(C'\fR character and continues to the end of |
| 614 | the line. |
| 615 | .IP "compilation unit" 4 |
| 616 | .IX Item "compilation unit" |
| 617 | The \*(L"file\*(R" (or \*(L"string\*(R", in the case of eval) |
| 618 | that is currently being compiled. |
| 619 | .IP "compile phase" 4 |
| 620 | .IX Item "compile phase" |
| 621 | Any time before Perl starts running your main program. See also |
| 622 | \&\*(L"run phase\*(R". Compile phase is mostly spent in \*(L"compile time\*(R", but |
| 623 | may also be spent in \*(L"run time\*(R" when \f(CW\*(C`BEGIN\*(C'\fR blocks, |
| 624 | use declarations, or constant subexpressions are being |
| 625 | evaluated. The startup and import code of any use |
| 626 | declaration is also run during compile phase. |
| 627 | .IP "compile time" 4 |
| 628 | .IX Item "compile time" |
| 629 | The time when Perl is trying to make sense of your code, as opposed to |
| 630 | when it thinks it knows what your code means and is merely trying to |
| 631 | do what it thinks your code says to do, which is \*(L"run time\*(R". |
| 632 | .IP "compiler" 4 |
| 633 | .IX Item "compiler" |
| 634 | Strictly speaking, a program that munches up another program and spits |
| 635 | out yet another file containing the program in a \*(L"more executable\*(R" |
| 636 | form, typically containing native machine instructions. The \fIperl\fR |
| 637 | program is not a compiler by this definition, but it does contain a |
| 638 | kind of compiler that takes a program and turns it into a more |
| 639 | executable form (syntax trees) within the \fIperl\fR |
| 640 | process itself, which the \*(L"interpreter\*(R" then interprets. There are, |
| 641 | however, extension modules to get Perl to act more like a |
| 642 | \&\*(L"real\*(R" compiler. See O. |
| 643 | .IP "composer" 4 |
| 644 | .IX Item "composer" |
| 645 | A \*(L"constructor\*(R" for a \*(L"referent\*(R" that isn't really an \*(L"object\*(R", |
| 646 | like an anonymous array or a hash (or a sonata, for that matter). For |
| 647 | example, a pair of braces acts as a composer for a hash, and a pair of |
| 648 | brackets acts as a composer for an array. See \*(L"Making References\*(R" in perlref. |
| 649 | .IP "concatenation" 4 |
| 650 | .IX Item "concatenation" |
| 651 | The process of gluing one cat's nose to another cat's tail. Also, a |
| 652 | similar operation on two strings. |
| 653 | .IP "conditional" 4 |
| 654 | .IX Item "conditional" |
| 655 | Something \*(L"iffy\*(R". See \*(L"Boolean context\*(R". |
| 656 | .IP "connection" 4 |
| 657 | .IX Item "connection" |
| 658 | In telephony, the temporary electrical circuit between the caller's |
| 659 | and the callee's phone. In networking, the same kind of temporary |
| 660 | circuit between a \*(L"client\*(R" and a \*(L"server\*(R". |
| 661 | .IP "construct" 4 |
| 662 | .IX Item "construct" |
| 663 | As a noun, a piece of syntax made up of smaller pieces. As a |
| 664 | transitive verb, to create an \*(L"object\*(R" using a \*(L"constructor\*(R". |
| 665 | .IP "constructor" 4 |
| 666 | .IX Item "constructor" |
| 667 | Any \*(L"class method\*(R", instance \*(L"method\*(R", or \*(L"subroutine\*(R" |
| 668 | that composes, initializes, blesses, and returns an \*(L"object\*(R". |
| 669 | Sometimes we use the term loosely to mean a \*(L"composer\*(R". |
| 670 | .IP "context" 4 |
| 671 | .IX Item "context" |
| 672 | The surroundings, or environment. The context given by the |
| 673 | surrounding code determines what kind of data a particular |
| 674 | \&\*(L"expression\*(R" is expected to return. The three primary contexts are |
| 675 | \&\*(L"list context\*(R", \*(L"scalar context\*(R", and \*(L"void context\*(R". Scalar |
| 676 | context is sometimes subdivided into \*(L"Boolean context\*(R", \*(L"numeric context\*(R", \*(L"string context\*(R", and \*(L"void context\*(R". There's also a |
| 677 | \&\*(L"don't care\*(R" scalar context (which is dealt with in Programming Perl, |
| 678 | Third Edition, Chapter 2, \*(L"Bits and Pieces\*(R" if you care). |
| 679 | .IP "continuation" 4 |
| 680 | .IX Item "continuation" |
| 681 | The treatment of more than one physical \*(L"line\*(R" as a single logical |
| 682 | line. \*(L"Makefile\*(R" lines are continued by putting a backslash before |
| 683 | the \*(L"newline\*(R". Mail headers as defined by \s-1RFC\s0 822 are continued by |
| 684 | putting a space or tab \fIafter\fR the newline. In general, lines in |
| 685 | Perl do not need any form of continuation mark, because \*(L"whitespace\*(R" |
| 686 | (including newlines) is gleefully ignored. Usually. |
| 687 | .IP "core dump" 4 |
| 688 | .IX Item "core dump" |
| 689 | The corpse of a \*(L"process\*(R", in the form of a file left in the |
| 690 | \&\*(L"working directory\*(R" of the process, usually as a result of certain |
| 691 | kinds of fatal error. |
| 692 | .IP "\s-1CPAN\s0" 4 |
| 693 | .IX Item "CPAN" |
| 694 | The Comprehensive Perl Archive Network. (See "What modules and extensions are available for Perl? What is \s-1CPAN\s0? What does \s-1CPAN\s0/src/... mean?" in perlfaq2). |
| 695 | .IP "cracker" 4 |
| 696 | .IX Item "cracker" |
| 697 | Someone who breaks security on computer systems. A cracker may be a |
| 698 | true \*(L"hacker\*(R" or only a \*(L"script kiddie\*(R". |
| 699 | .IP "current package" 4 |
| 700 | .IX Item "current package" |
| 701 | The \*(L"package\*(R" in which the current statement is compiled. Scan |
| 702 | backwards in the text of your program through the current lexical scope or any enclosing lexical scopes till you find |
| 703 | a package declaration. That's your current package name. |
| 704 | .IP "current working directory" 4 |
| 705 | .IX Item "current working directory" |
| 706 | See \*(L"working directory\*(R". |
| 707 | .IP "currently selected output channel" 4 |
| 708 | .IX Item "currently selected output channel" |
| 709 | The last \*(L"filehandle\*(R" that was designated with |
| 710 | select(\f(CW\*(C`FILEHANDLE\*(C'\fR); \*(L"\s-1STDOUT\s0\*(R", if no filehandle |
| 711 | has been selected. |
| 712 | .IP "\s-1CV\s0" 4 |
| 713 | .IX Item "CV" |
| 714 | An internal \*(L"code value\*(R" typedef, holding a \*(L"subroutine\*(R". The \*(L"\s-1CV\s0\*(R" |
| 715 | type is a subclass of \*(L"\s-1SV\s0\*(R". |
| 716 | .Sh "D" |
| 717 | .IX Subsection "D" |
| 718 | .IP "dangling statement" 4 |
| 719 | .IX Item "dangling statement" |
| 720 | A bare, single \*(L"statement\*(R", without any braces, hanging off an \f(CW\*(C`if\*(C'\fR |
| 721 | or \f(CW\*(C`while\*(C'\fR conditional. C allows them. Perl doesn't. |
| 722 | .IP "data structure" 4 |
| 723 | .IX Item "data structure" |
| 724 | How your various pieces of data relate to each other and what shape |
| 725 | they make when you put them all together, as in a rectangular table or |
| 726 | a triangular-shaped tree. |
| 727 | .IP "data type" 4 |
| 728 | .IX Item "data type" |
| 729 | A set of possible values, together with all the operations that know |
| 730 | how to deal with those values. For example, a numeric data type has a |
| 731 | certain set of numbers that you can work with and various mathematical |
| 732 | operations that you can do on the numbers but would make little sense |
| 733 | on, say, a string such as \f(CW"Kilroy"\fR. Strings have their own |
| 734 | operations, such as \*(L"concatenation\*(R". Compound types made of a |
| 735 | number of smaller pieces generally have operations to compose and |
| 736 | decompose them, and perhaps to rearrange them. Objects |
| 737 | that model things in the real world often have operations that |
| 738 | correspond to real activities. For instance, if you model an |
| 739 | elevator, your elevator object might have an \f(CW\*(C`open_door()\*(C'\fR |
| 740 | \&\*(L"method\*(R". |
| 741 | .IP "datagram" 4 |
| 742 | .IX Item "datagram" |
| 743 | A packet of data, such as a \*(L"\s-1UDP\s0\*(R" message, that (from the viewpoint |
| 744 | of the programs involved) can be sent independently over the network. |
| 745 | (In fact, all packets are sent independently at the \*(L"\s-1IP\s0\*(R" level, but |
| 746 | \&\*(L"stream\*(R" protocols such as \*(L"\s-1TCP\s0\*(R" hide this from your program.) |
| 747 | .IP "\s-1DBM\s0" 4 |
| 748 | .IX Item "DBM" |
| 749 | Stands for \*(L"Data Base Management\*(R" routines, a set of routines that |
| 750 | emulate an \*(L"associative array\*(R" using disk files. The routines use a |
| 751 | dynamic hashing scheme to locate any entry with only two disk |
| 752 | accesses. \s-1DBM\s0 files allow a Perl program to keep a persistent |
| 753 | \&\*(L"hash\*(R" across multiple invocations. You can tie |
| 754 | your hash variables to various \s-1DBM\s0 implementations\*(--see AnyDBM_File |
| 755 | and DB_File. |
| 756 | .IP "declaration" 4 |
| 757 | .IX Item "declaration" |
| 758 | An \*(L"assertion\*(R" that states something exists and perhaps describes |
| 759 | what it's like, without giving any commitment as to how or where |
| 760 | you'll use it. A declaration is like the part of your recipe that |
| 761 | says, \*(L"two cups flour, one large egg, four or five tadpoles...\*(R" See |
| 762 | \&\*(L"statement\*(R" for its opposite. Note that some declarations also |
| 763 | function as statements. Subroutine declarations also act as |
| 764 | definitions if a body is supplied. |
| 765 | .IP "decrement" 4 |
| 766 | .IX Item "decrement" |
| 767 | To subtract a value from a variable, as in "decrement \f(CW$x\fR\*(L" (meaning |
| 768 | to remove 1 from its value) or \*(R"decrement \f(CW$x\fR by 3". |
| 769 | .IP "default" 4 |
| 770 | .IX Item "default" |
| 771 | A \*(L"value\*(R" chosen for you if you don't supply a value of your own. |
| 772 | .IP "defined" 4 |
| 773 | .IX Item "defined" |
| 774 | Having a meaning. Perl thinks that some of the things people try to |
| 775 | do are devoid of meaning, in particular, making use of variables that |
| 776 | have never been given a \*(L"value\*(R" and performing certain operations on |
| 777 | data that isn't there. For example, if you try to read data past the |
| 778 | end of a file, Perl will hand you back an undefined value. See also |
| 779 | \&\*(L"false\*(R" and \*(L"defined\*(R" in perlfunc. |
| 780 | .IP "delimiter" 4 |
| 781 | .IX Item "delimiter" |
| 782 | A \*(L"character\*(R" or \*(L"string\*(R" that sets bounds to an arbitrarily-sized |
| 783 | textual object, not to be confused with a \*(L"separator\*(R" or |
| 784 | \&\*(L"terminator\*(R". \*(L"To delimit\*(R" really just means \*(L"to surround\*(R" or \*(L"to |
| 785 | enclose\*(R" (like these parentheses are doing). |
| 786 | .IP "dereference" 4 |
| 787 | .IX Item "dereference" |
| 788 | A fancy computer science term meaning "to follow a \*(L"reference\*(R" to |
| 789 | what it points to\*(L". The \*(R"de" part of it refers to the fact that |
| 790 | you're taking away one level of \*(L"indirection\*(R". |
| 791 | .IP "derived class" 4 |
| 792 | .IX Item "derived class" |
| 793 | A \*(L"class\*(R" that defines some of its methods in terms of a |
| 794 | more generic class, called a \*(L"base class\*(R". Note that classes aren't |
| 795 | classified exclusively into base classes or derived classes: a class |
| 796 | can function as both a derived class and a base class simultaneously, |
| 797 | which is kind of classy. |
| 798 | .IP "descriptor" 4 |
| 799 | .IX Item "descriptor" |
| 800 | See \*(L"file descriptor\*(R". |
| 801 | .IP "destroy" 4 |
| 802 | .IX Item "destroy" |
| 803 | To deallocate the memory of a \*(L"referent\*(R" (first triggering its |
| 804 | \&\f(CW\*(C`DESTROY\*(C'\fR method, if it has one). |
| 805 | .IP "destructor" 4 |
| 806 | .IX Item "destructor" |
| 807 | A special \*(L"method\*(R" that is called when an \*(L"object\*(R" is thinking |
| 808 | about destroying itself. A Perl program's \f(CW\*(C`DESTROY\*(C'\fR |
| 809 | method doesn't do the actual destruction; Perl just |
| 810 | triggers the method in case the \*(L"class\*(R" wants to do any |
| 811 | associated cleanup. |
| 812 | .IP "device" 4 |
| 813 | .IX Item "device" |
| 814 | A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a |
| 815 | joystick or a mouse) attached to your computer, that the \*(L"operating system\*(R" tries to make look like a \*(L"file\*(R" (or a bunch of files). |
| 816 | Under Unix, these fake files tend to live in the \fI/dev\fR directory. |
| 817 | .IP "directive" 4 |
| 818 | .IX Item "directive" |
| 819 | A \*(L"pod\*(R" directive. See perlpod. |
| 820 | .IP "directory" 4 |
| 821 | .IX Item "directory" |
| 822 | A special file that contains other files. Some operating systems call these \*(L"folders\*(R", \*(L"drawers\*(R", or |
| 823 | \&\*(L"catalogs\*(R". |
| 824 | .IP "directory handle" 4 |
| 825 | .IX Item "directory handle" |
| 826 | A name that represents a particular instance of opening a directory to |
| 827 | read it, until you close it. See the opendir |
| 828 | function. |
| 829 | .IP "dispatch" 4 |
| 830 | .IX Item "dispatch" |
| 831 | To send something to its correct destination. Often used |
| 832 | metaphorically to indicate a transfer of programmatic control to a |
| 833 | destination selected algorithmically, often by lookup in a table of |
| 834 | function references or, in the case of object |
| 835 | methods, by traversing the inheritance tree looking for the |
| 836 | most specific definition for the method. |
| 837 | .IP "distribution" 4 |
| 838 | .IX Item "distribution" |
| 839 | A standard, bundled release of a system of software. The default |
| 840 | usage implies source code is included. If that is not the case, it |
| 841 | will be called a \*(L"binary\-only\*(R" distribution. |
| 842 | .IP "dweomer" 4 |
| 843 | .IX Item "dweomer" |
| 844 | An enchantment, illusion, phantasm, or jugglery. Said when Perl's |
| 845 | magical \*(L"dwimmer\*(R" effects don't do what you expect, but rather seem |
| 846 | to be the product of arcane dweomercraft, sorcery, or wonder working. |
| 847 | [From Old English] |
| 848 | .IP "dwimmer" 4 |
| 849 | .IX Item "dwimmer" |
| 850 | \&\s-1DWIM\s0 is an acronym for \*(L"Do What I Mean\*(R", the principle that something |
| 851 | should just do what you want it to do without an undue amount of fuss. |
| 852 | A bit of code that does \*(L"dwimming\*(R" is a \*(L"dwimmer\*(R". Dwimming can |
| 853 | require a great deal of behind-the-scenes magic, which (if it doesn't |
| 854 | stay properly behind the scenes) is called a \*(L"dweomer\*(R" instead. |
| 855 | .IP "dynamic scoping" 4 |
| 856 | .IX Item "dynamic scoping" |
| 857 | Dynamic scoping works over a dynamic scope, making variables visible |
| 858 | throughout the rest of the \*(L"block\*(R" in which they are first used and |
| 859 | in any subroutines that are called by the rest of the |
| 860 | block. Dynamically scoped variables can have their values temporarily |
| 861 | changed (and implicitly restored later) by a local |
| 862 | operator. (Compare \*(L"lexical scoping\*(R".) Used more loosely to mean |
| 863 | how a subroutine that is in the middle of calling another subroutine |
| 864 | \&\*(L"contains\*(R" that subroutine at \*(L"run time\*(R". |
| 865 | .Sh "E" |
| 866 | .IX Subsection "E" |
| 867 | .IP "eclectic" 4 |
| 868 | .IX Item "eclectic" |
| 869 | Derived from many sources. Some would say \fItoo\fR many. |
| 870 | .IP "element" 4 |
| 871 | .IX Item "element" |
| 872 | A basic building block. When you're talking about an \*(L"array\*(R", it's |
| 873 | one of the items that make up the array. |
| 874 | .IP "embedding" 4 |
| 875 | .IX Item "embedding" |
| 876 | When something is contained in something else, particularly when that |
| 877 | might be considered surprising: \*(L"I've embedded a complete Perl |
| 878 | interpreter in my editor!\*(R" |
| 879 | .IP "empty subclass test" 4 |
| 880 | .IX Item "empty subclass test" |
| 881 | The notion that an empty \*(L"derived class\*(R" should behave exactly like |
| 882 | its \*(L"base class\*(R". |
| 883 | .IP "en passant" 4 |
| 884 | .IX Item "en passant" |
| 885 | When you change a \*(L"value\*(R" as it is being copied. [From French, \*(L"in |
| 886 | passing\*(R", as in the exotic pawn-capturing maneuver in chess.] |
| 887 | .IP "encapsulation" 4 |
| 888 | .IX Item "encapsulation" |
| 889 | The veil of abstraction separating the \*(L"interface\*(R" from the |
| 890 | \&\*(L"implementation\*(R" (whether enforced or not), which mandates that all |
| 891 | access to an \*(L"object\*(R"'s state be through methods alone. |
| 892 | .IP "endian" 4 |
| 893 | .IX Item "endian" |
| 894 | See \*(L"little\-endian\*(R" and \*(L"big\-endian\*(R". |
| 895 | .IP "environment" 4 |
| 896 | .IX Item "environment" |
| 897 | The collective set of environment variables |
| 898 | your \*(L"process\*(R" inherits from its parent. Accessed via \f(CW%ENV\fR. |
| 899 | .IP "environment variable" 4 |
| 900 | .IX Item "environment variable" |
| 901 | A mechanism by which some high-level agent such as a user can pass its |
| 902 | preferences down to its future offspring (child processes, |
| 903 | grandchild processes, great-grandchild processes, and so on). Each |
| 904 | environment variable is a \*(L"key\*(R"/\*(L"value\*(R" pair, like one entry in a |
| 905 | \&\*(L"hash\*(R". |
| 906 | .IP "\s-1EOF\s0" 4 |
| 907 | .IX Item "EOF" |
| 908 | End of File. Sometimes used metaphorically as the terminating string |
| 909 | of a \*(L"here document\*(R". |
| 910 | .IP "errno" 4 |
| 911 | .IX Item "errno" |
| 912 | The error number returned by a \*(L"syscall\*(R" when it fails. Perl refers |
| 913 | to the error by the name \f(CW$!\fR (or \f(CW$OS_ERROR\fR if you use the English |
| 914 | module). |
| 915 | .IP "error" 4 |
| 916 | .IX Item "error" |
| 917 | See \*(L"exception\*(R" or \*(L"fatal error\*(R". |
| 918 | .IP "escape sequence" 4 |
| 919 | .IX Item "escape sequence" |
| 920 | See \*(L"metasymbol\*(R". |
| 921 | .IP "exception" 4 |
| 922 | .IX Item "exception" |
| 923 | A fancy term for an error. See \*(L"fatal error\*(R". |
| 924 | .IP "exception handling" 4 |
| 925 | .IX Item "exception handling" |
| 926 | The way a program responds to an error. The exception handling |
| 927 | mechanism in Perl is the eval operator. |
| 928 | .IP "exec" 4 |
| 929 | .IX Item "exec" |
| 930 | To throw away the current \*(L"process\*(R"'s program and replace it with |
| 931 | another without exiting the process or relinquishing any resources |
| 932 | held (apart from the old memory image). |
| 933 | .IP "executable file" 4 |
| 934 | .IX Item "executable file" |
| 935 | A \*(L"file\*(R" that is specially marked to tell the \*(L"operating system\*(R" |
| 936 | that it's okay to run this file as a program. Usually shortened to |
| 937 | \&\*(L"executable\*(R". |
| 938 | .IP "execute" 4 |
| 939 | .IX Item "execute" |
| 940 | To run a program or \*(L"subroutine\*(R". (Has nothing |
| 941 | to do with the kill built\-in, unless you're trying to |
| 942 | run a \*(L"signal handler\*(R".) |
| 943 | .IP "execute bit" 4 |
| 944 | .IX Item "execute bit" |
| 945 | The special mark that tells the operating system it can run this |
| 946 | program. There are actually three execute bits under Unix, and which |
| 947 | bit gets used depends on whether you own the file singularly, |
| 948 | collectively, or not at all. |
| 949 | .IP "exit status" 4 |
| 950 | .IX Item "exit status" |
| 951 | See \*(L"status\*(R". |
| 952 | .IP "export" 4 |
| 953 | .IX Item "export" |
| 954 | To make symbols from a \*(L"module\*(R" available for \*(L"import\*(R" by other modules. |
| 955 | .IP "expression" 4 |
| 956 | .IX Item "expression" |
| 957 | Anything you can legally say in a spot where a \*(L"value\*(R" is required. |
| 958 | Typically composed of literals, variables, |
| 959 | operators, functions, and \*(L"subroutine\*(R" |
| 960 | calls, not necessarily in that order. |
| 961 | .IP "extension" 4 |
| 962 | .IX Item "extension" |
| 963 | A Perl module that also pulls in compiled C or \*(C+ code. More |
| 964 | generally, any experimental option that can be compiled into Perl, |
| 965 | such as multithreading. |
| 966 | .Sh "F" |
| 967 | .IX Subsection "F" |
| 968 | .IP "false" 4 |
| 969 | .IX Item "false" |
| 970 | In Perl, any value that would look like \f(CW""\fR or \f(CW"0"\fR if evaluated |
| 971 | in a string context. Since undefined values evaluate to \f(CW""\fR, all |
| 972 | undefined values are false, but not all false values are undefined. |
| 973 | .IP "\s-1FAQ\s0" 4 |
| 974 | .IX Item "FAQ" |
| 975 | Frequently Asked Question (although not necessarily frequently |
| 976 | answered, especially if the answer appears in the Perl \s-1FAQ\s0 shipped |
| 977 | standard with Perl). |
| 978 | .IP "fatal error" 4 |
| 979 | .IX Item "fatal error" |
| 980 | An uncaught \*(L"exception\*(R", which causes termination of the \*(L"process\*(R" |
| 981 | after printing a message on your \*(L"standard error\*(R" stream. Errors |
| 982 | that happen inside an eval are not fatal. Instead, |
| 983 | the eval terminates after placing the exception |
| 984 | message in the \f(CW$@\fR (\f(CW$EVAL_ERROR\fR) variable. You can try to |
| 985 | provoke a fatal error with the die operator (known as |
| 986 | throwing or raising an exception), but this may be caught by a |
| 987 | dynamically enclosing eval. If not caught, the |
| 988 | die becomes a fatal error. |
| 989 | .IP "field" 4 |
| 990 | .IX Item "field" |
| 991 | A single piece of numeric or string data that is part of a longer |
| 992 | \&\*(L"string\*(R", \*(L"record\*(R", or \*(L"line\*(R". Variable-width fields are usually |
| 993 | split up by separators (so use split to |
| 994 | extract the fields), while fixed-width fields are usually at fixed |
| 995 | positions (so use unpack). Instance variables are also known as fields. |
| 996 | .IP "\s-1FIFO\s0" 4 |
| 997 | .IX Item "FIFO" |
| 998 | First In, First Out. See also \*(L"\s-1LIFO\s0\*(R". Also, a nickname for a |
| 999 | \&\*(L"named pipe\*(R". |
| 1000 | .IP "file" 4 |
| 1001 | .IX Item "file" |
| 1002 | A named collection of data, usually stored on disk in a \*(L"directory\*(R" |
| 1003 | in a \*(L"filesystem\*(R". Roughly like a document, if you're into office |
| 1004 | metaphors. In modern filesystems, you can actually give a file more |
| 1005 | than one name. Some files have special properties, like directories |
| 1006 | and devices. |
| 1007 | .IP "file descriptor" 4 |
| 1008 | .IX Item "file descriptor" |
| 1009 | The little number the \*(L"operating system\*(R" uses to keep track of which |
| 1010 | opened \*(L"file\*(R" you're talking about. Perl hides the file descriptor |
| 1011 | inside a "standard I/O" stream and then attaches the stream to |
| 1012 | a \*(L"filehandle\*(R". |
| 1013 | .IP "file test operator" 4 |
| 1014 | .IX Item "file test operator" |
| 1015 | A built-in unary operator that you use to determine whether something |
| 1016 | is \*(L"true\*(R" about a file, such as \f(CW\*(C`\-o $filename\*(C'\fR to test whether |
| 1017 | you're the owner of the file. |
| 1018 | .IP "fileglob" 4 |
| 1019 | .IX Item "fileglob" |
| 1020 | A \*(L"wildcard\*(R" match on filenames. See the |
| 1021 | glob function. |
| 1022 | .IP "filehandle" 4 |
| 1023 | .IX Item "filehandle" |
| 1024 | An identifier (not necessarily related to the real name of a file) |
| 1025 | that represents a particular instance of opening a file until you |
| 1026 | close it. If you're going to open and close several different files |
| 1027 | in succession, it's fine to open each of them with the same |
| 1028 | filehandle, so you don't have to write out separate code to process |
| 1029 | each file. |
| 1030 | .IP "filename" 4 |
| 1031 | .IX Item "filename" |
| 1032 | One name for a file. This name is listed in a \*(L"directory\*(R", and you |
| 1033 | can use it in an open to tell the \*(L"operating system\*(R" exactly which file you want to open, and associate the file |
| 1034 | with a \*(L"filehandle\*(R" which will carry the subsequent identity of that |
| 1035 | file in your program, until you close it. |
| 1036 | .IP "filesystem" 4 |
| 1037 | .IX Item "filesystem" |
| 1038 | A set of directories and files residing on a |
| 1039 | partition of the disk. Sometimes known as a \*(L"partition\*(R". You can |
| 1040 | change the file's name or even move a file around from directory to |
| 1041 | directory within a filesystem without actually moving the file itself, |
| 1042 | at least under Unix. |
| 1043 | .IP "filter" 4 |
| 1044 | .IX Item "filter" |
| 1045 | A program designed to take a \*(L"stream\*(R" of input and transform it into |
| 1046 | a stream of output. |
| 1047 | .IP "flag" 4 |
| 1048 | .IX Item "flag" |
| 1049 | We tend to avoid this term because it means so many things. It may |
| 1050 | mean a command-line \*(L"switch\*(R" that takes no argument |
| 1051 | itself (such as Perl's \fB\-n\fR and \fB\-p\fR |
| 1052 | flags) or, less frequently, a single-bit indicator (such as the |
| 1053 | \&\f(CW\*(C`O_CREAT\*(C'\fR and \f(CW\*(C`O_EXCL\*(C'\fR flags used in |
| 1054 | sysopen). |
| 1055 | .IP "floating point" 4 |
| 1056 | .IX Item "floating point" |
| 1057 | A method of storing numbers in \*(L"scientific notation\*(R", such that the |
| 1058 | precision of the number is independent of its magnitude (the decimal |
| 1059 | point \*(L"floats\*(R"). Perl does its numeric work with floating-point |
| 1060 | numbers (sometimes called \*(L"floats\*(R"), when it can't get away with |
| 1061 | using integers. Floating-point numbers are mere |
| 1062 | approximations of real numbers. |
| 1063 | .IP "flush" 4 |
| 1064 | .IX Item "flush" |
| 1065 | The act of emptying a \*(L"buffer\*(R", often before it's full. |
| 1066 | .IP "\s-1FMTEYEWTK\s0" 4 |
| 1067 | .IX Item "FMTEYEWTK" |
| 1068 | Far More Than Everything You Ever Wanted To Know. An exhaustive |
| 1069 | treatise on one narrow topic, something of a super\-\*(L"\s-1FAQ\s0\*(R". See Tom |
| 1070 | for far more. |
| 1071 | .IP "fork" 4 |
| 1072 | .IX Item "fork" |
| 1073 | To create a child \*(L"process\*(R" identical to the parent process at its |
| 1074 | moment of conception, at least until it gets ideas of its own. A |
| 1075 | thread with protected memory. |
| 1076 | .IP "formal arguments" 4 |
| 1077 | .IX Item "formal arguments" |
| 1078 | The generic names by which a \*(L"subroutine\*(R" knows its |
| 1079 | arguments. In many languages, formal arguments are |
| 1080 | always given individual names, but in Perl, the formal arguments are |
| 1081 | just the elements of an array. The formal arguments to a Perl program |
| 1082 | are \f(CW$ARGV[0]\fR, \f(CW$ARGV[1]\fR, and so on. Similarly, the formal |
| 1083 | arguments to a Perl subroutine are \f(CW$_[0]\fR, \f(CW$_[1]\fR, and so on. You |
| 1084 | may give the arguments individual names by assigning the values to a |
| 1085 | my list. See also \*(L"actual arguments\*(R". |
| 1086 | .IP "format" 4 |
| 1087 | .IX Item "format" |
| 1088 | A specification of how many spaces and digits and things to put |
| 1089 | somewhere so that whatever you're printing comes out nice and pretty. |
| 1090 | .IP "freely available" 4 |
| 1091 | .IX Item "freely available" |
| 1092 | Means you don't have to pay money to get it, but the copyright on it |
| 1093 | may still belong to someone else (like Larry). |
| 1094 | .IP "freely redistributable" 4 |
| 1095 | .IX Item "freely redistributable" |
| 1096 | Means you're not in legal trouble if you give a bootleg copy of it to |
| 1097 | your friends and we find out about it. In fact, we'd rather you gave |
| 1098 | a copy to all your friends. |
| 1099 | .IP "freeware" 4 |
| 1100 | .IX Item "freeware" |
| 1101 | Historically, any software that you give away, particularly if you |
| 1102 | make the source code available as well. Now often called \f(CW\*(C`open |
| 1103 | source software\*(C'\fR. Recently there has been a trend to use the term in |
| 1104 | contradistinction to \*(L"open source software\*(R", to refer only to free |
| 1105 | software released under the Free Software Foundation's \s-1GPL\s0 (General |
| 1106 | Public License), but this is difficult to justify etymologically. |
| 1107 | .IP "function" 4 |
| 1108 | .IX Item "function" |
| 1109 | Mathematically, a mapping of each of a set of input values to a |
| 1110 | particular output value. In computers, refers to a \*(L"subroutine\*(R" or |
| 1111 | \&\*(L"operator\*(R" that returns a \*(L"value\*(R". It may or may not have input |
| 1112 | values (called arguments). |
| 1113 | .IP "funny character" 4 |
| 1114 | .IX Item "funny character" |
| 1115 | Someone like Larry, or one of his peculiar friends. Also refers to |
| 1116 | the strange prefixes that Perl requires as noun markers on its |
| 1117 | variables. |
| 1118 | .IP "garbage collection" 4 |
| 1119 | .IX Item "garbage collection" |
| 1120 | A misnamed feature\*(--it should be called, \*(L"expecting your mother to |
| 1121 | pick up after you\*(R". Strictly speaking, Perl doesn't do this, but it |
| 1122 | relies on a reference-counting mechanism to keep things tidy. |
| 1123 | However, we rarely speak strictly and will often refer to the |
| 1124 | reference-counting scheme as a form of garbage collection. (If it's |
| 1125 | any comfort, when your interpreter exits, a \*(L"real\*(R" garbage collector |
| 1126 | runs to make sure everything is cleaned up if you've been messy with |
| 1127 | circular references and such.) |
| 1128 | .Sh "G" |
| 1129 | .IX Subsection "G" |
| 1130 | .IP "\s-1GID\s0" 4 |
| 1131 | .IX Item "GID" |
| 1132 | Group ID\*(--in Unix, the numeric group \s-1ID\s0 that the \*(L"operating system\*(R" |
| 1133 | uses to identify you and members of your \*(L"group\*(R". |
| 1134 | .IP "glob" 4 |
| 1135 | .IX Item "glob" |
| 1136 | Strictly, the shell's \f(CW\*(C`*\*(C'\fR character, which will match a \*(L"glob\*(R" of |
| 1137 | characters when you're trying to generate a list of filenames. |
| 1138 | Loosely, the act of using globs and similar symbols to do pattern |
| 1139 | matching. See also \*(L"fileglob\*(R" and \*(L"typeglob\*(R". |
| 1140 | .IP "global" 4 |
| 1141 | .IX Item "global" |
| 1142 | Something you can see from anywhere, usually used of |
| 1143 | variables and subroutines that are visible |
| 1144 | everywhere in your program. In Perl, only certain special variables |
| 1145 | are truly global\*(--most variables (and all subroutines) exist only in |
| 1146 | the current \*(L"package\*(R". Global variables can be declared with |
| 1147 | our. See \*(L"our\*(R" in perlfunc. |
| 1148 | .IP "global destruction" 4 |
| 1149 | .IX Item "global destruction" |
| 1150 | The \*(L"garbage collection\*(R" of globals (and the running of any |
| 1151 | associated object destructors) that takes place when a Perl |
| 1152 | \&\*(L"interpreter\*(R" is being shut down. Global destruction should not be |
| 1153 | confused with the Apocalypse, except perhaps when it should. |
| 1154 | .IP "glue language" 4 |
| 1155 | .IX Item "glue language" |
| 1156 | A language such as Perl that is good at hooking things together that |
| 1157 | weren't intended to be hooked together. |
| 1158 | .IP "granularity" 4 |
| 1159 | .IX Item "granularity" |
| 1160 | The size of the pieces you're dealing with, mentally speaking. |
| 1161 | .IP "greedy" 4 |
| 1162 | .IX Item "greedy" |
| 1163 | A \*(L"subpattern\*(R" whose \*(L"quantifier\*(R" wants to match as many things as |
| 1164 | possible. |
| 1165 | .IP "grep" 4 |
| 1166 | .IX Item "grep" |
| 1167 | Originally from the old Unix editor command for \*(L"Globally search for a |
| 1168 | Regular Expression and Print it\*(R", now used in the general sense of any |
| 1169 | kind of search, especially text searches. Perl has a built-in |
| 1170 | grep function that searches a list for elements |
| 1171 | matching any given criterion, whereas the \fIgrep\fR(1) program searches |
| 1172 | for lines matching a \*(L"regular expression\*(R" in one or more files. |
| 1173 | .IP "group" 4 |
| 1174 | .IX Item "group" |
| 1175 | A set of users of which you are a member. In some operating systems |
| 1176 | (like Unix), you can give certain file access permissions to other |
| 1177 | members of your group. |
| 1178 | .IP "\s-1GV\s0" 4 |
| 1179 | .IX Item "GV" |
| 1180 | An internal \*(L"glob value\*(R" typedef, holding a \*(L"typeglob\*(R". The \*(L"\s-1GV\s0\*(R" |
| 1181 | type is a subclass of \*(L"\s-1SV\s0\*(R". |
| 1182 | .Sh "H" |
| 1183 | .IX Subsection "H" |
| 1184 | .IP "hacker" 4 |
| 1185 | .IX Item "hacker" |
| 1186 | Someone who is brilliantly persistent in solving technical problems, |
| 1187 | whether these involve golfing, fighting orcs, or programming. Hacker |
| 1188 | is a neutral term, morally speaking. Good hackers are not to be |
| 1189 | confused with evil crackers or clueless script kiddies. If you confuse them, we will presume that |
| 1190 | you are either evil or clueless. |
| 1191 | .IP "handler" 4 |
| 1192 | .IX Item "handler" |
| 1193 | A \*(L"subroutine\*(R" or \*(L"method\*(R" that is called by Perl when your |
| 1194 | program needs to respond to some internal event, such as a \*(L"signal\*(R", |
| 1195 | or an encounter with an operator subject to \*(L"operator overloading\*(R". |
| 1196 | See also \*(L"callback\*(R". |
| 1197 | .IP "hard reference" 4 |
| 1198 | .IX Item "hard reference" |
| 1199 | A \*(L"scalar\*(R" \*(L"value\*(R" containing the actual address of a |
| 1200 | \&\*(L"referent\*(R", such that the referent's \*(L"reference\*(R" count accounts |
| 1201 | for it. (Some hard references are held internally, such as the |
| 1202 | implicit reference from one of a \*(L"typeglob\*(R"'s variable slots to its |
| 1203 | corresponding referent.) A hard reference is different from a |
| 1204 | \&\*(L"symbolic reference\*(R". |
| 1205 | .IP "hash" 4 |
| 1206 | .IX Item "hash" |
| 1207 | An unordered association of \*(L"key\*(R"/\*(L"value\*(R" pairs, stored such that |
| 1208 | you can easily use a string \*(L"key\*(R" to look up its associated data |
| 1209 | \&\*(L"value\*(R". This glossary is like a hash, where the word to be defined |
| 1210 | is the key, and the definition is the value. A hash is also sometimes |
| 1211 | septisyllabically called an \*(L"associative array\*(R", which is a pretty |
| 1212 | good reason for simply calling it a \*(L"hash\*(R" instead. |
| 1213 | .IP "hash table" 4 |
| 1214 | .IX Item "hash table" |
| 1215 | A data structure used internally by Perl for implementing associative |
| 1216 | arrays (hashes) efficiently. See also \*(L"bucket\*(R". |
| 1217 | .IP "header file" 4 |
| 1218 | .IX Item "header file" |
| 1219 | A file containing certain required definitions that you must include |
| 1220 | \&\*(L"ahead\*(R" of the rest of your program to do certain obscure operations. |
| 1221 | A C header file has a \fI.h\fR extension. Perl doesn't really have |
| 1222 | header files, though historically Perl has sometimes used translated |
| 1223 | \&\fI.h\fR files with a \fI.ph\fR extension. See \*(L"require\*(R" in perlfunc. |
| 1224 | (Header files have been superseded by the \*(L"module\*(R" mechanism.) |
| 1225 | .IP "here document" 4 |
| 1226 | .IX Item "here document" |
| 1227 | So called because of a similar construct in shells that |
| 1228 | pretends that the lines following the \*(L"command\*(R" are a |
| 1229 | separate \*(L"file\*(R" to be fed to the command, up to some terminating |
| 1230 | string. In Perl, however, it's just a fancy form of quoting. |
| 1231 | .IP "hexadecimal" 4 |
| 1232 | .IX Item "hexadecimal" |
| 1233 | A number in base 16, \*(L"hex\*(R" for short. The digits for 10 through 16 |
| 1234 | are customarily represented by the letters \f(CW\*(C`a\*(C'\fR through \f(CW\*(C`f\*(C'\fR. |
| 1235 | Hexadecimal constants in Perl start with \f(CW\*(C`0x\*(C'\fR. See also |
| 1236 | \&\*(L"hex\*(R" in perlfunc. |
| 1237 | .IP "home directory" 4 |
| 1238 | .IX Item "home directory" |
| 1239 | The directory you are put into when you log in. On a Unix system, the |
| 1240 | name is often placed into \f(CW$ENV{HOME}\fR or \f(CW$ENV{LOGDIR}\fR by |
| 1241 | \&\fIlogin\fR, but you can also find it with \f(CW\*(C`(getpwuid($<))[7]\*(C'\fR. |
| 1242 | (Some platforms do not have a concept of a home directory.) |
| 1243 | .IP "host" 4 |
| 1244 | .IX Item "host" |
| 1245 | The computer on which a program or other data resides. |
| 1246 | .IP "hubris" 4 |
| 1247 | .IX Item "hubris" |
| 1248 | Excessive pride, the sort of thing Zeus zaps you for. Also the |
| 1249 | quality that makes you write (and maintain) programs that other people |
| 1250 | won't want to say bad things about. Hence, the third great virtue of |
| 1251 | a programmer. See also \*(L"laziness\*(R" and \*(L"impatience\*(R". |
| 1252 | .IP "\s-1HV\s0" 4 |
| 1253 | .IX Item "HV" |
| 1254 | Short for a \*(L"hash value\*(R" typedef, which holds Perl's internal |
| 1255 | representation of a hash. The \*(L"\s-1HV\s0\*(R" type is a subclass of \*(L"\s-1SV\s0\*(R". |
| 1256 | .Sh "I" |
| 1257 | .IX Subsection "I" |
| 1258 | .IP "identifier" 4 |
| 1259 | .IX Item "identifier" |
| 1260 | A legally formed name for most anything in which a computer program |
| 1261 | might be interested. Many languages (including Perl) allow |
| 1262 | identifiers that start with a letter and contain letters and digits. |
| 1263 | Perl also counts the underscore character as a valid letter. (Perl |
| 1264 | also has more complicated names, such as \*(L"qualified\*(R" names.) |
| 1265 | .IP "impatience" 4 |
| 1266 | .IX Item "impatience" |
| 1267 | The anger you feel when the computer is being lazy. This makes you |
| 1268 | write programs that don't just react to your needs, but actually |
| 1269 | anticipate them. Or at least that pretend to. Hence, the second |
| 1270 | great virtue of a programmer. See also \*(L"laziness\*(R" and \*(L"hubris\*(R". |
| 1271 | .IP "implementation" 4 |
| 1272 | .IX Item "implementation" |
| 1273 | How a piece of code actually goes about doing its job. Users of the |
| 1274 | code should not count on implementation details staying the same |
| 1275 | unless they are part of the published \*(L"interface\*(R". |
| 1276 | .IP "import" 4 |
| 1277 | .IX Item "import" |
| 1278 | To gain access to symbols that are exported from another module. See |
| 1279 | \&\*(L"use\*(R" in perlfunc. |
| 1280 | .IP "increment" 4 |
| 1281 | .IX Item "increment" |
| 1282 | To increase the value of something by 1 (or by some other number, if |
| 1283 | so specified). |
| 1284 | .IP "indexing" 4 |
| 1285 | .IX Item "indexing" |
| 1286 | In olden days, the act of looking up a \*(L"key\*(R" in an actual index |
| 1287 | (such as a phone book), but now merely the act of using any kind of |
| 1288 | key or position to find the corresponding \*(L"value\*(R", even if no index |
| 1289 | is involved. Things have degenerated to the point that Perl's |
| 1290 | index function merely locates the position (index) |
| 1291 | of one string in another. |
| 1292 | .IP "indirect filehandle" 4 |
| 1293 | .IX Item "indirect filehandle" |
| 1294 | An \*(L"expression\*(R" that evaluates to something that can be used as a |
| 1295 | \&\*(L"filehandle\*(R": a \*(L"string\*(R" (filehandle name), a \*(L"typeglob\*(R", a |
| 1296 | typeglob \*(L"reference\*(R", or a low-level \*(L"\s-1IO\s0\*(R" object. |
| 1297 | .IP "indirect object" 4 |
| 1298 | .IX Item "indirect object" |
| 1299 | In English grammar, a short noun phrase between a verb and its direct |
| 1300 | object indicating the beneficiary or recipient of the action. In |
| 1301 | Perl, \f(CW\*(C`print STDOUT "$foo\en";\*(C'\fR can be understood as \*(L"verb |
| 1302 | indirect-object object\*(R" where \*(L"\s-1STDOUT\s0\*(R" is the recipient of the |
| 1303 | print action, and \f(CW"$foo"\fR is the object being |
| 1304 | printed. Similarly, when invoking a \*(L"method\*(R", you might place the |
| 1305 | invocant between the method and its arguments: |
| 1306 | .Sp |
| 1307 | .Vb 3 |
| 1308 | \& $gollum = new Pathetic::Creature "Smeagol"; |
| 1309 | \& give $gollum "Fisssssh!"; |
| 1310 | \& give $gollum "Precious!"; |
| 1311 | .Ve |
| 1312 | .IP "indirect object slot" 4 |
| 1313 | .IX Item "indirect object slot" |
| 1314 | The syntactic position falling between a method call and its arguments |
| 1315 | when using the indirect object invocation syntax. (The slot is |
| 1316 | distinguished by the absence of a comma between it and the next |
| 1317 | argument.) \*(L"\s-1STDERR\s0\*(R" is in the indirect object slot here: |
| 1318 | .Sp |
| 1319 | .Vb 2 |
| 1320 | \& print STDERR "Awake! Awake! Fear, Fire, |
| 1321 | \& Foes! Awake!\en"; |
| 1322 | .Ve |
| 1323 | .IP "indirection" 4 |
| 1324 | .IX Item "indirection" |
| 1325 | If something in a program isn't the value you're looking for but |
| 1326 | indicates where the value is, that's indirection. This can be done |
| 1327 | with either symbolic references or hard references. |
| 1328 | .IP "infix" 4 |
| 1329 | .IX Item "infix" |
| 1330 | An \*(L"operator\*(R" that comes in between its operands, such |
| 1331 | as multiplication in \f(CW\*(C`24 * 7\*(C'\fR. |
| 1332 | .IP "inheritance" 4 |
| 1333 | .IX Item "inheritance" |
| 1334 | What you get from your ancestors, genetically or otherwise. If you |
| 1335 | happen to be a \*(L"class\*(R", your ancestors are called base classes and your descendants are called derived classes. See \*(L"single inheritance\*(R" and \*(L"multiple inheritance\*(R". |
| 1336 | .IP "instance" 4 |
| 1337 | .IX Item "instance" |
| 1338 | Short for \*(L"an instance of a class\*(R", meaning an \*(L"object\*(R" of that \*(L"class\*(R". |
| 1339 | .IP "instance variable" 4 |
| 1340 | .IX Item "instance variable" |
| 1341 | An \*(L"attribute\*(R" of an \*(L"object\*(R"; data stored with the particular |
| 1342 | object rather than with the class as a whole. |
| 1343 | .IP "integer" 4 |
| 1344 | .IX Item "integer" |
| 1345 | A number with no fractional (decimal) part. A counting number, like |
| 1346 | 1, 2, 3, and so on, but including 0 and the negatives. |
| 1347 | .IP "interface" 4 |
| 1348 | .IX Item "interface" |
| 1349 | The services a piece of code promises to provide forever, in contrast to |
| 1350 | its \*(L"implementation\*(R", which it should feel free to change whenever it |
| 1351 | likes. |
| 1352 | .IP "interpolation" 4 |
| 1353 | .IX Item "interpolation" |
| 1354 | The insertion of a scalar or list value somewhere in the middle of |
| 1355 | another value, such that it appears to have been there all along. In |
| 1356 | Perl, variable interpolation happens in double-quoted strings and |
| 1357 | patterns, and list interpolation occurs when constructing the list of |
| 1358 | values to pass to a list operator or other such construct that takes a |
| 1359 | \&\*(L"\s-1LIST\s0\*(R". |
| 1360 | .IP "interpreter" 4 |
| 1361 | .IX Item "interpreter" |
| 1362 | Strictly speaking, a program that reads a second program and does what |
| 1363 | the second program says directly without turning the program into a |
| 1364 | different form first, which is what compilers do. Perl |
| 1365 | is not an interpreter by this definition, because it contains a kind |
| 1366 | of compiler that takes a program and turns it into a more executable |
| 1367 | form (syntax trees) within the \fIperl\fR process itself, |
| 1368 | which the Perl \*(L"run time\*(R" system then interprets. |
| 1369 | .IP "invocant" 4 |
| 1370 | .IX Item "invocant" |
| 1371 | The agent on whose behalf a \*(L"method\*(R" is invoked. In a \*(L"class\*(R" |
| 1372 | method, the invocant is a package name. In an \*(L"instance\*(R" method, |
| 1373 | the invocant is an object reference. |
| 1374 | .IP "invocation" 4 |
| 1375 | .IX Item "invocation" |
| 1376 | The act of calling up a deity, daemon, program, method, subroutine, or |
| 1377 | function to get it do what you think it's supposed to do. We usually |
| 1378 | \&\*(L"call\*(R" subroutines but \*(L"invoke\*(R" methods, since it sounds cooler. |
| 1379 | .IP "I/O" 4 |
| 1380 | .IX Item "I/O" |
| 1381 | Input from, or output to, a \*(L"file\*(R" or \*(L"device\*(R". |
| 1382 | .IP "\s-1IO\s0" 4 |
| 1383 | .IX Item "IO" |
| 1384 | An internal I/O object. Can also mean \*(L"indirect object\*(R". |
| 1385 | .IP "\s-1IP\s0" 4 |
| 1386 | .IX Item "IP" |
| 1387 | Internet Protocol, or Intellectual Property. |
| 1388 | .IP "\s-1IPC\s0" 4 |
| 1389 | .IX Item "IPC" |
| 1390 | Interprocess Communication. |
| 1391 | .IP "is-a" 4 |
| 1392 | .IX Item "is-a" |
| 1393 | A relationship between two objects in which one object is |
| 1394 | considered to be a more specific version of the other, generic object: |
| 1395 | \&\*(L"A camel is a mammal.\*(R" Since the generic object really only exists in |
| 1396 | a Platonic sense, we usually add a little abstraction to the notion of |
| 1397 | objects and think of the relationship as being between a generic |
| 1398 | \&\*(L"base class\*(R" and a specific \*(L"derived class\*(R". Oddly enough, |
| 1399 | Platonic classes don't always have Platonic relationships\*(--see |
| 1400 | \&\*(L"inheritance\*(R". |
| 1401 | .IP "iteration" 4 |
| 1402 | .IX Item "iteration" |
| 1403 | Doing something repeatedly. |
| 1404 | .IP "iterator" 4 |
| 1405 | .IX Item "iterator" |
| 1406 | A special programming gizmo that keeps track of where you are in |
| 1407 | something that you're trying to iterate over. The \f(CW\*(C`foreach\*(C'\fR loop in |
| 1408 | Perl contains an iterator; so does a hash, allowing you to |
| 1409 | each through it. |
| 1410 | .IP "\s-1IV\s0" 4 |
| 1411 | .IX Item "IV" |
| 1412 | The integer four, not to be confused with six, Tom's favorite editor. |
| 1413 | \&\s-1IV\s0 also means an internal Integer Value of the type a \*(L"scalar\*(R" can |
| 1414 | hold, not to be confused with an \*(L"\s-1NV\s0\*(R". |
| 1415 | .Sh "J" |
| 1416 | .IX Subsection "J" |
| 1417 | .IP "\s-1JAPH\s0" 4 |
| 1418 | .IX Item "JAPH" |
| 1419 | \&\*(L"Just Another Perl Hacker,\*(R" a clever but cryptic bit of Perl code that |
| 1420 | when executed, evaluates to that string. Often used to illustrate a |
| 1421 | particular Perl feature, and something of an ungoing Obfuscated Perl |
| 1422 | Contest seen in Usenix signatures. |
| 1423 | .Sh "K" |
| 1424 | .IX Subsection "K" |
| 1425 | .IP "key" 4 |
| 1426 | .IX Item "key" |
| 1427 | The string index to a \*(L"hash\*(R", used to look up the \*(L"value\*(R" |
| 1428 | associated with that key. |
| 1429 | .IP "keyword" 4 |
| 1430 | .IX Item "keyword" |
| 1431 | See \*(L"reserved words\*(R". |
| 1432 | .Sh "L" |
| 1433 | .IX Subsection "L" |
| 1434 | .IP "label" 4 |
| 1435 | .IX Item "label" |
| 1436 | A name you give to a \*(L"statement\*(R" so that you can talk about that |
| 1437 | statement elsewhere in the program. |
| 1438 | .IP "laziness" 4 |
| 1439 | .IX Item "laziness" |
| 1440 | The quality that makes you go to great effort to reduce overall energy |
| 1441 | expenditure. It makes you write labor-saving programs that other |
| 1442 | people will find useful, and document what you wrote so you don't have |
| 1443 | to answer so many questions about it. Hence, the first great virtue |
| 1444 | of a programmer. Also hence, this book. See also \*(L"impatience\*(R" and |
| 1445 | \&\*(L"hubris\*(R". |
| 1446 | .IP "left shift" 4 |
| 1447 | .IX Item "left shift" |
| 1448 | A \*(L"bit shift\*(R" that multiplies the number by some power of 2. |
| 1449 | .IP "leftmost longest" 4 |
| 1450 | .IX Item "leftmost longest" |
| 1451 | The preference of the \*(L"regular expression\*(R" engine to match the |
| 1452 | leftmost occurrence of a \*(L"pattern\*(R", then given a position at which a |
| 1453 | match will occur, the preference for the longest match (presuming the |
| 1454 | use of a \*(L"greedy\*(R" quantifier). See perlre for \fImuch\fR more on |
| 1455 | this subject. |
| 1456 | .IP "lexeme" 4 |
| 1457 | .IX Item "lexeme" |
| 1458 | Fancy term for a \*(L"token\*(R". |
| 1459 | .IP "lexer" 4 |
| 1460 | .IX Item "lexer" |
| 1461 | Fancy term for a \*(L"tokener\*(R". |
| 1462 | .IP "lexical analysis" 4 |
| 1463 | .IX Item "lexical analysis" |
| 1464 | Fancy term for \*(L"tokenizing\*(R". |
| 1465 | .IP "lexical scoping" 4 |
| 1466 | .IX Item "lexical scoping" |
| 1467 | Looking at your \fIOxford English Dictionary\fR through a microscope. |
| 1468 | (Also known as \*(L"static scoping\*(R", because dictionaries don't change |
| 1469 | very fast.) Similarly, looking at variables stored in a private |
| 1470 | dictionary (namespace) for each scope, which are visible only from |
| 1471 | their point of declaration down to the end of the lexical scope in |
| 1472 | which they are declared. \-\-Syn. \*(L"static scoping\*(R". |
| 1473 | \&\-\-Ant. \*(L"dynamic scoping\*(R". |
| 1474 | .IP "lexical variable" 4 |
| 1475 | .IX Item "lexical variable" |
| 1476 | A \*(L"variable\*(R" subject to \*(L"lexical scoping\*(R", declared by |
| 1477 | my. Often just called a \*(L"lexical\*(R". (The |
| 1478 | our declaration declares a lexically scoped name for a |
| 1479 | global variable, which is not itself a lexical variable.) |
| 1480 | .IP "library" 4 |
| 1481 | .IX Item "library" |
| 1482 | Generally, a collection of procedures. In ancient days, referred to a |
| 1483 | collection of subroutines in a \fI.pl\fR file. In modern times, refers |
| 1484 | more often to the entire collection of Perl modules on your |
| 1485 | system. |
| 1486 | .IP "\s-1LIFO\s0" 4 |
| 1487 | .IX Item "LIFO" |
| 1488 | Last In, First Out. See also \*(L"\s-1FIFO\s0\*(R". A \s-1LIFO\s0 is usually called a |
| 1489 | \&\*(L"stack\*(R". |
| 1490 | .IP "line" 4 |
| 1491 | .IX Item "line" |
| 1492 | In Unix, a sequence of zero or more non-newline characters terminated |
| 1493 | with a \*(L"newline\*(R" character. On non-Unix machines, this is emulated |
| 1494 | by the C library even if the underlying \*(L"operating system\*(R" has |
| 1495 | different ideas. |
| 1496 | .IP "line buffering" 4 |
| 1497 | .IX Item "line buffering" |
| 1498 | Used by a "standard I/O" output stream that flushes its |
| 1499 | \&\*(L"buffer\*(R" after every \*(L"newline\*(R". Many standard I/O libraries |
| 1500 | automatically set up line buffering on output that is going to the |
| 1501 | terminal. |
| 1502 | .IP "line number" 4 |
| 1503 | .IX Item "line number" |
| 1504 | The number of lines read previous to this one, plus 1. Perl keeps a |
| 1505 | separate line number for each source or input file it opens. The |
| 1506 | current source file's line number is represented by \f(CW\*(C`_\|_LINE_\|_\*(C'\fR. The |
| 1507 | current input line number (for the file that was most recently read |
| 1508 | via \f(CW\*(C`<FH>\*(C'\fR) is represented by the \f(CW$.\fR |
| 1509 | (\f(CW$INPUT_LINE_NUMBER\fR) variable. Many error messages report both |
| 1510 | values, if available. |
| 1511 | .IP "link" 4 |
| 1512 | .IX Item "link" |
| 1513 | Used as a noun, a name in a \*(L"directory\*(R", representing a \*(L"file\*(R". A |
| 1514 | given file can have multiple links to it. It's like having the same |
| 1515 | phone number listed in the phone directory under different names. As |
| 1516 | a verb, to resolve a partially compiled file's unresolved symbols into |
| 1517 | a (nearly) executable image. Linking can generally be static or |
| 1518 | dynamic, which has nothing to do with static or dynamic scoping. |
| 1519 | .IP "\s-1LIST\s0" 4 |
| 1520 | .IX Item "LIST" |
| 1521 | A syntactic construct representing a comma-separated list of |
| 1522 | expressions, evaluated to produce a \*(L"list value\*(R". Each |
| 1523 | \&\*(L"expression\*(R" in a \*(L"\s-1LIST\s0\*(R" is evaluated in \*(L"list context\*(R" and |
| 1524 | interpolated into the list value. |
| 1525 | .IP "list" 4 |
| 1526 | .IX Item "list" |
| 1527 | An ordered set of scalar values. |
| 1528 | .IP "list context" 4 |
| 1529 | .IX Item "list context" |
| 1530 | The situation in which an \*(L"expression\*(R" is expected by its |
| 1531 | surroundings (the code calling it) to return a list of values rather |
| 1532 | than a single value. Functions that want a \*(L"\s-1LIST\s0\*(R" of arguments tell |
| 1533 | those arguments that they should produce a list value. See also |
| 1534 | \&\*(L"context\*(R". |
| 1535 | .IP "list operator" 4 |
| 1536 | .IX Item "list operator" |
| 1537 | An \*(L"operator\*(R" that does something with a list of values, such as |
| 1538 | join or grep. Usually used for |
| 1539 | named built-in operators (such as print, |
| 1540 | unlink, and system) that do not |
| 1541 | require parentheses around their \*(L"argument\*(R" list. |
| 1542 | .IP "list value" 4 |
| 1543 | .IX Item "list value" |
| 1544 | An unnamed list of temporary scalar values that may be passed around |
| 1545 | within a program from any list-generating function to any function or |
| 1546 | construct that provides a \*(L"list context\*(R". |
| 1547 | .IP "literal" 4 |
| 1548 | .IX Item "literal" |
| 1549 | A token in a programming language such as a number or \*(L"string\*(R" that |
| 1550 | gives you an actual \*(L"value\*(R" instead of merely representing possible |
| 1551 | values as a \*(L"variable\*(R" does. |
| 1552 | .IP "little-endian" 4 |
| 1553 | .IX Item "little-endian" |
| 1554 | From Swift: someone who eats eggs little end first. Also used of |
| 1555 | computers that store the least significant \*(L"byte\*(R" of a word at a |
| 1556 | lower byte address than the most significant byte. Often considered |
| 1557 | superior to big-endian machines. See also \*(L"big\-endian\*(R". |
| 1558 | .IP "local" 4 |
| 1559 | .IX Item "local" |
| 1560 | Not meaning the same thing everywhere. A global variable in Perl can |
| 1561 | be localized inside a dynamic scope via the |
| 1562 | local operator. |
| 1563 | .IP "logical operator" 4 |
| 1564 | .IX Item "logical operator" |
| 1565 | Symbols representing the concepts \*(L"and\*(R", \*(L"or\*(R", \*(L"xor\*(R", and \*(L"not\*(R". |
| 1566 | .IP "lookahead" 4 |
| 1567 | .IX Item "lookahead" |
| 1568 | An \*(L"assertion\*(R" that peeks at the string to the right of the current |
| 1569 | match location. |
| 1570 | .IP "lookbehind" 4 |
| 1571 | .IX Item "lookbehind" |
| 1572 | An \*(L"assertion\*(R" that peeks at the string to the left of the current |
| 1573 | match location. |
| 1574 | .IP "loop" 4 |
| 1575 | .IX Item "loop" |
| 1576 | A construct that performs something repeatedly, like a roller coaster. |
| 1577 | .IP "loop control statement" 4 |
| 1578 | .IX Item "loop control statement" |
| 1579 | Any statement within the body of a loop that can make a loop |
| 1580 | prematurely stop looping or skip an \*(L"iteration\*(R". Generally you |
| 1581 | shouldn't try this on roller coasters. |
| 1582 | .IP "loop label" 4 |
| 1583 | .IX Item "loop label" |
| 1584 | A kind of key or name attached to a loop (or roller coaster) so that |
| 1585 | loop control statements can talk about which loop they want to |
| 1586 | control. |
| 1587 | .IP "lvaluable" 4 |
| 1588 | .IX Item "lvaluable" |
| 1589 | Able to serve as an \*(L"lvalue\*(R". |
| 1590 | .IP "lvalue" 4 |
| 1591 | .IX Item "lvalue" |
| 1592 | Term used by language lawyers for a storage location you can assign a |
| 1593 | new \*(L"value\*(R" to, such as a \*(L"variable\*(R" or an element of an |
| 1594 | \&\*(L"array\*(R". The \*(L"l\*(R" is short for \*(L"left\*(R", as in the left side of an |
| 1595 | assignment, a typical place for lvalues. An \*(L"lvaluable\*(R" function or |
| 1596 | expression is one to which a value may be assigned, as in \f(CW\*(C`pos($x) = |
| 1597 | 10\*(C'\fR. |
| 1598 | .IP "lvalue modifier" 4 |
| 1599 | .IX Item "lvalue modifier" |
| 1600 | An adjectival pseudofunction that warps the meaning of an \*(L"lvalue\*(R" |
| 1601 | in some declarative fashion. Currently there are three lvalue |
| 1602 | modifiers: my, our, and |
| 1603 | local. |
| 1604 | .Sh "M" |
| 1605 | .IX Subsection "M" |
| 1606 | .IP "magic" 4 |
| 1607 | .IX Item "magic" |
| 1608 | Technically speaking, any extra semantics attached to a variable such |
| 1609 | as \f(CW$!\fR, \f(CW$0\fR, \f(CW%ENV\fR, or \f(CW%SIG\fR, or to any tied variable. |
| 1610 | Magical things happen when you diddle those variables. |
| 1611 | .IP "magical increment" 4 |
| 1612 | .IX Item "magical increment" |
| 1613 | An \*(L"increment\*(R" operator that knows how to bump up alphabetics as |
| 1614 | well as numbers. |
| 1615 | .IP "magical variables" 4 |
| 1616 | .IX Item "magical variables" |
| 1617 | Special variables that have side effects when you access them or |
| 1618 | assign to them. For example, in Perl, changing elements of the |
| 1619 | \&\f(CW%ENV\fR array also changes the corresponding environment variables |
| 1620 | that subprocesses will use. Reading the \f(CW$!\fR variable gives you the |
| 1621 | current system error number or message. |
| 1622 | .IP "Makefile" 4 |
| 1623 | .IX Item "Makefile" |
| 1624 | A file that controls the compilation of a program. Perl programs |
| 1625 | don't usually need a \*(L"Makefile\*(R" because the Perl compiler has plenty |
| 1626 | of self\-control. |
| 1627 | .IP "man" 4 |
| 1628 | .IX Item "man" |
| 1629 | The Unix program that displays online documentation (manual pages) for |
| 1630 | you. |
| 1631 | .IP "manpage" 4 |
| 1632 | .IX Item "manpage" |
| 1633 | A \*(L"page\*(R" from the manuals, typically accessed via the \fIman\fR(1) |
| 1634 | command. A manpage contains a \s-1SYNOPSIS\s0, a \s-1DESCRIPTION\s0, a list of |
| 1635 | \&\s-1BUGS\s0, and so on, and is typically longer than a page. There are |
| 1636 | manpages documenting commands, syscalls, |
| 1637 | \&\*(L"library\*(R" functions, devices, |
| 1638 | protocols, files, and such. In this book, we |
| 1639 | call any piece of standard Perl documentation (like \fIperlop\fR or |
| 1640 | \&\fIperldelta\fR) a manpage, no matter what format it's installed in on |
| 1641 | your system. |
| 1642 | .IP "matching" 4 |
| 1643 | .IX Item "matching" |
| 1644 | See \*(L"pattern matching\*(R". |
| 1645 | .IP "member data" 4 |
| 1646 | .IX Item "member data" |
| 1647 | See \*(L"instance variable\*(R". |
| 1648 | .IP "memory" 4 |
| 1649 | .IX Item "memory" |
| 1650 | This always means your main memory, not your disk. Clouding the issue |
| 1651 | is the fact that your machine may implement \*(L"virtual\*(R" memory; that |
| 1652 | is, it will pretend that it has more memory than it really does, and |
| 1653 | it'll use disk space to hold inactive bits. This can make it seem |
| 1654 | like you have a little more memory than you really do, but it's not a |
| 1655 | substitute for real memory. The best thing that can be said about |
| 1656 | virtual memory is that it lets your performance degrade gradually |
| 1657 | rather than suddenly when you run out of real memory. But your |
| 1658 | program can die when you run out of virtual memory too, if you haven't |
| 1659 | thrashed your disk to death first. |
| 1660 | .IP "metacharacter" 4 |
| 1661 | .IX Item "metacharacter" |
| 1662 | A \*(L"character\*(R" that is \fInot\fR supposed to be treated normally. Which |
| 1663 | characters are to be treated specially as metacharacters varies |
| 1664 | greatly from context to context. Your \*(L"shell\*(R" will have certain |
| 1665 | metacharacters, double-quoted Perl strings have other |
| 1666 | metacharacters, and \*(L"regular expression\*(R" patterns have all the |
| 1667 | double-quote metacharacters plus some extra ones of their own. |
| 1668 | .IP "metasymbol" 4 |
| 1669 | .IX Item "metasymbol" |
| 1670 | Something we'd call a \*(L"metacharacter\*(R" except that it's a sequence of |
| 1671 | more than one character. Generally, the first character in the |
| 1672 | sequence must be a true metacharacter to get the other characters in |
| 1673 | the metasymbol to misbehave along with it. |
| 1674 | .IP "method" 4 |
| 1675 | .IX Item "method" |
| 1676 | A kind of action that an \*(L"object\*(R" can take if you tell it to. See |
| 1677 | perlobj. |
| 1678 | .IP "minimalism" 4 |
| 1679 | .IX Item "minimalism" |
| 1680 | The belief that \*(L"small is beautiful.\*(R" Paradoxically, if you say |
| 1681 | something in a small language, it turns out big, and if you say it in |
| 1682 | a big language, it turns out small. Go figure. |
| 1683 | .IP "mode" 4 |
| 1684 | .IX Item "mode" |
| 1685 | In the context of the stat syscall, refers to the field holding |
| 1686 | the \*(L"permission bits\*(R" and the type of the \*(L"file\*(R". |
| 1687 | .IP "modifier" 4 |
| 1688 | .IX Item "modifier" |
| 1689 | See \*(L"statement modifier\*(R", \*(L"regular expression modifier\*(R", and |
| 1690 | \&\*(L"lvalue modifier\*(R", not necessarily in that order. |
| 1691 | .IP "module" 4 |
| 1692 | .IX Item "module" |
| 1693 | A \*(L"file\*(R" that defines a \*(L"package\*(R" of (almost) the same name, which |
| 1694 | can either \*(L"export\*(R" symbols or function as an \*(L"object\*(R" class. (A |
| 1695 | module's main \fI.pm\fR file may also load in other files in support of |
| 1696 | the module.) See the use built\-in. |
| 1697 | .IP "modulus" 4 |
| 1698 | .IX Item "modulus" |
| 1699 | An integer divisor when you're interested in the remainder instead of |
| 1700 | the quotient. |
| 1701 | .IP "monger" 4 |
| 1702 | .IX Item "monger" |
| 1703 | Short for Perl Monger, a purveyor of Perl. |
| 1704 | .IP "mortal" 4 |
| 1705 | .IX Item "mortal" |
| 1706 | A temporary value scheduled to die when the current statement |
| 1707 | finishes. |
| 1708 | .IP "multidimensional array" 4 |
| 1709 | .IX Item "multidimensional array" |
| 1710 | An array with multiple subscripts for finding a single element. Perl |
| 1711 | implements these using references\-\-see perllol and |
| 1712 | perldsc. |
| 1713 | .IP "multiple inheritance" 4 |
| 1714 | .IX Item "multiple inheritance" |
| 1715 | The features you got from your mother and father, mixed together |
| 1716 | unpredictably. (See also \*(L"inheritance\*(R", and \*(L"single inheritance\*(R".) In computer languages (including Perl), the notion |
| 1717 | that a given class may have multiple direct ancestors or base classes. |
| 1718 | .Sh "N" |
| 1719 | .IX Subsection "N" |
| 1720 | .IP "named pipe" 4 |
| 1721 | .IX Item "named pipe" |
| 1722 | A \*(L"pipe\*(R" with a name embedded in the \*(L"filesystem\*(R" so that it can |
| 1723 | be accessed by two unrelated processes. |
| 1724 | .IP "namespace" 4 |
| 1725 | .IX Item "namespace" |
| 1726 | A domain of names. You needn't worry about whether the names in one |
| 1727 | such domain have been used in another. See \*(L"package\*(R". |
| 1728 | .IP "network address" 4 |
| 1729 | .IX Item "network address" |
| 1730 | The most important attribute of a socket, like your telephone's |
| 1731 | telephone number. Typically an \s-1IP\s0 address. See also \*(L"port\*(R". |
| 1732 | .IP "newline" 4 |
| 1733 | .IX Item "newline" |
| 1734 | A single character that represents the end of a line, with the \s-1ASCII\s0 |
| 1735 | value of 012 octal under Unix (but 015 on a Mac), and represented by |
| 1736 | \&\f(CW\*(C`\en\*(C'\fR in Perl strings. For Windows machines writing text files, and |
| 1737 | for certain physical devices like terminals, the single newline gets |
| 1738 | automatically translated by your C library into a line feed and a |
| 1739 | carriage return, but normally, no translation is done. |
| 1740 | .IP "\s-1NFS\s0" 4 |
| 1741 | .IX Item "NFS" |
| 1742 | Network File System, which allows you to mount a remote filesystem as |
| 1743 | if it were local. |
| 1744 | .IP "null character" 4 |
| 1745 | .IX Item "null character" |
| 1746 | A character with the \s-1ASCII\s0 value of zero. It's used by C to terminate |
| 1747 | strings, but Perl allows strings to contain a null. |
| 1748 | .IP "null list" 4 |
| 1749 | .IX Item "null list" |
| 1750 | A \*(L"list value\*(R" with zero elements, represented in Perl by \f(CW\*(C`()\*(C'\fR. |
| 1751 | .IP "null string" 4 |
| 1752 | .IX Item "null string" |
| 1753 | A \*(L"string\*(R" containing no characters, not to be confused with a |
| 1754 | string containing a \*(L"null character\*(R", which has a positive length |
| 1755 | and is \*(L"true\*(R". |
| 1756 | .IP "numeric context" 4 |
| 1757 | .IX Item "numeric context" |
| 1758 | The situation in which an expression is expected by its surroundings |
| 1759 | (the code calling it) to return a number. See also \*(L"context\*(R" and |
| 1760 | \&\*(L"string context\*(R". |
| 1761 | .IP "\s-1NV\s0" 4 |
| 1762 | .IX Item "NV" |
| 1763 | Short for Nevada, no part of which will ever be confused with |
| 1764 | civilization. \s-1NV\s0 also means an internal floating-point Numeric Value |
| 1765 | of the type a \*(L"scalar\*(R" can hold, not to be confused with an \*(L"\s-1IV\s0\*(R". |
| 1766 | .IP "nybble" 4 |
| 1767 | .IX Item "nybble" |
| 1768 | Half a \*(L"byte\*(R", equivalent to one \*(L"hexadecimal\*(R" digit, and worth |
| 1769 | four bits. |
| 1770 | .Sh "O" |
| 1771 | .IX Subsection "O" |
| 1772 | .IP "object" 4 |
| 1773 | .IX Item "object" |
| 1774 | An \*(L"instance\*(R" of a \*(L"class\*(R". Something that \*(L"knows\*(R" what |
| 1775 | user-defined type (class) it is, and what it can do because of what |
| 1776 | class it is. Your program can request an object to do things, but the |
| 1777 | object gets to decide whether it wants to do them or not. Some |
| 1778 | objects are more accommodating than others. |
| 1779 | .IP "octal" 4 |
| 1780 | .IX Item "octal" |
| 1781 | A number in base 8. Only the digits 0 through 7 are allowed. Octal |
| 1782 | constants in Perl start with 0, as in 013. See also the |
| 1783 | oct function. |
| 1784 | .IP "offset" 4 |
| 1785 | .IX Item "offset" |
| 1786 | How many things you have to skip over when moving from the beginning |
| 1787 | of a string or array to a specific position within it. Thus, the |
| 1788 | minimum offset is zero, not one, because you don't skip anything to |
| 1789 | get to the first item. |
| 1790 | .IP "one-liner" 4 |
| 1791 | .IX Item "one-liner" |
| 1792 | An entire computer program crammed into one line of text. |
| 1793 | .IP "open source software" 4 |
| 1794 | .IX Item "open source software" |
| 1795 | Programs for which the source code is freely available and freely |
| 1796 | redistributable, with no commercial strings attached. For a more |
| 1797 | detailed definition, see <http://www.opensource.org/osd.html>. |
| 1798 | .IP "operand" 4 |
| 1799 | .IX Item "operand" |
| 1800 | An \*(L"expression\*(R" that yields a \*(L"value\*(R" that an \*(L"operator\*(R" |
| 1801 | operates on. See also \*(L"precedence\*(R". |
| 1802 | .IP "operating system" 4 |
| 1803 | .IX Item "operating system" |
| 1804 | A special program that runs on the bare machine and hides the gory |
| 1805 | details of managing processes and devices. |
| 1806 | Usually used in a looser sense to indicate a particular culture of |
| 1807 | programming. The loose sense can be used at varying levels of |
| 1808 | specificity. At one extreme, you might say that all versions of Unix |
| 1809 | and Unix-lookalikes are the same operating system (upsetting many |
| 1810 | people, especially lawyers and other advocates). At the other |
| 1811 | extreme, you could say this particular version of this particular |
| 1812 | vendor's operating system is different from any other version of this |
| 1813 | or any other vendor's operating system. Perl is much more portable |
| 1814 | across operating systems than many other languages. See also |
| 1815 | \&\*(L"architecture\*(R" and \*(L"platform\*(R". |
| 1816 | .IP "operator" 4 |
| 1817 | .IX Item "operator" |
| 1818 | A gizmo that transforms some number of input values to some number of |
| 1819 | output values, often built into a language with a special syntax or |
| 1820 | symbol. A given operator may have specific expectations about what |
| 1821 | types of data you give as its arguments |
| 1822 | (operands) and what type of data you want back from it. |
| 1823 | .IP "operator overloading" 4 |
| 1824 | .IX Item "operator overloading" |
| 1825 | A kind of \*(L"overloading\*(R" that you can do on built-in |
| 1826 | operators to make them work on objects as if |
| 1827 | the objects were ordinary scalar values, but with the actual semantics |
| 1828 | supplied by the object class. This is set up with the overload |
| 1829 | \&\*(L"pragma\*(R". |
| 1830 | .IP "options" 4 |
| 1831 | .IX Item "options" |
| 1832 | See either switches or \*(L"regular expression modifier\*(R". |
| 1833 | .IP "overloading" 4 |
| 1834 | .IX Item "overloading" |
| 1835 | Giving additional meanings to a symbol or construct. Actually, all |
| 1836 | languages do overloading to one extent or another, since people are |
| 1837 | good at figuring out things from \*(L"context\*(R". |
| 1838 | .IP "overriding" 4 |
| 1839 | .IX Item "overriding" |
| 1840 | Hiding or invalidating some other definition of the same name. (Not |
| 1841 | to be confused with \*(L"overloading\*(R", which adds definitions that must |
| 1842 | be disambiguated some other way.) To confuse the issue further, we use |
| 1843 | the word with two overloaded definitions: to describe how you can |
| 1844 | define your own \*(L"subroutine\*(R" to hide a built-in \*(L"function\*(R" of the |
| 1845 | same name (see \*(L"Overriding Built-in Functions\*(R" in perlsub) and to |
| 1846 | describe how you can define a replacement \*(L"method\*(R" in a \*(L"derived class\*(R" to hide a \*(L"base class\*(R"'s method of the same name (see |
| 1847 | perlobj). |
| 1848 | .IP "owner" 4 |
| 1849 | .IX Item "owner" |
| 1850 | The one user (apart from the superuser) who has absolute control over |
| 1851 | a \*(L"file\*(R". A file may also have a \*(L"group\*(R" of users who may |
| 1852 | exercise joint ownership if the real owner permits it. See |
| 1853 | \&\*(L"permission bits\*(R". |
| 1854 | .Sh "P" |
| 1855 | .IX Subsection "P" |
| 1856 | .IP "package" 4 |
| 1857 | .IX Item "package" |
| 1858 | A \*(L"namespace\*(R" for global variables, |
| 1859 | subroutines, and the like, such that they can be kept |
| 1860 | separate from like-named symbols in other namespaces. In a |
| 1861 | sense, only the package is global, since the symbols in the package's |
| 1862 | symbol table are only accessible from code compiled outside the |
| 1863 | package by naming the package. But in another sense, all package |
| 1864 | symbols are also globals\*(--they're just well-organized globals. |
| 1865 | .IP "pad" 4 |
| 1866 | .IX Item "pad" |
| 1867 | Short for \*(L"scratchpad\*(R". |
| 1868 | .IP "parameter" 4 |
| 1869 | .IX Item "parameter" |
| 1870 | See \*(L"argument\*(R". |
| 1871 | .IP "parent class" 4 |
| 1872 | .IX Item "parent class" |
| 1873 | See \*(L"base class\*(R". |
| 1874 | .IP "parse tree" 4 |
| 1875 | .IX Item "parse tree" |
| 1876 | See \*(L"syntax tree\*(R". |
| 1877 | .IP "parsing" 4 |
| 1878 | .IX Item "parsing" |
| 1879 | The subtle but sometimes brutal art of attempting to turn your |
| 1880 | possibly malformed program into a valid \*(L"syntax tree\*(R". |
| 1881 | .IP "patch" 4 |
| 1882 | .IX Item "patch" |
| 1883 | To fix by applying one, as it were. In the realm of hackerdom, a |
| 1884 | listing of the differences between two versions of a program as might |
| 1885 | be applied by the \fIpatch\fR(1) program when you want to fix a bug or |
| 1886 | upgrade your old version. |
| 1887 | .IP "\s-1PATH\s0" 4 |
| 1888 | .IX Item "PATH" |
| 1889 | The list of directories the system searches to find a |
| 1890 | program you want to \*(L"execute\*(R". The list is stored as one of your |
| 1891 | environment variables, accessible in Perl as |
| 1892 | \&\f(CW$ENV{PATH}\fR. |
| 1893 | .IP "pathname" 4 |
| 1894 | .IX Item "pathname" |
| 1895 | A fully qualified filename such as \fI/usr/bin/perl\fR. Sometimes |
| 1896 | confused with \*(L"\s-1PATH\s0\*(R". |
| 1897 | .IP "pattern" 4 |
| 1898 | .IX Item "pattern" |
| 1899 | A template used in \*(L"pattern matching\*(R". |
| 1900 | .IP "pattern matching" 4 |
| 1901 | .IX Item "pattern matching" |
| 1902 | Taking a pattern, usually a \*(L"regular expression\*(R", and trying the |
| 1903 | pattern various ways on a string to see whether there's any way to |
| 1904 | make it fit. Often used to pick interesting tidbits out of a file. |
| 1905 | .IP "permission bits" 4 |
| 1906 | .IX Item "permission bits" |
| 1907 | Bits that the \*(L"owner\*(R" of a file sets or unsets to allow or disallow |
| 1908 | access to other people. These flag bits are part of the \*(L"mode\*(R" word |
| 1909 | returned by the stat built-in when you ask about a |
| 1910 | file. On Unix systems, you can check the \fIls\fR(1) manpage for more |
| 1911 | information. |
| 1912 | .IP "Pern" 4 |
| 1913 | .IX Item "Pern" |
| 1914 | What you get when you do \f(CW\*(C`Perl++\*(C'\fR twice. Doing it only once will |
| 1915 | curl your hair. You have to increment it eight times to shampoo your |
| 1916 | hair. Lather, rinse, iterate. |
| 1917 | .IP "pipe" 4 |
| 1918 | .IX Item "pipe" |
| 1919 | A direct \*(L"connection\*(R" that carries the output of one \*(L"process\*(R" to |
| 1920 | the input of another without an intermediate temporary file. Once the |
| 1921 | pipe is set up, the two processes in question can read and write as if |
| 1922 | they were talking to a normal file, with some caveats. |
| 1923 | .IP "pipeline" 4 |
| 1924 | .IX Item "pipeline" |
| 1925 | A series of processes all in a row, linked by |
| 1926 | pipes, where each passes its output stream to the next. |
| 1927 | .IP "platform" 4 |
| 1928 | .IX Item "platform" |
| 1929 | The entire hardware and software context in which a program runs. A |
| 1930 | program written in a platform-dependent language might break if you |
| 1931 | change any of: machine, operating system, libraries, compiler, or |
| 1932 | system configuration. The \fIperl\fR interpreter has to be compiled |
| 1933 | differently for each platform because it is implemented in C, but |
| 1934 | programs written in the Perl language are largely |
| 1935 | platform\-independent. |
| 1936 | .IP "pod" 4 |
| 1937 | .IX Item "pod" |
| 1938 | The markup used to embed documentation into your Perl code. See |
| 1939 | perlpod. |
| 1940 | .IP "pointer" 4 |
| 1941 | .IX Item "pointer" |
| 1942 | A \*(L"variable\*(R" in a language like C that contains the exact memory |
| 1943 | location of some other item. Perl handles pointers internally so you |
| 1944 | don't have to worry about them. Instead, you just use symbolic |
| 1945 | pointers in the form of keys and \*(L"variable\*(R" names, or hard references, which aren't pointers (but act like |
| 1946 | pointers and do in fact contain pointers). |
| 1947 | .IP "polymorphism" 4 |
| 1948 | .IX Item "polymorphism" |
| 1949 | The notion that you can tell an \*(L"object\*(R" to do something generic, |
| 1950 | and the object will interpret the command in different ways depending |
| 1951 | on its type. [<Gk many shapes] |
| 1952 | .IP "port" 4 |
| 1953 | .IX Item "port" |
| 1954 | The part of the address of a \s-1TCP\s0 or \s-1UDP\s0 socket that directs packets to |
| 1955 | the correct process after finding the right machine, something like |
| 1956 | the phone extension you give when you reach the company operator. |
| 1957 | Also, the result of converting code to run on a different platform |
| 1958 | than originally intended, or the verb denoting this conversion. |
| 1959 | .IP "portable" 4 |
| 1960 | .IX Item "portable" |
| 1961 | Once upon a time, C code compilable under both \s-1BSD\s0 and SysV. In |
| 1962 | general, code that can be easily converted to run on another |
| 1963 | \&\*(L"platform\*(R", where \*(L"easily\*(R" can be defined however you like, and |
| 1964 | usually is. Anything may be considered portable if you try hard |
| 1965 | enough. See \fImobile home\fR or \fILondon Bridge\fR. |
| 1966 | .IP "porter" 4 |
| 1967 | .IX Item "porter" |
| 1968 | Someone who \*(L"carries\*(R" software from one \*(L"platform\*(R" to another. |
| 1969 | Porting programs written in platform-dependent languages such as C can |
| 1970 | be difficult work, but porting programs like Perl is very much worth |
| 1971 | the agony. |
| 1972 | .IP "\s-1POSIX\s0" 4 |
| 1973 | .IX Item "POSIX" |
| 1974 | The Portable Operating System Interface specification. |
| 1975 | .IP "postfix" 4 |
| 1976 | .IX Item "postfix" |
| 1977 | An \*(L"operator\*(R" that follows its \*(L"operand\*(R", as in \f(CW\*(C`$x++\*(C'\fR. |
| 1978 | .IP "pp" 4 |
| 1979 | .IX Item "pp" |
| 1980 | An internal shorthand for a \*(L"push\-pop\*(R" code, that is, C code |
| 1981 | implementing Perl's stack machine. |
| 1982 | .IP "pragma" 4 |
| 1983 | .IX Item "pragma" |
| 1984 | A standard module whose practical hints and suggestions are received |
| 1985 | (and possibly ignored) at compile time. Pragmas are named in all |
| 1986 | lowercase. |
| 1987 | .IP "precedence" 4 |
| 1988 | .IX Item "precedence" |
| 1989 | The rules of conduct that, in the absence of other guidance, determine |
| 1990 | what should happen first. For example, in the absence of parentheses, |
| 1991 | you always do multiplication before addition. |
| 1992 | .IP "prefix" 4 |
| 1993 | .IX Item "prefix" |
| 1994 | An \*(L"operator\*(R" that precedes its \*(L"operand\*(R", as in \f(CW\*(C`++$x\*(C'\fR. |
| 1995 | .IP "preprocessing" 4 |
| 1996 | .IX Item "preprocessing" |
| 1997 | What some helper \*(L"process\*(R" did to transform the incoming data into a |
| 1998 | form more suitable for the current process. Often done with an |
| 1999 | incoming \*(L"pipe\*(R". See also \*(L"C preprocessor\*(R". |
| 2000 | .IP "procedure" 4 |
| 2001 | .IX Item "procedure" |
| 2002 | A \*(L"subroutine\*(R". |
| 2003 | .IP "process" 4 |
| 2004 | .IX Item "process" |
| 2005 | An instance of a running program. Under multitasking systems like |
| 2006 | Unix, two or more separate processes could be running the same program |
| 2007 | independently at the same time\*(--in fact, the fork |
| 2008 | function is designed to bring about this happy state of affairs. |
| 2009 | Under other operating systems, processes are sometimes called |
| 2010 | \&\*(L"threads\*(R", \*(L"tasks\*(R", or \*(L"jobs\*(R", often with slight nuances in meaning. |
| 2011 | .IP "program generator" 4 |
| 2012 | .IX Item "program generator" |
| 2013 | A system that algorithmically writes code for you in a high-level |
| 2014 | language. See also \*(L"code generator\*(R". |
| 2015 | .IP "progressive matching" 4 |
| 2016 | .IX Item "progressive matching" |
| 2017 | Pattern matching that picks up where it left off before. |
| 2018 | .IP "property" 4 |
| 2019 | .IX Item "property" |
| 2020 | See either \*(L"instance variable\*(R" or \*(L"character property\*(R". |
| 2021 | .IP "protocol" 4 |
| 2022 | .IX Item "protocol" |
| 2023 | In networking, an agreed-upon way of sending messages back and forth |
| 2024 | so that neither correspondent will get too confused. |
| 2025 | .IP "prototype" 4 |
| 2026 | .IX Item "prototype" |
| 2027 | An optional part of a \*(L"subroutine\*(R" declaration telling the Perl |
| 2028 | compiler how many and what flavor of arguments may be passed as |
| 2029 | \&\*(L"actual arguments\*(R", so that you can write subroutine calls that |
| 2030 | parse much like built-in functions. (Or don't parse, as the case may |
| 2031 | be.) |
| 2032 | .IP "pseudofunction" 4 |
| 2033 | .IX Item "pseudofunction" |
| 2034 | A construct that sometimes looks like a function but really isn't. |
| 2035 | Usually reserved for \*(L"lvalue\*(R" modifiers like my, for |
| 2036 | \&\*(L"context\*(R" modifiers like scalar, and for the |
| 2037 | pick-your-own-quotes constructs, \f(CW\*(C`q//\*(C'\fR, \f(CW\*(C`qq//\*(C'\fR, \f(CW\*(C`qx//\*(C'\fR, \f(CW\*(C`qw//\*(C'\fR, |
| 2038 | \&\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 \f(CW\*(C`tr///\*(C'\fR. |
| 2039 | .IP "pseudohash" 4 |
| 2040 | .IX Item "pseudohash" |
| 2041 | A reference to an array whose initial element happens to hold a |
| 2042 | reference to a hash. You can treat a pseudohash reference as either |
| 2043 | an array reference or a hash reference. |
| 2044 | .IP "pseudoliteral" 4 |
| 2045 | .IX Item "pseudoliteral" |
| 2046 | An \*(L"operator\*(R" that looks something like a \*(L"literal\*(R", such as the |
| 2047 | output-grabbing operator, \f(CW\*(C``\*(C'\fR\fI\f(CI\*(C`command\*(C'\fI\fR\f(CW\*(C``\*(C'\fR. |
| 2048 | .IP "public domain" 4 |
| 2049 | .IX Item "public domain" |
| 2050 | Something not owned by anybody. Perl is copyrighted and is thus |
| 2051 | \&\fInot\fR in the public domain\*(--it's just \*(L"freely available\*(R" and |
| 2052 | \&\*(L"freely redistributable\*(R". |
| 2053 | .IP "pumpkin" 4 |
| 2054 | .IX Item "pumpkin" |
| 2055 | A notional \*(L"baton\*(R" handed around the Perl community indicating who is |
| 2056 | the lead integrator in some arena of development. |
| 2057 | .IP "pumpking" 4 |
| 2058 | .IX Item "pumpking" |
| 2059 | A \*(L"pumpkin\*(R" holder, the person in charge of pumping the pump, or at |
| 2060 | least priming it. Must be willing to play the part of the Great |
| 2061 | Pumpkin now and then. |
| 2062 | .IP "\s-1PV\s0" 4 |
| 2063 | .IX Item "PV" |
| 2064 | A \*(L"pointer value\*(R", which is Perl Internals Talk for a \f(CW\*(C`char*\*(C'\fR. |
| 2065 | .Sh "Q" |
| 2066 | .IX Subsection "Q" |
| 2067 | .IP "qualified" 4 |
| 2068 | .IX Item "qualified" |
| 2069 | Possessing a complete name. The symbol \f(CW$Ent::moot\fR is qualified; |
| 2070 | \&\f(CW$moot\fR is unqualified. A fully qualified filename is specified from |
| 2071 | the top-level directory. |
| 2072 | .IP "quantifier" 4 |
| 2073 | .IX Item "quantifier" |
| 2074 | A component of a \*(L"regular expression\*(R" specifying how many times the |
| 2075 | foregoing \*(L"atom\*(R" may occur. |
| 2076 | .Sh "R" |
| 2077 | .IX Subsection "R" |
| 2078 | .IP "readable" 4 |
| 2079 | .IX Item "readable" |
| 2080 | With respect to files, one that has the proper permission bit set to |
| 2081 | let you access the file. With respect to computer programs, one |
| 2082 | that's written well enough that someone has a chance of figuring out |
| 2083 | what it's trying to do. |
| 2084 | .IP "reaping" 4 |
| 2085 | .IX Item "reaping" |
| 2086 | The last rites performed by a parent \*(L"process\*(R" on behalf of a |
| 2087 | deceased child process so that it doesn't remain a \*(L"zombie\*(R". See |
| 2088 | the wait and waitpid function |
| 2089 | calls. |
| 2090 | .IP "record" 4 |
| 2091 | .IX Item "record" |
| 2092 | A set of related data values in a \*(L"file\*(R" or \*(L"stream\*(R", often |
| 2093 | associated with a unique \*(L"key\*(R" field. In Unix, often commensurate |
| 2094 | with a \*(L"line\*(R", or a blank-line-terminated set of lines (a |
| 2095 | \&\*(L"paragraph\*(R"). Each line of the \fI/etc/passwd\fR file is a record, keyed |
| 2096 | on login name, containing information about that user. |
| 2097 | .IP "recursion" 4 |
| 2098 | .IX Item "recursion" |
| 2099 | The art of defining something (at least partly) in terms of itself, |
| 2100 | which is a naughty no-no in dictionaries but often works out okay in |
| 2101 | computer programs if you're careful not to recurse forever, which is |
| 2102 | like an infinite loop with more spectacular failure modes. |
| 2103 | .IP "reference" 4 |
| 2104 | .IX Item "reference" |
| 2105 | Where you look to find a pointer to information somewhere else. (See |
| 2106 | \&\*(L"indirection\*(R".) References come in two flavors, symbolic references and hard references. |
| 2107 | .IP "referent" 4 |
| 2108 | .IX Item "referent" |
| 2109 | Whatever a reference refers to, which may or may not have a name. |
| 2110 | Common types of referents include scalars, arrays, hashes, and |
| 2111 | subroutines. |
| 2112 | .IP "regex" 4 |
| 2113 | .IX Item "regex" |
| 2114 | See \*(L"regular expression\*(R". |
| 2115 | .IP "regular expression" 4 |
| 2116 | .IX Item "regular expression" |
| 2117 | A single entity with various interpretations, like an elephant. To a |
| 2118 | computer scientist, it's a grammar for a little language in which some |
| 2119 | strings are legal and others aren't. To normal people, it's a pattern |
| 2120 | you can use to find what you're looking for when it varies from case |
| 2121 | to case. Perl's regular expressions are far from regular in the |
| 2122 | theoretical sense, but in regular use they work quite well. Here's a |
| 2123 | regular expression: \f(CW\*(C`/Oh s.*t./\*(C'\fR. This will match strings like "\f(CW\*(C`Oh |
| 2124 | say can you see by the dawn's early light\*(C'\fR\*(L" and \*(R"\f(CW\*(C`Oh sit!\*(C'\fR". See |
| 2125 | perlre. |
| 2126 | .IP "regular expression modifier" 4 |
| 2127 | .IX Item "regular expression modifier" |
| 2128 | An option on a pattern or substitution, such as \f(CW\*(C`/i\*(C'\fR to render the |
| 2129 | pattern case insensitive. See also \*(L"cloister\*(R". |
| 2130 | .IP "regular file" 4 |
| 2131 | .IX Item "regular file" |
| 2132 | A \*(L"file\*(R" that's not a \*(L"directory\*(R", a \*(L"device\*(R", a named \*(L"pipe\*(R" |
| 2133 | or \*(L"socket\*(R", or a \*(L"symbolic link\*(R". Perl uses the \f(CW\*(C`\-f\*(C'\fR file test |
| 2134 | operator to identify regular files. Sometimes called a \*(L"plain\*(R" file. |
| 2135 | .IP "relational operator" 4 |
| 2136 | .IX Item "relational operator" |
| 2137 | An \*(L"operator\*(R" that says whether a particular ordering relationship |
| 2138 | is \*(L"true\*(R" about a pair of operands. Perl has both |
| 2139 | numeric and string relational operators. See \*(L"collating sequence\*(R". |
| 2140 | .IP "reserved words" 4 |
| 2141 | .IX Item "reserved words" |
| 2142 | A word with a specific, built-in meaning to a \*(L"compiler\*(R", such as |
| 2143 | \&\f(CW\*(C`if\*(C'\fR or delete. In many languages (not Perl), |
| 2144 | it's illegal to use reserved words to name anything else. (Which is |
| 2145 | why they're reserved, after all.) In Perl, you just can't use them to |
| 2146 | name labels or filehandles. Also called |
| 2147 | \&\*(L"keywords\*(R". |
| 2148 | .IP "return value" 4 |
| 2149 | .IX Item "return value" |
| 2150 | The \*(L"value\*(R" produced by a \*(L"subroutine\*(R" or \*(L"expression\*(R" when |
| 2151 | evaluated. In Perl, a return value may be either a \*(L"list\*(R" or a |
| 2152 | \&\*(L"scalar\*(R". |
| 2153 | .IP "\s-1RFC\s0" 4 |
| 2154 | .IX Item "RFC" |
| 2155 | Request For Comment, which despite the timid connotations is the name |
| 2156 | of a series of important standards documents. |
| 2157 | .IP "right shift" 4 |
| 2158 | .IX Item "right shift" |
| 2159 | A \*(L"bit shift\*(R" that divides a number by some power of 2. |
| 2160 | .IP "root" 4 |
| 2161 | .IX Item "root" |
| 2162 | The superuser (\s-1UID\s0 == 0). Also, the top-level directory of the |
| 2163 | filesystem. |
| 2164 | .IP "\s-1RTFM\s0" 4 |
| 2165 | .IX Item "RTFM" |
| 2166 | What you are told when someone thinks you should Read The Fine Manual. |
| 2167 | .IP "run phase" 4 |
| 2168 | .IX Item "run phase" |
| 2169 | Any time after Perl starts running your main program. See also |
| 2170 | \&\*(L"compile phase\*(R". Run phase is mostly spent in \*(L"run time\*(R" but may |
| 2171 | also be spent in \*(L"compile time\*(R" when require, |
| 2172 | do \f(CW\*(C`FILE\*(C'\fR, or eval \f(CW\*(C`STRING\*(C'\fR |
| 2173 | operators are executed or when a substitution uses the \f(CW\*(C`/ee\*(C'\fR |
| 2174 | modifier. |
| 2175 | .IP "run time" 4 |
| 2176 | .IX Item "run time" |
| 2177 | The time when Perl is actually doing what your code says to do, as |
| 2178 | opposed to the earlier period of time when it was trying to figure out |
| 2179 | whether what you said made any sense whatsoever, which is \*(L"compile time\*(R". |
| 2180 | .IP "run-time pattern" 4 |
| 2181 | .IX Item "run-time pattern" |
| 2182 | A pattern that contains one or more variables to be interpolated |
| 2183 | before parsing the pattern as a \*(L"regular expression\*(R", and that |
| 2184 | therefore cannot be analyzed at compile time, but must be re-analyzed |
| 2185 | each time the pattern match operator is evaluated. Run-time patterns |
| 2186 | are useful but expensive. |
| 2187 | .IP "\s-1RV\s0" 4 |
| 2188 | .IX Item "RV" |
| 2189 | A recreational vehicle, not to be confused with vehicular recreation. |
| 2190 | \&\s-1RV\s0 also means an internal Reference Value of the type a \*(L"scalar\*(R" can |
| 2191 | hold. See also \*(L"\s-1IV\s0\*(R" and \*(L"\s-1NV\s0\*(R" if you're not confused yet. |
| 2192 | .IP "rvalue" 4 |
| 2193 | .IX Item "rvalue" |
| 2194 | A \*(L"value\*(R" that you might find on the right side of an |
| 2195 | \&\*(L"assignment\*(R". See also \*(L"lvalue\*(R". |
| 2196 | .Sh "S" |
| 2197 | .IX Subsection "S" |
| 2198 | .IP "scalar" 4 |
| 2199 | .IX Item "scalar" |
| 2200 | A simple, singular value; a number, \*(L"string\*(R", or \*(L"reference\*(R". |
| 2201 | .IP "scalar context" 4 |
| 2202 | .IX Item "scalar context" |
| 2203 | The situation in which an \*(L"expression\*(R" is expected by its |
| 2204 | surroundings (the code calling it) to return a single \*(L"value\*(R" rather |
| 2205 | than a \*(L"list\*(R" of values. See also \*(L"context\*(R" and \*(L"list context\*(R". |
| 2206 | A scalar context sometimes imposes additional constraints on the |
| 2207 | return value\*(--see \*(L"string context\*(R" and \*(L"numeric context\*(R". |
| 2208 | Sometimes we talk about a \*(L"Boolean context\*(R" inside conditionals, but |
| 2209 | this imposes no additional constraints, since any scalar value, |
| 2210 | whether numeric or \*(L"string\*(R", is already true or false. |
| 2211 | .IP "scalar literal" 4 |
| 2212 | .IX Item "scalar literal" |
| 2213 | A number or quoted \*(L"string\*(R"\-\-an actual \*(L"value\*(R" in the text of your |
| 2214 | program, as opposed to a \*(L"variable\*(R". |
| 2215 | .IP "scalar value" 4 |
| 2216 | .IX Item "scalar value" |
| 2217 | A value that happens to be a \*(L"scalar\*(R" as opposed to a \*(L"list\*(R". |
| 2218 | .IP "scalar variable" 4 |
| 2219 | .IX Item "scalar variable" |
| 2220 | A \*(L"variable\*(R" prefixed with \f(CW\*(C`$\*(C'\fR that holds a single value. |
| 2221 | .IP "scope" 4 |
| 2222 | .IX Item "scope" |
| 2223 | How far away you can see a variable from, looking through one. Perl |
| 2224 | has two visibility mechanisms: it does \*(L"dynamic scoping\*(R" of |
| 2225 | local variables, meaning that the rest |
| 2226 | of the \*(L"block\*(R", and any subroutines that are called |
| 2227 | by the rest of the block, can see the variables that are local to the |
| 2228 | block. Perl does \*(L"lexical scoping\*(R" of my variables, |
| 2229 | meaning that the rest of the block can see the variable, but other |
| 2230 | subroutines called by the block \fIcannot\fR see the variable. |
| 2231 | .IP "scratchpad" 4 |
| 2232 | .IX Item "scratchpad" |
| 2233 | The area in which a particular invocation of a particular file or |
| 2234 | subroutine keeps some of its temporary values, including any lexically |
| 2235 | scoped variables. |
| 2236 | .IP "script" 4 |
| 2237 | .IX Item "script" |
| 2238 | A text \*(L"file\*(R" that is a program intended to be executed |
| 2239 | directly rather than compiled to another form of file |
| 2240 | before execution. Also, in the context of \*(L"Unicode\*(R", a writing |
| 2241 | system for a particular language or group of languages, such as Greek, |
| 2242 | Bengali, or Klingon. |
| 2243 | .IP "script kiddie" 4 |
| 2244 | .IX Item "script kiddie" |
| 2245 | A \*(L"cracker\*(R" who is not a \*(L"hacker\*(R", but knows just enough to run |
| 2246 | canned scripts. A cargo-cult programmer. |
| 2247 | .IP "sed" 4 |
| 2248 | .IX Item "sed" |
| 2249 | A venerable Stream EDitor from which Perl derives some of its ideas. |
| 2250 | .IP "semaphore" 4 |
| 2251 | .IX Item "semaphore" |
| 2252 | A fancy kind of interlock that prevents multiple threads or |
| 2253 | processes from using up the same resources simultaneously. |
| 2254 | .IP "separator" 4 |
| 2255 | .IX Item "separator" |
| 2256 | A \*(L"character\*(R" or \*(L"string\*(R" that keeps two surrounding strings from |
| 2257 | being confused with each other. The split function |
| 2258 | works on separators. Not to be confused with delimiters |
| 2259 | or terminators. The \*(L"or\*(R" in the previous sentence |
| 2260 | separated the two alternatives. |
| 2261 | .IP "serialization" 4 |
| 2262 | .IX Item "serialization" |
| 2263 | Putting a fancy \*(L"data structure\*(R" into linear order so that it can be |
| 2264 | stored as a \*(L"string\*(R" in a disk file or database or sent through a |
| 2265 | \&\*(L"pipe\*(R". Also called marshalling. |
| 2266 | .IP "server" 4 |
| 2267 | .IX Item "server" |
| 2268 | In networking, a \*(L"process\*(R" that either advertises a \*(L"service\*(R" or |
| 2269 | just hangs around at a known location and waits for clients |
| 2270 | who need service to get in touch with it. |
| 2271 | .IP "service" 4 |
| 2272 | .IX Item "service" |
| 2273 | Something you do for someone else to make them happy, like giving them |
| 2274 | the time of day (or of their life). On some machines, well-known |
| 2275 | services are listed by the getservent function. |
| 2276 | .IP "setgid" 4 |
| 2277 | .IX Item "setgid" |
| 2278 | Same as \*(L"setuid\*(R", only having to do with giving away \*(L"group\*(R" |
| 2279 | privileges. |
| 2280 | .IP "setuid" 4 |
| 2281 | .IX Item "setuid" |
| 2282 | Said of a program that runs with the privileges of its \*(L"owner\*(R" |
| 2283 | rather than (as is usually the case) the privileges of whoever is |
| 2284 | running it. Also describes the bit in the mode word (\*(L"permission bits\*(R") that controls the feature. This bit must be explicitly set by |
| 2285 | the owner to enable this feature, and the program must be carefully |
| 2286 | written not to give away more privileges than it ought to. |
| 2287 | .IP "shared memory" 4 |
| 2288 | .IX Item "shared memory" |
| 2289 | A piece of \*(L"memory\*(R" accessible by two different |
| 2290 | processes who otherwise would not see each other's memory. |
| 2291 | .IP "shebang" 4 |
| 2292 | .IX Item "shebang" |
| 2293 | Irish for the whole McGillicuddy. In Perl culture, a portmanteau of |
| 2294 | \&\*(L"sharp\*(R" and \*(L"bang\*(R", meaning the \f(CW\*(C`#!\*(C'\fR sequence that tells the system |
| 2295 | where to find the interpreter. |
| 2296 | .IP "shell" 4 |
| 2297 | .IX Item "shell" |
| 2298 | A \*(L"command\*(R"\-line \*(L"interpreter\*(R". The program that interactively |
| 2299 | gives you a prompt, accepts one or more lines of input, and |
| 2300 | executes the programs you mentioned, feeding each of them their proper |
| 2301 | arguments and input data. Shells can also execute |
| 2302 | scripts containing such commands. Under Unix, typical shells include |
| 2303 | the Bourne shell (\fI/bin/sh\fR), the C shell (\fI/bin/csh\fR), and the Korn |
| 2304 | shell (\fI/bin/ksh\fR). Perl is not strictly a shell because it's not |
| 2305 | interactive (although Perl programs can be interactive). |
| 2306 | .IP "side effects" 4 |
| 2307 | .IX Item "side effects" |
| 2308 | Something extra that happens when you evaluate an \*(L"expression\*(R". |
| 2309 | Nowadays it can refer to almost anything. For example, evaluating a |
| 2310 | simple assignment statement typically has the \*(L"side effect\*(R" of |
| 2311 | assigning a value to a variable. (And you thought assigning the value |
| 2312 | was your primary intent in the first place!) Likewise, assigning a |
| 2313 | value to the special variable \f(CW$|\fR (\f(CW$AUTOFLUSH\fR) has the side |
| 2314 | effect of forcing a flush after every write or |
| 2315 | print on the currently selected filehandle. |
| 2316 | .IP "signal" 4 |
| 2317 | .IX Item "signal" |
| 2318 | A bolt out of the blue; that is, an event triggered by the |
| 2319 | \&\*(L"operating system\*(R", probably when you're least expecting it. |
| 2320 | .IP "signal handler" 4 |
| 2321 | .IX Item "signal handler" |
| 2322 | A \*(L"subroutine\*(R" that, instead of being content to be called in the |
| 2323 | normal fashion, sits around waiting for a bolt out of the blue before |
| 2324 | it will deign to \*(L"execute\*(R". Under Perl, bolts out of the blue are |
| 2325 | called signals, and you send them with the kill |
| 2326 | built\-in. See \*(L"%SIG\*(R" in perlvar and \*(L"Signals\*(R" in perlipc. |
| 2327 | .IP "single inheritance" 4 |
| 2328 | .IX Item "single inheritance" |
| 2329 | The features you got from your mother, if she told you that you don't |
| 2330 | have a father. (See also \*(L"inheritance\*(R" and \*(L"multiple inheritance\*(R".) In computer languages, the notion that |
| 2331 | classes reproduce asexually so that a given class can only |
| 2332 | have one direct ancestor or \*(L"base class\*(R". Perl supplies no such |
| 2333 | restriction, though you may certainly program Perl that way if you |
| 2334 | like. |
| 2335 | .IP "slice" 4 |
| 2336 | .IX Item "slice" |
| 2337 | A selection of any number of elements from a \*(L"list\*(R", |
| 2338 | \&\*(L"array\*(R", or \*(L"hash\*(R". |
| 2339 | .IP "slurp" 4 |
| 2340 | .IX Item "slurp" |
| 2341 | To read an entire \*(L"file\*(R" into a \*(L"string\*(R" in one operation. |
| 2342 | .IP "socket" 4 |
| 2343 | .IX Item "socket" |
| 2344 | An endpoint for network communication among multiple |
| 2345 | processes that works much like a telephone or a post |
| 2346 | office box. The most important thing about a socket is its \*(L"network address\*(R" (like a phone number). Different kinds of sockets have |
| 2347 | different kinds of addresses\*(--some look like filenames, and some |
| 2348 | don't. |
| 2349 | .IP "soft reference" 4 |
| 2350 | .IX Item "soft reference" |
| 2351 | See \*(L"symbolic reference\*(R". |
| 2352 | .IP "source filter" 4 |
| 2353 | .IX Item "source filter" |
| 2354 | A special kind of \*(L"module\*(R" that does \*(L"preprocessing\*(R" on your |
| 2355 | script just before it gets to the \*(L"tokener\*(R". |
| 2356 | .IP "stack" 4 |
| 2357 | .IX Item "stack" |
| 2358 | A device you can put things on the top of, and later take them back |
| 2359 | off in the opposite order in which you put them on. See \*(L"\s-1LIFO\s0\*(R". |
| 2360 | .IP "standard" 4 |
| 2361 | .IX Item "standard" |
| 2362 | Included in the official Perl distribution, as in a standard module, a |
| 2363 | standard tool, or a standard Perl \*(L"manpage\*(R". |
| 2364 | .IP "standard error" 4 |
| 2365 | .IX Item "standard error" |
| 2366 | The default output \*(L"stream\*(R" for nasty remarks that don't belong in |
| 2367 | \&\*(L"standard output\*(R". Represented within a Perl program by the |
| 2368 | \&\*(L"filehandle\*(R" \*(L"\s-1STDERR\s0\*(R". You can use this stream explicitly, but the |
| 2369 | die and warn built-ins write to your |
| 2370 | standard error stream automatically. |
| 2371 | .IP "standard I/O" 4 |
| 2372 | .IX Item "standard I/O" |
| 2373 | A standard C library for doing buffered input and output to |
| 2374 | the \*(L"operating system\*(R". (The \*(L"standard\*(R" of standard I/O is only |
| 2375 | marginally related to the \*(L"standard\*(R" of standard input and output.) |
| 2376 | In general, Perl relies on whatever implementation of standard I/O a |
| 2377 | given operating system supplies, so the buffering characteristics of a |
| 2378 | Perl program on one machine may not exactly match those on another |
| 2379 | machine. Normally this only influences efficiency, not semantics. If |
| 2380 | your standard I/O package is doing block buffering and you want it to |
| 2381 | \&\*(L"flush\*(R" the buffer more often, just set the \f(CW$|\fR variable to a true |
| 2382 | value. |
| 2383 | .IP "standard input" 4 |
| 2384 | .IX Item "standard input" |
| 2385 | The default input \*(L"stream\*(R" for your program, which if possible |
| 2386 | shouldn't care where its data is coming from. Represented within a |
| 2387 | Perl program by the \*(L"filehandle\*(R" \*(L"\s-1STDIN\s0\*(R". |
| 2388 | .IP "standard output" 4 |
| 2389 | .IX Item "standard output" |
| 2390 | The default output \*(L"stream\*(R" for your program, which if possible |
| 2391 | shouldn't care where its data is going. Represented within a Perl |
| 2392 | program by the \*(L"filehandle\*(R" \*(L"\s-1STDOUT\s0\*(R". |
| 2393 | .IP "stat structure" 4 |
| 2394 | .IX Item "stat structure" |
| 2395 | A special internal spot in which Perl keeps the information about the |
| 2396 | last \*(L"file\*(R" on which you requested information. |
| 2397 | .IP "statement" 4 |
| 2398 | .IX Item "statement" |
| 2399 | A \*(L"command\*(R" to the computer about what to do next, like a step in a |
| 2400 | recipe: \*(L"Add marmalade to batter and mix until mixed.\*(R" A statement is |
| 2401 | distinguished from a \*(L"declaration\*(R", which doesn't tell the computer |
| 2402 | to do anything, but just to learn something. |
| 2403 | .IP "statement modifier" 4 |
| 2404 | .IX Item "statement modifier" |
| 2405 | A \*(L"conditional\*(R" or \*(L"loop\*(R" that you put after the \*(L"statement\*(R" |
| 2406 | instead of before, if you know what we mean. |
| 2407 | .IP "static" 4 |
| 2408 | .IX Item "static" |
| 2409 | Varying slowly compared to something else. (Unfortunately, everything |
| 2410 | is relatively stable compared to something else, except for certain |
| 2411 | elementary particles, and we're not so sure about them.) In |
| 2412 | computers, where things are supposed to vary rapidly, \*(L"static\*(R" has a |
| 2413 | derogatory connotation, indicating a slightly dysfunctional |
| 2414 | \&\*(L"variable\*(R", \*(L"subroutine\*(R", or \*(L"method\*(R". In Perl culture, the |
| 2415 | word is politely avoided. |
| 2416 | .IP "static method" 4 |
| 2417 | .IX Item "static method" |
| 2418 | No such thing. See \*(L"class method\*(R". |
| 2419 | .IP "static scoping" 4 |
| 2420 | .IX Item "static scoping" |
| 2421 | No such thing. See \*(L"lexical scoping\*(R". |
| 2422 | .IP "static variable" 4 |
| 2423 | .IX Item "static variable" |
| 2424 | No such thing. Just use a \*(L"lexical variable\*(R" in a scope larger than |
| 2425 | your \*(L"subroutine\*(R". |
| 2426 | .IP "status" 4 |
| 2427 | .IX Item "status" |
| 2428 | The \*(L"value\*(R" returned to the parent \*(L"process\*(R" when one of its child |
| 2429 | processes dies. This value is placed in the special variable \f(CW$?\fR. |
| 2430 | Its upper eight bits are the exit status of the defunct |
| 2431 | process, and its lower eight bits identify the signal (if any) that |
| 2432 | the process died from. On Unix systems, this status value is the same |
| 2433 | as the status word returned by \fIwait\fR(2). See \*(L"system\*(R" in perlfunc. |
| 2434 | .IP "\s-1STDERR\s0" 4 |
| 2435 | .IX Item "STDERR" |
| 2436 | See \*(L"standard error\*(R". |
| 2437 | .IP "\s-1STDIN\s0" 4 |
| 2438 | .IX Item "STDIN" |
| 2439 | See \*(L"standard input\*(R". |
| 2440 | .IP "\s-1STDIO\s0" 4 |
| 2441 | .IX Item "STDIO" |
| 2442 | See "standard I/O". |
| 2443 | .IP "\s-1STDOUT\s0" 4 |
| 2444 | .IX Item "STDOUT" |
| 2445 | See \*(L"standard output\*(R". |
| 2446 | .IP "stream" 4 |
| 2447 | .IX Item "stream" |
| 2448 | A flow of data into or out of a process as a steady sequence of bytes |
| 2449 | or characters, without the appearance of being broken up into packets. |
| 2450 | This is a kind of \*(L"interface\*(R"\-\-the underlying \*(L"implementation\*(R" may |
| 2451 | well break your data up into separate packets for delivery, but this |
| 2452 | is hidden from you. |
| 2453 | .IP "string" 4 |
| 2454 | .IX Item "string" |
| 2455 | A sequence of characters such as \*(L"He said !@#*&%@#*?!\*(R". A string does |
| 2456 | not have to be entirely printable. |
| 2457 | .IP "string context" 4 |
| 2458 | .IX Item "string context" |
| 2459 | The situation in which an expression is expected by its surroundings |
| 2460 | (the code calling it) to return a \*(L"string\*(R". See also \*(L"context\*(R" |
| 2461 | and \*(L"numeric context\*(R". |
| 2462 | .IP "stringification" 4 |
| 2463 | .IX Item "stringification" |
| 2464 | The process of producing a \*(L"string\*(R" representation of an abstract |
| 2465 | object. |
| 2466 | .IP "struct" 4 |
| 2467 | .IX Item "struct" |
| 2468 | C keyword introducing a structure definition or name. |
| 2469 | .IP "structure" 4 |
| 2470 | .IX Item "structure" |
| 2471 | See \*(L"data structure\*(R". |
| 2472 | .IP "subclass" 4 |
| 2473 | .IX Item "subclass" |
| 2474 | See \*(L"derived class\*(R". |
| 2475 | .IP "subpattern" 4 |
| 2476 | .IX Item "subpattern" |
| 2477 | A component of a \*(L"regular expression\*(R" pattern. |
| 2478 | .IP "subroutine" 4 |
| 2479 | .IX Item "subroutine" |
| 2480 | A named or otherwise accessible piece of program that can be invoked |
| 2481 | from elsewhere in the program in order to accomplish some sub-goal of |
| 2482 | the program. A subroutine is often parameterized to accomplish |
| 2483 | different but related things depending on its input |
| 2484 | arguments. If the subroutine returns a meaningful |
| 2485 | \&\*(L"value\*(R", it is also called a \*(L"function\*(R". |
| 2486 | .IP "subscript" 4 |
| 2487 | .IX Item "subscript" |
| 2488 | A \*(L"value\*(R" that indicates the position of a particular \*(L"array\*(R" |
| 2489 | \&\*(L"element\*(R" in an array. |
| 2490 | .IP "substitution" 4 |
| 2491 | .IX Item "substitution" |
| 2492 | Changing parts of a string via the \f(CW\*(C`s///\*(C'\fR operator. (We avoid use of |
| 2493 | this term to mean \*(L"variable interpolation\*(R".) |
| 2494 | .IP "substring" 4 |
| 2495 | .IX Item "substring" |
| 2496 | A portion of a \*(L"string\*(R", starting at a certain \*(L"character\*(R" |
| 2497 | position (\*(L"offset\*(R") and proceeding for a certain number of |
| 2498 | characters. |
| 2499 | .IP "superclass" 4 |
| 2500 | .IX Item "superclass" |
| 2501 | See \*(L"base class\*(R". |
| 2502 | .IP "superuser" 4 |
| 2503 | .IX Item "superuser" |
| 2504 | The person whom the \*(L"operating system\*(R" will let do almost anything. |
| 2505 | Typically your system administrator or someone pretending to be your |
| 2506 | system administrator. On Unix systems, the \*(L"root\*(R" user. On Windows |
| 2507 | systems, usually the Administrator user. |
| 2508 | .IP "\s-1SV\s0" 4 |
| 2509 | .IX Item "SV" |
| 2510 | Short for \*(L"scalar value\*(R". But within the Perl interpreter every |
| 2511 | \&\*(L"referent\*(R" is treated as a member of a class derived from \s-1SV\s0, in an |
| 2512 | object-oriented sort of way. Every \*(L"value\*(R" inside Perl is passed |
| 2513 | around as a C language \f(CW\*(C`SV*\*(C'\fR pointer. The \s-1SV\s0 \*(L"struct\*(R" knows its |
| 2514 | own \*(L"referent type\*(R", and the code is smart enough (we hope) not to try |
| 2515 | to call a \*(L"hash\*(R" function on a \*(L"subroutine\*(R". |
| 2516 | .IP "switch" 4 |
| 2517 | .IX Item "switch" |
| 2518 | An option you give on a command line to influence the way your program |
| 2519 | works, usually introduced with a minus sign. The word is also used as |
| 2520 | a nickname for a \*(L"switch statement\*(R". |
| 2521 | .IP "switch cluster" 4 |
| 2522 | .IX Item "switch cluster" |
| 2523 | The combination of multiple command-line switches (e.g., \fB\-a \-b \-c\fR) |
| 2524 | into one switch (e.g., \fB\-abc\fR). Any switch with an additional |
| 2525 | \&\*(L"argument\*(R" must be the last switch in a cluster. |
| 2526 | .IP "switch statement" 4 |
| 2527 | .IX Item "switch statement" |
| 2528 | A program technique that lets you evaluate an \*(L"expression\*(R" and then, |
| 2529 | based on the value of the expression, do a multiway branch to the |
| 2530 | appropriate piece of code for that value. Also called a \*(L"case |
| 2531 | structure\*(R", named after the similar Pascal construct. Most switch |
| 2532 | statements in Perl are spelled \f(CW\*(C`for\*(C'\fR. See \*(L"Basic BLOCKs and Switch Statements\*(R" in perlsyn. |
| 2533 | .IP "symbol" 4 |
| 2534 | .IX Item "symbol" |
| 2535 | Generally, any \*(L"token\*(R" or \*(L"metasymbol\*(R". Often used more |
| 2536 | specifically to mean the sort of name you might find in a \*(L"symbol table\*(R". |
| 2537 | .IP "symbol table" 4 |
| 2538 | .IX Item "symbol table" |
| 2539 | Where a \*(L"compiler\*(R" remembers symbols. A program like Perl must |
| 2540 | somehow remember all the names of all the variables, |
| 2541 | filehandles, and subroutines you've |
| 2542 | used. It does this by placing the names in a symbol table, which is |
| 2543 | implemented in Perl using a \*(L"hash table\*(R". There is a separate |
| 2544 | symbol table for each \*(L"package\*(R" to give each package its own |
| 2545 | \&\*(L"namespace\*(R". |
| 2546 | .IP "symbolic debugger" 4 |
| 2547 | .IX Item "symbolic debugger" |
| 2548 | A program that lets you step through the execution of your |
| 2549 | program, stopping or printing things out here and there to see whether |
| 2550 | anything has gone wrong, and if so, what. The \*(L"symbolic\*(R" part just |
| 2551 | means that you can talk to the debugger using the same symbols with |
| 2552 | which your program is written. |
| 2553 | .IP "symbolic link" 4 |
| 2554 | .IX Item "symbolic link" |
| 2555 | An alternate filename that points to the real \*(L"filename\*(R", which in |
| 2556 | turn points to the real \*(L"file\*(R". Whenever the \*(L"operating system\*(R" |
| 2557 | is trying to parse a \*(L"pathname\*(R" containing a symbolic link, it |
| 2558 | merely substitutes the new name and continues parsing. |
| 2559 | .IP "symbolic reference" 4 |
| 2560 | .IX Item "symbolic reference" |
| 2561 | A variable whose value is the name of another variable or subroutine. |
| 2562 | By dereferencing the first variable, you can get at |
| 2563 | the second one. Symbolic references are illegal under use strict 'refs'. |
| 2564 | .IP "synchronous" 4 |
| 2565 | .IX Item "synchronous" |
| 2566 | Programming in which the orderly sequence of events can be determined; |
| 2567 | that is, when things happen one after the other, not at the same time. |
| 2568 | .IP "syntactic sugar" 4 |
| 2569 | .IX Item "syntactic sugar" |
| 2570 | An alternative way of writing something more easily; a shortcut. |
| 2571 | .IP "syntax" 4 |
| 2572 | .IX Item "syntax" |
| 2573 | From Greek, \*(L"with\-arrangement\*(R". How things (particularly symbols) are |
| 2574 | put together with each other. |
| 2575 | .IP "syntax tree" 4 |
| 2576 | .IX Item "syntax tree" |
| 2577 | An internal representation of your program wherein lower-level |
| 2578 | constructs dangle off the higher-level constructs |
| 2579 | enclosing them. |
| 2580 | .IP "syscall" 4 |
| 2581 | .IX Item "syscall" |
| 2582 | A \*(L"function\*(R" call directly to the \*(L"operating system\*(R". Many of the |
| 2583 | important subroutines and functions you use aren't direct system |
| 2584 | calls, but are built up in one or more layers above the system call |
| 2585 | level. In general, Perl programmers don't need to worry about the |
| 2586 | distinction. However, if you do happen to know which Perl functions |
| 2587 | are really syscalls, you can predict which of these will set the \f(CW$!\fR |
| 2588 | (\f(CW$ERRNO\fR) variable on failure. Unfortunately, beginning programmers |
| 2589 | often confusingly employ the term \*(L"system call\*(R" to mean what happens |
| 2590 | when you call the Perl system function, which |
| 2591 | actually involves many syscalls. To avoid any confusion, we nearly |
| 2592 | always use say \*(L"syscall\*(R" for something you could call indirectly via |
| 2593 | Perl's syscall function, and never for something |
| 2594 | you would call with Perl's system function. |
| 2595 | .Sh "T" |
| 2596 | .IX Subsection "T" |
| 2597 | .IP "tainted" 4 |
| 2598 | .IX Item "tainted" |
| 2599 | Said of data derived from the grubby hands of a user and thus unsafe |
| 2600 | for a secure program to rely on. Perl does taint checks if you run a |
| 2601 | \&\*(L"setuid\*(R" (or \*(L"setgid\*(R") program, or if you use the \fB\-T\fR switch. |
| 2602 | .IP "\s-1TCP\s0" 4 |
| 2603 | .IX Item "TCP" |
| 2604 | Short for Transmission Control Protocol. A protocol wrapped around |
| 2605 | the Internet Protocol to make an unreliable packet transmission |
| 2606 | mechanism appear to the application program to be a reliable |
| 2607 | \&\*(L"stream\*(R" of bytes. (Usually.) |
| 2608 | .IP "term" 4 |
| 2609 | .IX Item "term" |
| 2610 | Short for a \*(L"terminal\*(R", that is, a leaf node of a \*(L"syntax tree\*(R". A |
| 2611 | thing that functions grammatically as an \*(L"operand\*(R" for the operators |
| 2612 | in an expression. |
| 2613 | .IP "terminator" 4 |
| 2614 | .IX Item "terminator" |
| 2615 | A \*(L"character\*(R" or \*(L"string\*(R" that marks the end of another string. |
| 2616 | The \f(CW$/\fR variable contains the string that terminates a |
| 2617 | readline operation, which chomp |
| 2618 | deletes from the end. Not to be confused with |
| 2619 | delimiters or separators. The period at |
| 2620 | the end of this sentence is a terminator. |
| 2621 | .IP "ternary" 4 |
| 2622 | .IX Item "ternary" |
| 2623 | An \*(L"operator\*(R" taking three operands. Sometimes |
| 2624 | pronounced \*(L"trinary\*(R". |
| 2625 | .IP "text" 4 |
| 2626 | .IX Item "text" |
| 2627 | A \*(L"string\*(R" or \*(L"file\*(R" containing primarily printable characters. |
| 2628 | .IP "thread" 4 |
| 2629 | .IX Item "thread" |
| 2630 | Like a forked process, but without \*(L"fork\*(R"'s inherent memory |
| 2631 | protection. A thread is lighter weight than a full process, in that a |
| 2632 | process could have multiple threads running around in it, all fighting |
| 2633 | over the same process's memory space unless steps are taken to protect |
| 2634 | threads from each other. See threads. |
| 2635 | .IP "tie" 4 |
| 2636 | .IX Item "tie" |
| 2637 | The bond between a magical variable and its implementation class. See |
| 2638 | \&\*(L"tie\*(R" in perlfunc and perltie. |
| 2639 | .IP "\s-1TMTOWTDI\s0" 4 |
| 2640 | .IX Item "TMTOWTDI" |
| 2641 | There's More Than One Way To Do It, the Perl Motto. The notion that |
| 2642 | there can be more than one valid path to solving a programming problem |
| 2643 | in context. (This doesn't mean that more ways are always better or |
| 2644 | that all possible paths are equally desirable\*(--just that there need |
| 2645 | not be One True Way.) Pronounced TimToady. |
| 2646 | .IP "token" 4 |
| 2647 | .IX Item "token" |
| 2648 | A morpheme in a programming language, the smallest unit of text with |
| 2649 | semantic significance. |
| 2650 | .IP "tokener" 4 |
| 2651 | .IX Item "tokener" |
| 2652 | A module that breaks a program text into a sequence of |
| 2653 | tokens for later analysis by a parser. |
| 2654 | .IP "tokenizing" 4 |
| 2655 | .IX Item "tokenizing" |
| 2656 | Splitting up a program text into tokens. Also known as |
| 2657 | \&\*(L"lexing\*(R", in which case you get \*(L"lexemes\*(R" instead of tokens. |
| 2658 | .IP "toolbox approach" 4 |
| 2659 | .IX Item "toolbox approach" |
| 2660 | The notion that, with a complete set of simple tools that work well |
| 2661 | together, you can build almost anything you want. Which is fine if |
| 2662 | you're assembling a tricycle, but if you're building a defranishizing |
| 2663 | comboflux regurgalator, you really want your own machine shop in which |
| 2664 | to build special tools. Perl is sort of a machine shop. |
| 2665 | .IP "transliterate" 4 |
| 2666 | .IX Item "transliterate" |
| 2667 | To turn one string representation into another by mapping each |
| 2668 | character of the source string to its corresponding character in the |
| 2669 | result string. See |
| 2670 | "tr/\s-1SEARCHLIST\s0/\s-1REPLACEMENTLIST\s0/cds" in perlop. |
| 2671 | .IP "trigger" 4 |
| 2672 | .IX Item "trigger" |
| 2673 | An event that causes a \*(L"handler\*(R" to be run. |
| 2674 | .IP "trinary" 4 |
| 2675 | .IX Item "trinary" |
| 2676 | Not a stellar system with three stars, but an \*(L"operator\*(R" taking |
| 2677 | three operands. Sometimes pronounced \*(L"ternary\*(R". |
| 2678 | .IP "troff" 4 |
| 2679 | .IX Item "troff" |
| 2680 | A venerable typesetting language from which Perl derives the name of |
| 2681 | its \f(CW$%\fR variable and which is secretly used in the production of |
| 2682 | Camel books. |
| 2683 | .IP "true" 4 |
| 2684 | .IX Item "true" |
| 2685 | Any scalar value that doesn't evaluate to 0 or \f(CW""\fR. |
| 2686 | .IP "truncating" 4 |
| 2687 | .IX Item "truncating" |
| 2688 | Emptying a file of existing contents, either automatically when |
| 2689 | opening a file for writing or explicitly via the |
| 2690 | truncate function. |
| 2691 | .IP "type" 4 |
| 2692 | .IX Item "type" |
| 2693 | See \*(L"data type\*(R" and \*(L"class\*(R". |
| 2694 | .IP "type casting" 4 |
| 2695 | .IX Item "type casting" |
| 2696 | Converting data from one type to another. C permits this. Perl does |
| 2697 | not need it. Nor want it. |
| 2698 | .IP "typed lexical" 4 |
| 2699 | .IX Item "typed lexical" |
| 2700 | A \*(L"lexical variable\*(R" that is declared with a \*(L"class\*(R" type: \f(CW\*(C`my |
| 2701 | Pony $bill\*(C'\fR. |
| 2702 | .IP "typedef" 4 |
| 2703 | .IX Item "typedef" |
| 2704 | A type definition in the C language. |
| 2705 | .IP "typeglob" 4 |
| 2706 | .IX Item "typeglob" |
| 2707 | Use of a single identifier, prefixed with \f(CW\*(C`*\*(C'\fR. For example, \f(CW*name\fR |
| 2708 | stands for any or all of \f(CW$name\fR, \f(CW@name\fR, \f(CW%name\fR, \f(CW&name\fR, or |
| 2709 | just \f(CW\*(C`name\*(C'\fR. How you use it determines whether it is interpreted as |
| 2710 | all or only one of them. See \*(L"Typeglobs and Filehandles\*(R" in perldata. |
| 2711 | .IP "typemap" 4 |
| 2712 | .IX Item "typemap" |
| 2713 | A description of how C types may be transformed to and from Perl types |
| 2714 | within an \*(L"extension\*(R" module written in \*(L"\s-1XS\s0\*(R". |
| 2715 | .Sh "U" |
| 2716 | .IX Subsection "U" |
| 2717 | .IP "\s-1UDP\s0" 4 |
| 2718 | .IX Item "UDP" |
| 2719 | User Datagram Protocol, the typical way to send datagrams |
| 2720 | over the Internet. |
| 2721 | .IP "\s-1UID\s0" 4 |
| 2722 | .IX Item "UID" |
| 2723 | A user \s-1ID\s0. Often used in the context of \*(L"file\*(R" or \*(L"process\*(R" |
| 2724 | ownership. |
| 2725 | .IP "umask" 4 |
| 2726 | .IX Item "umask" |
| 2727 | A mask of those \*(L"permission bits\*(R" that should be forced off when |
| 2728 | creating files or directories, in order to establish a policy of whom |
| 2729 | you'll ordinarily deny access to. See the umask |
| 2730 | function. |
| 2731 | .IP "unary operator" 4 |
| 2732 | .IX Item "unary operator" |
| 2733 | An operator with only one \*(L"operand\*(R", like \f(CW\*(C`!\*(C'\fR or |
| 2734 | chdir. Unary operators are usually prefix |
| 2735 | operators; that is, they precede their operand. The \f(CW\*(C`++\*(C'\fR and \f(CW\*(C`\-\-\*(C'\fR |
| 2736 | operators can be either prefix or postfix. (Their position \fIdoes\fR |
| 2737 | change their meanings.) |
| 2738 | .IP "Unicode" 4 |
| 2739 | .IX Item "Unicode" |
| 2740 | A character set comprising all the major character sets of the world, |
| 2741 | more or less. See <http://www.unicode.org>. |
| 2742 | .IP "Unix" 4 |
| 2743 | .IX Item "Unix" |
| 2744 | A very large and constantly evolving language with several alternative |
| 2745 | and largely incompatible syntaxes, in which anyone can define anything |
| 2746 | any way they choose, and usually do. Speakers of this language think |
| 2747 | it's easy to learn because it's so easily twisted to one's own ends, |
| 2748 | but dialectical differences make tribal intercommunication nearly |
| 2749 | impossible, and travelers are often reduced to a pidgin-like subset of |
| 2750 | the language. To be universally understood, a Unix shell programmer |
| 2751 | must spend years of study in the art. Many have abandoned this |
| 2752 | discipline and now communicate via an Esperanto-like language called |
| 2753 | Perl. |
| 2754 | .Sp |
| 2755 | In ancient times, Unix was also used to refer to some code that a |
| 2756 | couple of people at Bell Labs wrote to make use of a \s-1PDP\-7\s0 computer |
| 2757 | that wasn't doing much of anything else at the time. |
| 2758 | .Sh "V" |
| 2759 | .IX Subsection "V" |
| 2760 | .IP "value" 4 |
| 2761 | .IX Item "value" |
| 2762 | An actual piece of data, in contrast to all the variables, references, |
| 2763 | keys, indexes, operators, and whatnot that you need to access the |
| 2764 | value. |
| 2765 | .IP "variable" 4 |
| 2766 | .IX Item "variable" |
| 2767 | A named storage location that can hold any of various kinds of |
| 2768 | \&\*(L"value\*(R", as your program sees fit. |
| 2769 | .IP "variable interpolation" 4 |
| 2770 | .IX Item "variable interpolation" |
| 2771 | The \*(L"interpolation\*(R" of a scalar or array variable into a string. |
| 2772 | .IP "variadic" 4 |
| 2773 | .IX Item "variadic" |
| 2774 | Said of a \*(L"function\*(R" that happily receives an indeterminate number |
| 2775 | of \*(L"actual arguments\*(R". |
| 2776 | .IP "vector" 4 |
| 2777 | .IX Item "vector" |
| 2778 | Mathematical jargon for a list of scalar values. |
| 2779 | .IP "virtual" 4 |
| 2780 | .IX Item "virtual" |
| 2781 | Providing the appearance of something without the reality, as in: |
| 2782 | virtual memory is not real memory. (See also \*(L"memory\*(R".) The |
| 2783 | opposite of \*(L"virtual\*(R" is \*(L"transparent\*(R", which means providing the |
| 2784 | reality of something without the appearance, as in: Perl handles the |
| 2785 | variable-length \s-1UTF\-8\s0 character encoding transparently. |
| 2786 | .IP "void context" 4 |
| 2787 | .IX Item "void context" |
| 2788 | A form of \*(L"scalar context\*(R" in which an \*(L"expression\*(R" is not |
| 2789 | expected to return any \*(L"value\*(R" at all and is evaluated for its |
| 2790 | \&\*(L"side effects\*(R" alone. |
| 2791 | .IP "v\-string" 4 |
| 2792 | .IX Item "v-string" |
| 2793 | A \*(L"version\*(R" or \*(L"vector\*(R" \*(L"string\*(R" specified with a \f(CW\*(C`v\*(C'\fR followed by a |
| 2794 | series of decimal integers in dot notation, for instance, |
| 2795 | \&\f(CW\*(C`v1.20.300.4000\*(C'\fR. Each number turns into a \*(L"character\*(R" with the |
| 2796 | specified ordinal value. (The \f(CW\*(C`v\*(C'\fR is optional when there are at |
| 2797 | least three integers.) |
| 2798 | .Sh "W" |
| 2799 | .IX Subsection "W" |
| 2800 | .IP "warning" 4 |
| 2801 | .IX Item "warning" |
| 2802 | A message printed to the \*(L"\s-1STDERR\s0\*(R" stream to the effect that something |
| 2803 | might be wrong but isn't worth blowing up over. See \*(L"warn\*(R" in perlfunc |
| 2804 | and the warnings pragma. |
| 2805 | .IP "watch expression" 4 |
| 2806 | .IX Item "watch expression" |
| 2807 | An expression which, when its value changes, causes a breakpoint in |
| 2808 | the Perl debugger. |
| 2809 | .IP "whitespace" 4 |
| 2810 | .IX Item "whitespace" |
| 2811 | A \*(L"character\*(R" that moves your cursor but doesn't otherwise put |
| 2812 | anything on your screen. Typically refers to any of: space, tab, line |
| 2813 | feed, carriage return, or form feed. |
| 2814 | .IP "word" 4 |
| 2815 | .IX Item "word" |
| 2816 | In normal \*(L"computerese\*(R", the piece of data of the size most |
| 2817 | efficiently handled by your computer, typically 32 bits or so, give or |
| 2818 | take a few powers of 2. In Perl culture, it more often refers to an |
| 2819 | alphanumeric \*(L"identifier\*(R" (including underscores), or to a string of |
| 2820 | nonwhitespace characters bounded by whitespace or string |
| 2821 | boundaries. |
| 2822 | .IP "working directory" 4 |
| 2823 | .IX Item "working directory" |
| 2824 | Your current \*(L"directory\*(R", from which relative pathnames are |
| 2825 | interpreted by the \*(L"operating system\*(R". The operating system knows |
| 2826 | your current directory because you told it with a |
| 2827 | chdir or because you started out in the place where |
| 2828 | your parent \*(L"process\*(R" was when you were born. |
| 2829 | .IP "wrapper" 4 |
| 2830 | .IX Item "wrapper" |
| 2831 | A program or subroutine that runs some other program or subroutine for |
| 2832 | you, modifying some of its input or output to better suit your |
| 2833 | purposes. |
| 2834 | .IP "\s-1WYSIWYG\s0" 4 |
| 2835 | .IX Item "WYSIWYG" |
| 2836 | What You See Is What You Get. Usually used when something that |
| 2837 | appears on the screen matches how it will eventually look, like Perl's |
| 2838 | format declarations. Also used to mean the |
| 2839 | opposite of magic because everything works exactly as it appears, as |
| 2840 | in the three-argument form of open. |
| 2841 | .Sh "X" |
| 2842 | .IX Subsection "X" |
| 2843 | .IP "\s-1XS\s0" 4 |
| 2844 | .IX Item "XS" |
| 2845 | An extraordinarily exported, expeditiously excellent, expressly |
| 2846 | eXternal Subroutine, executed in existing C or \*(C+ or in an exciting |
| 2847 | new extension language called (exasperatingly) \s-1XS\s0. Examine perlxs |
| 2848 | for the exact explanation or perlxstut for an exemplary unexacting |
| 2849 | one. |
| 2850 | .IP "\s-1XSUB\s0" 4 |
| 2851 | .IX Item "XSUB" |
| 2852 | An external \*(L"subroutine\*(R" defined in \*(L"\s-1XS\s0\*(R". |
| 2853 | .Sh "Y" |
| 2854 | .IX Subsection "Y" |
| 2855 | .IP "yacc" 4 |
| 2856 | .IX Item "yacc" |
| 2857 | Yet Another Compiler Compiler. A parser generator without which Perl |
| 2858 | probably would not have existed. See the file \fIperly.y\fR in the Perl |
| 2859 | source distribution. |
| 2860 | .Sh "Z" |
| 2861 | .IX Subsection "Z" |
| 2862 | .IP "zero width" 4 |
| 2863 | .IX Item "zero width" |
| 2864 | A subpattern \*(L"assertion\*(R" matching the \*(L"null string\*(R" between |
| 2865 | characters. |
| 2866 | .IP "zombie" 4 |
| 2867 | .IX Item "zombie" |
| 2868 | A process that has died (exited) but whose parent has not yet received |
| 2869 | proper notification of its demise by virtue of having called |
| 2870 | wait or waitpid. If you |
| 2871 | fork, you must clean up after your child processes |
| 2872 | when they exit, or else the process table will fill up and your system |
| 2873 | administrator will Not Be Happy with you. |
| 2874 | .SH "AUTHOR AND COPYRIGHT" |
| 2875 | .IX Header "AUTHOR AND COPYRIGHT" |
| 2876 | Based on the Glossary of Programming Perl, Third Edition, |
| 2877 | by Larry Wall, Tom Christiansen & Jon Orwant. |
| 2878 | Copyright (c) 2000, 1996, 1991 O'Reilly Media, Inc. |
| 2879 | This document may be distributed under the same terms as Perl itself. |