Commit | Line | Data |
---|---|---|
920dae64 AT |
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. |