Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

$ variables, Building Character
${^WIDE_SYSTEM_CALLS}, Building Character
$!, portability of, System Interaction
$OSNAME, Special Variables in Alphabetical Order (see $^O variable)
%Config hash, Compiling Embedded Programs, Portable Perl
%EXPORT_TAGS hash, Special Variables in Alphabetical Order
%FIELDS hash, Special Variables in Alphabetical Order
%INC hash, Special Variables in Alphabetical Order
%SIG hash, Special Variables in Alphabetical Order
* (asterisk), Names
for typeglob names, Names
-a switch, perl, Special Variables in Alphabetical Order
-d (directory) file test, Some File Test Operators
-f (plain) file test, Some File Test Operators
-p file test operator, Named Pipes
-T (text) file test, Some File Test Operators
-w (writable by effective uid/gid) file test, Some File Test Operators
-w switch, perl, Controlling Warnings
-w switch, turning on warning messages with, How to Do It
.pm files, Using Modules
loading associated files with, Using Modules
/e modifier, Substitution evaluations
substitution evaluation, Substitution evaluations
0 but true, fcntl, fcntl
-w exemption, fcntl
-0 command-line switch, Command Processing
-0 switch, perl, Switches
0+ (numification) operator, Overloadable Operators
32-bit systems, Endianness and Number Width
64-bit systems, Endianness and Number Width
< (left angle bracket), Glossary
<< (left-shift) operator, Glossary
@+ array of ending positions, Special Variables in Alphabetical Order
& (ampersand), Variable Syntax, Verbs, Logical Operators, Names, Names, Named Unary and File Test Operators, Bitwise Operators, C-Style Logical (Short-Circuit) Operators, Assignment Operators, Assignment Operators, C Operators Missing from Perl, goto, Syntax, Prototypes, Prototypes, open, open
& (bitwise and) operator, Bitwise Operators
&& (logical and) operator, Logical Operators, C-Style Logical (Short-Circuit) Operators
&&= (assignment) operator, Assignment Operators
&= (assignment) operator, Assignment Operators, open
in filenames, open
address-of operator (in C), C Operators Missing from Perl
in filenames, open
Perl version 5, changes in use, Verbs
prototype character, Prototypes
for subroutine names, Variable Syntax, Names, Names, Syntax, Prototypes
omitting in prototypes, Prototypes
for subroutine names, goto
* (asterisk), Variable Syntax, Typeglobs and Filehandles, Terms and List Operators (Leftward), Exponentiation, Multiplicative Operators, Named Unary and File Test Operators, Assignment Operators, Assignment Operators, C Operators Missing from Perl, The Regular Expression Bestiary, Metacharacters and Metasymbols, Metasymbol Tables, Metasymbol Tables, Quantifiers, Prototypes
(multiplicative) operator, Terms and List Operators (Leftward)
** (exponentiation)operator, Exponentiation
**= (exponentiation assignment) operator, Assignment Operators
*= (multiplication assignment) operator, Assignment Operators
*? quantifier, Metasymbol Tables
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
multiplicative operator, Multiplicative Operators
prototype character, Prototypes
quantifier, Metasymbol Tables
in quantifiers, Quantifiers
typeglob, Variable Syntax, Typeglobs and Filehandles
@ (at sign), Variable Syntax, Variables, String Literals, Capturing, Capturing, Semantics, Prototypes, Using the Debugger, Previous Perl Traps, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order
@- array, Capturing, Special Variables in Alphabetical Order
@+ array of ending positions, Capturing
@_ array, Semantics, Special Variables in Alphabetical Order
for array names, Variable Syntax, Variables
changes in use, Perl versions, Previous Perl Traps
in debugger, Using the Debugger
inside strings, escaping with backslash, String Literals
prototype character, Prototypes
@ (at sign), Semantics
@_ arrays, Semantics
(backslash), Pick Your Own Quotes, Ideographic Unary Operators, The Regular Expression Bestiary, The Regular Expression Bestiary, Metacharacters and Metasymbols, Metasymbol Tables, When backslashes happen, The Backslash Operator, Using the Debugger, Debugger Commands, quotemeta
… metasymbol, Metasymbol Tables
entering continued commands in debugger, Debugger Commands
to escape metacharacters, The Regular Expression Bestiary, Metacharacters and Metasymbols
interpretation by regex parser, When backslashes happen
metacharacter, The Regular Expression Bestiary
for multiline commands, Using the Debugger
quoted strings, avoiding overuse in, Pick Your Own Quotes
quotemeta function for, quotemeta
reference operator, Ideographic Unary Operators, The Backslash Operator
\ (backslash), Singularities
double quotes, interpreting with, Singularities
(newline), Getting Started
` (backtick), String Literals, Command Input (Backtick) Operator, Anonymous Pipes, Accessing Commands and Files Under Reduced Privileges, Shell Traps, Programming with Style
operator, Command Input (Backtick) Operator
security and, Accessing Commands and Files Under Reduced Privileges
shell programming, Perl vs., Shell Traps
! (bang), Some Numeric and String Comparison Operators, Ideographic Unary Operators, Binding Operators, Equality Operators, Pattern-Matching Operators, Defining your own character properties, Overloadable Operators, Actions and Command Execution, Actions and Command Execution, Universal Blunders
! (logical negation) operator, Overloadable Operators
overloading, Overloadable Operators
!! debugger command, Actions and Command Execution
!= (not equal to) operator, Equality Operators, Universal Blunders
!~ (binding) operator, Binding Operators, Pattern-Matching Operators
using with pattern matching operators, Pattern-Matching Operators
complemented character sets, using for, Defining your own character properties
in debugger commands, Actions and Command Execution
logical negation operator, Ideographic Unary Operators
!= (not equal to) operator, Some Numeric and String Comparison Operators
{} (braces), Quantifiers, Interpolating Array Values, Terms and List Operators (Leftward), Compound Statements, Bare Blocks, The Regular Expression Bestiary, Metacharacters and Metasymbols, Metasymbol Tables, The anonymous hash composer, Braces, Brackets, and Quoting, Actions and Command Execution, Universal Blunders, Programming with Style
{ metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
bare blocks, creating with, Bare Blocks
in debugger commands, Actions and Command Execution
precedence of, Terms and List Operators (Leftward)
quantifier, Quantifiers, Metasymbol Tables
search patterns, clarifying with use, Interpolating Array Values
[] (brackets), Terms and List Operators (Leftward), The Regular Expression Bestiary, Metacharacters and Metasymbols, Metasymbol Tables, Metasymbol Tables, Custom Character Classes, The Little Engine That /Could(n't)?/, The anonymous array composer
[ metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
[…] character class, Metasymbol Tables
character classes, Metasymbol Tables, Custom Character Classes
to match characters, The Little Engine That /Could(n't)?/
precedence of, Terms and List Operators (Leftward)
^ (caret), Bitwise Operators, Assignment Operators, The Regular Expression Bestiary, The m// Operator (Matching), Metacharacters and Metasymbols, Custom Character Classes, Beginnings: The A and ^ Assertions, The Little Engine That /Could(n't)?/, Formats
^= (assignment) operator, Assignment Operators
bitwise xor operator, Bitwise Operators
inverting character class, Custom Character Classes
character class, inverting, Custom Character Classes
in matching, The m// Operator (Matching), The Little Engine That /Could(n't)?/
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
in picture lines, Formats
: (colon), Names, Or Leave the Quotes Out Entirely, Packages, Using Modules, Previous Perl Traps
:: in module names, translating to system directory separators, Using Modules
:: for package identifiers, Or Leave the Quotes Out Entirely, Packages, Previous Perl Traps
:: in fully qualified names, Names
, (comma), Hashes., Complexities, List Values and Arrays, List Values and Arrays, Hashes, Comma Operators, Comma Operators, Universal Blunders, Previous Perl Traps
delimiting list values, List Values and Arrays, List Values and Arrays
error in print statements, Universal Blunders
key/value pairs and, Hashes., Hashes
operator, Comma Operators, Comma Operators, Previous Perl Traps
(see also => operator)
in scalar context, Previous Perl Traps
as separator, Complexities
$ (dollar sign), Variables, Array Length, Endings: The z, , and $ Assertions, Prototypes, Using the Debugger
$# prefix, Array Length
in debugger, Using the Debugger
line boundary, Endings: The z, , and $ Assertions
for scalar variable names, Variables
$ (dollar sign), The m// Operator (Matching)
in matching, The m// Operator (Matching)
$ variables, Command Input (Backtick) Operator, Filename Globbing Operator, foreach Loops, Capturing, Capturing, Capturing, Capturing, Formats, Formats, Format Variables, Format Variables, Format Variables, Format Variables, Format Variables, Format Variables, Footers, Footers, Accessing Formatting Internals, Switches, Switches, Switches, Universal Blunders, Time Efficiency, Time Efficiency, Time Efficiency, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, close, close, formline, grep, map
$^ ($FORMAT_TOP_NAME), Universal Blunders
$1 et al, Special Variables in Alphabetical Order
$0 ($PROGRAM_NAME), Special Variables in Alphabetical Order
$a and $b (sort variables), Special Variables in Alphabetical Order
@', Capturing
@&, Capturing, Time Efficiency, Special Variables in Alphabetical Order
$' ($POSTMATCH), Time Efficiency, Special Variables in Alphabetical Order
$*, Special Variables in Alphabetical Order
$@ ($EVAL_ERROR), Special Variables in Alphabetical Order
$ ($OUPUT_RECORD_SEPARATOR), Switches, Special Variables in Alphabetical Order
$` ($PREMATCH), Special Variables in Alphabetical Order
$` ($PREMATCH), Time Efficiency
$! ($OS_ERROR), Special Variables in Alphabetical Order
${^WARNING_BITS}, Special Variables in Alphabetical Order
${^WIDE_SYSTEM_CALLS}, Special Variables in Alphabetical Order
$[ (index of first array variable), Special Variables in Alphabetical Order
$] ($PERL_VERSION), Special Variables in Alphabetical Order
$^ ($FORMAT_TOP_NAME), Format Variables, Footers, Special Variables in Alphabetical Order
$^A ($ACCUMULATOR), Accessing Formatting Internals, Special Variables in Alphabetical Order, formline
formline function output, formline
$^C ($COMPILING), Special Variables in Alphabetical Order
$^D ($DEBUGGING), Switches, Special Variables in Alphabetical Order
$^E ($EXTENDED_OS_ERROR), Special Variables in Alphabetical Order
$^F ($SYSTEM_FD_MAX), Special Variables in Alphabetical Order
$^H, Special Variables in Alphabetical Order
$^I ($INPLACE_EDIT), Special Variables in Alphabetical Order
$^L ($FORMAT_LINEFEED), Format Variables, Special Variables in Alphabetical Order
$^M, Special Variables in Alphabetical Order
$^O ($OSNAME), Special Variables in Alphabetical Order
$^P ($PERLDB), Special Variables in Alphabetical Order
$^S ($EXCEPTIONS_BEING_CAUGHT), Special Variables in Alphabetical Order
$^T ($BASETIME), Special Variables in Alphabetical Order
$^V ($PERL_VERSION), Special Variables in Alphabetical Order
$^W ($WARNING), Special Variables in Alphabetical Order
$^X ($EXECUTABLE_NAME), Special Variables in Alphabetical Order
$: ($FORMAT_LINE_BREAK_CHARACTERS), Formats, Special Variables in Alphabetical Order
$, ($LIST_SEPARATOR), Special Variables in Alphabetical Order, Special Variables in Alphabetical Order
$$ ($PROCESS_ID), Special Variables in Alphabetical Order
$. ($INPUT_LINE_NUMBER), Special Variables in Alphabetical Order, close
resetting with close function, close
$= ($FORMAT_LINES_PER_PAGE), Format Variables, Special Variables in Alphabetical Order
@`, Capturing
$- ($FORMAT_LINES_LEFT), Special Variables in Alphabetical Order
$< ($REAL_USER_ID), Special Variables in Alphabetical Order
$- ($FORMAT_LINES_LEFT), Formats, Footers
$) ($EFFECTIVE_GROUP_ID), Special Variables in Alphabetical Order
$( ($REAL_GROUP_ID), Special Variables in Alphabetical Order
$) ($EFFECTIVE_GROUP_ID), Special Variables in Alphabetical Order
$% ($FORMAT_PAGE_NUMBER), Format Variables, Special Variables in Alphabetical Order
@+, Capturing, Special Variables in Alphabetical Order
$? ($CHILD_ERROR), Command Input (Backtick) Operator, Special Variables in Alphabetical Order, close
backtick operator and, Command Input (Backtick) Operator
close function and, close
$> ($EFFECTIVE_USER_ID), Special Variables in Alphabetical Order
$; ($SUBSCRIPT_SEPARATOR), Special Variables in Alphabetical Order
$#, Special Variables in Alphabetical Order
obsolete variable for numeric output, Special Variables in Alphabetical Order
$/ ($INPUT_RECORD_SEPARATOR), Switches, Special Variables in Alphabetical Order
$~ ($FORMAT_NAME), Format Variables, Special Variables in Alphabetical Order
$_ ($ARG) ;glob function with, Filename Globbing Operator, foreach Loops, Special Variables in Alphabetical Order, grep, map
grep function and, grep
map function and, map
$| ($OUTPUT_AUTOFLUSH), Format Variables, Special Variables in Alphabetical Order
$^F variable, fileno
$. ($INPUT_LINE_NUMBER), Range Operator
$ (dollar sign), Variable Syntax, Arrays., Hashes., Names, Names, Names, String Literals, Hashes, Controlling Warnings, The Regular Expression Bestiary, Pattern-Matching Operators, Pattern-Matching Operators, Pattern-Matching Operators, Metacharacters and Metasymbols, Portable Perl
$&, Pattern-Matching Operators
$`, Pattern-Matching Operators
${^ (internal variable names), Names
$^W, Controlling Warnings
$$ (current process ID), Names
$? (exit status, last child process), Names
$; (SUBSCRIPT_SEPARATOR), Hashes
$', Pattern-Matching Operators
$ variables, Portable Perl
$^O variable, Portable Perl
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
for scalar variable names, Arrays.
scalar variable interpolation and, String Literals
signifying scalar variables, Variable Syntax
$! variable, Logical Operators
$ variables, Regular Expressions
$_ variable, Regular Expressions
$ variables, The while and until statements, Quantifiers
$line, The while and until statements
$_ variable, Quantifiers
. (dot), String Operators, Regular Expressions, Quantifiers, V-String Literals, Additive Operators, Named Unary and File Test Operators, Range Operator, Range Operator, Assignment Operators, The Regular Expression Bestiary, Pattern Modifiers, Metacharacters and Metasymbols, Wildcard Metasymbols, Overloadable Operators, Using the Debugger, Stepping and Running, Time Efficiency
(concatenation) operator, String Operators, Additive Operators, Overloadable Operators
autogeneration via stringification handler, Overloadable Operators
.. (range) operator, Range Operator
.= (assignment) operator, Assignment Operators
character wildcard, Regular Expressions, Pattern Modifiers, Wildcard Metasymbols
in debugger command, Using the Debugger, Stepping and Running
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
quantifiers, use in, Quantifiers
separating integers in v-strings, V-String Literals
… (range operator), Range Operator
" (double quotes), Pattern-Matching Operators, The s/// Operator (Substitution), When backslashes happen, Braces, Brackets, and Quoting, Overloadable Operators
conversion operator, stringification, Overloadable Operators
in replacement string, The s/// Operator (Substitution)
translation escape processing, When backslashes happen
" (double quotes), Pattern-Matching Operators, formline
(see also qq//; print function)
in formline arguments, formline
= (equal sign), Singularities, Hashes., Assignment Operators, Some Numeric and String Comparison Operators, Hashes, Binding Operators, Equality Operators, Assignment Operators, Comma Operators, Pattern-Matching Operators, Using the Debugger, Miscellaneous Commands, Universal Blunders
= (assignment) operator, Assignment Operators
= (assignment) operator, Singularities
== (equal to) operator, Assignment Operators, Some Numeric and String Comparison Operators, Equality Operators, Universal Blunders
==> current line marker, Using the Debugger
=> (corresponds to) operator, Hashes, Comma Operators
=~ (pattern binding) operator, Binding Operators, Pattern-Matching Operators
using with pattern matching operators, Pattern-Matching Operators
debugger command, Miscellaneous Commands
=> (corresponds to) operator, Hashes.
@EXPORT array, Special Variables in Alphabetical Order
@EXPORT_OK array, Special Variables in Alphabetical Order
> (right angle bracket), Filehandles, Some Numeric and String Comparison Operators, Some Numeric and String Comparison Operators, open, sort
> (greater than) operator, Filehandles, Some Numeric and String Comparison Operators, Some Numeric and String Comparison Operators
<=> (comparison) operator, sort
in filenames, open
- (hyphen), The Arrow Operator, Autoincrement and Autodecrement, Ideographic Unary Operators, Additive Operators, Named Unary and File Test Operators, Assignment Operators, Custom Character Classes, Defining your own character properties, The Little Engine That /Could(n't)?/, Using the Arrow Operator, Using the Arrow Operator, Method Invocation Using the Arrow Operator, Command Processing, Switches, Locating Code
-*- for emacs, Command Processing
-= (assignment) operator, Assignment Operators
-- (autodecrement) operator, Autoincrement and Autodecrement, Switches
-> (arrow) operator, The Arrow Operator, Using the Arrow Operator, Using the Arrow Operator, Method Invocation Using the Arrow Operator
method invocation with, Method Invocation Using the Arrow Operator
arithmetic negation operator, Ideographic Unary Operators
in character ranges, Custom Character Classes
character set subtraction, Defining your own character properties
in debugger commands, Locating Code
subtractive operator, Additive Operators
@INC array, Module Installation Support
@ISA array, Special Variables in Alphabetical Order
< (left angle bracket), Shift Operators, Relational Operators, Relational Operators, Equality Operators, Assignment Operators, Format Variables
for left justification, Format Variables
<= (less than or equal) operator, Relational Operators
<=> (comparison)operator, Equality Operators
<< (left-shift) operator, Shift Operators
<<= (assignment) operator, Assignment Operators
less than operator, Relational Operators
< (left angle bracket), Filehandles, Some Numeric and String Comparison Operators, Some Numeric and String Comparison Operators, Some Numeric and String Comparison Operators, Actions and Command Execution, open
<=> (comparison) operator, Some Numeric and String Comparison Operators
< (less than) operator, Filehandles, Some Numeric and String Comparison Operators, Some Numeric and String Comparison Operators
in debugger commands, Actions and Command Execution
in filenames, open
|| (OR logical operator), Logical Operators
(thinsp&;) (parentheses), Complexities, Backreferences, List Values and Arrays, List Values and Arrays, List Values and Arrays, Terms and List Operators (Leftward), Conditional Operator, The Regular Expression Bestiary, The Regular Expression Bestiary, Metacharacters and Metasymbols, Capturing, Capturing, Clustering, The Little Engine That /Could(n't)?/, Universal Blunders, Programming with Style, Functions
(?:PATTERN) notation, clustering without capturing, Clustering
for backreferences, Backreferences, Capturing, Capturing
conditional operator, use with, Conditional Operator
in functions, Functions
grouping operator, The Regular Expression Bestiary
for list values, List Values and Arrays, List Values and Arrays
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
as quote characters, List Values and Arrays
() (parentheses), Metasymbol Tables, Clustering
(?:PATTERN) notation, clustering without capturing, Clustering
(…) grouping, Metasymbol Tables
% (percent sign), Variable Syntax, Hashes., Variables, Multiplicative Operators, Named Unary and File Test Operators, Assignment Operators, Prototypes, unpack
%= (modulus assignment) operator, Assignment Operators
for checksums, unpack
for hash names, Hashes., Variables
modulus operator, Multiplicative Operators
prototype character, Prototypes
signifying variable type, Variable Syntax
| (pipe symbol), Alternation
for pattern alternation, Alternation
+ (plus sign), Terms and List Operators (Leftward), Autoincrement and Autodecrement, Ideographic Unary Operators, Additive Operators, Named Unary and File Test Operators, Assignment Operators, The Regular Expression Bestiary, Metacharacters and Metasymbols, Metasymbol Tables, Metasymbol Tables, open
+ unary operator, Terms and List Operators (Leftward)
+= (assignment) operator, Assignment Operators
++ (autoincrement) operator, Autoincrement and Autodecrement
+? quantifier, Metasymbol Tables
additive operator, Additive Operators
in filenames, open
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
quantifier, Metasymbol Tables
+ (plus sign), Quantifiers
in quantifiers, Quantifiers
?(question mark), Named Unary and File Test Operators, Conditional Operator, Case Structures, The Regular Expression Bestiary, The m// Operator (Matching), Metacharacters and Metasymbols, Metasymbol Tables, Metasymbol Tables, Lookaround Assertions, Nonbacktracking Subpatterns
?: (conditional) operator, Conditional Operator, Case Structures
(?>), Nonbacktracking Subpatterns
(?<!), Lookaround Assertions
?? quantifier, Metasymbol Tables
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
quantifier, Metasymbol Tables
?? operator, The m// Operator (Matching) (see m?? operator)
? (question mark), Quantifiers
in quantifiers, Quantifiers
' (single quotes), String Literals
" (double quotes), String Literals
> (right angle bracket), Filename Globbing Operator, Shift Operators, Relational Operators, Relational Operators, Assignment Operators, Format Variables, Actions and Command Execution
>= (greater than or equal) operator, Relational Operators
>> (right-shift) operator, Shift Operators
>>= (assignment) operator, Assignment Operators
in debugger commands, Actions and Command Execution
for filename globbing, Filename Globbing Operator
greater than operator, Relational Operators
for right justification, Format Variables
; (semicolon), Molecules, Simple Statements, Simple Statements, Debugger Commands, Cleaning Up Your Environment, Universal Blunders
errors, omitting trailing, Universal Blunders
in filenames, security risks of, Cleaning Up Your Environment
in debugger commands, Debugger Commands
Perl statements, terminating with, Molecules
simple statements, ending in, Simple Statements
# (sharp), Molecules, Pattern Modifiers, Formats, Command Processing, #! and Quoting on Non-Unix Systems
#! (shebang) notation, Command Processing, #! and Quoting on Non-Unix Systems
simulating on non-Unix systems, #! and Quoting on Non-Unix Systems
for comments, Molecules, Pattern Modifiers
/x pattern modifier, using with, Pattern Modifiers
in formats, Formats
' (single quotes), When backslashes happen
suppressing transliteration escape processing, When backslashes happen
' (single quotes), Pick Your Own Quotes
as delimiters, variable interpolation and, Pick Your Own Quotes
/ (slash), Pick Your Own Quotes, Multiplicative Operators, Named Unary and File Test Operators, Assignment Operators, The m// Operator (Matching), Locating Code, chroot, m//
/=; (assignment) operator, Assignment Operators
// operator==>match operator, m//
debugger command, Locating Code
delimiters, replacing as, Pick Your Own Quotes
division operator, Multiplicative Operators
root directory, chroot
//, The m// Operator (Matching) (see m// operator)
~ (tilde), Ideographic Unary Operators, Formats
bitwise negation operator, Ideographic Unary Operators
to suppress blank lines, Formats
_ (underscore), Names, Previous Perl Traps, Programming with Style, Special Variables in Alphabetical Order
global filehandle, Special Variables in Alphabetical Order
Perl versions, changes in use, Previous Perl Traps
in variable names, Programming with Style
| (vertical bar), Metasymbol Tables
…|… alternation, Metasymbol Tables
| (vertical bar), Bitwise Operators, C-Style Logical (Short-Circuit) Operators, Assignment Operators, Assignment Operators, The Regular Expression Bestiary, The Regular Expression Bestiary, Metacharacters and Metasymbols, Format Variables, Talking to Yourself, Talking to Yourself, Actions and Command Execution, Actions and Command Execution
-| piping pseudocommand, Talking to Yourself
|= (assignment) operator, Assignment Operators
|- piping pseudocommand, Talking to Yourself
|| (OR) operator, C-Style Logical (Short-Circuit) Operators, Actions and Command Execution
||= (assignment) operator, Assignment Operators
for alternation, The Regular Expression Bestiary
bitwise or operator, Bitwise Operators
for centering, Format Variables
debugger command, Actions and Command Execution
metacharacter, The Regular Expression Bestiary, Metacharacters and Metasymbols
| (vertical bar), Terms and List Operators (Leftward), Letting Perl Do the Work, open
|| logical OR operator, Terms and List Operators (Leftward), Letting Perl Do the Work
precedence, chdir vs., Terms and List Operators (Leftward)
in filenames, open
(backslash), String Literals
Q notation for backslashing nonalphanumeric characters, String Literals
C, matching single byte in C language, Effects of Character Semantics
, Newlines
(see also newlines)
P (doesn't match property), Effects of Character Semantics
p (matches property), Effects of Character Semantics
w, Effects of Character Semantics
matching ideograph with, Effects of Character Semantics
X, Effects of Character Semantics
matching extended Unicode sequence with, Effects of Character Semantics
_ (underscore), Packages
in variable names, Packages
{thinsp&;} (braces), Hashes.
hash key, enclosing in, Hashes.
| (vertical bar), Syntactic Snafus with Indirect Objects
|| (logical or) operator, Syntactic Snafus with Indirect Objects

A

-a (autosplit) command-line switch, Switches
abbreviations, text, String Processing, Language Text Processing, Parsing, and Searching
abs (absolute value) function, abs
abstraction, Packages, Method Invocation
in object-oriented programming, Method Invocation
accept function, accept
access checks, setting in constructor, Using Closures for Private Objects
access time, file, stat, utime
accessing, Access and Printing, Slices, Access and Printing of a Hash of Arrays, Access and Printing of an Array of Hashes, Access and Printing of a Hash of Hashes, Composition, Access, and Printing of More Elaborate Records, Accessing Overridden Methods, Array-Tying Methods
array of hashes, Access and Printing of an Array of Hashes
elements, tied arrays, Array-Tying Methods
hashes of arrays, Access and Printing of a Hash of Arrays
multidimensional arrays, Access and Printing
multidimensional hashes, Access and Printing of a Hash of Hashes
overridden methods, Accessing Overridden Methods
records of elaborate data structures, Composition, Access, and Printing of More Elaborate Records
slices of multidimensional arrays, Slices
accessor methods, Initializers, Managing Instance Data, Field Declarations with use fields, Generating Accessors with Autoloading, Generating Accessors with Closures, Managing Class Data, Glossary
class data methods, working like, Managing Class Data
creating, Managing Instance Data
generating with autoloading, Generating Accessors with Autoloading
generating with closures, Generating Accessors with Closures
pseudohashes and, Field Declarations with use fields
$ACCUMULATOR, Special Variables in Alphabetical Order
actions (debugger), Breakpoints, Actions and Command Execution
command execution, specifying from debugger, Actions and Command Execution
listing all, Breakpoints
ActiveState Perl distribution, #! and Quoting on Non-Unix Systems, Using CPAN Modules, Microsoft-Related Modules
installing on Windows systems, #! and Quoting on Non-Unix Systems
Microsoft-only modules, Microsoft-Related Modules
PPM (Perl Package Manager), Using CPAN Modules
addition, Some Binary Arithmetic Operators, Overload Handlers
overloaded plus (+) operator, Overload Handlers
additive operators, Additive Operators
address-of operator (in C), C Operators Missing from Perl, Glossary
addresses, Debugger Options, C Traps, bind, gethostbyaddr, gethostbyname, getnetbyaddr, getnetbyname, getsockname
C language, Perl vs., C Traps
getting from hostnames, getnetbyname
network, getting from hostnames, gethostbyname
network, translating to names, gethostbyaddr, getnetbyaddr
packed socket, getsockname
reused, displaying contents of, Debugger Options
socket names as, bind
alarm function, Code Masquerading as Data, alarm
pattern match, timing out, Code Masquerading as Data
alert (bell), String Literals
algorithms, Glossary
aliases, Name Lookups, Typeglobs and Filehandles, Case Structures, Modifying strings en passant, Specific Characters, Symbol Tables, Miscellaneous Commands, Glossary
for characters, Specific Characters
debugger command for, Miscellaneous Commands
in for/foreach loops, Modifying strings en passant
searching and replacing elements in arrays, Modifying strings en passant
for/foreach loops, creating with, Case Structures
symbol table entries, Name Lookups, Typeglobs and Filehandles
symbol table key, assignment to typeglob, Symbol Tables
aliasing, foreach Loops
in foreach loops, foreach Loops
ALRM signal, Timing Out Slow Operations
alternation, The Regular Expression Bestiary, Metasymbol Tables, Custom Character Classes, Clustering, Alternation, The Little Engine That /Could(n't)?/, Glossary
character classes and, Custom Character Classes
interior, limiting scope of, Clustering
match one or the other (…|…), Metasymbol Tables
in patterns, Alternation
precedence, pattern matching, The Little Engine That /Could(n't)?/
American Standard Code for Information Interchange, Glossary (see ASCII)
anchors, Nailing Things Down, Positions
and (&) bitwise operator, Bitwise Operators
and (&&) logical operator, Logical Operators, C-Style Logical (Short-Circuit) Operators, Logical and, or, not, and xor
and operator, Programming with Style
angle brackets, Filehandles (see <; >)
angle operator, Filehandle-Tying Methods, Switches, Frequently Ignored Advice
reading filehandle from, Filehandle-Tying Methods
anonymous, Subroutines, What Is a Reference?, The anonymous array composer, The anonymous hash composer, The anonymous subroutine composer, Slices, Composition of a Hash of Arrays, Composition of an Array of Hashes, Composition of a Hash of Hashes, Anonymous Pipes, Glossary
array composer, The anonymous array composer
arrays, Slices, Composition of a Hash of Arrays
hash of, creating, Composition of a Hash of Arrays
two-dimensional array slice, Slices
hash composer, The anonymous hash composer
hashes, Composition of an Array of Hashes, Composition of a Hash of Hashes
adding to multidimensional hashes, Composition of a Hash of Hashes
array of, creating, Composition of an Array of Hashes
pipes, Anonymous Pipes
referents, What Is a Reference?
subroutine composer, The anonymous subroutine composer
subroutines, Subroutines
AnyDBM_File module, DBM Interfaces
Apache web server, Executing Your Code, Embedding Perl (Using Perl from C), World Wide Web
CGI::Apache module, World Wide Web
mod_perl extension, Executing Your Code
appending, Growing Your Own, Generation of an Array of Hashes, push
elements to arrays, Growing Your Own, push
members to existing hash, Generation of an Array of Hashes
architecture, Glossary
arctangents, atan2
$ARG, Special Variables in Alphabetical Order
arguments, Special Variables in Alphabetical Order, Glossary, Glossary, Glossary, Glossary
(see also parameters)
actual, Glossary
formal, Special Variables in Alphabetical Order, Glossary
@ARGV array, Line Input (Angle) Operator, Special Variables in Alphabetical Order, Glossary
ARGV filehandle, Special Variables in Alphabetical Order
$ARGV variable, Special Variables in Alphabetical Order, Glossary, Glossary
ARGVOUT filehandle, Special Variables in Alphabetical Order
arithmetic, Overload Handlers
overloaded objects and, Overload Handlers
arithmetic operators, Some Binary Arithmetic Operators, Some Binary Arithmetic Operators, Ideographic Unary Operators, Overloadable Operators, Glossary
binary arithmetic operators, Some Binary Arithmetic Operators
order of evaluation, Some Binary Arithmetic Operators
overloading, Overloadable Operators
arity, Unary and Binary Operators, Unary and Binary Operators
highest to lowest, listing of, Unary and Binary Operators
array context, Glossary (see list context)
arrayDepth option (debugger), Debugger Options
arrays, Variable Syntax, Pluralities, Complexities, Built-in Data Types, Variables, List Values and Arrays, List Values and Arrays, Array Length, Array Length, Modifying strings en passant, Semantics, Tricks with Parameter Lists, Passing References, What Is a Reference?, The anonymous array composer, Arrays of Arrays, Common Mistakes, Arrays of Arrays, Creating and Accessing a Two-Dimensional Array, Hashes of Arrays, Arrays of Hashes, Generation of an Array of Hashes, Access and Printing of an Array of Hashes, Field Declarations with use fields, Field Declarations with use fields, Tying Arrays, Array-Tying Methods, Notational Convenience, Debugger Options, Internal Data Types, Handling Insecure Data, Previous Perl Traps, Previous Perl Traps, Time Efficiency, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Perl Functions by Category, dbmopen, exists, local, pop, push, shift, splice, splice, unshift, String Processing, Language Text Processing, Parsing, and Searching, Convenient Classes, Glossary, Glossary, Glossary
(see also lists)
@_ arrays, Semantics, Tricks with Parameter Lists
copying values to my list, Tricks with Parameter Lists
anonymous, objects implemented as, Field Declarations with use fields, Field Declarations with use fields
use fields pragma, overcoming problems with, Field Declarations with use fields
anonymous, references to, The anonymous array composer
appending elements to, push
associative, dbmopen (see hashes)
AV (array value) typedef in C, corresponding to, Internal Data Types
deleting elements of, shift, splice
elements, giving temporary values to, local
exists function and, exists
first element of, Special Variables in Alphabetical Order
of hashes, Arrays of Hashes, Generation of an Array of Hashes, Access and Printing of an Array of Hashes
accessing and printing, Access and Printing of an Array of Hashes
generating, Generation of an Array of Hashes
hashes of, Hashes of Arrays
last element of, Array Length
length of, Array Length
list values vs., List Values and Arrays
lists and, List Values and Arrays
multidimensional, Complexities, Arrays of Arrays, Glossary
names for, Variables
negative subscripts, counting from end of array, Previous Perl Traps
nested, Arrays of Arrays, Common Mistakes, Creating and Accessing a Two-Dimensional Array
two-dimensional arrays, creating and accessing, Creating and Accessing a Two-Dimensional Array
output style, changing in debugger, Debugger Options
parsing text into, String Processing, Language Text Processing, Parsing, and Searching
passing by reference into or out of functions, Passing References
performance and, Time Efficiency
pop function and, pop
prepending elements to, unshift
processing, functions for, Perl Functions by Category
references to, What Is a Reference?
replacing/removing elements, splice
s/// (substitution) operator and, Modifying strings en passant
subscript separator, Special Variables in Alphabetical Order (see $; variable)
taint in, Handling Insecure Data
tied, delete function and, Previous Perl Traps
tying, Tying Arrays, Array-Tying Methods, Notational Convenience, Convenient Classes
methods for, Array-Tying Methods
notational convenience, Notational Convenience
Tie::Array module, Convenient Classes
arrow (->, Using the Arrow Operator, Method Invocation Using the Arrow Operator
) operator, Using the Arrow Operator, Method Invocation Using the Arrow Operator
arrow (->) operator, The Arrow Operator
artificial languages, Natural and Artificial Languages
ASCII, Atoms, chr, ord, Glossary
converting to characters, chr
values for characters, ord
ASCII characters, Effects of Character Semantics
converting to Unicode, Effects of Character Semantics
assertions, The Little Engine That /Could(n't)?/, Lookaround Assertions, Defining Your Own Assertions
defining your own, Defining Your Own Assertions
lookaround assertions, Lookaround Assertions
precedence, pattern matching, The Little Engine That /Could(n't)?/
assertions (in matching), Endings: The z, , and $ Assertions, Boundaries: The  and B Assertions
 and B (word and non word boundary), Boundaries: The  and B Assertions
positional, Endings: The z, , and $ Assertions
z, , and $ assertions, Endings: The z, , and $ Assertions
assertions (in patterns), The m// Operator (Matching), Metasymbol Tables, Custom Character Classes, Positions, Beginnings: The A and ^ Assertions, Glossary
character classes and, Custom Character Classes
positional, Positions, Beginnings: The A and ^ Assertions
A and ^ assertions (string boundary), Beginnings: The A and ^ Assertions
G positional assertion, The m// Operator (Matching)
assignment, Conditional Operator, Growing Your Own, Scalar-Tying Methods, Array-Tying Methods
to conditional operator, Conditional Operator
elements, two-dimsional arrays, Growing Your Own
of tied variables, Scalar-Tying Methods
tied array element, Array-Tying Methods
assignment operator, Built-in Data Types
assignment operators, Assignment Operators, Assignment Operators, Assignment Operators, Assignment Operators, Overloadable Operators, The Copy Constructor (=), Previous Perl Traps, Glossary
overloading, Overloadable Operators, The Copy Constructor (=)
(see also copy constructor)
precedence, Perl versions, differences in, Previous Perl Traps
values, returning, Assignment Operators
associative arrays, Hashes., dbmopen (see hashes)
associativity of operators, Glossary
asssociativity, Relational Operators
operators, Relational Operators
* (asterisk), Quantifiers
quantifier, Quantifiers
async function, Thread creation
asynchronous events, Glossary
atan function, atan2
$atime file statistic, stat
atoms, The Little Engine That /Could(n't)?/, The Little Engine That /Could(n't)?/, Glossary
precedence, pattern matching, The Little Engine That /Could(n't)?/
attributes, Complexities, Some File Test Operators, Subroutine Attributes, Subroutine Attributes, The lvalue Attribute, The locked and method Attributes, Initializers, Managing Instance Data, New Tricks, New Tricks, Managing Class Data, The locked attribute, my, our, Perl Language Extensions and Internals, Glossary
attributes module, Perl Language Extensions and Internals
class, my
class, storing state for, Managing Class Data
files, test operators for, Some File Test Operators
locked and method, using with threads, New Tricks
locked, subroutines, The locked attribute
lvalue, subroutines, New Tricks
objects, hashes of, Complexities
subclass, overriding superclass ancestor, Managing Instance Data
subroutines, Subroutine Attributes, The lvalue Attribute, The locked and method Attributes
names, syntax for, The locked and method Attributes
variable interpolation and, our
attrs module (obsolete), Perl Language Extensions and Internals
authentication, Perl modules for, Authentication, Security, and Encryption
autodecrement (--) operator, Unary Arithmetic Operators, Autoincrement and Autodecrement, Overloadable Operators
magical, Overloadable Operators
autoflushing buffers, Special Variables in Alphabetical Order, Glossary
autogeneration, overloading, Overloadable Operators, Overloadable Operators, When an Overload Handler Is Missing (nomethod and fallback), Glossary
autoincrement and autodecrement, Overloadable Operators
preventing, When an Overload Handler Is Missing (nomethod and fallback)
autoincrement (++) operator, Unary Arithmetic Operators, Autoincrement and Autodecrement, Autoincrement and Autodecrement, Overloadable Operators, Glossary
magical, Autoincrement and Autodecrement, Overloadable Operators
AUTOLOAD subroutine, Autoloading
AUTOLOAD subroutines, goto
AutoLoader module, Module Installation Support
autoloading, Generating Accessors with Autoloading, Glossary
generating accessors with, Generating Accessors with Autoloading
automatic, line-end processing, Switches
autosplit mode, Switches
autosplit mode (with -a switch), Glossary
AutoSplit module, Module Installation Support
AutoSplit, portability of, Files and Filesystems
AutoTrace option (debugger), Debugger Options
autouse module, Module Installation Support
autouse pragma, use autouse
autovivification, Filehandle-Tying Methods, exists, open, Glossary
of filehandles, open
typeglobs, Filehandle-Tying Methods
AV (internal array value), Internal Data Types, Glossary
awk, Regular Expressions, Hashes, Glossary
converting to/from Perl, Hashes

B

 assertion, The Little Engine That /Could(n't)?/
for backspace, The Little Engine That /Could(n't)?/
 (backspace assertion in character classes), Custom Character Classes
-B (binary file) test operator, Named Unary and File Test Operators
B module, Perl Compiler and Code Generator
B (non word boundary), Boundaries: The  and B Assertions
b word boundary= (word boundary), Nailing Things Down
B::Asmdata module, Perl Compiler and Code Generator
B::Assemble module, Perl Compiler and Code Generator
B::Bblock module, Perl Compiler and Code Generator
B::Bytecode module, The Bytecode Generator, Perl Compiler and Code Generator
B::C and B::CC modules, The C Code Generators
B::C module, Perl Compiler and Code Generator
B::CC module, Perl Compiler and Code Generator
B::Debug module, Perl Compiler and Code Generator
B::Deparse module, Code Development Tools, Perl Compiler and Code Generator
B::Disassembler module, Perl Compiler and Code Generator
B::Lint module, Code Development Tools, Perl Compiler and Code Generator
B::Showlex module, Perl Compiler and Code Generator
B::Stash module, Perl Compiler and Code Generator
B::Terse module, Perl Compiler and Code Generator
B::Xref module, Code Development Tools, Perl Compiler and Code Generator
backends, compiler, Compiler Backends, Compiler Backends, Compiler Backends, Perl Compiler and Code Generator, Perl Compiler and Code Generator
generic interface to, Perl Compiler and Code Generator
modules, Compiler Backends
modules, calling, Compiler Backends
backquotes (`), Singularities
backreferences, Backreferences, The m// Operator (Matching), Capturing, Capturing, Capturing, Match-time pattern interpolation, Universal Blunders, Special Variables in Alphabetical Order, Glossary
(see also patterns ;backreference)
accessing with numbered variables, Capturing
creating with parentheses, Capturing
deriving patterns from matched substrings, Match-time pattern interpolation
backslash (), interpreting with double quotes, Singularities
backspace, Custom Character Classes, Boundaries: The  and B Assertions
 assertion in character class, Boundaries: The  and B Assertions
 assertion in character classes, Custom Character Classes
backspace character, String Literals
BACKSPACE character, The Little Engine That /Could(n't)?/
/b for, The Little Engine That /Could(n't)?/
backticks, Interprocess Communication (IPC)
portability of, Interprocess Communication (IPC)
backtracking, The Little Engine That /Could(n't)?/, Nonbacktracking Subpatterns, Glossary
nonbacktracking subpatterns, Nonbacktracking Subpatterns
in pattern matching, The Little Engine That /Could(n't)?/
backup files, Switches
backward compatibility, Glossary
bar, The Regular Expression Bestiary (see |)
bare blocks, Bare Blocks, Case Structures
case structures, doing with, Case Structures
bare identifiers, Or Leave the Quotes Out Entirely
barewords, Controlling the Use of Globals, Frequently Ignored Advice, Previous Perl Traps, Glossary
avoiding, reasons for, Frequently Ignored Advice
Perl versions, changes in, Previous Perl Traps
strict pragma, checking use of, Controlling the Use of Globals
base class, UNIVERSAL: The Ultimate Ancestor Class
overridden methods, invoking all, UNIVERSAL: The Ultimate Ancestor Class
base classes, Brief Refresher on Object-Oriented Lingo, Initializers, Convenient Classes, Convenient Classes, Documentation Support, Glossary
constructors and, Initializers
for pod filters and translators, Documentation Support
UNIVERSAL module, providing for all classes, Convenient Classes
base module, Perl Language Extensions and Internals
basename, files, Filenames, Filesystems, and File Locking
$BASETIME, Special Variables in Alphabetical Order
basetime ($^T), Special Variables in Alphabetical Order
BASIC programming language, Logical Operators
logical operators borrowed from, Logical Operators
BEGIN blocks, Scoping Issues, Using Modules, The Life Cycle of a Perl Program, Avant-Garde Compiler, Retro Interpreter, Avant-Garde Compiler, Retro Interpreter, How Perl Works
altering compiler parsing of file, Avant-Garde Compiler, Retro Interpreter
initializing variables before calling subroutines, Scoping Issues
modifications to @INC array, handling with, Using Modules
order of running, Avant-Garde Compiler, Retro Interpreter
beginnings of strings, matching, Beginnings: The A and ^ Assertions
Benchmark module, Development Support, Benchmark, Benchmark
comparing running times of alternate code versions, Benchmark, Benchmark
bidirectional rendering, Unicode properties, Standard Unicode properties
big-endian, Endianness and Number Width, Glossary
/bin/sh, Command Processing
binary, Multiplicative Operators, Bitwise Operators, binmode, open, pack, Glossary
files, open
mode on filehandles, binmode
operators, Bitwise Operators (see bitwise operators)
pack function, pack
repetition (x) operator, Multiplicative Operators
binary files, Some File Test Operators, Code Development Tools
decompiling with B::Deparse module, Code Development Tools
as regular files, Some File Test Operators
binary operators, Operators, Unary and Binary Operators, Unary and Binary Operators, The overload Pragma, Glossary
class handler, invoking, The overload Pragma
bind function, bind
binding, Binding Operators, dbmopen, tie, untie, Glossary
DBM file to hash, dbmopen
operators, Binding Operators
variables to packages, tie, untie
binding operator (=~), Regular Expressions
binding operators, Pattern-Matching Operators, The tr/// Operator (Transliteration)
pattern-matching operators, using with, Pattern-Matching Operators
tr/// (substitution) operator, use with, The tr/// Operator (Transliteration)
binmode, open
binmode function, binmode
bit vector, providing array interface to, Tie Modules on CPAN
bit-shift operators, Shift Operators
bit-shift operators (<<, >>), Glossary
bitmasks, select (ready file descriptors)
bits, Glossary, Glossary
execute bits, Glossary
bitwise, Ideographic Unary Operators, Bitwise Operators, Logical and, or, not, and xor
negation (~) operator, Ideographic Unary Operators
operators, Bitwise Operators, Logical and, or, not, and xor
bitwise operators, Overloadable Operators
overloading, Overloadable Operators
blank lines, truth value of, The while and until statements
bless function, What Is a Reference?, Object Construction, Object Construction, Tied Variables, bless, Glossary
constructors, using with, Object Construction
reference as argument for, What Is a Reference?
tie vs., Tied Variables
bless operator, Other Tricks You Can Do with Hard References
blib, Creating Extensions
blib pragma, use blib, Module Installation Support
$blksize file statistic, stat
BLOCK, Compound Statements, Compound Statements
(see also blocks)
block properties, Unicode, Unicode block properties
blocking calls, lock, threads, Synchronizing access with lock
blocking signals, Blocking Signals
blocking, shared locks, File Locking
blocks, The if and unless statements, The if and unless statements, Molecules, Simple Statements, Compound Statements, while and until Statements, Loop Control, Loop Control, Bare Blocks, Using a BLOCK as a Variable Name, Packages, last, stat, Glossary
(see also statements)
bare, Bare Blocks
continue block, while and until Statements
loops, Loop Control (see loops)
loops and, last
package declarations, span of, Packages
Boolean, Some File Test Operators, What Is Truth?, Boolean Context, Glossary, Glossary
context, Boolean Context, Glossary
definition of truth, What Is Truth?
operators, Some File Test Operators
Boolean context, The m// Operator (Matching), Overloadable Operators
bool conversion operator, Overloadable Operators
m// (match) operator in, The m// Operator (Matching)
Boolean values, Singularities
bootstrapping modules, Creating Extensions, Module Installation Support
boundaries, words (matching), Boundaries: The  and B Assertions
boundary assertions, Nailing Things Down
bounded array, creating, Array-Tying Methods
{} (braces), The if and unless statements
for statement blocks, The if and unless statements
break command (in C), C Traps
break statement, Loop Control (see last operator)
breakpoints, The Perl Debugger, Using the Debugger, Breakpoints, Breakpoints, Tracing, Glossary
deleting, Breakpoints
listing all, Breakpoints
setting for debugger, The Perl Debugger
setting on load, Using the Debugger
watch expressions, causing, Tracing
broadcasting, Glossary
BSD (Berkeley Standard Distribution), Glossary
BSD::Resource module, per-process resource limits, setting, Code Masquerading as Data
buckets, Glossary
buffering, Bidirectional Communication, fork, getc, Glossary, Glossary, Glossary, Glossary
bi-directional pipes, problems with, Bidirectional Communication
block, Glossary
commands, Glossary
line, Glossary
single-character input and, getc
unflushed buffers in Perl versions, fork
bugs, Diagnostic Messages
built-in, Built-in Data Types, Documentation Support, Glossary
data types, Built-in Data Types
functions, Documentation Support
listing by type, Documentation Support
built-in functions, Prototypes, Overriding Built-in Functions
overriding, Overriding Built-in Functions
subroutines, prototyping to emulate, Prototypes
built-in methods, Accessing Overridden Methods
overridden, calling via CORE pseudopackage, Accessing Overridden Methods
built-in operators, Effects of Character Semantics
character semantics, operating on, Effects of Character Semantics
bundles, The CPAN modules Directory, Glossary
byte meanings, character class shortcuts, Classic Perl Character Class Shortcuts
bytecode, The Life Cycle of a Perl Program, Glossary
Byteloader module, The Bytecode Generator
ByteLoader module, Perl Compiler and Code Generator
bytes, Atoms, Shift Operators, Unicode, Functions, read, sysread, Glossary, Glossary
bit-shift operators, Shift Operators
characters vs., Unicode, Functions
reading, read, sysread
storage locations, Glossary (see big-endian; little-endian)
bytes module, Internationalization and Locale

C

-c (check syntax) command-line switch, Switches, How Perl Works, Special Variables in Alphabetical Order
C language, Unary and Binary Operators, C-Style Logical (Short-Circuit) Operators, C Operators Missing from Perl, Signals, Executing Your Code, Compiler Backends, The C Code Generators, Internals and Externals, Extending Perl (Using C from Perl), XS and XSUBs, XSUB Input and Output, Using Functions from an External C Library, Embedding Perl (Using Perl from C), Adding a Perl Interpreter to Your C Program, Calling a Perl Subroutine from C, Evaluating a Perl Statement from C, Fiddling with the Perl Stack from C, Unix Kernel Security Bugs, C Traps, Functions, pack, Operating System Interfaces, Operating System Interfaces
accesing Perl from enclosing framework, Compiler Backends
C code generators, The C Code Generators
C stack, storing C variables on, Executing Your Code
C-style logical operators, C-Style Logical (Short-Circuit) Operators
fcntl.h definitions, loading as Perl constants, Operating System Interfaces
library functions, Functions
library, signals triggering core dumps in, Signals
operators missing in Perl, C Operators Missing from Perl
operators, precedence relationships, Unary and Binary Operators
Perl extensions and, Internals and Externals
Perl functions, wrapping around, XS and XSUBs
Perl, extending with, Extending Perl (Using C from Perl), Using Functions from an External C Library
external C library, using functions from, Using Functions from an External C Library
Perl, running from, Fiddling with the Perl Stack from C
Perl stack, manipulating, Fiddling with the Perl Stack from C
Perl, using from, XSUB Input and Output, Embedding Perl (Using Perl from C), Adding a Perl Interpreter to Your C Program, Calling a Perl Subroutine from C, Evaluating a Perl Statement from C
adding Perl interpreter, Adding a Perl Interpreter to Your C Program
Perl statement, evaluating, Evaluating a Perl Statement from C
Perl subroutine, calling from, Calling a Perl Subroutine from C
XSUB input and output, XSUB Input and Output
programming, differences from Perl, C Traps
structs, pack
syslog functions, using in Perl, Operating System Interfaces
wrapper programs, Unix Kernel Security Bugs
/c modifier, Progressive Matching
failed matches, searching past, Progressive Matching
-C (native wide characters) command-line switch, Building Character
/c pattern modifier, The tr/// Operator (Transliteration)
C preprocessor, Switches
C wildcard metasymbol, Wildcard Metasymbols
C/C++ languages, Scoping Issues
static variables, Scoping Issues
C language, Glossary, Glossary, Glossary
header files, Glossary
preprocessor, Glossary
callbacks, Closures, Glossary
caller function, Previous Perl Traps, caller
Perl versions, changes in return value, Previous Perl Traps
calling, Glossary, Glossary
by reference, Glossary
by value, Glossary
can method, UNIVERSAL: The Ultimate Ancestor Class
canonical decomposition, characters, Standard Unicode properties
canonicalization, Effects of Character Semantics, Glossary
characters, information on, Effects of Character Semantics
capitalization, Names, String Literals, Or Leave the Quotes Out Entirely, Loop Statements, The s/// Operator (Substitution), The tr/// Operator (Transliteration), Syntax, Using Modules, Tied Variables, Programming with Style, lc, uc, Listings by Type
barewords, problems with, Or Leave the Quotes Out Entirely
changing, The tr/// Operator (Transliteration)
escape sequences for, String Literals
label names, Loop Statements
lc and lcfirst functions, lc
method names, tied variables, Tied Variables
in module names, Listings by Type
module names, Using Modules
package/module names, Programming with Style
subroutine names, Syntax
uppercase, converting to (u escape), The s/// Operator (Substitution)
capturing in patterns, The m// Operator (Matching), Clustering, Glossary
suppressing in clustering, Clustering
words, alphanumeric, The m// Operator (Matching)
^ (caret), Quantifiers, Nailing Things Down
assertion, Quantifiers
line boundary, Nailing Things Down
Carp module, Scalar-Tying Methods, Warnings and Exceptions, Carp
carriage returns, Newlines
(see also newlines)
case, Pattern Modifiers, Metasymbol Tables, When backslashes happen, Effects of Character Semantics
case-sensitive matching, switching off, When backslashes happen
escape sequences for, Metasymbol Tables
processing during variable interpolation pass, Metasymbol Tables
matching, /i operator, Pattern Modifiers
translation operators, using Unicode tables, Effects of Character Semantics
case sensitivity, Pattern Modifiers, The tr/// Operator (Transliteration)
/i modifier (case insensitive), Pattern Modifiers
casting, Scalar Values, Glossary
data types, Glossary
strings and, Scalar Values
cat command (Unix), Hash-Tying Methods
categories, Perl Functions by Category
of functions, Perl Functions by Category
categories, characters, Standard Unicode properties
cbreak option, getc
centering, Format Variables
/cg pattern modifier, The m// Operator (Matching)
CGI module, World Wide Web, CGI
managing HTML forms with, CGI
CGI scripts, Handling Insecure Data, Safe examples
input, evaluating (Safe module), Safe examples
taint mode, necessity of running under, Handling Insecure Data
CGI::Apache module, World Wide Web
CGI::Carp module, World Wide Web, CGI::Carp
CGI::Cookie module, World Wide Web
CGI::Fast module, World Wide Web
CGI::Pretty module, World Wide Web
CGI::Push module, World Wide Web
character classes, Interpolating Array Values, Metasymbol Tables, Wildcard Metasymbols, Character Classes, Custom Character Classes, Classic Perl Character Class Shortcuts, Unicode Properties, Defining your own character properties, Defining your own character properties, POSIX-Style Character Classes, The Little Engine That /Could(n't)?/, Effects of Character Semantics, Effects of Character Semantics, Glossary
confusing with array subscripts, Interpolating Array Values
custom, Custom Character Classes
matching against character properties in Unicode, Effects of Character Semantics
metasymbols used within, Metasymbol Tables
Perl classic, Defining your own character properties
Perl shortcuts for, Classic Perl Character Class Shortcuts
POSIX-style, POSIX-Style Character Classes
predefined, availability of, Effects of Character Semantics
Unicode properties, Unicode Properties, Defining your own character properties
wildcard metasymbols and, Wildcard Metasymbols
character metasymbols, Custom Character Classes
in character classes, Custom Character Classes
character semantics, effects of, Effects of Character Semantics
character sets, The tr/// Operator (Transliteration), Unicode
ordering and ranges of characters in, The tr/// Operator (Transliteration)
Unicode, Unicode
character sets, portability of, Internationalization
characters, Atoms, Numeric Literals, Numeric Literals, The Regular Expression Bestiary, The Regular Expression Bestiary, The tr/// Operator (Transliteration), Specific Characters, Wildcard Metasymbols, Standard Unicode properties, Defining your own character properties, Defining your own character properties, The Little Engine That /Could(n't)?/, The Little Engine That /Could(n't)?/, Prototypes, Tied Variables, Unicode, Building Character, Special Variables in Alphabetical Order, Functions, chomp, chr, chr, getc, length, ord, pack, uc, Glossary, Glossary, Glossary
(see also patterns)
$[ variable, Special Variables in Alphabetical Order
aliases for, Specific Characters
bytes vs., Unicode, Functions
case of, uc (see capitalization)
converting between fixed 8-bit and variable-length UTF-8, Building Character
decomposition of, Standard Unicode properties
deleting, chomp
in formats, pack
funny characters preceding variable names, Tied Variables, Glossary
getting ASCII values of, ord
getting from ASCII values, chr
getting from Unicode values, chr
hexadecimal, Numeric Literals (see hexadecimal characters)
length in, length
metacharacters, The Regular Expression Bestiary
octal, Numeric Literals (see octal characters)
in patterns, The Regular Expression Bestiary
properties, Defining your own character properties, Defining your own character properties, Glossary
(see also under Unicode)
defining your own, Defining your own character properties
prototype, Prototypes
replacing in strings, The tr/// Operator (Transliteration)
single-character input, getc
special, The Little Engine That /Could(n't)?/
wildcard matches for, Wildcard Metasymbols
charnames module, Internationalization and Locale
charts, generating, Formats
chdir command, calling without argument, Environment Variables
chdir function, Terms and List Operators (Leftward), chdir
precedence and, Terms and List Operators (Leftward)
CHECK blocks, The Life Cycle of a Perl Program, Avant-Garde Compiler, Retro Interpreter, How Perl Works
order of running, Avant-Garde Compiler, Retro Interpreter
checking, taint, Handling Insecure Data
checksums, unpack
child processes, Anonymous Pipes, Anonymous Pipes, fork, wait
(see also processes)
ID, returning, fork
readable, starting, Anonymous Pipes
starting writeable, Anonymous Pipes
$CHILD_ERROR, Special Variables in Alphabetical Order
chmod function, How to Do It, chmod
chomp function, Filehandles, chomp
chop function, Filehandles, chop, chop
(see also chomp function)
chown function, chown
chr function, Effects of Character Semantics, chr
chroot function, chroot
chroot syscall, Restricting namespace access
circular references, Garbage Collection with DESTROY Methods, Overloadable Operators
breaking, Garbage Collection with DESTROY Methods
overloading, avoiding in, Overloadable Operators
circumfix operator, Glossary
class inheritance, Class Inheritance
class methods, Brief Refresher on Object-Oriented Lingo, Method Invocation, Inheritable Constructors, The Thread Module, Glossary
constructors as, Inheritable Constructors
package names as invocants for, Method Invocation
Thread class, The Thread Module
Class::Contract module, Using Closures for Private Objects
Class::Multimethods module, Accessing Overridden Methods
Class::Struct module, Data Types, Class::Struct
classes, The Arrow Operator, Packages, Packages, Using Modules, Brief Refresher on Object-Oriented Lingo, Perl's Object System, Object Construction, Class Inheritance, Inheritance Through @ISA, UNIVERSAL: The Ultimate Ancestor Class, UNIVERSAL: The Ultimate Ancestor Class, Method Autoloading, Private Methods, Managing Class Data, Managing Class Data, Tied Variables, Scalar-Tying Methods, Tying Hashes, Tying Filehandles, Perl Functions by Category, my, tie, untie, Perl Language Extensions and Internals, Glossary, Glossary
data, managing for, Managing Class Data, Managing Class Data
storing references to class data in object itself, Managing Class Data
definitions of, Using Modules
object-oriented modules as, Using Modules
derived, Glossary (see derived classes)
functions dealing with, Perl Functions by Category
implementing tie, Tied Variables
implementing tied filehandles, Tying Filehandles
implementing tied hashes, Tying Hashes
inheritance among, Class Inheritance, UNIVERSAL: The Ultimate Ancestor Class, Method Autoloading, Private Methods, Perl Language Extensions and Internals
base module, Perl Language Extensions and Internals
method autoloading, Method Autoloading
private methods, avoiding with, Private Methods
UNIVERSAL class and, UNIVERSAL: The Ultimate Ancestor Class
@ISA array, including with base pragma, Inheritance Through @ISA
modules vs., Packages
objects, giving to, Object Construction
package, The Arrow Operator, tie, untie
packages as, Perl's Object System
pseudohash implementations of, my
scalar-tying, Scalar-Tying Methods
version number, returning, UNIVERSAL: The Ultimate Ancestor Class
classes, Perl, Character Classes
clearing hashes, Hash-Tying Methods
clients, Glossary
clients, networking, Networking Servers
getting name of, Networking Servers
cloisters, Cloistered Pattern Modifiers, Glossary
close function, Anonymous Pipes, close
close-on-exec flag, Special Variables in Alphabetical Order
closedir function, closedir
closing, Networking Clients
server connections (half-close), Networking Clients
closing tied filehandles, Filehandle-Tying Methods
closures, Lexically Scoped Variables: my, Syntax, Closures as function templates, Nested subroutines, Autoloading, Generating Accessors with Closures, Using Closures for Private Objects, Thread creation, Glossary
assigning to glob to define subroutine, Autoloading
creating, Syntax
as function templates, Closures as function templates
generating accessor methods with, Generating Accessors with Closures
nested subroutines, emulating with, Nested subroutines
private objects, using for, Using Closures for Private Objects
threads, Thread creation
clustering in patterns, Clustering, Clustering, Glossary
without capturing, reasons for, Clustering
cmp operator, Some Numeric and String Comparison Operators, sort
code, Building Character, Locating Code, Handling Insecure Code, Safe Compartments, Safe examples, Code Masquerading as Data, Programmer Efficiency, Programming with Style
effienciency of, Programmer Efficiency
extracting and displaying with debugger, Locating Code
insecure, handling, Handling Insecure Code, Safe Compartments, Safe examples, Code Masquerading as Data
code masquerading as data, Code Masquerading as Data
safe compartments for, Safe Compartments
safe examples, Safe examples
mixing character semantics with byte semantics, Building Character
reusing, Programming with Style
code generation, The Life Cycle of a Perl Program, Perl Compiler and Code Generator
code generators, Compiler Backends, Code Generators, The Bytecode Generator, Glossary
bytecode generator, The Bytecode Generator
code subpatterns in regular expressions, Match-time code evaluation, Glossary
collating sequence, Glossary
combining character sequence, matching with X, Wildcard Metasymbols
combining character sequence, X, matching with, Effects of Character Semantics
comma (,), Hashes. (see ,)
command line, How to Do It, Debugger Options, Option, Argument, Parameter, and Configuration File Processing
calling perl interpreter from, How to Do It
modules for processing, Option, Argument, Parameter, and Configuration File Processing
screen appearance of, Debugger Options
command processing, Location of Perl
location of Perl, Location of Perl
command-line arguments, Glossary
commands, Verbs, Loop Control, Hashes of Functions, Command Processing, Command Processing, Using the Debugger, Debugger Commands, Stepping and Running, Display, Display, Locating Code, Actions and Command Execution, Miscellaneous Commands, Miscellaneous Commands, Miscellaneous Commands, Miscellaneous Commands, Debugger Options, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges, Special Variables in Alphabetical Order, Glossary
accessing under reduced privileges, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges
buffering, Special Variables in Alphabetical Order, Glossary
debugger, Debugger Commands, Stepping and Running, Display, Display, Locating Code, Actions and Command Execution, Miscellaneous Commands, Miscellaneous Commands, Miscellaneous Commands, Miscellaneous Commands
actions and, Actions and Command Execution
for display, Display, Display
documentation, viewing, Miscellaneous Commands
locating code, Locating Code
options, manipulating, Miscellaneous Commands
quitting debugger, Miscellaneous Commands
restarting debugger, Miscellaneous Commands
stepping and running, Stepping and Running
for loop control, Loop Control
hashes of functions, storing in, Hashes of Functions
history, debugger and, Using the Debugger
names for, Verbs
processing, Command Processing, Command Processing
(see also interpreters; Perl interpreter)
recalling, debugger option, Debugger Options
comments, Molecules, Pattern Modifiers, Letting Perl Do the Work, C Traps, Pod in a Nutshell, Glossary
definition, Molecules
discarding before processing, Letting Perl Do the Work
extending with /x pattern modifier, Pattern Modifiers
multiline, Pod in a Nutshell
Perl vs. C syntax for, C Traps
comp.lang.perl newsgroups, Usenet Newsgroups
comparing, Relational Operators, Identifying threads, Universal Blunders, Filenames, Filesystems, and File Locking, Development Support
files, Filenames, Filesystems, and File Locking
running time of alternate code versions, Development Support
strings, Relational Operators, Universal Blunders
thread objects, Identifying threads
comparision operators, Overloadable Operators
overloading, Overloadable Operators
comparison operators, Some Numeric and String Comparison Operators, Some Numeric and String Comparison Operators, Equality Operators, sort
sort function and, sort
compatibility decomposition, characters, Standard Unicode properties
compilation, Avant-Garde Compiler, Retro Interpreter, Internals and Externals
order of, Avant-Garde Compiler, Retro Interpreter
compilation phase, processing Perl program, How Perl Works
compilation units, Name Lookups, Glossary
compile phase, Glossary
compile phase vs. compile time, Compiling Your Code
compile time, Glossary
compile time, controlling debugger during, Using the Debugger
compiler, Special Variables in Alphabetical Order
compiler hints, Special Variables in Alphabetical Order
compiler, Perl, Compiler Backends, The CPAN modules Directory
backends for, Compiler Backends
modules related to, The CPAN modules Directory
compilers, Global Declarations, The Regex Compiler, Glossary
global declarations and, Global Declarations
regex compiler, The Regex Compiler
compilers, Perl, Avant-Garde Compiler, Retro Interpreter, Perl Compiler and Code Generator
interpreters, interaction with, Avant-Garde Compiler, Retro Interpreter
modules related to, Perl Compiler and Code Generator
compiling, Compiling, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, Compiling Your Code
compiling your code, Compiling Your Code
life cycle of Perl programs, The Life Cycle of a Perl Program
life cycle, Perl programs, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program
code generation phase, The Life Cycle of a Perl Program
compile phase, The Life Cycle of a Perl Program
parse tree reconstruction, The Life Cycle of a Perl Program
complementation, History Made Practical (see negation)
complex data structures, Complexities, Data Structures
creating in Perl, Data Structures
representing as scalars, Complexities
composite Unicode properties, Perl's Unicode properties
Comprehensive Pearl Archive Network, Simplicities (see CPAN)
COMSPEC environment variable, Environment Variables
concatenating strings, String Operators, Glossary
concatenation (.) operator, String Operators, Additive Operators, Overloadable Operators, Overloading Constants, Time Efficiency
autogeneration via stringification handler, Overloadable Operators
string constants, overloading, Overloading Constants
condition variables, Condition variables
conditional (?:) operator, Conditional Operator, Case Structures
conditional code execution, Logical Operators
conditional context, Boolean Context (see Boolean context)
conditional statements, Compound Statements, if and unless Statements
(see also if statements; unless statements)
without braces, writing, Compound Statements
conditionals, interpolation into patterns, Conditional interpolation
conditions, expressions in loops, for Loops
Config module, Signals, Module Installation Support
operating system mapping between signal names and numbers, Signals
configuration, Perl, for debugging, Switches
connect function, connect
connections, shutdown, Glossary
shutting down, shutdown
constant pragma, Symbol Tables
constants, Inlining Constant Functions, Symbol Tables, Overloading Constants, Operating System Interfaces, Networking and Interprocess Communication
inlining constant functions, Inlining Constant Functions
overloading, Overloading Constants
Perl, loading fcntl.h definitions as, Operating System Interfaces
System V IPC, defining for, Networking and Interprocess Communication
constructors, Brief Refresher on Object-Oriented Lingo, Object Construction, Object Construction, Inheritable Constructors, Inheritable Constructors, Initializers, Using Closures for Private Objects, Tied Variables, new, Glossary, Glossary
access checks, setting in, Using Closures for Private Objects
bless function and, Object Construction
class names or objects, working with, Inheritable Constructors
inheritable, Inheritable Constructors
initializers, Initializers
new method, new
tied variable classes, Tied Variables
container classes holding pointers to self-referential data structures, Garbage Collection with DESTROY Methods
context, Context, Context, Scalar and List Context, wantarray, Glossary
(see also list context, scalar context)
scalar and list context, Scalar and List Context
void, wantarray
context stack, Executing Your Code
continuation lines, Loop Control, Special Variables in Alphabetical Order, Glossary
continue block, while and until Statements, foreach Loops, Loop Control, Loop Control
(see also loops)
continue command (in C), C Traps
contract between module and user, Module Privacy and the Exporter
contractions in words, avoiding confusion with single quotes, Lookaround Assertions
control characters, String Literals, Specific Characters, #! and Quoting on Non-Unix Systems
metasymbols in patterns, Specific Characters
non-ASCII on Macintosh, #! and Quoting on Non-Unix Systems
control structures, Control Structures, Breaking out: next and last, What Is Truth?
truth, defining, What Is Truth?
control variables, foreach Loops
Control-A, The s/// Operator (Substitution)
Control-C, String Literals, Signals
signals, handler for, Signals
Control-C or Control-Z, generating signals with, Signals
Control-D as eof, Generating Perl in Other Languages
Control-D character, Other Literal Tokens
Control-Z as eof, Generating Perl in Other Languages
Control-Z character, Other Literal Tokens
conversion operators, Overloadable Operators, Overloadable Operators, Overloadable Operators
Boolean context, interpreting object in, Overloadable Operators
numification (nonnumeric variable converted to number), Overloadable Operators
stringification, Overloadable Operators
converting, The s/// Operator (Substitution), Effects of Character Semantics, Fiddling with the Perl Stack from C, Generating Perl in Other Languages, chr, chr, gmtime, hex, join, localtime, oct, ord, pack, split, sprintf, sprintf, unpack
ASCII value to character, chr
between integers and UTF-8 characters, Effects of Character Semantics
between languages, Generating Perl in Other Languages
characters to ASCII values, ord
data types between C and Perl, Fiddling with the Perl Stack from C
decimal numbers to binary digits or octals, sprintf
decimal numbers to octal or hexadecimal, sprintf
hexadecimal numbers to decimal, hex
list values to strings, join, pack
numbers to/from hexadecimal, The s/// Operator (Substitution)
octal numbers to decimal, oct
strings to list values, split, unpack
time, gmtime, localtime
Unicode value to character, chr
cookies (HTTP), setting and getting, World Wide Web
copy constructor, The Copy Constructor (=)
copy-on-write semantics, The Process Model
copying filenames or filehandles, Filenames, Filesystems, and File Locking
core dumps, Other standard threading modules, Code Masquerading as Data, dump, Glossary
denial-of-service problems with pattern matching, Code Masquerading as Data
dump function for, dump
Thread::Signal module, preventing with, Other standard threading modules
core dumps, signals triggering in C library, Signals
core files, Switches
core modules, Perl, The CPAN modules Directory
CORE pseudopackage, Overriding Built-in Functions, Accessing Overridden Methods
CORE::GLOBAL pseudopackage, Overriding Built-in Functions
cos function (cosines), cos
counters, magical counter variables, Magical Counter Variables
CPAN, Packages
CPAN (Comprehensive Pearl Archive Network), Simplicities
CPAN (Comprehensive Perl Archive Network), Packages, Modules, Tie Modules on CPAN, CPAN, CPAN, The CPAN modules Directory, The CPAN modules Directory, Using CPAN Modules, Decompressing and Unpacking CPAN Modules, Creating CPAN Modules, CPAN, Glossary
CPAN module as automated interface to, CPAN
modules, The CPAN modules Directory, Using CPAN Modules, Decompressing and Unpacking CPAN Modules, Creating CPAN Modules
categories of modules, The CPAN modules Directory
creating, Creating CPAN Modules
decompressing and unpacking, Decompressing and Unpacking CPAN Modules
installing and building, Using CPAN Modules
modules directory, The CPAN modules Directory
subdirectories, CPAN
tie modules on, Tie Modules on CPAN
CPAN module, Using CPAN Modules, Standard Modules, Module Installation Support, CPAN
installing modules with, Using CPAN Modules
portability of, Standard Modules
CPU, Condition variables, Handling Timing Glitches
access in multitasking environment, Handling Timing Glitches
condition variables allowing threads to relinquish, Condition variables
CPU time, times
CPU, yielding (threads), Yielding the processor
cracker, Glossary
creation time, History Made Practical (see modification time, file)
CRLF, Networking Servers, Newlines
(see also newlines)
in Internet programs, Networking Servers
crypt function, crypt
cryptography, srand
$ctime file statistic, stat
curly braces, Hashes., Quantifiers (see {thinsp&;}) (see {})
current package, Glossary
customization, Debugger Customization, Editor Support for Debugging, Customizing with Init Files, Debugger Options, Writing Your Own Debugger
debugger, Debugger Customization, Editor Support for Debugging, Customizing with Init Files, Debugger Options, Writing Your Own Debugger
debugger options, Debugger Options
editor support for, Editor Support for Debugging
functions for, Writing Your Own Debugger
init files, using, Customizing with Init Files
CV (internal code value), Glossary
Cwd module, Filenames, Filesystems, and File Locking, Cwd
current working directory for process, determining, Cwd

D

^D (Control-D) as eof, Generating Perl in Other Languages
-d (debug) command-line switch, Switches, Switches, The Perl Debugger
-D (debugging) command-line switch, Switches
d for digit=d (for digit), Regular Expressions
/d modifier, The tr/// Operator (Transliteration)
/d pattern modifier, The tr/// Operator (Transliteration)
-d switch, perl, The Perl Profiler
daemons, Handling Insecure Data
taint mode, importance of enabling for, Handling Insecure Data
dangling statements, Glossary
data, Unicode, Handling Insecure Data, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges, Perl Functions by Category, Perl Language Extensions and Internals
byte-oriented vs. character-oriented, Unicode
fixed-length, functions for, Perl Functions by Category
insecure, handling, Handling Insecure Data, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges
command and file access under reduced privileges, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges
screen dump, providing, Perl Language Extensions and Internals
data access, Data Access, Synchronizing access with lock, Synchronizing access with lock, Deadlock, Locking subroutines, Locking methods, Condition variables
threads, Data Access, Synchronizing access with lock, Synchronizing access with lock, Deadlock, Locking subroutines, Locking methods, Condition variables
condition variables, Condition variables
deadlock, Deadlock
locking methods, Locking methods
locking subroutines, Locking subroutines
synchronizing with lock, Synchronizing access with lock
unlocking, Synchronizing access with lock
DATA filehandle, Special Variables in Alphabetical Order
data organization in Perl, Common Mistakes
data structures, Complexities, References, What Is a Reference?, Data Structures, Hashes of Arrays, Arrays of Hashes, Hashes of Hashes, Hashes of Functions, More Elaborate Records, Saving Data Structures, Saving Data Structures, Brief Refresher on Object-Oriented Lingo, Garbage Collection with DESTROY Methods, Tie Modules on CPAN, Glossary
arrays of hashes, Arrays of Hashes
complex, representing as scalars, Complexities
flat, linear in Perl, References
hashes of arrays, Hashes of Arrays
hashes of functions, Hashes of Functions
multidimensional hashes, Hashes of Hashes
objects, Brief Refresher on Object-Oriented Lingo (see objects)
persistent, providing via tie, Tie Modules on CPAN
records of elaborate, More Elaborate Records
references to, What Is a Reference?
saving, Saving Data Structures
self-referential, container classes holding pointers to, Garbage Collection with DESTROY Methods
stringifying, Saving Data Structures
__DATA__ token, Other Literal Tokens, Special Variables in Alphabetical Order
data types, Variable Syntax, Built-in Data Types, Scalar Values, Typeglobs and Filehandles, Internal Data Types, Fiddling with the Perl Stack from C, my, Glossary
built-in, Built-in Data Types
converting between C and Perl, Fiddling with the Perl Stack from C
internal, Perl and C, Internal Data Types
scalars, Scalar Values (see scalars)
TYPE declarations in Perl, my
typeglobs, Typeglobs and Filehandles
Data::Dumper, Saving Data Structures
Data::Dumper module, Perl Language Extensions and Internals, Data::Dumper
databases, Pattern Matching, Tied Variables, Glossary
Data Base Management, Glossary (see DBM files)
Perl connections to, Pattern Matching
tying hash variables to, Tied Variables
datagrams, Sockets, Glossary
date function, localtime (see localtime function)
dates, portability of, Dates and Times
DB module, Perl Language Extensions and Internals
DB package, caller
caller function, caller
DBM file, Tie Modules on CPAN
storing complex data values in, Tie Modules on CPAN
DBM files, File Locking, dbmclose, delete, DBM Interfaces, Glossary
dbmclose and dbmopen functions, dbmclose
deleting from, delete
locking, File Locking
modules for, DBM Interfaces
DBM modules, portability of, Standard Modules
dbmclose function, Tied Variables
dbmopen function, Tied Variables, Tied Variables
use declarations with, Tied Variables
dbprofpp program, The Perl Profiler, The Perl Profiler
DB_File module, DBM Interfaces
deadlock in threads, Deadlock
debugging, Class Inheritance, Managing Class Data, Overloading Diagnostics, Filehandle-Tying Methods, Compiler Backends, Switches, Environment Variables, Environment Variables, The Perl Debugger, Debugger Commands, Debugger Customization, Debugger Options, Unattended Execution, Debugger Support, Handling Insecure Data, Perl Language Extensions and Internals, Perl Language Extensions and Internals, Glossary
(see also taint)
backend modules for, Compiler Backends
DB module, Perl Language Extensions and Internals
debug level, setting through class or instances, Managing Class Data
debugger code, command for loading, Environment Variables
debugger customization, Debugger Customization
debugger support, Perl, Debugger Support
debugger, customizing, Debugger Options
options, Debugger Options
debugger, unattended execution, Unattended Execution
Devel::Peek module for XS programs, Perl Language Extensions and Internals
global destruction of objects other references, controlling, Environment Variables
overloading, Overloading Diagnostics
Perl debugger commands, Debugger Commands
Perl, using C compiler -DDEBUGGING option, Class Inheritance
symbolic, Glossary
turning on in tied filehandle, Filehandle-Tying Methods
$DEBUGGING, Special Variables in Alphabetical Order
debugging flags, Special Variables in Alphabetical Order
decimal points, lining up, Formats
declarations, Getting Started, Simplicities, Simplicities, Statements and Declarations, Global Declarations, Global Declarations, Scoped Declarations, Scoped Declarations, Lexically Scoped Global Declarations: our, Syntax, Packages, Generating Classes with Class::Struct, New Tricks, package, Glossary
global, Global Declarations
global variables, Lexically Scoped Global Declarations: our
lexically scoped, Lexically Scoped Global Declarations: our
methods, New Tricks
lvalues, indicating return of, New Tricks
package, Packages, package
packages, Simplicities, Scoped Declarations
scoped, Scoped Declarations
structs, Generating Classes with Class::Struct
subroutines, Global Declarations, Syntax
with definitions, Syntax
use declarations, Simplicities
variables, Statements and Declarations
declarative approach, regular expression programming, Programmatic Patterns
declaring, Syntax, Formats, sub
formats, Formats
subroutines, Syntax, sub
without defining, Syntax
decomposing characters into simpler ones, Standard Unicode properties
decompressing CPAN modules, Decompressing and Unpacking CPAN Modules
decrementing variables, Unary Arithmetic Operators, Glossary
decryption, crypt (see encryption)
default package, Scoped Declarations
DEFAULT pseudosignal, Signals
default values, Glossary
defined function, defined, Glossary
defining, Semantics
subroutines, Semantics
definitions, Global Declarations, Global Declarations, Using Modules, Glossary
classes (object-oriented modules as), Using Modules
subroutines, Global Declarations, Global Declarations
declarations vs., Global Declarations
loading from other files, Global Declarations
DEL in hexadecimal, String Literals
delete function, Previous Perl Traps, delete
tied arrays, not returning deleted value for, Previous Perl Traps
deleting, The tr/// Operator (Transliteration), Breakpoints, Actions and Command Execution, chomp, delete, pop, rmdir, splice, unlink, unlink
all debugger actions, Actions and Command Execution
array elements, pop, splice
breakpoints, Breakpoints
characters, chomp
directories, rmdir, unlink
files, unlink
found but unreplaced characters, The tr/// Operator (Transliteration)
hash elements, delete
delimiters, Pattern-Matching Operators, Glossary
pattern-matching operators and, Pattern-Matching Operators
denial-of-service problems (patterns and regular expressions), security concerns, Code Masquerading as Data
dereference operators, overloading, Overloadable Operators
dereference-address operator (*), C language, C Operators Missing from Perl
dereferencing, What Is a Reference?, What Is a Reference?, Using Hard References, Using a Variable as a Variable Name, Using the Arrow Operator, Using the Arrow Operator, Access and Printing, Hashes of Functions, Symbol Tables, Glossary
(see also references)
array elements, Access and Printing
hash values as functions, Hashes of Functions
operator for, Using the Arrow Operator (see arrow operator)
typeglobs, Symbol Tables
derived classes, Brief Refresher on Object-Oriented Lingo, Accessing Overridden Methods, Glossary, Glossary
empty subclass test, Glossary
methods as wrappers around base class methods, Accessing Overridden Methods
descriptors, Glossary (see file descriptors)
destroying threads, Thread destruction, The detach method
detach method, The detach method
join method, Thread destruction
destructors, Instance Destructors, Garbage Collection with DESTROY Methods, System V IPC, Environment Variables, Glossary, Glossary
controlling, Environment Variables
garbage collection with, Garbage Collection with DESTROY Methods
shared memory and semaphore, System V IPC
detach method, The detach method
$dev file statistic, stat
Devel::Dprof module, The Perl Profiler, The Perl Profiler, The Perl Profiler
profiling subroutine execution with, The Perl Profiler, The Perl Profiler
Devel::DProf module, Perl Language Extensions and Internals
Devel::Peek module, Perl Language Extensions and Internals
Devel::SelfStubber module, Module Installation Support
Devel::SmallProf module, The Perl Profiler
development support, modules for, The CPAN modules Directory
devices (hardware), Glossary
diagnostic messages, Diagnostic Messages (see error messages; warning messages)
diagnostics module, Perl Language Extensions and Internals
die function, Signals, die, exit, Glossary
exit function versus, exit
fatal errors, causing, Glossary
quit signal handling and, Signals
dieLevel option (debugger), Debugger Options
digits, Regular Expressions, Names
in names, Names
directives (pod), Glossary
directories, Some File Test Operators, Switches, Perl Functions by Category, chdir, chroot, closedir, mkdir, opendir, readdir, rewinddir, rmdir, seekdir, unlink, Filenames, Filesystems, and File Locking, Filenames, Filesystems, and File Locking, Filenames, Filesystems, and File Locking, Filehandle, Directory Handle, and Stream I/O Utilities, Filehandle, Directory Handle, and Stream I/O Utilities, Glossary
changing working, chdir
closing, closedir
creating, mkdir
creating or removing portably, Filenames, Filesystems, and File Locking
current working, getting pathname of, Filenames, Filesystems, and File Locking
deleting, rmdir, unlink
DirHandle module, Filehandle, Directory Handle, and Stream I/O Utilities
file test checks on trees, Filenames, Filesystems, and File Locking
file test operator, Some File Test Operators
functions dealing with, Perl Functions by Category
handles, Glossary
IO::Dir module, Filehandle, Directory Handle, and Stream I/O Utilities
opendir function, opendir
prepending to @INC, Switches
reading entries from, readdir
rewinddir function, rewinddir
root, redefining, chroot
seekdir function, seekdir
disciplines, binmode, open
filehandles, setting up with binmode, binmode
division, Multiplicative Operators (see multiplicative operators)
DNS (domain name server), Sockets
do, Simple Statements
loop controls, Simple Statements
do BLOCK, Bare Blocks, Bare Blocks
iterating, Bare Blocks
terminating, Bare Blocks
do BLOCK operator, do (block)
do FILE operator, do (file)
do loops, Universal Blunders
do SUBROUTINE operator, do (subroutine)
do {}, Bare Blocks
loop controls and, Bare Blocks
doc directory (CPAN), official Perl manpages, CPAN
documentation, Online Documentation, Offline Documentation, Bug Reports, Miscellaneous Commands, Functions, Documentation Support
books on Perl, Offline Documentation
bug reports, Bug Reports
C library functions, Functions
default system viewer, calling, Miscellaneous Commands
modules for, Documentation Support
Perl manpages, Online Documentation
documentation, standard modules, Modules
documentation,embedded in Perl programs, Plain Old Documentation
(see also pod)
$ (dollar sign), Nailing Things Down
word boundary, Nailing Things Down
dollar sign ($), Hashes. (see $)
dosish.h file, #! and Quoting on Non-Unix Systems
double quotes, Singularities, Singularities
strings, use in, Singularities
double quotes ("), The s/// Operator (Substitution), When backslashes happen
replacement string, use with, The s/// Operator (Substitution)
translation escape processing, When backslashes happen
double-ended pipe, opening with tied filehandle, Creative Filehandles
double-quote context, The s/// Operator (Substitution)
scalar variables, expanding in, The s/// Operator (Substitution)
double-quoted strings, String Operators
interpolation and concatenation, String Operators
down method, Semaphores
DProf, The Perl Profiler (see Devel::Dprof module)
dump function, dump
Dumpvalue module, Perl Language Extensions and Internals
duplicate replaced characters, eliminating, The tr/// Operator (Transliteration)
dweomer, Glossary
dwimmer, Glossary
DynaLoader, Creating Extensions
DynaLoader module, Autoloading, Module Installation Support
dynamic linking, Extending Perl (Using C from Perl), XS and XSUBs
C source code from Perl, Extending Perl (Using C from Perl)
dynamic scoping, Scoped Declarations, Scoped Variable Declarations, Pattern-Matching Operators, The s/// Operator (Substitution), Glossary
pattern variables, Pattern-Matching Operators, The s/// Operator (Substitution)

E

-e (execute) command-line switch, Switches
-e (exists) file test, Some File Test Operators
/e pattern modifier, The s/// Operator (Substitution)
each function, Access and Printing of a Hash of Hashes, Hash-Tying Methods, each
editors, support for debugging, Editor Support for Debugging
effective GID, Special Variables in Alphabetical Order (see $) variable)
effective GID (group ID), Special Variables in Alphabetical Order
effective UID ($EFFECTIVE_USER_ID), Special Variables in Alphabetical Order
(see also $< and $> variables)
$EFFECTIVE_GROUP_ID, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order
$EFFECTIVE_USER_ID, Special Variables in Alphabetical Order
efficiency, The Perl Profiler, Efficiency (see performance)
profiling, The Perl Profiler
elements, Arrays.
in arrays, Arrays.
elements in arrays, Glossary
eleseif statements, The if and unless statements
ellipses (…), Metasymbol Tables
else statements, The if and unless statements
emacs, Command Processing, Editor Support for Debugging
-*- sequences, Command Processing
editor support for debugger, Editor Support for Debugging
emacs editor, Regular Expressions
regular expressions, use of, Regular Expressions
embedding Perl, Internals and Externals, Embedding Perl (Using Perl from C), Adding a Perl Interpreter to Your C Program, Evaluating a Perl Statement from C, Fiddling with the Perl Stack from C, Module Installation Support, Glossary
adding Perl interpreter to C program, Adding a Perl Interpreter to Your C Program
evaluating Perl statement from C, Evaluating a Perl Statement from C
perl interpreter program, Internals and Externals
Perl stack, manipulating from C, Fiddling with the Perl Stack from C
empty angle operator (<>), Filehandles
empty subclass test, Class Inheritance, Glossary
encapsulation, Complexities, Brief Refresher on Object-Oriented Lingo, Using Closures for Private Objects, Tie Modules on CPAN, Glossary
namespace-based, Tie Modules on CPAN
objects in closures, Using Closures for Private Objects
encryption, crypt, Authentication, Security, and Encryption
modules for, Authentication, Security, and Encryption
__END__; use of, Generating Perl in Other Languages
END block, Avant-Garde Compiler, Retro Interpreter
exit value of program, modifying, Avant-Garde Compiler, Retro Interpreter
END blocks, The Life Cycle of a Perl Program, Avant-Garde Compiler, Retro Interpreter, Avant-Garde Compiler, Retro Interpreter
order of running, Avant-Garde Compiler, Retro Interpreter
skipping, Avant-Garde Compiler, Retro Interpreter
end of string, matching, Endings: The z, , and $ Assertions
__END__ token, Special Variables in Alphabetical Order
endgrent function, getgrent
endhostent function, gethostent
ending, kill (see terminating)
ending escape sequences for character modification, String Literals
endless loop, for Loops (see infinite loops)
endprotoent function, getprotoent
endpwent function, getpwent
endservent function, getservent
English module, Perl Language Extensions and Internals
enqueue method, Queues
%ENV hash, System Interaction, Special Variables in Alphabetical Order, delete
deleting from, delete
portability of, System Interaction
Env module, Perl Language Extensions and Internals
env program, starting Perl with, Command Processing
environment, Glossary
environment variables, Garbage Collection with DESTROY Methods, Environment Variables, Environment Variables, Unattended Execution, Handling Insecure Data, Shell Traps, System Interaction, Special Variables in Alphabetical Order, Perl Language Extensions and Internals, Glossary
Env module, Perl Language Extensions and Internals
modules, Perl use of, Environment Variables
PERLDB_OPTS, setting debugger options with, Unattended Execution
PERL_DESTRUCT_LEVEL, Garbage Collection with DESTROY Methods
portability of, System Interaction
shells vs. Perl, Shell Traps
taint checking, Handling Insecure Data
EOF (end-of-file), Glossary
eof function, The while and until statements, Filehandle-Tying Methods, Time Efficiency, eof
tied filehandle, using on, Filehandle-Tying Methods
eq operator, Universal Blunders
equal method, Identifying threads
equal to (=) operator, Equality Operators
equality operators, Equality Operators
erasing, rmdir (see deleting)
errno, Special Variables in Alphabetical Order, Glossary, Glossary (see $OS_ERROR)
(see also dollar sign, $! under Symbols; $OS_ERROR)
Errno module, Perl Language Extensions and Internals
error messages, User Efficiency, Programming with Style, Diagnostic Messages
user efficiency, improving with, User Efficiency
errors, Error Indications, Managing unknown symbols, Handling Insecure Data, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, fileno, warn, World Wide Web, Carp, CGI::Carp, Diagnostic Messages, Glossary
(see also STDERR filehandle)
$@ variable for, Special Variables in Alphabetical Order
$! variable for, Special Variables in Alphabetical Order
$? variable for, Special Variables in Alphabetical Order
Carp module, Carp
CGI::Carp module, handling of, CGI::Carp
failed symbol exports, Managing unknown symbols
insecure data, Handling Insecure Data
number (errno), Glossary
out-of-memory errors, Special Variables in Alphabetical Order
subroutines, Error Indications
warn function, producing error messages, warn
writing to httpd or other CGI errors logs, World Wide Web
ESC character, String Literals
ESC in octal, String Literals
escape sequences for control characters, String Literals
/etc/group file, Time Efficiency, getgrent
/etc/hosts file, gethostent
/etc/networks file, getnetent
/etc/passwd file, Time Efficiency, getpwent
/etc/protocols file, getprotoent
/etc/services file, getservent
/etc/utmp file, getlogin
eval, Name Lookups
eval function, The tr/// Operator (Transliteration), Packages, Time Efficiency, Time Efficiency, die, eval
die function and, die
loops and, Time Efficiency
packages and, Packages
translating with variables, The tr/// Operator (Transliteration)
eval method, Catching exceptions from join, Restricting namespace access
restricted (reval), Restricting namespace access
threads, catching exceptions with, Catching exceptions from join
eval {}, Bare Blocks
loop controls and, Bare Blocks
eval {} operator, Terms and List Operators (Leftward)
$EVAL_ERROR, Special Variables in Alphabetical Order
eval_sv and eval_pv functions, Evaluating a Perl Statement from C
exceptions, Error Indications, Catching exceptions from join, The detach method, Handling Insecure Data, Special Variables in Alphabetical Order, Perl Functions in Alphabetical Order, die, eval, Perl Language Extensions and Internals, Warnings and Exceptions, Glossary, Glossary
in detached child threads, The detach method
die function and, die
fatal errors, causing, Glossary
functions raising, Perl Functions in Alphabetical Order
insecure data, Handling Insecure Data
intercepting, Special Variables in Alphabetical Order
modules for, Warnings and Exceptions
raising on failure, Perl Language Extensions and Internals
raising to indicate subroutine errors, Error Indications
threads, catching, Catching exceptions from join
trapping, eval
$EXCEPTIONS_BEING_CAUGHT, Special Variables in Alphabetical Order
exclusive file locks, File Locking, File Locking
obtaining, File Locking
exclusive or (xor) operator, Bitwise Operators, Logical and, or, not, and xor
exec function, Passing Filehandles, Code Masquerading as Data, Interprocess Communication (IPC), exec, Glossary
filehandles, leaving open across calls, Passing Filehandles
list argument form, avoiding shell with, Code Masquerading as Data
portability of, Interprocess Communication (IPC)
executable files, Glossary
executable image file, The Life Cycle of a Perl Program
$EXECUTABLE_NAME, Special Variables in Alphabetical Order
execute bit, Glossary
executing, How to Do It, Logical Operators, Method Invocation, Executing Your Code, Command Processing, system
code, Executing Your Code
code, conditionally, Logical Operators
methods, Method Invocation
other programs from Perl, system
Perl program, How to Do It
Perl programs, Command Processing
execution, The Life Cycle of a Perl Program, Avant-Garde Compiler, Retro Interpreter, Unattended Execution
code, order of, Avant-Garde Compiler, Retro Interpreter
Perl programs, The Life Cycle of a Perl Program
unattended, debugger, Unattended Execution
execv function (in C), exec
execvp function (in C), exec
existence, Signaling Process Groups
of a process, Signaling Process Groups
exists function, Hash-Tying Methods, exists
invoking on hash, Hash-Tying Methods
exit function, Thread destruction, exit, fork
threads and, Thread destruction
exit status, Special Variables in Alphabetical Order
exiting, for Loops, Bare Blocks, Bare Blocks, Miscellaneous Commands, Debugger Options
debugger, Debugger Options
if or unless blocks, Bare Blocks
infinite loop, for Loops
once-through blocks, Bare Blocks
Perl debugger, Miscellaneous Commands
exiting programs, Getting Started
exp function, exp
expansion, filename, glob
Expect module, Bidirectional Communication
explicit method invocations, Method Invocation
exponential notation, Numeric Literals
exponentiation (**) operator, Exponentiation
exponentiation of integers, Fiddling with the Perl Stack from C
Exporter, Creating Extensions
Exporter module, Module Privacy and the Exporter, Tag-handling utility functions, Module Installation Support
module privacy and, Module Privacy and the Exporter, Tag-handling utility functions
exporting, Modules
exporting symbols, Creating Modules, Module Privacy and the Exporter, Exporting without using Exporter's import method, Glossary
without using import method from Exporter, Exporting without using Exporter's import method
export_fail method, Managing unknown symbols
export_to_level method, Exporting without using Exporter's import method
expressions, Compound Statements, for Loops, for Loops, Programmatic Patterns, Glossary
EXPR and LIST, Compound Statements
loops, separating with commas (,), for Loops
multiple, in loops, for Loops
Perl, supplying in replacement strings, Programmatic Patterns
EXPRs, Compound Statements, goto
goto operator, use with, goto
$EXTENDED_OS_ERROR, Special Variables in Alphabetical Order
extending arrays, Array Length
extending Perl, Extending Perl (Using C from Perl), XSUB Input and Output, Using Functions from an External C Library, Perl Language Extensions and Internals, Glossary
extensions, creating, Perl Language Extensions and Internals, Glossary
using functions from external C libraby, Using Functions from an External C Library
XSUB input and output, XSUB Input and Output
external subroutines, External Subroutines (XS)
portability of, External Subroutines (XS)
extracting substrings, substr
ExtUtils::Command module, Module Installation Support
ExtUtils::Embed module, Compiling Embedded Programs, Module Installation Support
ExtUtils::Install module, Module Installation Support
ExtUtils::Installed module, Module Installation Support
ExtUtils::Liblist module, Module Installation Support
ExtUtils::MakeMaker, Creating CPAN Modules, Creating CPAN Modules
(see also MakeMaker)
ExtUtils::MakeMaker module, Module Installation Support
ExtUtils::Manifest module, Module Installation Support
ExtUtils::Mkbootstrap module, Module Installation Support
ExtUtils::Mksymlists module, Module Installation Support
ExtUtils::MM_Cygwin module, Module Installation Support
ExtUtils::MM_OS2 module, Module Installation Support
ExtUtils::MM_Unix module, Module Installation Support
ExtUtils::MM_VMS module, Module Installation Support
ExtUtils::MM_Win32 module, Module Installation Support
ExtUtils::Packlist module, Module Installation Support
ExtUtils::testlib module, Module Installation Support

F

@F array, Special Variables in Alphabetical Order
-F (pattern to split on)command-line switch, Switches, Switches
failed matches, searching past position of, Progressive Matching
fallback overloading key, When an Overload Handler Is Missing (nomethod and fallback)
false value, What Is Truth? (see false value)
false values, Singularities, Glossary
FAQ, Perl online, Common Goofs for Novices
Fast CGI protocol, using, World Wide Web
fatal errors, Glossary, Glossary
Fatal module, Perl Language Extensions and Internals
fcntl function, Temporary Files, fcntl
security risks associated with, Temporary Files
Fcntl module, Operating System Interfaces
fcntl syscall, Passing Filehandles
filehandle close-on exec flag, manipulating, Passing Filehandles
field separator, specifying different, Switches, Glossary
fields module, Perl Language Extensions and Internals
FIFOs, Glossary
__FILE__; setting, Generating Perl in Other Languages
file descriptors, Filehandle-Tying Methods, Passing Filehandles, Passing Filehandles, fileno, select (ready file descriptors), Glossary
filehandles, passing with, Passing Filehandles
passing through environment variable or command-line option, Passing Filehandles
returning for tied filehandles, Filehandle-Tying Methods
file test operators, Named Pipes
-p, checking for FIFO, Named Pipes
file tests, Handling Race Conditions, Glossary
race conditions with, Handling Race Conditions
File::Basename module, Files and Filesystems, Filenames, Filesystems, and File Locking
File::CheckTree module, Filenames, Filesystems, and File Locking
File::chmod module, chmod
File::Compare module, Filenames, Filesystems, and File Locking
File::Copy module, Filenames, Filesystems, and File Locking
File::DosGlob module, Filenames, Filesystems, and File Locking
File::Find module, Filenames, Filesystems, and File Locking
File::Glob module, Filenames, Filesystems, and File Locking
File::Path module, Filenames, Filesystems, and File Locking
File::Spec module, Files and Filesystems, Filenames, Filesystems, and File Locking
File::Spec::Functions module, Filenames, Filesystems, and File Locking
File::Spec::Mac module, Filenames, Filesystems, and File Locking
File::Spec::OS2 module, Filenames, Filesystems, and File Locking
File::Spec::Unix module, Filenames, Filesystems, and File Locking
File::Spec::VMS module, Filenames, Filesystems, and File Locking, Filenames, Filesystems, and File Locking
File::Spec::Win32 module, Filenames, Filesystems, and File Locking
File::stat module, Filenames, Filesystems, and File Locking
File::Temp module, dealing with race conditions, Temporary Files
FileHandle module, Format Variables, Accessing Formatting Internals, Filehandle, Directory Handle, and Stream I/O Utilities
filehandle-tying, Filehandle-Tying Methods, Creative Filehandles
filehandles, Filehandles, Filehandles, Names, Typeglobs and Filehandles, Typeglobs and Filehandles, Prototypes, Formats, Formats, What Is a Reference?, Handle References, Tying Filehandles, Filehandle-Tying Methods, Creative Filehandles, Creative Filehandles, Tie Modules on CPAN, File Locking, Passing Filehandles, Passing Filehandles, Passing Filehandles, Handling Race Conditions, Special Variables in Alphabetical Order, Perl Functions by Category, local, open, open, open, read, seek, select (output filehandle), Filehandle, Directory Handle, and Stream I/O Utilities, Filehandle, Directory Handle, and Stream I/O Utilities, Glossary, Glossary
anonymous, Handle References
creating, Filehandles
duplicating, reasons for, open
ending with _TOP, Formats, Special Variables in Alphabetical Order
file locks on, File Locking
formats associated with, default names of, Formats
functions dealing with, Perl Functions by Category
implicit referencing in, What Is a Reference?
indirect, Glossary
local, creating, local
localizing, Typeglobs and Filehandles
names for, Names
object methods for, using, Filehandle, Directory Handle, and Stream I/O Utilities
open function, open
passing, Prototypes
passing in IPC, Passing Filehandles, Passing Filehandles, Passing Filehandles
through standard filehandles, Passing Filehandles
piped, explicitly closing, open
positioning file pointer for, seek
reading bytes of data from, read
selecting for output, select (output filehandle)
SelectSaver module, Filehandle, Directory Handle, and Stream I/O Utilities
syslog tying output to, Tie Modules on CPAN
tying, Tying Filehandles, Filehandle-Tying Methods, Creative Filehandles, Creative Filehandles
creative filehandles, Creative Filehandles
methods for, Filehandle-Tying Methods, Creative Filehandles
typeglobs for, Typeglobs and Filehandles
use instead of filenames, security benefits of, Handling Race Conditions
filenames, Locating Code, Cleaning Up Your Environment, System Interaction, Special Variables in Alphabetical Order, glob, link, open, open, readlink, rename, symlink, Glossary
%INC hash of, Special Variables in Alphabetical Order
& (ampersand) in, open
changing name of, rename
expansions of, glob
external data in, security risks of, Cleaning Up Your Environment
getting from symbolic links, readlink
globbing, System Interaction
linking symbolically, symlink
linking with hard links, link
mode, separating from, open
viewing different program or eval statement, Locating Code
fileno, Filehandle-Tying Methods (see file descriptors)
fileno function, fileno
files, Some File Test Operators, Name Lookups, Lexically Scoped Variables: my, Packages, Autoloading, Files, File Locking, Passing Filehandles, Passing Filehandles, Switches, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges, Files and Filesystems, System Interaction, Perl Functions by Category, binmode, chmod, chown, close, do (file), eof, eval, open, open, rename, stat, stat, symlink, sysopen, sysopen, sysread, syswrite, tell, truncate, umask, unlink, utime, Filenames, Filesystems, and File Locking, Microsoft-Related Modules, Glossary, Glossary, Glossary
access and modification times, stat, utime
accessing under reduced privileges, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges
changing name of, rename
closing, close
core, Switches
deleting, unlink
do FILE operator, do (file)
end-of-file, eof
end-of-file (EOF), Glossary
executable, Glossary
functions dealing with, Perl Functions by Category
getting statistics of, stat
in interprocess communication, Files, File Locking, Passing Filehandles, Passing Filehandles
locking mechanisms, File Locking
passing filehandles, Passing Filehandles, Passing Filehandles
lexically scoped variables and, Name Lookups
modules for cross-platform access methods, Filenames, Filesystems, and File Locking
modules, autoloading, Autoloading
open function, open
opening via low-level system call, sysopen
ownership and group, changing, chown
path components, separators for, Files and Filesystems
Perl module, housing in single, Packages
permissions, chmod, sysopen, umask (see permissions, file)
portably opening, System Interaction
read in binary mode, binmode
reading via low-level system call, sysread
renaming, program for, eval
returning current position for, tell
scopes, Lexically Scoped Variables: my
symbolically linking, symlink
test operators, Some File Test Operators
text/binary distinction, open
truncating, truncate
Win32API::File module, Microsoft-Related Modules
writing via low-level system call, syswrite
filesystems, Glossary, Glossary
filesystems, portability, Files and Filesystems
filtering output with forking open, Talking to Yourself
filters, Source Filters, Glossary
source code, Source Filters
filters, source code, List Processing
find function, Filenames, Filesystems, and File Locking
traversing file trees like, Filenames, Filesystems, and File Locking
FindBin module, Module Installation Support
findstr function, Regular Expressions, Regular Expressions
fixed 8-bit chracters, Building Character
flags, Pattern Modifiers, Switches, Glossary, Glossary (see modifiers) (see switches, command-line)
(see also modifiers; switches)
floating-point numbers, Scalar Values, Endianness and Number Width, pack, rand, Data Types, Glossary
computer storage, order of, Endianness and Number Width
Math::BigFloat module, Data Types
rand function, returning, rand
flock function, Scalar-Tying Methods, Timing Out Slow Operations, File Locking, flock
alarms and, Timing Out Slow Operations
flow of program control, functions for, Perl Functions by Category
flushing buffers, Special Variables in Alphabetical Order, Glossary
fmt (Unix utility), Format Variables
FMTEYEWTK (Far More Than Everything You Ever Wanted to Know), Glossary
footers, Footers
for, foreach Loops
as an alias of foreach, foreach Loops
for loops, The for statement, Modifying strings en passant
searching and replacing elements in arrays, Modifying strings en passant
foreach loops, The foreach statement, Modifying strings en passant, Shell Traps, Previous Perl Traps, Time Efficiency
loop variable, Perl vs. shell programming, Shell Traps
Perl versions, changes in, Previous Perl Traps
searching and replacing elements in arrays, Modifying strings en passant
foreach modifier, Simple Statements
fork function, Reaping Zombies, Passing Filehandles, Talking to Yourself, Networking Servers, Interprocess Communication (IPC), flock, fork, Glossary
child processes, inheriting parent filehandles, Passing Filehandles
fork-open, Talking to Yourself
locks, inheriting across calls to, flock
portability of, Interprocess Communication (IPC)
servers, cloning themselves with, Networking Servers
zombie processes and, Reaping Zombies
fork syscall, Anonymous Pipes
forking, Accessing Commands and Files Under Reduced Privileges
pipe open, avoiding shell in, Accessing Commands and Files Under Reduced Privileges
forks, The Process Model, open, open, open
cloned interpreter on Windows, The Process Model
fork open, open
open command, two-argument form, open
form feed, Special Variables in Alphabetical Order
formal arguments, Special Variables in Alphabetical Order, Glossary
format, Special Variables in Alphabetical Order
format function, format, formline
declaration, format
output accumulator, formline
formats, Formats, Formats, Formats, Formats, Format Variables, Format Variables, Footers, Accessing Formatting Internals, Code Development Tools, Previous Perl Traps, pack, pack, pack, sprintf, Glossary
accessing formatting internals, Accessing Formatting Internals
argument lists for, evaluating in list context, Previous Perl Traps
B::Xref module, cross-references with C, Code Development Tools
characters in, pack
declaring, Formats
fmt (Unix utility), Format Variables
footers, Footers
integers, pack
lexical variables in, Formats
pack/unpack, pack
for strings, sprintf
top-of-form processing, Formats
variables, Format Variables
$FORMAT_FORMFEED, Special Variables in Alphabetical Order
$FORMAT_LINES_LEFT, Special Variables in Alphabetical Order
$FORMAT_LINES_PER_PAGE, Special Variables in Alphabetical Order
$FORMAT_LINE_BREAK_CHARACTERS, Special Variables in Alphabetical Order
$FORMAT_NAME, Special Variables in Alphabetical Order
$FORMAT_PAGE_NUMBER, Special Variables in Alphabetical Order
$FORMAT_TOP_NAME, Special Variables in Alphabetical Order
formline function, formline
formline operator, Accessing Formatting Internals
Fortran, Molecules
frame option (debugger), Debugger Options
free-form languages, Molecules
freeware, Glossary
fully-qualified names, Names
function call, Bidirectional Communication
pipe, low-level for bi-directional communication, Bidirectional Communication
function calls, Terms and List Operators (Leftward)
function templates, closures as, Closures as function templates
functions, Unary and Binary Operators, Named Unary and File Test Operators, Loop Control, Passing References, Closures, Hashes of Functions, Autoloading, Module Privacy and the Exporter, Overriding Built-in Functions, Method Autoloading, Public Overload Functions, Notational Convenience, Effects of Character Semantics, Signals, Sockets, The Thread Module, Customizing with Init Files, Writing Your Own Debugger, XS and XSUBs, Temporary Files, Frequently Ignored Advice, Programming with Style, Portable Perl, Functions, Functions, Functions, Functions, Perl Functions by Category, Perl Functions in Alphabetical Order, Documentation Support, Glossary
(see also under specific function name)
autoloading, Autoloading, Method Autoloading
built-in, listing by type, Documentation Support
by category, Perl Functions by Category
byte-oriented wrappers for, Effects of Character Semantics
C library, Functions
debugger customization, Writing Your Own Debugger
debugger, calling internal, Customizing with Init Files
default arguments, avoiding errors with, Frequently Ignored Advice
generation of, Closures
hashes of, Hashes of Functions
interpolating, Notational Convenience
in list or scalar context, Functions
modules, exporting to programs, Module Privacy and the Exporter
named unary operators, Named Unary and File Test Operators
names for, Programming with Style
operators and, Unary and Binary Operators
for overloading, Public Overload Functions
overriding, Overriding Built-in Functions
Perl, varying across platforms, Portable Perl
Perl, wrapping around C, XS and XSUBs
references, using for both input and output, Passing References
return operators in, Loop Control
returning tainted data, Perl Functions in Alphabetical Order
signal-handling, Signals
socket-related in Perl, Sockets
temporary filenames, generating, Temporary Files
Thread module, The Thread Module
funny characters, Tied Variables, Glossary
$^F variable, fileno

G

/g (global) pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution)
/g pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution)
G positional assertion, The m// Operator (Matching)
garbage collection, Garbage Collection with DESTROY Methods, Scalar-Tying Methods, Glossary
with DESTROY methods, Garbage Collection with DESTROY Methods
of globals, Glossary
objects associated with tied variables, Scalar-Tying Methods
GDBM_File module, DBM Interfaces
GDMB files (GNU DBM), locking, File Locking
generated patterns, Generated patterns
generators, Perl programs, Program Generation, Generating Other Languages in Perl, Generating Perl in Other Languages, Source Filters
in other languages, Generating Perl in Other Languages
other languages in Perl, Generating Other Languages in Perl
source filters, Source Filters
getc function, Time Efficiency, getc
GETC method, Filehandle-Tying Methods
getgrent function, getgrent
getgrgid function, getgrgid
getgrnam function, getgrnam
gethost* functions, overriding built-in, Networking and Interprocess Communication
gethostbyaddr function, Building Character, gethostbyaddr
converting characters back into bytes, Building Character
gethostbyname function, gethostbyname
gethostent function, gethostent
getlogin function, getlogin
getnet* functions, overriding built-in, Networking and Interprocess Communication
getnetbyaddr function, getnetbyaddr
getnetbyname function, getnetbyname
getnetent function, getnetent
Getopt::Long module, Option, Argument, Parameter, and Configuration File Processing
Getopt::Std module, Option, Argument, Parameter, and Configuration File Processing
Getopts::* modules, Loop Control
getpeername function, Networking Servers, getpeername
getpgrp function, getpgrp
getppid function, getppid
getpriority function, getpriority
getproto* functions, overriding built-in, Networking and Interprocess Communication
getprotobyname function, getprotobyname
getprotobynumber function, getprotobynumber
getprotoent function, getprotoent
getpwent function, getpwent
getpwnam function, getpwnam
getpwuid function, getlogin, getpwuid
getserv* functions, overriding built-in, Networking and Interprocess Communication
getservbyname function, getservbyname
getservbyport function, getservbyport
getservent function, getservent
getsockname function, getsockname
getsockopt function, getsockopt
$gid file statistic, stat
gid (group ID), Talking to Yourself
assumed, Talking to Yourself
GID (group ID), Special Variables in Alphabetical Order, chown, getgrgid, Glossary
(see also $( variable; $) variable)
looking up files by, getgrgid
GID (group ID), effective, Special Variables in Alphabetical Order
glob function, Filename Globbing Operator, glob
global, Global Declarations
declarations, Global Declarations
global (variables), Glossary
global declarations, our
(see also our declarations)
global matching, The m// Operator (Matching) (see /g modifier)
global names, Simplicities
prefixing with module name, Simplicities
global search and replace, The s/// Operator (Substitution)
global variables, Dynamically Scoped Variables: local, Controlling the Use of Globals, Packages, Data Access, local, our, Perl Language Extensions and Internals
controlling use with strict pragma, Controlling the Use of Globals
declaring, our
local operator, using on, Dynamically Scoped Variables: local
localizing, local
package variables as, Packages
predeclaring, vars module, Perl Language Extensions and Internals
threads, accessing in, Data Access
globbing filenames, System Interaction, Filenames, Filesystems, and File Locking, Glossary
portability of, System Interaction
glue language, Perl as, Filehandles, Glossary
gmtime function, gmtime, Data Types
goto function, goto, Time Efficiency, goto
greater than (>) operator, Relational Operators
greater than or equal (>=) operator, Relational Operators
greedy matching, Quantifiers, Molecules, Quantifiers, Quantifiers, The Little Engine That /Could(n't)?/, Glossary
tokens, Molecules
Greenwich Mean Time (GMT), gmtime
grep function, Regular Expressions, Programming with Style, grep
grep program, When backslashes happen
grep utility, Glossary
group ID, chown (see GID)
group name, getgrnam
grouping operator, Unary and Binary Operators, The Regular Expression Bestiary, Metasymbol Tables, The Little Engine That /Could(n't)?/
for expressions, Unary and Binary Operators
groupings, Capturing
nesting of, Capturing
groups, Signaling Process Groups, Perl Functions by Category, Perl Functions by Category, getgrent, getgrnam, getpriority, kill, Glossary
process, getpriority, kill
killing, kill
returning priority of, getpriority
processes, Signaling Process Groups, Perl Functions by Category
functions dealing with, Perl Functions by Category
users, Perl Functions by Category, getgrent, getgrnam, Glossary
functions dealing with, Perl Functions by Category
group name, getgrnam
members, login names, getgrent
GUI, using PerlTk, User Efficiency
GV (internal glob value), Internal Data Types, Glossary

H

-h (help) command-line switch, Switches
h2xs, Creating CPAN Modules
h2xs utility, XS and XSUBs
hacker, Glossary
>shutdown, shutdown
handlers, The overload Pragma, Overload Handlers, Overloadable Operators, When an Overload Handler Is Missing (nomethod and fallback), Signals, Glossary
overload, The overload Pragma, Overload Handlers, When an Overload Handler Is Missing (nomethod and fallback)
missing, When an Overload Handler Is Missing (nomethod and fallback)
overloading, Overloadable Operators
as_string handler, Overloadable Operators
for signals, Signals
handles, Variable Syntax, Filehandle, Directory Handle, and Stream I/O Utilities, Convenient Classes, Glossary
directories, Filehandle, Directory Handle, and Stream I/O Utilities, Glossary
tied, base class definitons for, Convenient Classes
hard links, filenames, link
hard references, The Arrow Operator, What Is a Reference?, Creating References, Using Hard References, Signals, Glossary
%SIG array, Signals
using, Using Hard References
hardware devices, Glossary
hardware drivers, Perl modules for interacting with, The CPAN modules Directory
hashDepth option (debugger), Debugger Options
hashes, Variable Syntax, Pluralities, Hashes., Hashes., Built-in Data Types, Built-in Data Types, Variables, Hashes, Hashes, Hashes, Hashes, Multiplicative Operators, foreach Loops, Case Structures, The m// Operator (Matching), Passing References, What Is a Reference?, The anonymous hash composer, Data Structures, Common Mistakes, Hashes of Arrays, Generation of a Hash of Arrays, Access and Printing of a Hash of Arrays, Arrays of Hashes, Generation of an Array of Hashes, Hashes of Hashes, Generation of a Hash of Hashes, Access and Printing of a Hash of Hashes, Symbol Tables, Symbol Tables, Symbol Tables, Using Modules, Managing Instance Data, Using Closures for Private Objects, Tied Variables, Tying Hashes, Hash-Tying Methods, Signals, Debugger Options, Internal Data Types, Handling Insecure Data, Time Efficiency, Perl Functions by Category, dbmopen, delete, each, exists, keys, local, reverse, values, Convenient Classes, Glossary, Glossary, Glossary
%INC for modules, Using Modules
%SIG, references to signal handlers, Signals
anonymous, Managing Instance Data
data structure for objects, Managing Instance Data
anonymous, references to, The anonymous hash composer
of arrays, Generation of a Hash of Arrays
generating, Generation of a Hash of Arrays
binding DBM files to, dbmopen
buckets, Glossary
cascading conditionals, using instead of, Case Structures
deleting values from, delete
elements, giving temporary values to, local
exists function and, exists
flat lookup tables, providing access to, Data Structures
HV (hash value) typedef in C, Internal Data Types
initializing with x operator, Multiplicative Operators
instead of linear searches, Time Efficiency
inverting, reverse
key/value pair precedence, Hashes
key/value pairs, Built-in Data Types, Hashes, The m// Operator (Matching)
capturing from string with m//g operator, The m// Operator (Matching)
key/value pairs in, Hashes.
keys, Glossary
keys, finding number in, Hashes
keys, returning list of, keys
multidimensional, Hashes of Hashes, Generation of a Hash of Hashes, Access and Printing of a Hash of Hashes
accessing and printing, Access and Printing of a Hash of Hashes
generation of, Generation of a Hash of Hashes
names for, Variables
of arrays, Hashes of Arrays, Access and Printing of a Hash of Arrays, Arrays of Hashes, Generation of an Array of Hashes
access and printing of, Access and Printing of a Hash of Arrays
generating, Generation of an Array of Hashes
output style, changing in debugger, Debugger Options
passing by reference into or out of functions, Passing References
Perl data organization in, Common Mistakes
printing out in sorted order, foreach Loops
processing, functions for, Perl Functions by Category
references to, What Is a Reference?
restricted, implementing, Using Closures for Private Objects
returning key/value pairs, each
returning values of, values
symbol tables, Symbol Tables, Symbol Tables, Symbol Tables
key/value pairs in, Symbol Tables
typeglobs in, Symbol Tables
taint in, Handling Insecure Data
tying, Tied Variables, Tying Hashes, Hash-Tying Methods, Convenient Classes
methods for, Hash-Tying Methods
Tie::Hash module, providing base class definitions, Convenient Classes
header files, Glossary, Glossary
(see also modules)
headers, format names, Footers
here documents, "Here" Documents, Universal Blunders, Glossary, Glossary
end-of-file, Glossary
indentation of, "Here" Documents
semicolon (;), omitting trailing, Universal Blunders
hex function, hex
hexadecimal, The s/// Operator (Substitution), Glossary
converting numbers to, The s/// Operator (Substitution)
hexadecimal characters, Numeric Literals
hexadecimal numbers, Specific Characters, hex
character numbers, specifying as, Specific Characters
hints, compiler, Special Variables in Alphabetical Order
history of Perl, History Made Practical
history, command, Using the Debugger
home directory, chdir, Glossary
home page, Perl, Perl on the Web
HOME variable, Environment Variables
hostnames, gethostbyaddr, gethostbyname, getnetbyname, Operating System Interfaces
getting from network addresses, gethostbyaddr
Sys::Hostname module, Operating System Interfaces
translating to addresses, gethostbyname, getnetbyname
hosts, Glossary
hosts (remote), checking for reachability, Networking and Interprocess Communication
hosts file, getnetent (see /etc/hosts file)
HTML, World Wide Web, World Wide Web, Documentation Support
CGI module, generation of, World Wide Web
code, producing nicely formatted, World Wide Web
pod files, converting to, Documentation Support
HTTP, World Wide Web
cookies, setting and getting, World Wide Web
HTTP (Hypertext Transfer Protocol), Regular Expressions
links, searching for, Regular Expressions
hubris, Glossary
HV (internal hash value), Internal Data Types, Glossary
- (hyphen), Unary Arithmetic Operators
-- (autodecrement) operator, Unary Arithmetic Operators

I

-i (in-place editing) command-line switch, Switches
-I (include path) command-line switch,, Command Processing, Switches
/i pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution)
/i pattern modifier, Pattern Modifiers
I/O (input/output), Glossary
I18N::Collate module, Internationalization and Locale
identifiers, Molecules, Names, Names, String Literals, String Literals, Or Leave the Quotes Out Entirely, Using Modules, Effects of Character Semantics, Signaling Process Groups, Identifying threads, Handling Insecure Data, Accessing Commands and Files Under Reduced Privileges, Temporary Files, Previous Perl Traps, getpwuid, open, semget, shmget, Glossary, Glossary
(see also UID; GID)
bare, barewords vs., Or Leave the Quotes Out Entirely
effective UID or GID, setting back to real, Accessing Commands and Files Under Reduced Privileges
effective user or group IDs, differing from real, Handling Insecure Data
enclosing in braces, String Literals
GID (group ID), Glossary
names vs., Names
Perl modules, Using Modules
PIDs, guessing, Temporary Files
process group ID, Signaling Process Groups
processes (pid), open
semaphores, semget
shared memory segments, shmget
single quotes (') in, String Literals
starting with underscore (_), changes in Perl versions, Previous Perl Traps
thread IDs, Identifying threads
Unicode alphanumeric characters, containing, Effects of Character Semantics
identifiers, package, Packages, Packages
in package symbol table, Packages
ideographic unary operators, Ideographic Unary Operators
ideographs, Regular Expressions, Effects of Character Semantics
matching with w, Effects of Character Semantics
idioms, Perl, Fluent Perl
if modifier, Simple Statements
if statements, Logical Operators, Logical Operators, The if and unless statements, if and unless Statements, C Traps
C language, differences from Perl, C Traps
logical operators and, Logical Operators
IGNORE pseudosignal, Signals
impatience, Glossary
imperative programming style, Programmatic Patterns
implicit method invocation, Method Invocation
implicit referencing or dereferencing, What Is a Reference?
import function, Using Modules, Exporting without using Exporter's import method, import
import method, Overloading Constants, Glossary
overloading constants, Overloading Constants
importing, Global Declarations, Symbol Tables, use
semantics into package, use
symbols from one package to another, Symbol Tables
importing symbols, Module Privacy and the Exporter
(see also Exporter module; exporting symbols)
@INC array, Using Modules, Switches, Special Variables in Alphabetical Order
%INC hash, Using Modules
incrementing variables, Unary Arithmetic Operators
index function, index, Glossary
indexing arrays, Access and Printing of a Hash of Arrays
indirect filehandles, open, Glossary
indirect object slot, Method Invocation Using Indirect Objects
indirect object syntax, Method Invocation Using Indirect Objects, Syntactic Snafus with Indirect Objects, Package-Quoted Classes
ambiguities in, Syntactic Snafus with Indirect Objects, Package-Quoted Classes
indirect objects, Handling Insecure Data, Glossary
explicit path, passing in slot, Handling Insecure Data
indirection, Name Lookups, Method Invocation, Glossary, Glossary
(see also hard references; symbolic references)
between class use and implementation, Method Invocation
inequality, Equality Operators (see equality operators; relational operators)
inet_ntoa function, gethostbyaddr
infinite loops, for Loops
infix dereference operator, The Arrow Operator (see arrow operator)
infix operators, Operators, Glossary
inheritance, Packages, Module Privacy and the Exporter, Brief Refresher on Object-Oriented Lingo, Inheritable Constructors, Class Inheritance, Class Inheritance, Inheritance Through @ISA, Field Declarations with use fields, Using Closures for Private Objects, Managing Class Data, Inheritance and Overloading, Perl Language Extensions and Internals, Glossary
base class, establishing at compile time, Perl Language Extensions and Internals
class, Packages, Class Inheritance, Class Inheritance
single or multiple, Class Inheritance
class accessors, Managing Class Data
classes and objects, Field Declarations with use fields
pseudohash implementation and, Field Declarations with use fields
constructors, Inheritable Constructors
through @ISA array, Inheritance Through @ISA
modules, from Exporter class, Module Privacy and the Exporter
overloading and, Inheritance and Overloading
restricted access and, Using Closures for Private Objects
inhibit_exit option (debugger), Debugger Options
INIT blocks, Scoping Issues, The Life Cycle of a Perl Program, Avant-Garde Compiler, Retro Interpreter, Avant-Garde Compiler, Retro Interpreter
initializing variables before calling subroutine, Scoping Issues
order of running, Avant-Garde Compiler, Retro Interpreter, Avant-Garde Compiler, Retro Interpreter
init program, getppid
initial caps, ucfirst (see capitalization)
initialization, Customizing with Init Files
debugger, customizing with init files, Customizing with Init Files
initialization expressions, for Loops
initializing, Hashes, Scoping Issues, Initializers
hash variables, Hashes
objects, Initializers
variables before calling subroutines, Scoping Issues
inlining constant functions, Inlining Constant Functions, Inlining Constant Functions
preventing inlining, Inlining Constant Functions
$ino file statistic, stat
inplace editing ($^I, $INPLACE_EDIT), Switches
inplace edits with $^I, Special Variables in Alphabetical Order
$INPLACE_EDIT, Special Variables in Alphabetical Order
input, Input Operators, Pipes, Pipes, Anonymous Pipes, Bidirectional Communication, Switches, Unattended Execution, XSUB Input and Output, Special Variables in Alphabetical Order, Perl Functions by Category, fileno, getc, ioctl, open, select (ready file descriptors)
(see also STDIN filehandle)
checking file descriptors for, select (ready file descriptors)
debugger, setting, Unattended Execution
files, locating end with eof, Switches
files, open mode for, open
functions dealing with, Perl Functions by Category
ioctl function, ioctl
operators, Input Operators
pipes, Pipes, Pipes, Anonymous Pipes, Bidirectional Communication
multistage pipelines, Anonymous Pipes
tridirectional, Bidirectional Communication
record separator, Special Variables in Alphabetical Order (see $/ variable)
single-character, buffered and unbuffered, getc
XSUBs, XSUB Input and Output
input filehandles, Filehandles
$INPUT_LINE_NUMBER, Special Variables in Alphabetical Order
$INPUT_RECORD_SEPARATOR, Special Variables in Alphabetical Order
insecure dependency errors, Handling Insecure Data
installation, Using CPAN Modules, Installing CPAN Modules into the Perl Library, Module Installation Support
modules supporting, Module Installation Support
modules, CPAN, Using CPAN Modules, Installing CPAN Modules into the Perl Library
into Perl library, Installing CPAN Modules into the Perl Library
installed modules, inventory of, Module Installation Support
instance data, Managing Instance Data, Generating Accessors with Autoloading, Generating Accessors with Closures, Using Closures for Private Objects, New Tricks, Glossary
managing, Managing Instance Data, Generating Accessors with Autoloading, Generating Accessors with Closures, Using Closures for Private Objects, New Tricks
generating accesors with autoloading, Generating Accessors with Autoloading
generating accessors with closures, Generating Accessors with Closures
new features, Perl 5.6, New Tricks
using closures for private objects, Using Closures for Private Objects
instance methods, Brief Refresher on Object-Oriented Lingo, Method Invocation
object references as invocants for, Method Invocation
instance variables, Initializers, Managing Instance Data
separate functions, writing for each, Managing Instance Data
instances, Brief Refresher on Object-Oriented Lingo, Glossary
int function, int
integers, Overloading, Effects of Character Semantics, Internal Data Types, Internal Data Types, Fiddling with the Perl Stack from C, Endianness and Number Width, int, pack, sprintf, vec, Data Types, Glossary, Glossary
computer storage, order of, Endianness and Number Width
converting to UTF-8 characters, Effects of Character Semantics
exponentiation, Fiddling with the Perl Stack from C
formats, pack
formats for, sprintf
IV (internal integer value), Glossary
IV (internal integer values), Internal Data Types
IV typedef in C, Internal Data Types
Math::BigInt module, Overloading
standard modules for arithmetic with, Data Types
strings as vectors of, vec
intercept signals, handler for, Signals
interfaces, Brief Refresher on Object-Oriented Lingo, Building Character, Glossary
byte vs. character semantics in, Building Character
internal variable names, Perl, Names
internationalization, Atoms, Unicode, Internationalization, Internationalization and Locale
modules for, Internationalization and Locale
textual data, with Unicode, Unicode
Internet services, CPAN modules for, Sockets
interpolating variables, Variable Interpolation, The qr// quote regex operator
pattern matching, controlling with, Variable Interpolation, The qr// quote regex operator
interpolation, String Operators, Backreferences, String Literals, String Literals, String Literals, List Values and Arrays, Filename Globbing Operator, Pattern-Matching Operators, Pattern-Matching Operators, Match-time pattern interpolation, Conditional interpolation, Notational Convenience
backreference variables, Backreferences
conditionals into patterns, Conditional interpolation
double quotes ("), using, Pattern-Matching Operators
double-quoted strings, String Operators
functions, Notational Convenience
glob operator, using for, Filename Globbing Operator
list, List Values and Arrays
match-time pattern interpolation, Match-time pattern interpolation
scalar values, String Literals, String Literals
characters into double-quoted strings, String Literals
variables, String Literals, Pattern-Matching Operators
in double-quoted strings, String Literals
into patterns, Pattern-Matching Operators
interpolation of variables, Singularities
interpolation, variable, Glossary
interpreter, Perl, Executing Your Code, Executing Your Code, Executing Your Code, Executing Your Code, Avant-Garde Compiler, Retro Interpreter, Command Processing, Embedding Perl (Using Perl from C), Embedding Perl (Using Perl from C), Adding a Perl Interpreter to Your C Program, Glossary
accessing from C, Embedding Perl (Using Perl from C)
adding to C program, Adding a Perl Interpreter to Your C Program
compiler, interaction with, Avant-Garde Compiler, Retro Interpreter
embedding in applications, Executing Your Code
invoking with #! (shebang) line, Command Processing
multiple, running, Executing Your Code
persistent, Embedding Perl (Using Perl from C)
interpreters, Natural and Artificial Languages, Garbage Collection with DESTROY Methods, The Process Model, Command Processing, #! and Quoting on Non-Unix Systems
for commands, Command Processing, #! and Quoting on Non-Unix Systems
quoting on Unix systems, #! and Quoting on Non-Unix Systems
object destruction at shutdown, Garbage Collection with DESTROY Methods
threads, The Process Model
interpreters, Perl, How to Do It
interprocess communication, Pipes
pipes, Pipes
interrupt signals, handler for, Signals
intersection of sets, Passing References
ints, pack
inverting arrays and hashes, reverse
invocant, Method Invocation, Glossary
invoking, Interprocess Communication (see executing)
IO (internal I/O object), Glossary, Glossary
(see also indirect objects)
IO module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Dir module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::File module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Handle module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Pipe module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Poll module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Pty module, Bidirectional Communication
IO::Seekable module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Select module, Filehandle, Directory Handle, and Stream I/O Utilities
IO::Socket module, Sockets, Networking and Interprocess Communication
IO::Socket::INET module, Networking Clients, Networking and Interprocess Communication
IO::Socket::UNIX module, Networking and Interprocess Communication
ioctl function, ioctl
IP (Internet Protocol), Sockets, Glossary
IP addresses, Building Character, gethostbyaddr, getnetent
network names and, getnetent
using v-string notation for, gethostbyaddr
UTF-8 representation of, Building Character
IPC (interprocess communication), Interprocess Communication, Interprocess Communication, Signals, Interprocess Communication (IPC), Filehandle, Directory Handle, and Stream I/O Utilities, Networking and Interprocess Communication
between processes on same machine, Interprocess Communication
modules for, Filehandle, Directory Handle, and Stream I/O Utilities, Networking and Interprocess Communication
portability and, Interprocess Communication (IPC)
signals, Signals
IPC::Msg module, Networking and Interprocess Communication
IPC::Open2, Embedding Perl (Using Perl from C)
IPC::Open2 module, Networking and Interprocess Communication
IPC::Open3, Embedding Perl (Using Perl from C)
IPC::Open3 module, Networking and Interprocess Communication
IPC::Semaphore module, Networking and Interprocess Communication
IPC::Shareable module, System V IPC
IPC::SysV module, Networking and Interprocess Communication
irregular files, Some File Test Operators
is-a, Glossary
@ISA array, use base
use base pragma and, use base
@ISA array, Class Inheritance, Inheritance Through @ISA
inheritance through, Inheritance Through @ISA
isa method, UNIVERSAL: The Ultimate Ancestor Class
iteration, Glossary, Glossary
(see also loops)
iterative operator, overloading, Overloadable Operators
iterative statements, Iterative (Looping) Constructs, The while and until statements, The while and until statements, The for statement, The foreach statement
for loops, The for statement
foreach statement, The foreach statement
until statements, The while and until statements
while loops, The while and until statements
ithreads, The Process Model, Executing Your Code
Perl API to, Executing Your Code
itimer routines, alarm
IV (internal integer value), Internal Data Types
IV (internal integer values), Glossary

J

JAPH (Just Another Perl Hacker), Glossary
Java, Perl modules for, The CPAN modules Directory
join function, join
join method, Thread destruction, Catching exceptions from join
catching exceptions from, Catching exceptions from join
jumpenv stack, Executing Your Code

K

kernels, Signals, Reaping Zombies, Reaping Zombies, The Thread Model, Unix Kernel Security Bugs
autoreaping zombies on, Reaping Zombies
generating signals, Signals
signal reliability on, Reaping Zombies
threads and, The Thread Model
Unix, set-id script bug in, Unix Kernel Security Bugs
key/value pairs, Hashes., Glossary (see hashes, key/value pairs)
key/value pairs, hashes, Built-in Data Types, Hashes, Common Mistakes, Symbol Tables, Using Modules, Tying Hashes, each
deleting, Tying Hashes
modules, %INC hash, Using Modules
organizing and accessing data in, Common Mistakes
returning with each function, each
symbol tables, Symbol Tables
keyboard sequences, generating signals with, Signals
keys function, List Processing, Hashes, Hash-Tying Methods, keys
keys(thinsp;&), Hashes.
keys, hash, Convenient Classes
providing references as, Convenient Classes
keys, hashes, Hashes.
braces {thinsp&;}, enclosing in, Hashes.
keywords, Glossary (see reserved words)
kill function, Signals, Signals, Signaling Process Groups, kill
Microsoft systems and, Signaling Process Groups

L

-l (automatic line ending) command-line switch, Switches
labels, Names, Compound Statements, Loop Statements, Loop Control, goto, Packages, Programming with Style, goto, Glossary, Glossary
with goto statement, goto, goto
with loops, Loop Statements, Programming with Style
loops and, Glossary
names for, Names
packages and, Packages
language extensions, Perl modules for, The CPAN modules Directory
languages, Natural and Artificial Languages, Unicode block properties, Generating Perl in Other Languages
checking characters for, Unicode block properties
natural vs. artificial, Natural and Artificial Languages
translating, Generating Perl in Other Languages
last command, C Traps
do {} while construct, not taking, C Traps
last function, Programming with Style
last operator, Breaking out: next and last, for Loops, Loop Control, Loop Control, Bare Blocks, Case Structures, Time Efficiency, last
used in a do while, Bare Blocks
$LAST_PAREN_MATCH, Special Variables in Alphabetical Order
laziness, Glossary
lc function, lc
lcfirst function, lcfirst
left justification, Format Variables
left-shift (<<) operator, Shift Operators
leftmost longest matching, Quantifiers, Glossary
length, Array Length, Time Efficiency, Special Variables in Alphabetical Order
of arrays, Array Length
of matched string, Special Variables in Alphabetical Order
of strings, Time Efficiency
LENGTH (awk variable), Special Variables in Alphabetical Order (see @+)
length function, Effects of Character Semantics, length
byte-oriented wrapper for, Effects of Character Semantics
length, matching, Quantifiers
less module, Perl Language Extensions and Internals
less than (<) operator, Relational Operators
less than or equal (<=) operator, Relational Operators
lexer, Compiling Your Code, Glossary
(see also lexical analysis)
lexical analysis, Compiling Your Code, How Perl Works, Glossary
in the Perl compiler, Compiling Your Code
lexical scope, Lexically Scoped Variables: my, Pragmas
pragmas and, Pragmas
lexical scopes, Names, Names, Name Lookups, Glossary
package variables, searching for, Name Lookups
variables attached to, Names
lexical variables, Scoping Issues, Scoping Issues, Formats, Symbolic References, Private Methods, Data Access, Executing Your Code, my, Perl Compiler and Code Generator, Glossary, Glossary
accessing from functions, Scoping Issues
file-scoped, storing anonymous subroutine in, Private Methods
in functions or files, showing, Perl Compiler and Code Generator
persistence across function calls, Scoping Issues
recursive lexical pad stack, Executing Your Code
symbolic references and, Symbolic References
threads, accessing in, Data Access
typed, Glossary
lexical warnings, Special Variables in Alphabetical Order, Warnings and Exceptions
${^WARNING_BITS}, Special Variables in Alphabetical Order
lexically scoped declarations, Scoped Declarations
lexicals, Scoped Variable Declarations
(see also lexical scope)
lib module, Module Installation Support
lib pragma, Using Modules
libraries, Environment Variables, Using Functions from an External C Library, Module Installation Support, Module Installation Support, Module Installation Support, Module Installation Support, Glossary
C/C++, loading as Perl extensions, Module Installation Support, Module Installation Support
ExtUtils::Liblist module, Module Installation Support
math library, C, Using Functions from an External C Library
Perl library files, searching for, Environment Variables
uninstalled extensions from MakeMaker, Module Installation Support
life cycle, Perl programs, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program
code generation phase, The Life Cycle of a Perl Program
compilation phase, The Life Cycle of a Perl Program
execution phase, The Life Cycle of a Perl Program
parse tree reconstruction, The Life Cycle of a Perl Program
LIFO (Last In, First Out), Glossary
#line directive, Generating Perl in Other Languages, Generating Perl in Other Languages
line counter, close (see $. variable)
line numbers, Special Variables in Alphabetical Order, Glossary
of input file, Special Variables in Alphabetical Order
line reading operator, Filehandles
line separator character, Molecules
line terminators, Internet programs, Networking Servers
line-end processing, automatic, Switches
LineInfo option (debugger), Debugger Options
lines, Beginnings: The A and ^ Assertions, Glossary
boundary assertions, Beginnings: The A and ^ Assertions
link function, link
links, Regular Expressions, readlink, Glossary
(see also symbolic links)
HTTP, searching for, Regular Expressions
lint (C program verifier), Code Development Tools
list, List Values and Arrays
interpolation, List Values and Arrays
list context, Hashes., The foreach statement, List Processing, Hashes, Line Input (Angle) Operator, Range Operator, Conditional Operator, Assignment Operators, Comma Operators, Compound Statements, Scoped Variable Declarations, The m// Operator (Matching), The m// Operator (Matching), Semantics, Other Tricks You Can Do with Hard References, Using the Debugger, Display, Frequently Ignored Advice, Functions, scalar, Glossary, Glossary
angle operator in, Line Input (Angle) Operator
backslash operator, supplying, Other Tricks You Can Do with Hard References
comma operator in, Comma Operators
conditional operator in, Conditional Operator
evaluating expressions in (debugger), Display
expressions in, Compound Statements (see LISTs)
forcing scalar context instead, scalar
foreach statements, providing, The foreach statement
functions in, Functions
hash variables, using in, Hashes
hashes in, Hashes.
list assignment in, Assignment Operators
lvalues in, Scoped Variable Declarations
m// (match) operator in, The m// Operator (Matching)
m//g, listing all matches found, The m// Operator (Matching)
operations behaving differently in, Frequently Ignored Advice
range (..) operator in, Range Operator
recognizing in debugger, Using the Debugger
subroutines, calling and evaluating in, Semantics
list method, Listing current threads
current thread objects in process, Listing current threads
list operators, Unary and Binary Operators, Terms and List Operators (Leftward), Named Unary and File Test Operators, List Operators (Rightward), Glossary
unary operators, distinguishing from, Named Unary and File Test Operators
list values, List Values and Arrays, List Values and Arrays
arrays and, List Values and Arrays
arrays vs., List Values and Arrays
listen function, listen
listing code, Locating Code
lists, Pluralities, Complexities, Scalar and List Context, List Values and Arrays, List Values and Arrays, List Values and Arrays, List Assignment, Multiplicative Operators, Arrays of Arrays, Common Mistakes, Functions, Functions, Perl Functions by Category, chop, map, reverse, sort, syscall, Glossary, Glossary
assignment, List Assignment
chopping, chop
converting to scalars, Complexities
flattening, Functions
as function arguments, Functions
LISTs, Scalar and List Context, List Values and Arrays
map function and, map
nested, Arrays of Arrays
null, List Values and Arrays, Glossary
ordered, data records in arrays, Common Mistakes
processing, functions for, Perl Functions by Category
replicating with x operator, Multiplicative Operators
returning elements in reverse order, reverse
sorting, sort
syscall function with, syscall
LISTs, List Processing, Compound Statements
LISTs===>lists, List Processing
$LIST_SEPARATOR, Special Variables in Alphabetical Order
literals, Scalar Values, Scalar Values, Input Operators, The Regular Expression Bestiary, Effects of Character Semantics, Glossary
numeric, Scalar Values (see numeric literals)
pseudoliterals, Input Operators (see input operators)
string, Scalar Values (see string literals)
UTF-8, enabling use in, Effects of Character Semantics
little-endian, Endianness and Number Width, Glossary
loading data structures, Generation of a Hash of Complex Records
local, Signals, Frequently Ignored Advice, local, Glossary
signal handler assignment, Signals
variables, Frequently Ignored Advice, local
my declarations, using for, Frequently Ignored Advice
local declaration, local
local function, Scoped Variable Declarations, Lexically Scoped Variables: my, Universal Blunders, Frequently Ignored Advice, local
common programming errors with, Universal Blunders
my declaration, using instead of, Frequently Ignored Advice
locale module, Internationalization and Locale
locales, Relational Operators, Classic Perl Character Class Shortcuts, POSIX-Style Character Classes, Formats, lc, Internationalization and Locale
decimal points in formats, Formats
declarations, string comparisons and, Relational Operators
modules for, Internationalization and Locale
Perl character class shortcuts and, Classic Perl Character Class Shortcuts
Unicode and, lc
use locale pragma with POSIX character classes, POSIX-Style Character Classes
localized values, saving, Executing Your Code
localtime function, localtime, Data Types, Operating System Interfaces
lock function, What Is a Reference?, Synchronizing access with lock
data access control in threads, Synchronizing access with lock
reference as argument for, What Is a Reference?
locked attribute, New Tricks
locked attribute (subroutines), Subroutine Attributes
locked attribute, subroutines, The locked attribute
locking, lock
locking files, File Locking, File Locking, File Locking, File Locking, dbmopen, flock
DBM files, File Locking, dbmopen
dissolving locks by closing files, File Locking
flock function, flock
shared and exclusive locks, File Locking
locking methods, Locking methods
locking subroutines, Locking subroutines
log function, log
logarithm, log
LOGDIR variable, Environment Variables
logical, Ideographic Unary Operators, C-Style Logical (Short-Circuit) Operators, C-Style Logical (Short-Circuit) Operators, C-Style Logical (Short-Circuit) Operators, Logical and, or, not, and xor, The Process Model
AND (&&) operator, C-Style Logical (Short-Circuit) Operators
negation (!) operator, Ideographic Unary Operators
operators, C-Style Logical (Short-Circuit) Operators, Logical and, or, not, and xor
OR (||) operator, C-Style Logical (Short-Circuit) Operators
separation, parent and child processes, The Process Model
logical operators, Logical Operators, Global Declarations, Letting Perl Do the Work, Overloadable Operators, Glossary
or operator, Global Declarations
use with list operators, Global Declarations
overloading, Overloadable Operators
Perl, doing alternation, Letting Perl Do the Work
login names, Perl Functions by Category, getgrent, getgrgid, getgrnam, getlogin
functions dealing with, Perl Functions by Category
getgrent function, getgrent
getgrgid function, returning, getgrgid
getgrnam function, returning, getgrnam
getlogin function for, getlogin
long longs, pack
longs, pack
lookahead, Glossary
lookbehind, Glossary
loops, Iterative (Looping) Constructs, The while and until statements, The for statement, The foreach statement, Breaking out: next and last, Loop Statements, while and until Statements, for Loops, for Loops, for Loops, for Loops, Loop Control, Loop Control, Modifying strings en passant, When a global substitution just isn't global enough, Where You Left Off: The G Assertion, Letting Perl Do the Work, Slices, Universal Blunders, Time Efficiency, Programming with Style, last, next, redo, reset, Glossary, Glossary, Glossary, Glossary
comments and blank lines, discarding before processing, Letting Perl Do the Work
control operators for, Loop Control
control statements in, Glossary
eval function within, Time Efficiency
extracting slices, multidimensional arrays, Slices
for loops, The for statement
foreach loops, The foreach statement
infinite, for Loops
iteration through, for Loops, Glossary
labels for, Loop Control, Glossary
last operator, for Loops, last
next and last operators, Breaking out: next and last
next operator, next
redo operator and, redo
reset function and, reset
s/// (substitution) operator, using on arrays, Modifying strings en passant
using for, for Loops
using in (global substitutions), When a global substitution just isn't global enough
using until, while and until Statements
while loops, The while and until statements
G assertion, using in, Where You Left Off: The G Assertion
lowercase, converting to, String Literals
lport manpage, function portability information, Perl Functions in Alphabetical Order
lstat function, lstat, lstat, Filenames, Filesystems, and File Locking
(see also stat function)
lvalue, Built-in Data Types
lvalues, Assignment Operators, Assignment Operators, Variables, Assignment Operators, Scoped Variable Declarations, Pattern-Matching Operators, Subroutine Attributes, The lvalue Attribute, New Tricks, Glossary
assignment operators and, Assignment Operators
lvalue attribute, subroutines, Subroutine Attributes, The lvalue Attribute
methods, declaring to indicate return of, New Tricks
modifiers and, Scoped Variable Declarations
operators and, Assignment Operators, Assignment Operators
pattern-matching operators, use on, Pattern-Matching Operators

M

/m pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution)
/m pattern modifier, Pattern Modifiers
-m (use module)command-line switch, Switches
-M (use module) command-line switch, Switches
m// (match operator), Pattern-Matching Operators
double quote interpolation, providing, Pattern-Matching Operators
m// (match) operator, Pattern-Matching Operators, Pattern Modifiers, The m// Operator (Matching), Universal Blunders, m//, pos
=~ (binding) operator, using with, Pattern-Matching Operators
modifiers for, Pattern Modifiers, The m// Operator (Matching)
pos function and, pos
m// (matching) operator, The m// Operator (Matching), Locating Code
m//g operator, Previous Perl Traps
Perl versions, changes in, Previous Perl Traps
m?? (match) operator, The m// Operator (Matching), Locating Code
m?? operator, reset
reset function and, reset
Macintosh operating system, How to Do It, #! and Quoting on Non-Unix Systems, #! and Quoting on Non-Unix Systems, Filenames, Filesystems, and File Locking
command-line interface in versions, How to Do It
File::Spec::Mac module, Filenames, Filesystems, and File Locking
invoking Perl application on, #! and Quoting on Non-Unix Systems
quoting on, #! and Quoting on Non-Unix Systems
magic, Glossary
magical autodecrement and autoincrement, Overloadable Operators
magical autoincrement, Autoincrement and Autodecrement
magical autoincrement operator, Range Operator
magical counter variables, Magical Counter Variables
mail, Interprocess Communication (IPC)
sending, portability and, Interprocess Communication (IPC)
main package, Name Lookups, Packages
Makefile, Module Installation Support, Glossary
creating for Perl extensions, Module Installation Support
Makefile.PL, Using CPAN Modules, Creating CPAN Modules
MakeMaker, Creating CPAN Modules, Creating CPAN Modules
malloc errors, Special Variables in Alphabetical Order
malloc function, Environment Variables
PERL_DEBUG_MSTATS environment variable, using with, Environment Variables
man command, Online Documentation, Modules, Miscellaneous Commands, Glossary, Glossary
(see also perldoc)
MANIFEST file, Creating Extensions, Module Installation Support
manpages, Online Documentation, CPAN, Documentation Support, Glossary
CPAN doc subdirectory, containing, CPAN
Pod::Man module, Documentation Support
map function, List Processing, Programming with Style, map
mark stack, Executing Your Code
marshalling modules, Data::Dumper
$MATCH, Special Variables in Alphabetical Order
match (??) operator, reset function and, reset
match (m//) operator, Universal Blunders, m//, pos
pos function and, pos
match-time pattern interpolation, Match-time pattern interpolation
matching, The Little Engine That /Could(n't)?/ (see patterns)
matching patterns, Pattern Matching, Pattern Matching
(see also patterns)
math library, C language, Using Functions from an External C Library
Math::BigFloat module, Data Types
Math::BigInt module, Overloading, Data Types
Math::Complex module, Data Types
Math::Trig module, Data Types
mathematical functions, overloading, Overloadable Operators
mathematics, Operators, Unary and Binary Operators
operators, Unary and Binary Operators
operators in Perl, Operators
maximal matching, Metasymbol Tables, Quantifiers
maximum and minimum item matches, specifying, Quantifiers
maxTraceLen option (debugger), Debugger Options
member data, Initializers
memory, Instance Destructors, System V IPC, System V IPC, Environment Variables, Space Efficiency, Special Variables in Alphabetical Order, shmget, Glossary
efficiency of, Space Efficiency
management, destructors and, Instance Destructors
running out of, Special Variables in Alphabetical Order
shared memory segment ID, shmget
shared, System V IPC, System V IPC, System V IPC
controlled access to, System V IPC
statistics on, displaying, Environment Variables
message, Switches
script embedded in, Switches
messages, System V IPC, Message Passing, Debugger Options, msgctl, recv, send, Networking and Interprocess Communication
functions for, msgctl
IPC::Msg module, Networking and Interprocess Communication
passing with UDP, Message Passing
printing on entry and exit from subroutines, Debugger Options
receiving on sockets, recv
sending on sockets, send
System V IPC, System V IPC
metacharacters, The Regular Expression Bestiary, The Regular Expression Bestiary, Metacharacters and Metasymbols, Metacharacters and Metasymbols, Time Efficiency, exec, open, quotemeta, Glossary
escaping with backslash (), Metacharacters and Metasymbols
escaping with quotemeta, quotemeta
in exec arguments, exec
in patterns, Metacharacters and Metasymbols
shell, in pipe commands, open
structural, The Regular Expression Bestiary
metasymbols, Metacharacters and Metasymbols, Metasymbol Tables, Metasymbol Tables, Specific Characters, Glossary
alphanumeric, in patterns, Metasymbol Tables
extension syntax for, Metasymbol Tables
in patterns, Metacharacters and Metasymbols, Specific Characters
Method (overload::Method), Public Overload Functions
method attribute, New Tricks
method attribute (subroutines), Subroutine Attributes
methods, Subroutines, Closures, Brief Refresher on Object-Oriented Lingo, Perl's Object System, Method Invocation, Method Invocation, Method Invocation, Method Invocation Using the Arrow Operator, Method Invocation Using Indirect Objects, Package-Quoted Classes, Inheritable Constructors, Class Inheritance, Inheritance Through @ISA, Accessing Overridden Methods, UNIVERSAL: The Ultimate Ancestor Class, UNIVERSAL: The Ultimate Ancestor Class, Private Methods, Managing Instance Data, New Tricks, Managing Class Data, Tied Variables, Scalar-Tying Methods, Tying Arrays, Array-Tying Methods, Tying Hashes, Hash-Tying Methods, Tying Filehandles, The Thread Module, Locking methods, Programming with Style, Glossary
adding to an existing class, Accessing Overridden Methods
array-tying, Array-Tying Methods
called by tied variables, Tied Variables
class data, working like accessors, Managing Class Data
classes implementing tied arrays, Tying Arrays
classes implementing tied filehandles, Tying Filehandles
classes implementing tied hashes, Tying Hashes
declarations, New Tricks
lvalues, indicating return of, New Tricks
hash-tying, Hash-Tying Methods
invoking, Method Invocation, Method Invocation, Method Invocation Using the Arrow Operator, Method Invocation Using Indirect Objects, Package-Quoted Classes, Inheritable Constructors
explicitly or implicitly, Method Invocation
using indirect objects, Method Invocation Using Indirect Objects, Package-Quoted Classes
subroutine calls vs., Inheritable Constructors
using arrow operator, Method Invocation Using the Arrow Operator
names for, Programming with Style
object methods, Locking methods
locking, Locking methods
Perl classes inheritance of, Managing Instance Data
private methods, ignoring inheritance with, Private Methods
references to, Closures
searching for, Class Inheritance, Inheritance Through @ISA
class inheritance, Class Inheritance
inheritance through @ISA array, Inheritance Through @ISA
subroutines as, Perl's Object System
subroutines vs., Subroutines, Method Invocation
Thread class, The Thread Module
tying scalars, Scalar-Tying Methods
UINVERSAL class, UNIVERSAL: The Ultimate Ancestor Class
adding to, UNIVERSAL: The Ultimate Ancestor Class
in UNIVERSAL class, UNIVERSAL: The Ultimate Ancestor Class
Microsoft Windows, Tie Modules on CPAN, Building Character, Interprocess Communication, Signaling Process Groups, Named Pipes, The Process Model, #! and Quoting on Non-Unix Systems, #! and Quoting on Non-Unix Systems, Environment Variables, Decompressing and Unpacking CPAN Modules, Filenames, Filesystems, and File Locking, Filenames, Filesystems, and File Locking, Microsoft-Related Modules
ActiveState Perl distribution, installing, #! and Quoting on Non-Unix Systems
CPAN modules, installing on, Decompressing and Unpacking CPAN Modules
File::Spec::Win32 module, Filenames, Filesystems, and File Locking
fileglobbing, File::DosGlob module, Filenames, Filesystems, and File Locking
fork operation, cloning interpreter objects, The Process Model
modules for, Microsoft-Related Modules
porting information (perlwin32), Interprocess Communication
registry, manipulating, Tie Modules on CPAN
shell, setting alternative for Perl use, Environment Variables
signal number 0 on, Signaling Process Groups
system calls using wide-character APIs, Building Character
Win32::Pipe module, Named Pipes
Windows NT, quoting on, #! and Quoting on Non-Unix Systems
minimal matching, Minimal Matching, Metasymbol Tables, Quantifiers
minus (-) operator, Ideographic Unary Operators
miscellaneous functions, Perl Functions by Category
mkdir function, mkdir
mkfifo function, Named Pipes
MLDBM module, Tie Modules on CPAN
mmap syscall, System V IPC
$mode file statistic, stat
modes, opening files in, open
modification time, file, stat, utime
modifiers, Simple Statements, The Regular Expression Bestiary, Pattern Modifiers, The m// Operator (Matching), The s/// Operator (Substitution), The tr/// Operator (Transliteration), Cloistered Pattern Modifiers
for patterns, The m// Operator (Matching)
m// (match) operator, The m// Operator (Matching)
pattern, The s/// Operator (Substitution), Cloistered Pattern Modifiers
cloistered, Cloistered Pattern Modifiers
with s/// (substitution) operator, The s/// Operator (Substitution)
for patterns, Pattern Modifiers, The tr/// Operator (Transliteration)
with tr/// (transliteration) operator, The tr/// Operator (Transliteration)
statements, The Regular Expression Bestiary
quantifiers vs., The Regular Expression Bestiary
statements, simple, Simple Statements
modules, The Pursuit of Happiness, Simplicities, Simplicities, Names, Packages, Packages, Packages, Autoloading, Modules, Creating Modules, Tag-handling utility functions, Module Privacy and the Exporter, Tag-handling utility functions, Version checking, Managing unknown symbols, Overriding Built-in Functions, Inheritance Through @ISA, Private Methods, Tie Modules on CPAN, The Thread Model, Other Thread Modules, Compiler Backends, Compiler Backends, XSUB Input and Output, CPAN, The CPAN modules Directory, The CPAN modules Directory, Using CPAN Modules, Decompressing and Unpacking CPAN Modules, Building CPAN Modules, Creating CPAN Modules, Creating CPAN Modules, Programming with Style, Interprocess Communication (IPC), Standard Modules, Perl Functions by Category, import, Standard Modules, Data Types, String Processing, Language Text Processing, Parsing, and Searching, Option, Argument, Parameter, and Configuration File Processing, Filenames, Filesystems, and File Locking, Filehandle, Directory Handle, and Stream I/O Utilities, Internationalization and Locale, Operating System Interfaces, Networking and Interprocess Communication, DBM Interfaces, User Interfaces, Authentication, Security, and Encryption, Perl Language Extensions and Internals, Convenient Classes, Warnings and Exceptions, Documentation Support, Module Installation Support, Module Installation Support, Development Support, Perl Compiler and Code Generator
(see also packages)
backend, Compiler Backends
backend, calling, Compiler Backends
built-in functions, overriding, Overriding Built-in Functions
class system and, Inheritance Through @ISA
classes vs., Packages
classes, storing in for privacy, Private Methods
CPAN, The CPAN modules Directory, The CPAN modules Directory, Using CPAN Modules, Decompressing and Unpacking CPAN Modules, Building CPAN Modules, Creating CPAN Modules, Interprocess Communication (IPC), Standard Modules
building, Building CPAN Modules
categories of, The CPAN modules Directory
creating, Creating CPAN Modules
decompressing and unpacking, Decompressing and Unpacking CPAN Modules
mail, sending, Interprocess Communication (IPC)
making available to programs, Using CPAN Modules
portability of, Standard Modules
CPAN directory for, CPAN
CPAN, collection of, Simplicities
CPAN, storing in, Packages
creating, Creating Modules, Tag-handling utility functions, Module Privacy and the Exporter, Tag-handling utility functions, Version checking, Managing unknown symbols
privacy and the Exporter, Module Privacy and the Exporter, Tag-handling utility functions
symbol exportation, preventing, Managing unknown symbols
version checking, Version checking
exporting names to other modules, import
functions dealing with, Perl Functions by Category
importing, Module Installation Support
names for, Programming with Style
standard, Standard Modules, Data Types, String Processing, Language Text Processing, Parsing, and Searching, Option, Argument, Parameter, and Configuration File Processing, Filenames, Filesystems, and File Locking, Filehandle, Directory Handle, and Stream I/O Utilities, Internationalization and Locale, Operating System Interfaces, Networking and Interprocess Communication, DBM Interfaces, User Interfaces, Authentication, Security, and Encryption, Perl Language Extensions and Internals, Convenient Classes, Warnings and Exceptions, Documentation Support, Module Installation Support, Development Support, Perl Compiler and Code Generator
base classes and convenience, Convenient Classes (see )
command-line processing, Option, Argument, Parameter, and Configuration File Processing
for data types, Data Types
DBM file management libraries, loading, DBM Interfaces
development support, Development Support
documentation support, Documentation Support
files, cross-platform methods of access, Filenames, Filesystems, and File Locking
internationalization and locales, Internationalization and Locale
module installation support, Module Installation Support
networking and interprocess communication, Networking and Interprocess Communication
object-oriented file, directory, and IPC access, Filehandle, Directory Handle, and Stream I/O Utilities
operating system interfaces, manipulating, Operating System Interfaces
Perl compiler and code generator, Perl Compiler and Code Generator
Perl language extensions and externals, Perl Language Extensions and Internals
security, dealing with, Authentication, Security, and Encryption
text, manipulating with, String Processing, Language Text Processing, Parsing, and Searching
user interfaces, providing, User Interfaces
warnings and exceptions, Warnings and Exceptions
testing, XSUB Input and Output, Creating CPAN Modules
thread modules, Other Thread Modules
thread safety and, The Thread Model
tie modules on CPAN, Tie Modules on CPAN
user-defined, capitalization in names, Names
modulus (%) operator, Multiplicative Operators
mod_perl module, Executing Your Code, Embedding Perl (Using Perl from C)
more than sign, Format Variables (see >)
MS-DOS operating system, invoking Perl applications on, #! and Quoting on Non-Unix Systems
msgctl function, msgctl
msgget function, msgget
msgrcv function, msgrcv
msgsnd function, msgsnd
$mtime file statistic, stat
mulitple inheritance, SUPER pseudopackage, working with, Accessing Overridden Methods
multidimensional arrays, Complexities, Arrays of Arrays, Common Mistakes, Glossary
multidimensional hashes, Hashes of Hashes, Generation of a Hash of Hashes, Access and Printing of a Hash of Hashes
accessing and printing, Access and Printing of a Hash of Hashes
generation of, Generation of a Hash of Hashes
multiple inheritance, Class Inheritance, UNIVERSAL: The Ultimate Ancestor Class, Method Autoloading, Glossary
AUTOLOAD subroutine and, Method Autoloading
methods, invoking all overridden base class, UNIVERSAL: The Ultimate Ancestor Class
multiplication, Some Binary Arithmetic Operators, String Operators
strings, repeat operator, String Operators
multiplicative operators, Multiplicative Operators
multiprocessing, The Thread Model, Other standard threading modules, Handling Timing Glitches
processer access, unpredictability of, Handling Timing Glitches
thread model, The Thread Model, Other standard threading modules
multithreading, Threads
mutators, copying and, The Copy Constructor (=)
my declarations, Names, Statements and Declarations, Dynamically Scoped Variables: local, Closures, Frequently Ignored Advice, my
closures and, Closures
local vs., Dynamically Scoped Variables: local
local, using instead of, Frequently Ignored Advice
my function, foreach Loops, Scoped Variable Declarations, Lexically Scoped Variables: my

N

-n (loop) command-line switch, Switches
named, Specific Characters, Effects of Character Semantics, Glossary
character, metasymbol for, Specific Characters
characters, inserting, Effects of Character Semantics
pipes, Glossary
named character, String Literals
named unary operators, Filename Globbing Operator, Named Unary and File Test Operators, Named Unary and File Test Operators
listing of, Named Unary and File Test Operators
names, Pluralities, Verbs, Verbs, Variables, Variables, Variables, Names, Names, Names, Names, Name Lookups, Typeglobs and Filehandles, Scoped Variable Declarations, Syntax, Syntax, Tricks with Parameter Lists, The locked and method Attributes, Formats, Packages, Symbol Tables, Using Modules, Using Modules, Package-Quoted Classes, Initializers, Tied Variables, Signals, Temporary Files, Programming with Style, Programming with Style, Special Variables in Alphabetical Order, format, getgrent, getgrnam, gethostbyaddr, gethostbyname, getnetbyaddr, getnetbyname, getprotobyname, getpwnam, getservbyname, getservbyport, rename, Glossary
arrays, Variables
attributes, subroutines, The locked and method Attributes
capitalization conventions, Names
classes, distinguishing from subroutines, Package-Quoted Classes
commands, Verbs, Glossary
constructors, Initializers
for files==>filenames, rename
format, format (see format names)
formats associated with filehandles, Formats
functions, Verbs
getting from network addresses, gethostbyaddr
group names, getgrnam
hashes, Variables
hashes, storing in, Pluralities
hostnames, translating to network addresses, gethostbyname
identifiers vs., Names
labels and filehandles, Names
login, getgrent (see login names)
lookups of, Name Lookups
methods, tied variables, Tied Variables
modules, Using Modules, Using Modules
capitalization in, Using Modules
modules/packages, Programming with Style
network addresses, getting from, getnetbyaddr
packages, Packages
parameters, not requiring, Tricks with Parameter Lists
ports, getting from number, getservbyname
program, Special Variables in Alphabetical Order (see $0 variable)
protocols, getting from port numbers, getservbyport
protocols, translating to/from numbers, getprotobyname
scope, confining to, Scoped Variable Declarations
signals, Signals
subroutines, Syntax, Syntax
capitalization in, Syntax
symbol tables, Symbol Tables
temporary files, generating, Temporary Files
translating to network addresses, getnetbyname
typeglobs, Typeglobs and Filehandles
users, getpwnam
variable, Programming with Style
variables, Variables
namespace, Packages, Module Privacy and the Exporter, Tie Modules on CPAN (see packages)
encapsulation based on, Tie Modules on CPAN
modules and, Module Privacy and the Exporter
namespaces, Simplicities, Names, Restricting namespace access, Glossary
access, restricting with Safe module, Restricting namespace access
for packages, Simplicities
naming, socket, bind
natural languages, Natural and Artificial Languages, Environment Variables
environment variables controlling Perl handling of, Environment Variables
NDBM_File module, DBM Interfaces
ne operator, Universal Blunders
negation, Ideographic Unary Operators, Ideographic Unary Operators, Ideographic Unary Operators, Custom Character Classes, Classic Perl Character Class Shortcuts, POSIX-Style Character Classes
arithmetic (-)operator, Ideographic Unary Operators
bitwise (~) operator, Ideographic Unary Operators
character classes, Custom Character Classes, Classic Perl Character Class Shortcuts
logical (!) operator, Ideographic Unary Operators
POSIX character classes, POSIX-Style Character Classes
negation operator (!), overloading, Overloadable Operators
negative array subscripts, counting from end of array, Previous Perl Traps
negative lookahead assertions, The Little Engine That /Could(n't)?/, Lookaround Assertions
negative subscripts in Perl, Built-in Data Types
nested, Arrays of Arrays, Arrays of Arrays, Common Mistakes, Instance Destructors, Display
arrays, Arrays of Arrays, Common Mistakes
data structures, printed, Display
destruction, Instance Destructors
lists, Arrays of Arrays
nested data structures, Complexities
nested subroutines, Nested subroutines
Net::hostent module, gethostent, Networking and Interprocess Communication, Class::Struct
Class::Struct, using to create objects and accesors, Class::Struct
Net::netent module, getnetbyaddr, Networking and Interprocess Communication
Net::Ping module, Networking and Interprocess Communication
Net::proto module, getprotobynumber
Net::protoent module, Networking and Interprocess Communication
Net::servent module, Networking and Interprocess Communication
networking, Networking Servers, Perl Functions by Category, gethostbyaddr, getnetbyaddr, Networking and Interprocess Communication, Microsoft-Related Modules, Glossary, Glossary
connections (between client and server), Glossary
modules for, Networking and Interprocess Communication
network addresses, getnetbyaddr
translating to names, getnetbyaddr
network addresses, translating into names, gethostbyaddr
network filesystems, Glossary (see NFS)
network information, functions for retrieving, Perl Functions by Category
servers, Networking Servers
Win32 network modules, Microsoft-Related Modules
networking modules, Sockets
networks file, getnetent (see /etc/networks file)
new method, Thread creation, new
newline, Molecules
newlines, Filehandles, The while and until statements, Pattern Modifiers, Wildcard Metasymbols, Cleaning Up Your Environment, Newlines, chomp
blank lines, truth values and, The while and until statements
chomp function, deleting with, chomp
dot (.) metacharacter, matching, Wildcard Metasymbols
in filenames, security risks of, Cleaning Up Your Environment
Perl program portability and, Newlines
removing, Filehandles
strings containing, matches against, Pattern Modifiers
next, Bare Blocks
used in a do while, Bare Blocks
next command, C Traps
do {} while construct, not taking, C Traps
next operator, Breaking out: next and last, while and until Statements, Loop Control, Loop Control, Bare Blocks, Time Efficiency, next
exiting once-through blocks with, Bare Blocks
next if construct, Time Efficiency
NFS (network filesystems), Sockets, Glossary
limitations of, Sockets
$nlink file statistic, stat
NNN metasymbol, Specific Characters
no declaration, Using Modules, no
no declarations, Global Declarations, Pragmas, Magically Banishing $_
(see also pragmas)
nomethod overloading key, When an Overload Handler Is Missing (nomethod and fallback)
nonbacktracking subpatterns, Nonbacktracking Subpatterns
noninteractive mode, putting debugger in, Unattended Execution
not (!) operator, Ideographic Unary Operators
not equal to (!=) operator, Equality Operators
notational convenience, tied arrays, Notational Convenience
nouns, Natural and Artificial Languages, Simplicities
packages, handling of, Simplicities
novice programmers, common mistakes of, Common Goofs for Novices
null, List Values and Arrays, Line Input (Angle) Operator, Glossary
filehandle ;angle operator and, Line Input (Angle) Operator
list, List Values and Arrays
values, Glossary
null device, Unix, Creative Filehandles
null list, Array Length
assigning to arrays, Array Length
null values ("" or 0), Singularities
number width, Endianness and Number Width
numbered variables, Special Variables in Alphabetical Order
numbers, Variable Syntax, Pluralities, Some Numeric and String Comparison Operators, What Is Truth?, Regular Expressions, Names, Scalar Values, Scalar Values, Numeric Literals, Numeric Literals, Numeric Literals, Bitwise Operators, The s/// Operator (Substitution), Formats, Format Variables, Overloadable Operators, Using the Debugger, Endianness and Number Width, Special Variables in Alphabetical Order, Perl Functions by Category, getprotobynumber, getservbyname, getservbyport, hex, int, oct, rand, srand, Glossary, Glossary
arrays, storing in, Pluralities
bitwise operators, working with, Bitwise Operators
command, Using the Debugger (see command history, debugger and)
commas, inserting into, Format Variables
comparison operators for, Some Numeric and String Comparison Operators
converting nonnumeric variables to, Overloadable Operators
d for digit=d (for digit), Regular Expressions
digits in names, Names
floating-point, Glossary (see floating-point numbers)
functions dealing with, Perl Functions by Category
hexadecimal, Numeric Literals, hex (see hexadecimal characters)
hexadecimal, converting to, The s/// Operator (Substitution)
integers, Glossary (see integers)
justifying by decimal point, Formats
large, underscore and, Numeric Literals
octal, Numeric Literals, oct (see octal characters)
for pages, Special Variables in Alphabetical Order
port, getting name for, getservbyname
ports, getting protocol names from, getservbyport
protocol, getprotobynumber
random, rand, srand
strings, converting to, Scalar Values
truncating with int, int
truth values of, What Is Truth?
typing in Perl, Scalar Values
width of, Endianness and Number Width
numeric context, Scalar and List Context, Glossary
NV (internal double value), Internal Data Types

O

/o pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution), Variable Interpolation
recompilation, suppressing with, Variable Interpolation
O module, Compiler Backends, Code Development Tools, Perl Compiler and Code Generator
/o pattern modifier, Pattern Modifiers, Pattern Modifiers
object, Packages
classes, Packages
object methods, The Thread Module, Locking methods
locking, Locking methods
Thread objects, The Thread Module
object-oriented modules, Using Modules, Creating Modules
method calls, allowing, Creating Modules
object-oriented programming, Packages, Packages, Brief Refresher on Object-Oriented Lingo, Method Invocation, Filenames, Filesystems, and File Locking, Filehandle, Directory Handle, and Stream I/O Utilities
abstraction in, Method Invocation
modules for file, directory, and IPC access, Filehandle, Directory Handle, and Stream I/O Utilities
portable filename operations, Filenames, Filesystems, and File Locking
references in Perl, emulating, Packages
objects, Singularities, Complexities, The Arrow Operator, Other Tricks You Can Do with Hard References, Closures, Closures, Objects, Perl's Object System, Object Construction, Inheritable Constructors, Initializers, Inheritance Through @ISA, Instance Destructors, Instance Destructors, Garbage Collection with DESTROY Methods, Managing Instance Data, Generating Accessors with Autoloading, Generating Accessors with Closures, Using Closures for Private Objects, New Tricks, Managing Class Data, Tied Variables, A Subtle Untying Trap, Environment Variables, Perl Functions by Category, bless, Glossary, Glossary
blessing, The Arrow Operator, bless
class data, managing, Managing Class Data
constructors, Object Construction, Inheritable Constructors, Initializers
inheritable, Inheritable Constructors
initializers, Initializers
destruction of (global), controlling, Environment Variables
functions dealing with, Perl Functions by Category
indirect, Glossary (see indirect objects)
inheritance, through @ISA array, Inheritance Through @ISA
instance data, managing, Managing Instance Data, Generating Accessors with Autoloading, Generating Accessors with Closures, Using Closures for Private Objects, New Tricks
generating accesors with closures, Generating Accessors with Closures
generating accessors with autoloading, Generating Accessors with Autoloading
new features, Perl 5.6, New Tricks
private objects, using closures for, Using Closures for Private Objects
instance destructors, Instance Destructors, Garbage Collection with DESTROY Methods
garbage collection with, Garbage Collection with DESTROY Methods
methods, references to, Closures, Closures
(see also closures)
Perl object system, Perl's Object System
references to, in scalars, Singularities
storing within other objects vs. inheritance, Instance Destructors
stringifying, Other Tricks You Can Do with Hard References
tied variables, underlying, Tied Variables, A Subtle Untying Trap
breaking reference to, A Subtle Untying Trap
oct function, Numeric Literals, oct
octal characters, Numeric Literals
octal numbers, Specific Characters, Building Character, Switches, oct
characters, representing, Building Character
characters, specifying with, Specific Characters
specifying $/ as, Switches
octets, Building Character (see bytes)
offsets, pos, read, seek, Glossary
for m// successes, pos
read function and, read
seek function, seek
one-liners, How to Do It, Glossary
OOP, Brief Refresher on Object-Oriented Lingo (see object-oriented programming)
Opcode module, Authentication, Security, and Encryption
opcodes, Compiling Your Code, Executing Your Code, How Perl Works
open function, Filehandles, Passing Filehandles, Anonymous Pipes, Anonymous Pipes, Talking to Yourself, Cleaning Up Your Environment, Code Masquerading as Data, Interprocess Communication (IPC), close, fileno, open, open, open, open
$. and, close
converting file descriptor to filehandle, Passing Filehandles
fileno function and, fileno
fork-open, open
forking open, Talking to Yourself
modes in three-argument form, open
piped, Code Masquerading as Data
list argument form, avoiding shell with, Code Masquerading as Data
piped (two-argument form), open
for pipes, security risks posed by, Cleaning Up Your Environment
pipes, opening with, Anonymous Pipes
portability of, Interprocess Communication (IPC)
open source software, Glossary
Open2, Open3 library modules, Bidirectional Communication
opendir function, opendir
opening, socket, sysopen
files via low-level system call, sysopen
sockets, socket
operand stack, Executing Your Code
operating system, The Pursuit of Happiness
operating system name, Special Variables in Alphabetical Order
operating systems, How to Do It, Using Modules, Signals, Reaping Zombies, File Locking, Passing Filehandles, Sockets, The Thread Model, Command Processing, Command Processing, #! and Quoting on Non-Unix Systems, CPAN, The CPAN modules Directory, Portable Perl, Newlines, System Interaction, Operating System Interfaces, Glossary
#! technique, simulating on non-Unix systems, #! and Quoting on Non-Unix Systems
command interpreters for, Command Processing
flock support on, File Locking
fork operator, support for, Passing Filehandles
GUIs, relying on, System Interaction
interfaces to, manipulating, Operating System Interfaces
invoking interpreters with #! line, Command Processing
module names, translating to directory names, Using Modules
newlines, variations in, Newlines
perl interpreter, starting on, How to Do It
Perl modules for, The CPAN modules Directory
Perl ports to, CPAN
Perl program portability, Portable Perl
signal reliability on, Reaping Zombies
signals and default behaviors of, Signals
sockets, support for, Sockets
threading libraries, The Thread Model
operations, Scalar and List Context
contexts, evaluation in, Scalar and List Context
operators, Singularities, Singularities, Operators, Some Binary Arithmetic Operators, String Operators, Assignment Operators, Assignment Operators, Logical Operators, Unary and Binary Operators, Unary and Binary Operators, Unary and Binary Operators, C Operators Missing from Perl, Pattern Matching, Pattern-Matching Operators, Pattern Modifiers, Overloading, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Effects of Character Semantics, Restricting operator access, Data Types, Glossary, Glossary
access, restricting with Safe module, Restricting operator access
assignment operators, Assignment Operators, Assignment Operators
associativity of, Unary and Binary Operators
C language, missing in Perl, C Operators Missing from Perl
logical operators, Logical Operators
matching and substitution, Pattern Matching
overloadable, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, Glossary
arithmetic operators, Overloadable Operators
assignment operators, Overloadable Operators
bitwise operators, Overloadable Operators
circular references, problems with, Overloadable Operators
comparison operators, Overloadable Operators
conversion operators, Overloadable Operators
dereference operators, Overloadable Operators
iterative operator, Overloadable Operators
logical negation operator, Overloadable Operators
overloading, Unary and Binary Operators, Overloading, Data Types
pattern-matching, Pattern-Matching Operators, Pattern Modifiers
modifiers for, Pattern Modifiers
positions or lengths, switching to character positions, Effects of Character Semantics
precedence of, Some Binary Arithmetic Operators, Unary and Binary Operators
C precedence, retaining in Perl, Unary and Binary Operators
quotes, syntactical similarity to, Singularities
scalar context, supplying to parameters, Singularities
string operators, String Operators
operators, for loop control, Loop Control
ops module, Authentication, Security, and Encryption
optimizing, Compiling Your Code, Efficiency
in the Perl compiler, Compiling Your Code
performance and, Efficiency
option processing, Option, Argument, Parameter, and Configuration File Processing
Perl modules for, Option, Argument, Parameter, and Configuration File Processing
options, Pattern Modifiers, Switches (see modifiers) (see switches, command-line)
OR (||) operator, C-Style Logical (Short-Circuit) Operators, Global Declarations
list operators and, Global Declarations
OR logical operator, Logical Operators
Or operator, Logical Operators
or operator, Bitwise Operators, C-Style Logical (Short-Circuit) Operators, Logical and, or, not, and xor, Global Declarations, Letting Perl Do the Work, Programming with Style
list operators, use with, Global Declarations
| (bitwise), Bitwise Operators
ord function, Effects of Character Semantics, ord
order, The Little Engine That /Could(n't)?/, Functions (see precedence)
of function precedence, Functions
ornaments option (debugger), Debugger Options
OS/2 operating system, #! and Quoting on Non-Unix Systems
invoking Perl applications on, #! and Quoting on Non-Unix Systems
OS2 operating system, Filenames, Filesystems, and File Locking
File::Spec::OS2 module, Filenames, Filesystems, and File Locking
$OSNAME, Special Variables in Alphabetical Order
$OS_ERROR, Special Variables in Alphabetical Order
our declarations, Name Lookups, Scalar and List Context, Statements and Declarations, Lexically Scoped Global Declarations: our, our
context rules and, Scalar and List Context
global variables, lexically scoped, Lexically Scoped Global Declarations: our
our function, Scoped Variable Declarations, Lexically Scoped Variables: my, our
out of memory errors, Special Variables in Alphabetical Order
output, Pipes, Pipes, Anonymous Pipes, Talking to Yourself, Bidirectional Communication, Bidirectional Communication, Debugger Options, Unattended Execution, XSUB Input and Output, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Perl Functions by Category, fileno, formline, ioctl, open, select (output filehandle), select (ready file descriptors), Glossary
(see also STDOUT filehandle)
array and hash, changing style (debugger), Debugger Options
checking file descriptors for, select (ready file descriptors)
currently selected channel, Glossary
debugger, setting, Unattended Execution
field separator, Special Variables in Alphabetical Order (see $, variable)
files, open mode for, open
format output accumulator, formline
functions dealing with, Perl Functions by Category
ioctl function, ioctl
pipes, Pipes, Pipes, Anonymous Pipes, Talking to Yourself, Bidirectional Communication, Bidirectional Communication
bidirectional, Bidirectional Communication
filtering, Talking to Yourself
STDOUT as pipe to another program, Anonymous Pipes
tridirectional, Bidirectional Communication
record separator, Special Variables in Alphabetical Order (see $ variable)
selecting filehandles for, select (output filehandle)
XSUBs, XSUB Input and Output
output filehandles, Filehandles
output record formats, declaring, Formats
$OUTPUT_AUTOFLUSH, Special Variables in Alphabetical Order
$OUTPUT_FIELD_SEPARATOR, Special Variables in Alphabetical Order
$OUTPUT_RECORD_SEPARATOR, Special Variables in Alphabetical Order
overlaoding, Overloadable Operators
mathematical functions, Overloadable Operators
overload handlers, Overload Handlers
overloaded, Scalar and List Context
functions, Scalar and List Context
Overloaded (overload::Overloaded), Public Overload Functions
overloaded string constants, translating text with, Defining Your Own Assertions
overloading, Unary and Binary Operators, Overloading, The overload Pragma, Overloadable Operators, Overloadable Operators, Overloadable Operators, Overloadable Operators, The Copy Constructor (=), When an Overload Handler Is Missing (nomethod and fallback), Overloading Constants, Public Overload Functions, Inheritance and Overloading, Run-Time Overloading, Overloading Diagnostics, Filehandle-Tying Methods, Data Types, Glossary
autogeneration of, Overloadable Operators
circular references, avoiding, Overloadable Operators
constants, Overloading Constants
copy constructor (=), The Copy Constructor (=)
diagnostics, Overloading Diagnostics
functions for, Public Overload Functions
inheritance and, Inheritance and Overloading
nonmethod and fallback, When an Overload Handler Is Missing (nomethod and fallback)
overload module, Data Types
overload pragma, The overload Pragma
overloadable operators, Overloadable Operators
at run time, Run-Time Overloading
sorting and, Overloadable Operators
stringifying, Filehandle-Tying Methods
overloading, autogeneration of, Overloadable Operators
overridden methods, base class, invoking all, UNIVERSAL: The Ultimate Ancestor Class
overriding functions, Overriding Built-in Functions
overwriting existing files, race conditions and, Handling Race Conditions
ownership, file, chown

P

-p (print while looping) command-line switch, Switches
-P (C preprocessor) command-line switch, Switches
pack, Endianness and Number Width
pack function, Effects of Character Semantics, pack, pack
template characters for, pack
unpack function, Unicode characters and, Effects of Character Semantics
package declaration, Scoped Declarations, Packages, package
package variable, Managing Class Data
wrapping declaration in block scope, Managing Class Data
package variable, storing class data in, Managing Class Data
package variables, Names, Name Lookups, Scoped Variable Declarations, Data Access, our (see global variables)
declaring, our
threads, no protection in, Data Access
packages, Simplicities, Names, Names, Or Leave the Quotes Out Entirely, Packages, Packages, Packages, Symbol Tables, Autoloading, Method Invocation, Object Construction, Inheritance Through @ISA, Accessing Overridden Methods, Debugger Options, Programming with Style, bless, tie, untie, use, Module Installation Support, Glossary, Glossary
(see also modules)
adding methods to existing, Accessing Overridden Methods
binding variables to, untie
bless function arguments, Object Construction
blessing objects into, bless
current package, Glossary
delimiters for, Packages
identifiers, Packages
importing semantics to, use
in @ISA array, inheritance through, Inheritance Through @ISA
methods and subroutines, resolving for, Method Invocation
names for, Or Leave the Quotes Out Entirely, Programming with Style
splitting for autoloading, Module Installation Support
symbol tables, Debugger Options
displaying, Debugger Options
symbol tables for, Symbol Tables
tying variables to, tie
packed sockaddr, getpeername
pads, Names
page numbers, Special Variables in Alphabetical Order
pager option (debugger), Debugger Options
pages, Special Variables in Alphabetical Order
PalmPilot, Perl modules for, The CPAN modules Directory
paragraph mode, Switches, Special Variables in Alphabetical Order
paragraph separator character, Molecules
parameters, Singularities, Tricks with Parameter Lists, Tricks with Parameter Lists, Special Variables in Alphabetical Order (see arguments)
scalar context, providing for, Singularities
subroutines, Tricks with Parameter Lists, Tricks with Parameter Lists
changing in place, Tricks with Parameter Lists
working with, Tricks with Parameter Lists
parent classes, Brief Refresher on Object-Oriented Lingo
parent processes, fork (see processes)
parentheses (thinsp&;), Complexities (see (thinsp&;))
parse trees, The Life Cycle of a Perl Program, The Life Cycle of a Perl Program, Compiling Your Code, Compiler Backends, The Bytecode Generator
internal, keeping, Compiler Backends
original, reconstituting and splicing into current parse tree, The Bytecode Generator
reconstruction of, The Life Cycle of a Perl Program
parsing, Pattern-Matching Operators, Compiling Your Code, How Perl Works
double-quote interpolation and regular expressions, Pattern-Matching Operators
in the Perl compiler, Compiling Your Code
passing by reference, Semantics, What Is a Reference?, Glossary
prototypes declaring function calls as, What Is a Reference?
passing by value, Glossary
passing by value, copying @_ values to my list, Tricks with Parameter Lists
passing references, Passing References
passwords, crypt, getpwent, srand
crypt function and, crypt
passwd file, getpwent
PATH environment variable, Switches, Environment Variables, Cleaning Up Your Environment
security and, Cleaning Up Your Environment
path for library searches, %INC, Special Variables in Alphabetical Order
pathnames, Using Modules
module installed on Windows system, Using Modules
pattern space, Special Variables in Alphabetical Order
patterns, Lookaround Assertions, Switches, Locating Code, Previous Perl Traps
autosplitting via -a switch, Switches
debugger, commands for matching, Locating Code
fancy patterns, Lookaround Assertions
replacements, changes in Perl versions, Previous Perl Traps
patterns (and regular expressions), Regular Expressions, Regular Expressions, Quantifiers, Minimal Matching, Backreferences, Pattern Matching, The Regular Expression Bestiary, The Regular Expression Bestiary, The Regular Expression Bestiary, Pattern-Matching Operators, Pattern-Matching Operators, Pattern-Matching Operators, Pattern-Matching Operators, Pattern-Matching Operators, Pattern Modifiers, Pattern Modifiers, The s/// Operator (Substitution), Metacharacters and Metasymbols, Metasymbol Tables, Metasymbol Tables, Metasymbol Tables, Specific Characters, Character Classes, Quantifiers, Positions, Capturing and Clustering, Cloistered Pattern Modifiers, Staying in Control, Letting Perl Do the Work, The Regex Compiler, The Little Engine That /Could(n't)?/, The Little Engine That /Could(n't)?/, Lookaround Assertions, Programmatic Patterns, Programmatic Patterns, Generated patterns, Substitution evaluations, Match-time code evaluation, Match-time pattern interpolation, Match-time pattern interpolation, Conditional interpolation, Defining Your Own Assertions, Effects of Character Semantics, Detecting and Laundering Tainted Data, Code Masquerading as Data, Perl Functions by Category, grep, m//, split, study, Perl Language Extensions and Internals
(see also m// operator; m?? operator)
alphanumeric metasymbols, Metasymbol Tables
assertions in, The Regular Expression Bestiary
assertions, defining your own, Defining Your Own Assertions
backreferences, Backreferences
capturing in, Capturing and Clustering
character classes, Character Classes
characters in, The Regular Expression Bestiary
conditional interpolation in, Conditional interpolation
controlling matching, Staying in Control, Letting Perl Do the Work, The Regex Compiler
Perl flow control, deciding pattern execution, Letting Perl Do the Work
regex compiler, The Regex Compiler
extension syntax, Metasymbol Tables
extensions, Lookaround Assertions
lookaround assertions, Lookaround Assertions
finding duplicate words in paragraphs, Pattern Modifiers
functions for matching, Perl Functions by Category
generated, Generated patterns
greedy matching, Quantifiers, The Little Engine That /Could(n't)?/
grep function and, grep
match-time code evaluation, Match-time code evaluation
match-time pattern interpolation, Match-time pattern interpolation
matching, Regular Expressions, Pattern-Matching Operators, Pattern-Matching Operators, Pattern-Matching Operators, The s/// Operator (Substitution)
operators for, Regular Expressions, Pattern-Matching Operators
special variables for, Pattern-Matching Operators, The s/// Operator (Substitution)
substrings corresponding to subpatterns, Pattern-Matching Operators
metacharacters and metasymbols in, Metacharacters and Metasymbols
metasymbols in, Specific Characters
minimal matching, Minimal Matching
modifiers, Cloistered Pattern Modifiers
cloistering, Cloistered Pattern Modifiers
modifiers for, Pattern Modifiers
Perl code, interjecting into, Programmatic Patterns
positions for matching, Positions
programming style for, Programmatic Patterns
quantifiers in, The Regular Expression Bestiary, Metasymbol Tables, Quantifiers, The Little Engine That /Could(n't)?/
re pragma, altering default behavior of, Perl Language Extensions and Internals
recursive matching, Match-time pattern interpolation
security concerns, Code Masquerading as Data
split function, split
split function and, Pattern-Matching Operators
study function, study
substitution evaluation, Substitution evaluations
terminating delimiter for, Pattern-Matching Operators
Unicode properties, matching on, Effects of Character Semantics
for untainting data, Detecting and Laundering Tainted Data
PAUSE, Creating CPAN Modules
pausing scripts, sleep
percent (%) sign, Hashes. (see %)
percent sign (%), unpack (see % (percent sign))
performance, The Pursuit of Happiness, Efficiency, times
measuring, times
Perl programs, efficiency in, Efficiency
period, Quantifiers (see . (dot))
Perl, Variable Syntax, Caveats, The Thread Model, The Life Cycle of a Perl Program, Location of Perl, Extending Perl (Using C from Perl), XSUB Input and Output, Using Functions from an External C Library, Embedding Perl (Using Perl from C), Adding a Perl Interpreter to Your C Program, Calling a Perl Subroutine from C, Evaluating a Perl Statement from C, Fiddling with the Perl Stack from C, CPAN, Common Practices, Perl Language Extensions and Internals
C, extending with, XSUB Input and Output
XSUB input and output, XSUB Input and Output
C, using from, Extending Perl (Using C from Perl), Using Functions from an External C Library
external C library functions, using, Using Functions from an External C Library
CPAN (Comprehensive Perl Archive Network), CPAN
embedding in C, Embedding Perl (Using Perl from C), Adding a Perl Interpreter to Your C Program, Calling a Perl Subroutine from C, Evaluating a Perl Statement from C, Fiddling with the Perl Stack from C
Perl interpreter, adding to C program, Adding a Perl Interpreter to Your C Program
Perl stack, manipulating from C, Fiddling with the Perl Stack from C
Perl statement, evaluating from C, Evaluating a Perl Statement from C
Perl subroutine, calling from C, Calling a Perl Subroutine from C
extensions and internals, modules for, Perl Language Extensions and Internals
location of, Location of Perl
programming, common practices, Common Practices
programs, life cycle of, The Life Cycle of a Perl Program
special characters in, Variable Syntax
thread programming in, The Thread Model
use of Unicode, caveats on, Caveats
Perl Data Language (PDL) module, Slices
Perl interpreter, How to Do It, How to Do It, How to Do It, The Life Cycle of a Perl Program, Command Processing, Command Processing, Command Processing, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, Switches, The Perl Debugger, The Perl Debugger
-- switch, Switches
-0 switch, Command Processing, Switches
-a switch, Switches
-c switch, Switches
-d switch, Switches, The Perl Debugger
-D switch, Switches
-e switch, How to Do It, Switches
-F switch, Switches, Switches
-h switch, Switches
-I switch, Command Processing, Switches
-i switch, Switches
-l switch, Switches
-m switch, Switches
-M switch, Switches
-n switch, Switches
-p switch, Switches
-P switch, Switches
-s switch, Switches, The Perl Debugger
-S switch, Switches
switches, Switches
-T switch, Switches
-u switch, Switches
-U switch, Switches
-v switch, Switches
-V switch, Switches
-w switch, Switches
-w switch, How to Do It
-x switch, Command Processing, Switches
-X switch, Switches
perl interpreter program, Networking Servers, The Perl Profiler, Handling Insecure Data, Time Efficiency, Special Variables in Alphabetical Order, Diagnostic Messages
-a switch, Special Variables in Alphabetical Order
-d switch, The Perl Profiler
sticky bit, Time Efficiency
-T switch, Networking Servers, Handling Insecure Data
-w switch, Diagnostic Messages
Perl virtual machine, Executing Your Code, Executing Your Code
Perl, history of, History Made Practical
Perl/Tk, User Efficiency
PERL5DB environment variable, Environment Variables, Customizing with Init Files
debugger, customizing with, Customizing with Init Files
PERL5LIB environment variable, Environment Variables
PERL5OPT environment variable, Environment Variables
PERL5SHELL environment variable, Environment Variables
perlapi manpage, Evaluating a Perl Statement from C
perlcall manpage, Fiddling with the Perl Stack from C
perlcc, Special Variables in Alphabetical Order
perlcc command, Compiler Backends, The Bytecode Generator
pbyscript resulting from, The Bytecode Generator
$PERLDB, Special Variables in Alphabetical Order
PERLDB_OPTS environment variable, Using the Debugger, Debugger Customization
AutoTrace option, tracing compile-phase statements, Using the Debugger
debugger customization via, Debugger Customization
perldoc command, Online Documentation, Modules, Miscellaneous Commands
debugger invoking, Miscellaneous Commands
perlembed manpage, Embedding Perl (Using Perl from C), Evaluating a Perl Statement from C
eval_sv function, demonstrating, Evaluating a Perl Statement from C
perlfork documentation, Interprocess Communication
perllocale manpage, lc
perlmodinstall manpage, Using CPAN Modules
perlport documentation, Interprocess Communication
perlwin32 documentation, Interprocess Communication
PERL_DEBUG_MSTATS environment variable, Environment Variables
PERL_DESTRUCT_LEVEL environment variable, Environment Variables
PERL_DESTRUCT_LEVEL variable, Garbage Collection with DESTROY Methods
$PERL_VERSION, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order
permissions, Named Unary and File Test Operators, Handling Insecure Data, sysopen, umask
file permission operators, interpreting, Named Unary and File Test Operators
users, granting limited, Handling Insecure Data
persistent data structures, providing via tie, Tie Modules on CPAN
persistent Perl interpreter, Embedding Perl (Using Perl from C)
pi, atan2
picture lines, format
pid, open (see processes)
PID (process ID), Special Variables in Alphabetical Order
pid (process ID), setpgrp
getting process group, setpgrp
pipe function, Interprocess Communication (IPC), pipe
portability of, Interprocess Communication (IPC)
pipelines, Anonymous Pipes, Anonymous Pipes
multistage, for input, Anonymous Pipes
multistage, for output, Anonymous Pipes
pipes, Creative Filehandles, Pipes, Talking to Yourself, Named Pipes, Cleaning Up Your Environment, close, open, Filehandle, Directory Handle, and Stream I/O Utilities, Glossary
closing, close
double-ended, opening with tied filehandle, Creative Filehandles
in interprocess communication, Pipes
in interprocess communication, Talking to Yourself, Named Pipes
named pipes, Named Pipes
process talking to itself, Talking to Yourself
IO::Pipe module, Filehandle, Directory Handle, and Stream I/O Utilities
named, Glossary
open function, security risks posed by, Cleaning Up Your Environment
read-only filehandles, opening, open
plain old documentation, Molecules (see pod)
pluralities, Pluralities
+ (plus), Unary Arithmetic Operators
++ (autoincrement) operator, Unary Arithmetic Operators
.pm file extension, Packages
pod, Molecules, The CPAN modules Directory, Pod Directives, Glossary
directives, Pod Directives, Glossary
embedding in Perl, Molecules
Perl modules for, The CPAN modules Directory
pod modules, Pod Translators and Modules
pod translators, Pod in a Nutshell, Pod Translators and Modules
Pod::Checker module, Documentation Support
Pod::Functions module, Documentation Support
Pod::Html module, Documentation Support
Pod::InputObjects module, Documentation Support
Pod::Man module, Documentation Support
Pod::Parser module, Documentation Support
Pod::Select module, Documentation Support
Pod::Text module, Documentation Support
Pod::Text::Termcap module, Documentation Support
Pod::Usage module, Documentation Support
poetry in Perl, Perl Poetry
pointers, Built-in Data Types, Scalar Values, pack
references, unable to convert to, Scalar Values
to strings, pack
poll function, Filehandle, Directory Handle, and Stream I/O Utilities
polluting your namespace, Module Privacy and the Exporter
polymorphism, Brief Refresher on Object-Oriented Lingo, Glossary
pop function, Data Structures, pop
POP method, Array-Tying Methods
popen function (C language), Embedding Perl (Using Perl from C)
portability, Files and Filesystems, System Interaction, Perl Functions in Alphabetical Order, gethostent
of files and filesystems, Files and Filesystems
functions, information on, Perl Functions in Alphabetical Order
scripts using gethostent function, gethostent
of signals, System Interaction
porting, Interprocess Communication
information on, Interprocess Communication
porting, efficiency of, Porter Efficiency
ports, CPAN, getservbyname, Glossary
name/number translations for, getservbyname
Perl, to operating systems, CPAN
pos function, Progressive Matching, pos
positional assertions, Alternation
ordering of matching, changing with, Alternation
positions, Positions, Positions, Beginnings: The A and ^ Assertions, Endings: The z, , and $ Assertions, Boundaries: The  and B Assertions, Where You Left Off: The G Assertion, The Little Engine That /Could(n't)?/, Effects of Character Semantics
beginnings of strings, matching, Beginnings: The A and ^ Assertions
ends of strings, matching, Endings: The z, , and $ Assertions
operators switching to character positions, Effects of Character Semantics
position just after previous match, specifying, Where You Left Off: The G Assertion
precedence in pattern matching, The Little Engine That /Could(n't)?/
substr function, manipulating with, Positions
word boundaries, matching, Boundaries: The  and B Assertions
positive lookahead assertions, The Little Engine That /Could(n't)?/, Lookaround Assertions
POSIX classes, Character Classes
POSIX module, Using Modules, Blocking Signals, getc, localtime, Operating System Interfaces
getattr function, getc
getting exported functions and variables with, Using Modules
signal blocking with, Blocking Signals
strftime function, localtime
POSIX-style character classes, POSIX-Style Character Classes
possible matches, specifying set of, Alternation
post-incremented (post-decremented) variables, Unary Arithmetic Operators
postincrement and postdecrement operators, Unary and Binary Operators
$POSTMATCH, Special Variables in Alphabetical Order
PPM (Perl Package Manager), Using CPAN Modules, Using CPAN Modules
pragmas, Simplicities, Names, String Literals, Global Declarations, Pragmas, Pragmas, Packages, Using Modules, Switches, use
lexically scoped, Pragmas
modules and, Using Modules
names, capitalization in, Names
use charnames, String Literals
pre-extending arrays, Time Efficiency
pre-incremented (pre-decremented) variables, Unary Arithmetic Operators
precedence, Logical Operators, Hashes, Unary and Binary Operators, Named Unary and File Test Operators, Logical and, or, not, and xor, Scoped Variable Declarations, Previous Perl Traps, Functions, Diagnostic Messages, Glossary
diagnostic messages, Diagnostic Messages
key/value pair (hashes), Hashes
logical operators, Logical Operators, Logical and, or, not, and xor
modifiers vs. commas, Scoped Variable Declarations
operator, table of, Unary and Binary Operators
Perl versions, changes in, Previous Perl Traps
unary operators, higher than binary, Named Unary and File Test Operators
predeclaring subroutines, Method Autoloading, Perl Language Extensions and Internals
prefix operators, Operators, Unary and Binary Operators, Metacharacters and Metasymbols
metacharacters working as, Metacharacters and Metasymbols
$PREMATCH, Special Variables in Alphabetical Order
prepending, directories to @INC, Switches
preprocessing Perl, Generating Perl in Other Languages, Glossary
preprocessor (C language), Glossary
print function, Filehandles, List Processing, Filehandle-Tying Methods, Time Efficiency, Time Efficiency, print
implementing to tied filehandle, Filehandle-Tying Methods
print statements, Universal Blunders
comma error in, Universal Blunders
printf function, Filehandle-Tying Methods, Time Efficiency, printf, sprintf
using on tied filehandle, Filehandle-Tying Methods
printing, Access and Printing, Hashes of Arrays, Access and Printing of a Hash of Arrays, Access and Printing of an Array of Hashes, Hashes of Hashes, Access and Printing of a Hash of Hashes, Composition, Access, and Printing of More Elaborate Records, Display, Debugger Options
arrays of hashes, Access and Printing of an Array of Hashes
hashes of arrays, Access and Printing of a Hash of Arrays
multidimensional arrays, Access and Printing, Hashes of Arrays, Hashes of Hashes
multidimensional hashes, Access and Printing of a Hash of Hashes, Composition, Access, and Printing of More Elaborate Records
nested data structures, Display
typeglob contents, Debugger Options
PrintRet option (debugger), Debugger Options
priority, process, getpriority, setpriority
privacy, Module Privacy and the Exporter, Tag-handling utility functions, Brief Refresher on Object-Oriented Lingo
Perl modules and, Module Privacy and the Exporter, Tag-handling utility functions
private methods, ignoring inheritance with, Private Methods
private objects, closures, using for, Using Closures for Private Objects
private variables, my (see local variables)
procedureal programming style, Programmatic Patterns
procedures, Verbs
process group, getpgrp, setpgrp
process groups, Signals
process ID (pid), fork, getpgrp, getppid, waitpid
getting process group from, getpgrp
returning, getppid
returning with fork, fork
waitpid function, waitpid
processes, Filehandles, Interprocess Communication, Interprocess Communication, Interprocess Communication, Signaling Process Groups, Signaling Process Groups, Files, System V IPC, Sockets, The Process Model, Handling Timing Glitches, Special Variables in Alphabetical Order, Perl Functions by Category, fork, getpriority, kill, open, setpgrp, setpriority, umask, wait
checking for existence, Signaling Process Groups
fork function, fork
functions dealing with, Perl Functions by Category
getting group for, setpgrp
ID (pid), open
interprocess communication, Interprocess Communication, Interprocess Communication, Interprocess Communication, Files, System V IPC, Sockets
between processes on same machine, Interprocess Communication
files, Files
on the Internet, Interprocess Communication
sockets, Sockets
System V IPC, System V IPC
killing, kill
multitasking environments, CPU access, Handling Timing Glitches
priority, setting, setpriority
process model, threads, The Process Model
returning priority of, getpriority
signaling process groups, Signaling Process Groups
standard input, output, and error in, Filehandles
umask for, umask
variables for, Special Variables in Alphabetical Order
waiting for, wait
processing shell commands, Command Processing
processor, Yielding the processor (see CPU)
$PROCESS_ID, Special Variables in Alphabetical Order
profiler, Perl, The Perl Profiler, The Perl Profiler
profiling, Devel::DProf module, Perl Language Extensions and Internals
program arguments, shell vs. Perl, Shell Traps
program name, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order
of perl executable, Special Variables in Alphabetical Order
of perl script, Special Variables in Alphabetical Order
programming style, patterns, Programmatic Patterns
programming, Perl, Common Goofs for Novices, Previous Perl Traps, Previous Perl Traps, Efficiency, Programming with Style, Fluent Perl, Program Generation, Generating Other Languages in Perl, Generating Perl in Other Languages, Source Filters, Files and Filesystems
common mistakes by novices, Previous Perl Traps, Previous Perl Traps
Perl traps, previous versions, Previous Perl Traps, Previous Perl Traps
common mistakes of novices, Common Goofs for Novices
efficiency, Efficiency
file-manipulating programs, writing portable, Files and Filesystems
fluent, Fluent Perl
program generation, Program Generation, Generating Perl in Other Languages
generating Perl in other languages, Generating Perl in Other Languages
program generators, Generating Other Languages in Perl, Source Filters
other languages in Perl, Generating Other Languages in Perl
source filters, Source Filters
programming with style, Programming with Style
programs, Getting Started, Stepping and Running, dump, exit, system, Glossary, Glossary
core dump of, dump
executing, system, Glossary
exiting, Getting Started, exit
one-liners, Glossary
stepping through with debugger, Stepping and Running
programs, Perl, An Average Example
student gade averages, calculating and printing, An Average Example
$PROGRAM_NAME, Special Variables in Alphabetical Order
projects, large, benefits of strict pragma in, Simplicities
properties, Character Classes, Initializers, Effects of Character Semantics, Effects of Character Semantics
case, Unicode, Effects of Character Semantics
Unicode, Character Classes
Unicode database of, Effects of Character Semantics
protocols, name/number translations, getprotobyname
prototypes, Prototypes, Prototypes, Prototypes, Inlining Constant Functions, Care with Prototypes, What Is a Reference?, Closures as function templates, Glossary
& (ampersand), omitting from subroutine names, Prototypes
built-in functions, emulating, Prototypes
careful use of, Care with Prototypes
closures, giving to, Closures as function templates
implicit pass-by-reference in, What Is a Reference?
inlining constant functions, Inlining Constant Functions
prototyping, Prototypes, The lvalue Attribute
pseudo-operators, overloading and, Overloadable Operators
pseudocommands, piping, Talking to Yourself
pseudohashes, Pseudohashes, Field Declarations with use fields, Overloadable Operators, my
implementing classes with, Field Declarations with use fields, my
inheritance and, Field Declarations with use fields
simulating with overload function, Overloadable Operators
pseudoliterals, Input Operators (see input operators)
pumpkins and pumpkings, Glossary
punctuation characters, Boundaries: The  and B Assertions
word boundary matching and, Boundaries: The  and B Assertions
punctuation variables, English module, handling with, Perl Language Extensions and Internals
push function, Built-in Data Types, Data Structures, push
pop function, Built-in Data Types
push-pop (PP) codes, Executing Your Code
PV (internal string value), Internal Data Types
pwd command (Unix), Time Efficiency
Python, Molecules

Q

q// (pattern match) operator, Overloading Constants
qr// (quote regex) operator, Interpolative Context, Pattern-Matching Operators, Pattern Modifiers, The qr// quote regex operator
modifiers for, Pattern Modifiers
quantifiers, Regular Expressions, Quantifiers, Metasymbol Tables, Wildcard Metasymbols, Custom Character Classes, Quantifiers, Quantifiers, Quantifiers, The Little Engine That /Could(n't)?/, Time Efficiency
atoms and, The Little Engine That /Could(n't)?/
greedy, Quantifiers
in matches, Wildcard Metasymbols
dot (.) metacharacter, using with, Wildcard Metasymbols
in matching, Metasymbol Tables, Custom Character Classes, Quantifiers
character classes and, Custom Character Classes
minimal and maximal, Metasymbol Tables
minimal and maximal, Quantifiers
quantifiers (in matching), The Regular Expression Bestiary, Metasymbol Tables
quarantining suspicious code, Handling Insecure Code
? (question mark), Quantifiers
quantifier, Quantifiers
queues, Data Structures
queues, Thread::Queue module, Queues
quit signals, handler for, Signals
quitting, for Loops, Miscellaneous Commands
infinite loop, for Loops
Perl debugger, Miscellaneous Commands
quotation marks, String Literals, Pattern-Matching Operators, Braces, Brackets, and Quoting, #! and Quoting on Non-Unix Systems, Debugger Options, formline, Glossary
(see also " (double quotes) and ' (single quotes) under Symbols)
double ("), Pattern-Matching Operators
false values, Glossary
in formline arguments, formline
on non-Unix systems, #! and Quoting on Non-Unix Systems
strings, Debugger Options
changing style of string display, Debugger Options
strings and, String Literals
quote operators, Terms and List Operators (Leftward)
quoted execution operator, Command Input (Backtick) Operator (see ` (backtick) operator)
quotemeta function, quotemeta
quotes, Singularities
strings, use in, Singularities
quoting mechanisms, Singularities
qw (quote words), List Values and Arrays
qw operator, Or Leave the Quotes Out Entirely
qx// (quote construct) operator, readpipe
qx// (quoted execution) operator, Command Input (Backtick) Operator, Command Input (Backtick) Operator
(see also ` (backtick) operator)

R

-r (readable by effective uid/gid) file test, Some File Test Operators
race conditions, File Locking, Handling Race Conditions
file locking and, File Locking
handling, Handling Race Conditions
rand function, Terms and List Operators (Leftward), rand
random numbers, Creative Filehandles, rand, srand
producing as handles or scalars, Creative Filehandles
range (.. and …) operator, Range Operator
ranges, The tr/// Operator (Transliteration), Custom Character Classes
character sets, specifying in, The tr/// Operator (Transliteration)
characters, Custom Character Classes
$rdev file statistic, stat
re module, Perl Language Extensions and Internals
re-initialization expressions, loops, for Loops
read function, Filehandle-Tying Methods, read
readable file test operator, Some File Test Operators, Named Unary and File Test Operators
readdir function, readdir
reading, shmread, sysread
data via low-level system call, sysread
shared memory segment ID, shmread
reading files, open
open mode and, open
readline function, Line Input (Angle) Operator
READLINE method, Filehandle-Tying Methods
ReadLine module, disabling support to debugger, Unattended Execution
readline packages, User Interfaces
readlink function, readlink
ready file descriptors, select (ready file descriptors)
real GID, Special Variables in Alphabetical Order (see $( variable)
real UID, Special Variables in Alphabetical Order (see $< variable)
real values, testing for with defined function, defined
$REAL_GROUP_ID, Special Variables in Alphabetical Order
$REAL_USER_ID, Special Variables in Alphabetical Order
reaping zombie processes, Networking Servers
servers, Networking Servers
recallCommand option (debugger), Debugger Options
recompiling patterns, limiting with /o modifier, Pattern Modifiers
record delimiter, Switches (see $/ variable)
record mode, Special Variables in Alphabetical Order
records, More Elaborate Records, Composition, Access, and Printing of More Elaborate Records, Generation of a Hash of Complex Records, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, Perl Functions by Category
functions dealing with, Perl Functions by Category
input, separator for, Special Variables in Alphabetical Order (see $/ variable)
output, separator for, Special Variables in Alphabetical Order (see $ variable)
of various data structures, More Elaborate Records, Composition, Access, and Printing of More Elaborate Records, Generation of a Hash of Complex Records
composing, accessing, and printing, Composition, Access, and Printing of More Elaborate Records
generating hash of, Generation of a Hash of Complex Records
records, variable-length, Formats
recursion of subroutines, Scoping Issues
recursive lexical pad stacks, Executing Your Code
recursive matching, Match-time pattern interpolation
recursivity, Synchronizing access with lock
locks, Synchronizing access with lock
recv function, recv
redo operator, Loop Control, Loop Control, redo
redundancy in Perl, Some Numeric and String Comparison Operators
ref function, Object Construction, ref
ref operator, Other Tricks You Can Do with Hard References
references, Singularities, What Is Truth?, Name Lookups, Scalar Values, The Arrow Operator, C Operators Missing from Perl, Syntax, Semantics, Passing References, References, References, What Is a Reference?, What Is a Reference?, Creating References, The Backslash Operator, Object Constructors, Symbol Table References, Using Object Methods, Other Tricks You Can Do with Hard References, Symbolic References, Braces, Brackets, and Quoting, References Don't Work as Hash Keys, Garbage Collection, Circular References, and Weak References, Creating and Accessing a Two-Dimensional Array, Common Mistakes, Hashes of Functions, More Elaborate Records, Packages, Symbol Tables, Symbol Tables, Symbol Tables, Perl's Object System, Method Invocation, Object Construction, Object Construction, Garbage Collection with DESTROY Methods, Overloading, Overloadable Operators, Scalar-Tying Methods, Array-Tying Methods, A Subtle Untying Trap, Signals, Synchronizing access with lock, Environment Variables, open, ref, Convenient Classes, Glossary, Glossary
blessing, Object Construction
braces, brackets and quoting in, Braces, Brackets, and Quoting
casting to other pointer types, Scalar Values
checking for, ref
circular, Overloadable Operators
in overloading, Overloadable Operators
circular, and memory, Garbage Collection, Circular References, and Weak References
creating, Creating References, The Backslash Operator
with backslash operator, The Backslash Operator
to data structures, What Is a Reference?
defining, What Is a Reference?
destruction of, controlling, Environment Variables
to filehandles, open
to functions, Hashes of Functions
storing in data structures, Hashes of Functions
hard, The Arrow Operator, Glossary, Glossary
(see also hard references)
hash keys, providing as, Convenient Classes
to hashes, More Elaborate Records
multidimensional hashes, More Elaborate Records
indirection, References
locking, Synchronizing access with lock
in multidimsional arrays, Creating and Accessing a Two-Dimensional Array
object-oriented programming and, Packages
to objects, Object Constructors, Using Object Methods, Perl's Object System, Method Invocation
invocants for instance methods, Method Invocation
objects as, Object Construction
to objects, Overloading
overloading and, Overloading
passing, Passing References
passing by, Semantics
Perl, C pointers vs., C Operators Missing from Perl
references and, Name Lookups
to signal handlers (user-defined), Signals
stringifying, Other Tricks You Can Do with Hard References, References Don't Work as Hash Keys
to subroutines, Syntax
to symbol table entries, Symbol Tables
to symbol tables, Symbol Table References, Symbol Tables
symbolic, Symbolic References
to tied arrays, Array-Tying Methods
to tied scalar variables, Scalar-Tying Methods
to tied variable objects, breaking, A Subtle Untying Trap
to hashes, Common Mistakes
to subroutines, Symbol Tables
retrieving from or passing to, Symbol Tables
truth value of, What Is Truth?
weakening or breaking, Garbage Collection with DESTROY Methods
referents, What Is a Reference?, Perl's Object System
objects as, Perl's Object System
reftype function, Object Construction
regex, Pattern Matching (see patterns)
regexes, Regular Expressions (see patterns)
regexps, Regular Expressions (see patterns)
registry (Microsoft Windows), manipulating, Tie Modules on CPAN, Microsoft-Related Modules
regular expressions, Interpolating Array Values, Pattern Matching, Effects of Character Semantics, Perl Functions by Category (see patterns)
character classes, confusing with array subscripts, Interpolating Array Values
characters, matching instead of bytes, Effects of Character Semantics
functions dealing with, Perl Functions by Category
regular files, testing for, Some File Test Operators
relational databases, Tie Modules on CPAN
hashes, tying to, Tie Modules on CPAN
relational operators, Some Numeric and String Comparison Operators, Relational Operators, Relational Operators (see relational operators)
nonassociation of, Relational Operators
removing, rmdir (see deleting)
rename function, rename
repetition (x) operator, String Operators, String Operators, Multiplicative Operators
replacement strings, Substitution evaluations
/e modifier, building with, Substitution evaluations
replacement, matched substrings, The s/// Operator (Substitution) (see s/// (substitution) operator)
replacing array elements, splice
reports, generating, Formats
require, Global Declarations
require declarations, Tied Variables
tie function and, Tied Variables
require function, Using Modules
require operator, Global Declarations, Special Variables in Alphabetical Order, require
REs, Regular Expressions (see patterns)
reserved words, Names
reset function, reset
return function, return
return operators, Loop Control
return stack, Executing Your Code
return value, Stepping and Running
currently executing subroutine, displaying in debugger, Stepping and Running
return value, subroutine, Semantics
reused addresses, displaying contents of, Debugger Options
reusing code, Programming with Style
reval method, running suspicious code with, Restricting namespace access
reverse function, List Processing, reverse
reverse, disallowing as sort subroutine name, Previous Perl Traps
reversing print and printf statements (tied filehandles), Tying Filehandles
revision, Special Variables in Alphabetical Order (see version)
rewinddir function, rewinddir
right justification, Format Variables
right-shift (>>) operator, Shift Operators
rindex function, rindex
rmdir function, rmdir
root directory, redefining, chroot
root user, Glossary
rot13 encryption, The tr/// Operator (Transliteration)
RS (awk variable), Special Variables in Alphabetical Order (see $INPUT_RECORD_SEPARATOR)
RSTART (awk variable), Special Variables in Alphabetical Order (see @-)
run phase, The Life Cycle of a Perl Program
run phase vs. run time, Compiling Your Code
running, Filehandles (see executing)
RV (internal reference value), Internal Data Types
rvalue, Built-in Data Types

S

s for whitespace=s (for whitespace), Regular Expressions
/s pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution)
s operator, Regular Expressions (see substitution operator)
/s pattern modifier, Pattern Modifiers, The tr/// Operator (Transliteration)
-S (search for script) command-line switch, Switches
-s (switch) command-line switch, Switches, The Perl Debugger
s// (substitution) operator, Universal Blunders
s/// (substitution operator), Pattern-Matching Operators
double-quote interpolation, providing, Pattern-Matching Operators
s/// (substitution) operator, Pattern-Matching Operators, Pattern Modifiers, The s/// Operator (Substitution), When a global substitution just isn't global enough, The s/// Operator (Substitution), Glossary
=~ and !~ binding operators, using with, Pattern-Matching Operators
modifiers for, Pattern Modifiers
pattern modifiers used with, The s/// Operator (Substitution)
Safe module, Safe Compartments, Restricting operator access, Authentication, Security, and Encryption
insecure code, handling, Restricting operator access
restricting operator access, Restricting operator access
insecure code, handling with, Safe Compartments
save stack, Executing Your Code
saving, data structures, Saving Data Structures
scalar context, Scalar and List Context, Scalar and List Context, Boolean Context, Void Context, List Assignment, Hashes, Range Operator, Conditional Operator, Assignment Operators, Comma Operators, Compound Statements, Scoped Variable Declarations, The m// Operator (Matching), The m// Operator (Matching), Semantics, Hash-Tying Methods, Using the Debugger, Frequently Ignored Advice, Previous Perl Traps, Functions, scalar, Glossary, Glossary
/g pattern modifier, use in, The m// Operator (Matching)
Boolean values and, Boolean Context, Glossary
comma operator in, Comma Operators, Previous Perl Traps
conditional operator in, Conditional Operator
expressions in, Compound Statements (see EXPRs)
forcing, scalar
functions in, Functions
hash variables, evaluating in, Hashes
keys function, calling in, Hash-Tying Methods
list assignment in, List Assignment, Assignment Operators
lvalues in, Scoped Variable Declarations
m// (match) operator in, The m// Operator (Matching)
operations behaving differently in, Frequently Ignored Advice
range (..) operator in, Range Operator
recognizing in debugger, Using the Debugger
subroutines, calling and evaluating in, Semantics
subtypes of, Scalar and List Context
void context, Void Context
scalar pseudofunction, scalar
scalar reverse function, Effects of Character Semantics
scalar values, Scalar Values, Scalar Values, Numeric Literals, String Literals, Interpolating Array Values, "Here" Documents, V-String Literals, Unary and Binary Operators
here documents, "Here" Documents
interpolating array values, Interpolating Array Values
numeric literals, Numeric Literals
operators fo, Unary and Binary Operators
string literals, String Literals
v-string literals, V-String Literals
scalar variables, Line Input (Angle) Operator, The s/// Operator (Substitution)
in angle brackets, Line Input (Angle) Operator
in double-quote context, The s/// Operator (Substitution)
scalars, Variable Syntax, Singularities, Singularities, Pluralities, Hashes., Complexities, Complexities, What Is Truth?, Built-in Data Types, Variables, Semantics, What Is a Reference?, Symbol Tables, Symbol Tables, Tying Scalars, Scalar-Tying Methods, Magical Counter Variables, Magically Banishing $_, Internal Data Types, Evaluating a Perl Statement from C, Perl Functions by Category, length, Convenient Classes, Glossary
characters, length of, length
complex data structures, representing as, Complexities
constants, Symbol Tables, Symbol Tables
(see also constants)
functions for manipulating, Perl Functions by Category
hard references as, What Is a Reference?
list of, Pluralities (see arrays)
lists, converting to, Complexities
parameter and return lists, subroutines, Semantics
Perl, converting to C types, Evaluating a Perl Statement from C
references, Singularities
SV (scalar value) in C, Internal Data Types
truth, evaluating in, What Is Truth?
tying, Tying Scalars, Scalar-Tying Methods, Magical Counter Variables, Magically Banishing $_, Convenient Classes
base class definitions, providing, Convenient Classes
magical counter variables, Magical Counter Variables
methods for, Scalar-Tying Methods
preventing unlocalized use of $_ variables, Magically Banishing $_
unordered set of, Hashes. (see hashes)
scheduling and preemption policies, threads, The Thread Model
scope, Variable Syntax, Simplicities, Names, Names, if and unless Statements, while and until Statements, for Loops, foreach Loops, Scoped Declarations, Scoping Issues, Queues, Perl Functions by Category, my
declarations and, Scoped Declarations
functions dealing with, Perl Functions by Category
lexically scoped variables, Names
loop variable in foreach, foreach Loops
private variables, my (see lexical variables)
subroutines, Scoping Issues
in threads, Queues
variables, Variable Syntax, Simplicities
strict pragma and, Simplicities
variables in if statements, if and unless Statements
variables in three-part for loops, for Loops
variables in while loops, while and until Statements
scope modifiers, Scoped Variable Declarations
scope operators, Scoped Variable Declarations
scopes, Compound Statements, Compound Statements, Lexically Scoped Variables: my, Lexically Scoped Variables: my, Lexically Scoped Variables: my, Lexically Scoped Variables: my, Pattern-Matching Operators, Packages, Packages, Signals, Executing Your Code, Glossary, Glossary
block, Lexically Scoped Variables: my
blocks, Compound Statements
dynamic, Glossary
file, Lexically Scoped Variables: my
lexical scope, Lexically Scoped Variables: my
my variables, Packages
package declarations, Packages
pattern-matching operations, Pattern-Matching Operators
scope stack, Executing Your Code
signal handling, Signals
static, Lexically Scoped Variables: my (see scopes; lexical)
screen appearance of command line, Debugger Options
scripts, Other Literal Tokens, Named Unary and File Test Operators, Unicode block properties, Command Processing, Switches, Switches, Switches, Switches, Switches, Switches, Switches, CPAN, Handling Insecure Data, Handling Insecure Code, Common Goofs for Novices, Shell Traps, Efficiency, Programming with Style, Fluent Perl, Special Variables in Alphabetical Order, exec, sleep, system, Development Support
building with -e switch, Switches
CGI, taint mode and, Handling Insecure Data
checking syntax of, Switches
debugging, Switches, Switches
(see also debugging)
dumping core files, Switches
embedding in messages, Switches
end marker for, Other Literal Tokens
executing, system
insecure, Handling Insecure Code
interpretation, shells vs. Perl, Shell Traps
languages, checking for, Unicode block properties
names of, Special Variables in Alphabetical Order (see $0 variable)
pausing, sleep
Perl, Common Goofs for Novices, Efficiency, Programming with Style, Fluent Perl, Development Support
common mistakes of novices, Common Goofs for Novices
idiomatic Perl, using, Fluent Perl
performance of, Efficiency
programming with style, Programming with Style
test scripts, Development Support
Perl, CPAN directory of, CPAN
Perl, searching for and compiling, Command Processing
running time of, Named Unary and File Test Operators
searching for, Switches
terminating with exec, exec
scripts, Perl, How to Do It
perl interpreter, associating with, How to Do It
SDBM_File module, DBM Interfaces
search and replace, global, The s/// Operator (Substitution)
search path, Special Variables in Alphabetical Order
%INC, Special Variables in Alphabetical Order
search programs, Regular Expressions
Search::Dict module, String Processing, Language Text Processing, Parsing, and Searching
searching, Name Lookups, The s/// Operator (Substitution), Switches, Time Efficiency, grep, index, rindex
grep function for, grep
linear, versus hashes, Time Efficiency
rules for name searches, Name Lookups
for scripts, Switches
for substrings, The s/// Operator (Substitution), index, rindex
security, The Pursuit of Happiness, Security, Handling Insecure Data, Handling Insecure Data, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges, Handling Timing Glitches, Handling Race Conditions, Temporary Files, Temporary Files, Handling Insecure Code, srand, Authentication, Security, and Encryption, Microsoft-Related Modules, Glossary
cracking, Glossary
handling insecure data, Handling Insecure Data
insecure code, handling, Handling Insecure Code
insecure data, handling, Handling Insecure Data, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges
command and file access under reduced privileges, Accessing Commands and Files Under Reduced Privileges, Accessing Commands and Files Under Reduced Privileges
modules for, Authentication, Security, and Encryption
timing glitches, handling, Handling Timing Glitches, Handling Race Conditions, Temporary Files, Temporary Files
race conditions, Handling Race Conditions
temporary files, Temporary Files, Temporary Files
Win32::FileSecurity module, Microsoft-Related Modules
security, of file test operators, use filetest
sed, Regular Expressions, The tr/// Operator (Transliteration)
seed, random number, srand
seek function, seek, tell
(see also tell function)
SEEK method, Filehandle-Tying Methods
seekable I/O objects, Filehandle, Directory Handle, and Stream I/O Utilities
seekdir function, seekdir
select function, Format Variables, Format Variables, fileno, print, select (output filehandle), select (ready file descriptors), Filehandle, Directory Handle, and Stream I/O Utilities
for format variables, Format Variables
for format variables, Format Variables
select syscall, Networking Servers
multiplexing I/O between clients, Networking Servers
SelectSaver module, Filehandle, Directory Handle, and Stream I/O Utilities
self method, thread accessing own thread object, Identifying threads
self-matching characters, The Little Engine That /Could(n't)?/
SelfLoader module, Module Installation Support, Module Installation Support
Devel::SelfStubber module, using with, Module Installation Support
semantics, use
semaphore file, use in file locking, File Locking
semaphore files, System V IPC, System V IPC
shared memory, System V IPC
System V IPC, System V IPC
semaphores, The Thread Model, Semaphores, semctl, Networking and Interprocess Communication, Microsoft-Related Modules, Glossary
functions for, semctl
IPC::Semaphore module, Networking and Interprocess Communication
thread safety and, The Thread Model
Thread::Semaphore module, Semaphores
Win32::Semaphore module, Microsoft-Related Modules
semctl function, semctl
semget function, semget
semop function, semop
send function, send
separators, Regular Expressions
split operator, defining, Regular Expressions
sequential matches, The Little Engine That /Could(n't)?/
serial ports, Perl modules for, The CPAN modules Directory
serializing Perl data structures, Perl Language Extensions and Internals
server-push CGI scripting, World Wide Web
servers, Handling Insecure Data
taint mode, importance of enabling for, Handling Insecure Data
servers, networking, Networking Servers, Networking Servers
forking clones to handle incoming connections, Networking Servers
servers, TCP, Networking Clients
service port name/number translations, getservbyname
set-id program, Accessing Commands and Files Under Reduced Privileges
dangerous operations, UID and GID setting to real, Accessing Commands and Files Under Reduced Privileges
set-id programs, Handling Insecure Data
setgid function, Talking to Yourself
setgid program, Handling Insecure Data
setgrent function, getgrent
sethostent function, gethostent
setpgrp function, setpgrp
setprgp function, Signaling Process Groups
setpriority function, setpriority
setprotoent function, getprotoent
setpwent function, getpwent
sets, Passing References
intersection, Passing References
setservent function, getservent
setsockopt function, setsockopt
setuid function, Talking to Yourself
setuid program, Handling Insecure Data
sh (Bourne shell), Glossary
shadow, password entries, getpwnam
shared file locks, File Locking
shared memory, System V IPC, System V IPC, System V IPC, shmctl
controlled access to, System V IPC
functions for, shmctl
# (sharp), How to Do It
#! (shebang) notation, How to Do It
shebang notation, How to Do It (see #!)
shell module, Operating System Interfaces
shells, Filehandles, Anonymous Pipes, Anonymous Pipes, Talking to Yourself, Command Processing, Switches, Environment Variables, Environment Variables, Actions and Command Execution, Debugger Options, Cleaning Up Your Environment, Accessing Commands and Files Under Reduced Privileges, Code Masquerading as Data, Shell Traps, open, Glossary, Glossary
alternative for Perl, Windows systems, Environment Variables
avoiding use of, Accessing Commands and Files Under Reduced Privileges
avoiding with multi-argument piped open, Anonymous Pipes
Bourne shell (sh), Command Processing
bypassing with -| piping pseudocommand, Talking to Yourself
commands in, Glossary
debugger commands and, Actions and Command Execution
environment variables as security hazards, Cleaning Up Your Environment
environment variables, using with, Environment Variables
I/O streams, setting up, Filehandles
pipe commands with shell metacharacters, passing to, open
pipe commands with special characters, handling, Anonymous Pipes
programming, Perl vs., Shell Traps
quotes, passing through, Switches
security pitfalls with use, avoiding, Code Masquerading as Data
spawning, characters for, Debugger Options
shift function, Data Structures
shift operator, The while and until statements
shift operators, Shift Operators, Shift Operators
shmctl function, shmctl
ShMem package, System V IPC
shmget function, shmget
shmread function, shmread
shmwrite function, shmwrite
short-circuit operators, Logical Operators, C-Style Logical (Short-Circuit) Operators, Overloadable Operators (see logical operators)
overloading and, Overloadable Operators
shortening arrays, Array Length
shorts, sprintf
shutdown function, shutdown
shutdown syscall, Networking Clients
%SIG hash, Signals
sigaction function, Reaping Zombies
SIGALRM signal, alarm
signal handlers, Packages, C Traps
%SIG, Perl vs. C language, C Traps
defining as strings, Packages
signal handling, Operating System Interfaces
sigtrap module, Operating System Interfaces
signal level option (debugger), Debugger Options
signals, Interprocess Communication, Signals, Signals, Signals, Signals, Signaling Process Groups, Blocking Signals, The Thread Model, Other standard threading modules, System Interaction, Special Variables in Alphabetical Order, kill
%SIG hash, Special Variables in Alphabetical Order
blocking, Blocking Signals
core dumps, triggering in C library, Signals
killing processes with, kill
portability of, System Interaction
signaling process groups, Signaling Process Groups
sources of, Signals
Thread::Signal module, Other standard threading modules
threads, delivering to, The Thread Model
trapping with sigtrap pragma, Signals
sigprocmask syscall, Blocking Signals
sigtrap pragma, Signals, Signals
sin function (sine), sin
single inheritance, Class Inheritance
single quotes, Singularities
suppressing interpolation, Singularities
single quotes ('), Pattern Modifiers, When backslashes happen, Lookaround Assertions, Packages
contractions in words, avoiding confusion with, Lookaround Assertions
as package delimiters, Packages
pattern recompilation and, Pattern Modifiers
suppressing variable interpolation and translation escape processing, When backslashes happen
singularities, Singularities (see singularities)
$size file statistic, stat
sleep function, select (ready file descriptors), sleep
select function instead of, select (ready file descriptors)
slices of arrays or hashes, Variables
slices of multidimensional arrays, Slices
slurping files, Switches, Glossary
Perl, setting value for, Switches
Socket module, Sockets, Networking Clients, gethostbyaddr, Networking and Interprocess Communication
inet_ntoa function, gethostbyaddr
networking client, connecting to server, Networking Clients
socketpair function, socketpair
socketpair syscall, Bidirectional Communication
sockets, Interprocess Communication, Sockets, Sockets, Sockets, Sockets, Networking Servers, Message Passing, Newlines, Perl Functions by Category, accept, bind, close, connect, getpeername, getsockname, listen, recv, send, setsockopt, shutdown, shutdown, socket, Networking and Interprocess Communication
accepting connections from clients, accept
attaching address to, bind
closing, close
closing one side, shutdown
connecting, connect
functions (Perl), dealing with, Sockets
functions for, getsockname
getting packed sockaddr address, getpeername
in interprocess communication, Sockets, Networking Servers, Message Passing
message passing, Message Passing
networking servers, Networking Servers
listen function for, listen
low-level access, functions for, Perl Functions by Category
modules for, Networking and Interprocess Communication
newlines, sending across, Newlines
opening with socket function, socket
protocols and, Interprocess Communication
receiving messages on, recv
sending messages on, send
setting options, setsockopt
shutting down connection, shutdown
TCP and, Sockets
Unix-domain sockets, Sockets
sort, Special Variables in Alphabetical Order
variables, Special Variables in Alphabetical Order
sort function, List Processing
sort subroutines, Some Numeric and String Comparison Operators
comparison operators in, Some Numeric and String Comparison Operators
sort(thinsp;&), Hashes.
keys, lists of, Hashes.
sorting, Access and Printing of a Hash of Arrays, Access and Printing of a Hash of Hashes, Overloadable Operators, keys, sort, sort
arrays in hashes of, Access and Printing of a Hash of Arrays
hashes, Access and Printing of a Hash of Hashes
keys and values, hashes, keys
lists, sort
overloading and, Overloadable Operators
sort function, sort
source code, The Bytecode Generator, Code Development Tools, Using the Debugger, CPAN, Security, Source Filters
CPAN, for Perl distribution, CPAN
development tools for, Code Development Tools
filter for, The Bytecode Generator
filters for, Source Filters
foreign code, executing, Security
window around breakpoint, examining, Using the Debugger
source filters, The CPAN modules Directory
space, Molecules
spaceship operator (<=>), Equality Operators
special characters, The Little Engine That /Could(n't)?/
speed, The Perl Profiler, Efficiency (see efficiency) (see performance)
splice function, Previous Perl Traps, splice
Perl versions, changes in, Previous Perl Traps
splicing tied arrays, Array-Tying Methods
split function, Regular Expressions, Pattern-Matching Operators, Clustering, Time Efficiency, split, Glossary
variable-width fields, extracting with, Glossary
sprintf function, Filehandle-Tying Methods, sprintf
sqrt function (square root), sqrt
srand function, srand
src directory (CPAN), CPAN
stacks, Arrays., Built-in Data Types, Data Structures, Executing Your Code, Using the Debugger, Fiddling with the Perl Stack from C, caller, open
backtracing with T command, Using the Debugger
disciplines, open
expression evaluation, Built-in Data Types
Perl virtuall machine, Executing Your Code
Perl, manipulating from C, Fiddling with the Perl Stack from C
subroutines, current calls, caller
standard input, Command Processing
scripts, passing by, Command Processing
standard Unicode properties, Standard Unicode properties
star, Prototypes (see asterisk)
starting position of matched string, Special Variables in Alphabetical Order
stat, oct
file permissions as octal, oct
stat function, Handling Race Conditions, stat, Filenames, Filesystems, and File Locking
filehandles, calling on, Handling Race Conditions
state, Managing Class Data, Managing Class Data
common, sharing by class objects, Managing Class Data
inheritance with class data accessor methods, Managing Class Data
statements, Simple Statements, Compound Statements, if and unless Statements, if and unless Statements, Global Declarations, Evaluating a Perl Statement from C, Glossary, Glossary
compound, Compound Statements
dangling, Glossary
global declarations and, Global Declarations
if and unless, if and unless Statements
labels for, Glossary (see labels)
loops, if and unless Statements (see loops)
Perl, evaluating from C, Evaluating a Perl Statement from C
simple, Simple Statements
static linking, XS and XSUBs
static scoping, Lexically Scoped Variables: my (see lexical scope)
static variables, Scoping Issues
variables, Scoping Issues
static, Scoping Issues
status of exiting process, Special Variables in Alphabetical Order
STDERR filehandle, Programming with Style, Special Variables in Alphabetical Order, fileno
STDIN, Filehandles
STDIN filehandle, Special Variables in Alphabetical Order, fileno, getc
reading single characters from, getc
STDIN, STDOUT, and STDERR, Networking Servers
reassigning to client connection, Networking Servers
STDIN, STDOUT, and STDERR filehandles, Passing Filehandles, Passing Filehandles
passing filehandles to new programs through, Passing Filehandles
STDOUT, Filehandles
STDOUT filehandle, Special Variables in Alphabetical Order, fileno, print, Glossary
printing to, print
stepping through code, Stepping and Running
sticky bit, Time Efficiency
stopping, for Loops, kill (see terminating)
infinite loop, for Loops
storage locations, Assignment Operators, Glossary, Glossary, Glossary
for bytes, Glossary (see big endian; little endian)
lvalues for, Assignment Operators, Glossary, Glossary
(see also lvalues)
storing complex data values in DBM file, Tie Modules on CPAN
strict module, Simplicities, Perl Language Extensions and Internals
strict pragma, Name Lookups, Controlling the Use of Globals, Symbolic References
string context, Scalar and List Context
string literals, String Literals, String Literals, V-String Literals
newlines in, String Literals
v-strings (vector or version), V-String Literals
stringification, Overloadable Operators
stringifying, Other Tricks You Can Do with Hard References, Other Tricks You Can Do with Hard References, References Don't Work as Hash Keys, Access and Printing, Common Mistakes, Saving Data Structures
data structures, Saving Data Structures
objects, Other Tricks You Can Do with Hard References
references, Other Tricks You Can Do with Hard References, References Don't Work as Hash Keys, Access and Printing, Common Mistakes
stringifying operator, Filehandle-Tying Methods
overloading, Filehandle-Tying Methods
strings, Variable Syntax, Singularities, String Operators, Some Numeric and String Comparison Operators, What Is Truth?, Nailing Things Down, Name Lookups, Scalar Values, Numeric Literals, String Literals, Additive Operators, Relational Operators, Bitwise Operators, Range Operator, Pattern Modifiers, The s/// Operator (Substitution), Modifying strings en passant, Beginnings: The A and ^ Assertions, Other Tricks You Can Do with Hard References, References Don't Work as Hash Keys, Debugger Options, Universal Blunders, Previous Perl Traps, Time Efficiency, Time Efficiency, Special Variables in Alphabetical Order, Special Variables in Alphabetical Order, index, join, lc, oct, oct, oct, pack, print, rindex, split, sprintf, study, substr, unpack, vec, Glossary
binary, oct (see binary numbers)
bitwise operators, working with, Bitwise Operators
boundary assertions, Nailing Things Down, Beginnings: The A and ^ Assertions
breaking, Special Variables in Alphabetical Order (see $: variable)
capitalization of, lc (see capitalization)
comparing, Relational Operators
comparison operators, Some Numeric and String Comparison Operators
as compilation units, Name Lookups
concatenating, Additive Operators, Time Efficiency
containing newlines, matches against, Pattern Modifiers
context of, Glossary
converting to list values, unpack
converting to numbers, Numeric Literals
0x, 0b, and 0 prefixes, handling of, Numeric Literals
display, changing in debugger, Debugger Options
double-quoted, String Literals, Previous Perl Traps
changes in Perl versions, Previous Perl Traps
character interpolation in, String Literals
eval function and, Time Efficiency
extracting substrings, substr
first character of, Special Variables in Alphabetical Order
formats for, sprintf
hexadecimal, oct (see hexadecimal numbers)
index function, index
joining, join
list values, converting to, pack
modifying, Modifying strings en passant
numbers, converting to, Scalar Values
octal, oct (see octal numbers)
operators, String Operators, Universal Blunders
printing, print
printing values in, Other Tricks You Can Do with Hard References
quoted, Singularities
range operator, working with, Range Operator
references and, References Don't Work as Hash Keys
rindex function, rindex
searching for and replacing substrings (s/// operator), The s/// Operator (Substitution)
splitting into substrings, split
study function and, study
truth values of, What Is Truth?
vec function and, vec
stripping, chomp (see deleting characters)
Struct::Class module, Managing Instance Data
structs, pack
formatting, pack
structural metacharacters in regular expressions, The Regular Expression Bestiary
structural metasymbols, Metasymbol Tables
StrVal (overload::StrVal), Public Overload Functions
stubs for modules, generating, Module Installation Support
study function, study
style, programming with, Programming with Style
sub declaration, The anonymous subroutine composer, sub
sub keyword, Syntax, Prototypes
sub {}, Bare Blocks
loop controls and, Bare Blocks
subarrays and subhashes, Arrays.
references to, in arrays, Arrays.
subclasses, Brief Refresher on Object-Oriented Lingo, Managing Instance Data
attributes, overriding superclass ancestors, Managing Instance Data
subnamespaces, for variables, Names
subroutine call stack, caller
subroutine calls, Stepping and Running
executing without stepping through, Stepping and Running
subroutines, Variable Syntax, Singularities, Names, Names, goto, Global Declarations, Global Declarations, Syntax, Syntax, Syntax, Semantics, Semantics, Tricks with Parameter Lists, Error Indications, Scoping Issues, Passing References, Inlining Constant Functions, Care with Prototypes, The anonymous subroutine composer, Nested subroutines, Symbol Tables, Symbol Tables, Autoloading, Perl's Object System, Method Invocation, Package-Quoted Classes, Inheritable Constructors, Class Inheritance, Method Autoloading, New Tricks, Locking subroutines, The locked attribute, Code Development Tools, Avant-Garde Compiler, Retro Interpreter, Locating Code, Extending Perl (Using C from Perl), Calling a Perl Subroutine from C, Previous Perl Traps, Previous Perl Traps, Time Efficiency, External Subroutines (XS), Special Variables in Alphabetical Order, do (subroutine), exit, goto, localtime, my, return, sub, Perl Language Extensions and Internals, Module Installation Support, Glossary
aborting with exit, exit
anonymous, The anonymous subroutine composer
references to, The anonymous subroutine composer
arguments, Special Variables in Alphabetical Order
atrributes, getting and setting, Perl Language Extensions and Internals
autoloading, Autoloading, Module Installation Support
B::Xref module, cross-references with C, Code Development Tools
barewords, confusing with, Previous Perl Traps
calling indirectly, Syntax
calling, method invocations vs., Inheritable Constructors
classes with same names, Package-Quoted Classes
constant, Symbol Tables
debugger command for pattern match listings, Locating Code
declaring, Global Declarations, sub
declaring in package for AUTOLOAD management, Method Autoloading
defining, Semantics
definitions, loading from other files, Global Declarations
do SUBROUTINE operator, do (subroutine)
errors, indicating, Error Indications
executing, Glossary
external, External Subroutines (XS)
portability of, External Subroutines (XS)
external (XSUBs), Extending Perl (Using C from Perl)
importing from another module, Syntax
lexically scoped, my
locking for threads, Locking subroutines, The locked attribute
locked attribute, The locked attribute
lvalue attribute, New Tricks
method resolution, steps for, Class Inheritance
methods vs., Method Invocation
named, compiler/interpreter interaction, Avant-Garde Compiler, Retro Interpreter
names for, Names, Names
names of, Syntax
nested, Nested subroutines
parameter lists, working with, Tricks with Parameter Lists
passing references in, Passing References
performance and, Time Efficiency
Perl, calling from C, Calling a Perl Subroutine from C
prototyping, careful use of, Care with Prototypes
redefining, inlining and, Inlining Constant Functions
references to, Symbol Tables
retrieving from or passing to, Symbol Tables
references to, in scalars, Singularities
return function, return
return values, Semantics
scoping issues, Scoping Issues
sorting, reverse disallowed as name for, Previous Perl Traps
substituting with goto, goto, goto
timelocal, localtime
subs module, Perl Language Extensions and Internals
subs pragma, Overriding Built-in Functions
overriding built-in functions with, Overriding Built-in Functions
$SUBSCRIPT_SEPARATOR, Hashes
subscript separator, Special Variables in Alphabetical Order (see $; variable)
subscripting, Built-in Data Types, Time Efficiency, Glossary
negative, Built-in Data Types
subscripts, arrays, Arrays.
$SUBSCRIPT_SEPARATOR, Special Variables in Alphabetical Order
subshells, environment variables, using with, Environment Variables
substitute (s//) operator, Universal Blunders
substitution (s///) operator, Pattern-Matching Operators
substitution evaluations, Substitution evaluations
substitution, shells versus Perl, Shell Traps
substr function, Positions, Time Efficiency, chop, substr
chop function and, chop
manipulating string positions with, Positions
substrings, The s/// Operator (Substitution), Glossary
searching for and replacing with s/// operator, The s/// Operator (Substitution)
subtracting pattern modifiers from cloisters, Cloistered Pattern Modifiers
subtracting, from character sets, Defining your own character properties
subtraction, Additive Operators, Overload Handlers (see additive operators)
overloaded objects, Overload Handlers
SUPER pseudoclass, Accessing Overridden Methods
superclasses, Brief Refresher on Object-Oriented Lingo
superuser, Glossary
SV (internal scalar value), Internal Data Types
SWIG, XS and XSUBs
SWIG system, XS and XSUBs
XSUBs, automatically generating, XS and XSUBs
switch statement, C Traps, Time Efficiency, Glossary
Perl vs. C programming, C Traps
switches, Functions
-w switch, Functions
switches, command-line, Command Processing, Command Processing, Switches, Environment Variables, Option, Argument, Parameter, and Configuration File Processing
-e switches, Command Processing
default, taking switches as, Environment Variables
single character, processing with clustering, Option, Argument, Parameter, and Configuration File Processing
symbol table entries, Typeglobs and Filehandles
aliasing, Typeglobs and Filehandles
symbol tables, Names, Names, Names, Dynamically Scoped Variables: local, What Is a Reference?, Symbol Table References, Packages, Packages, Symbol Tables, Symbol Tables, Debugger Options, format, package, Data Types
containing references to other symbol tables, Symbol Tables
current package, determining use of, Packages
displaying for packages, Debugger Options
format name identifiers in, format
in fully qualified names, Names
local operator, making temporary changes with, Dynamically Scoped Variables: local
for packages, Packages, package
references to, Symbol Table References
Symbol module, Data Types
symbolic references naming entries in, What Is a Reference?
symbolic debugging, Glossary, Glossary
(see also debugging)
symbolic dereferences, Controlling the Use of Globals
checking with strict pragma, Controlling the Use of Globals
symbolic links, Unix Kernel Security Bugs, lstat, readlink, symlink
getting filenames from, readlink
lstat function and, lstat
security risks in Unix, Unix Kernel Security Bugs
symbolic references, What Is a Reference?, Symbolic References, Glossary
symbols, Wildcard Metasymbols, Using Modules, Creating Modules, Module Privacy and the Exporter
exporting from modules, Creating Modules
importing into current package, Using Modules
leaving off export list or deleting from import list, Module Privacy and the Exporter
metasymbols, generic wildcards, Wildcard Metasymbols
symbols, exporting, Managing unknown symbols
prevention of, Managing unknown symbols
symlink function, symlink
synchronization, Synchronizing access with lock, Glossary
data access in threads, Synchronizing access with lock
syntactic sugar, Glossary
syntax, Glossary
syntax, checking, Switches
syntax, Perl, Built-in Data Types
Sys::Hostname module, Operating System Interfaces
Sys::Syslog module, Operating System Interfaces
syscall function, alarm, syscall
syscalls, Reaping Zombies, C Traps, Time Efficiency, ioctl, Glossary
ioctl and fcntl returns, ioctl
performance and, Time Efficiency
Perl, C language vs., C Traps
signal interruption of, Reaping Zombies
syslog, filehandle tying to, Tie Modules on CPAN
sysopen command, Handling Race Conditions
file overwriting, controlling, Handling Race Conditions
sysopen function, File Locking, Named Pipes, open, sysopen
sysread function, Filehandle-Tying Methods, sysread
system calls, syscall
system function, Code Masquerading as Data, Time Efficiency, Interprocess Communication (IPC), system
list argument form, avoiding shell with, Code Masquerading as Data
performance and, Time Efficiency
portability of, Interprocess Communication (IPC)
System V IPC, System V IPC, Interprocess Communication (IPC), Perl Functions by Category, kill, msgctl, semctl, shmctl, Networking and Interprocess Communication
functions dealing with, Perl Functions by Category
functions for semaphores, semctl
IPC::SysV module, Networking and Interprocess Communication
killing proces groups, kill
messages, syscalls for, msgctl
portability of, Interprocess Communication (IPC)
shared memory, functions for, shmctl
System V IPC syscalls, Interprocess Communication, Reaping Zombies
reliable signals, not supporting, Reaping Zombies
$SYSTEM_FD_MAX, Special Variables in Alphabetical Order
syswrite function, Tying Filehandles, Filehandle-Tying Methods, syswrite

T

-T (taint checking) switch, Sockets, Networking Servers, Handling Insecure Data
-T (taint checking) command-line switch, Switches
tables, Arrays of Arrays
(see also multidimensional arrays)
tags (HTML and XML), transforming text to, Defining Your Own Assertions
tags, symbol sets, Exporter, Tag-handling utility functions
taint, Security, Handling Insecure Data, Handling Insecure Data, Handling Insecure Data, Handling Insecure Data, Detecting and Laundering Tainted Data, Handling Insecure Code, Perl Functions in Alphabetical Order
functions returning tainted data, Perl Functions in Alphabetical Order
taint checking code, Handling Insecure Code
taint checks, Handling Insecure Data
taint mode, Handling Insecure Data, Handling Insecure Data, Handling Insecure Data
automatic enabling of, Handling Insecure Data
enabling explicitly with -T switch, Handling Insecure Data
programs needing to run with, Handling Insecure Data
taint mode, using, Security
tainted data, detecting and laundering, Detecting and Laundering Tainted Data
taint checking, Networking Servers, Switches, Glossary
taintperl program, Previous Perl Traps
tan function, atan2
tangent, atan2
tarballs (.tar.gz files), Using CPAN Modules
(see also tar files)
TCP, Sockets, Glossary
over Internet-domain sockets, Sockets
tee program, Unix, Creative Filehandles
tell function, Filehandle-Tying Methods, tell
using on tied filehandle, Filehandle-Tying Methods
telldir function, telldir
templates, characters for pack/unpack, pack
templates, strings, pack
temporary files, security risks with, Temporary Files, Temporary Files
temporary values, Built-in Data Types
Tengwar script, Effects of Character Semantics
Term::Cap module, User Interfaces
Term::Complete module, User Interfaces
Term::ReadKey modlue, getc
Term::ReadKey module, Editor Support for Debugging
Term::ReadLine module, Editor Support for Debugging, User Interfaces
Term::Rendezvous module, Unattended Execution
terminal, setting for debugging I/O, Unattended Execution
terminating, for Loops, kill
infinite loop, for Loops
processes, kill
terms, Unary and Binary Operators, Terms and List Operators (Leftward), Glossary
precedence of, Terms and List Operators (Leftward)
relationships among, expressing with operators, Unary and Binary Operators
terms in Perl, Built-in Data Types
ternary operators, Unary and Binary Operators (see trinary operator)
test command (Unix), How to Do It
Test module, Development Support
test operators (files), Some File Test Operators
test.pl, Creating Extensions, XSUB Input and Output
Test::Harness module, Development Support
testing, defined
if defined, defined
testing modules, Creating CPAN Modules, Internal Testing, External Testing
external testing, External Testing
internal testing, Internal Testing
text, Names, Pattern Matching, Accessing Formatting Internals, Unicode, String Processing, Language Text Processing, Parsing, and Searching, Documentation Support
lexical scope and, Names
Perl modules for, String Processing, Language Text Processing, Parsing, and Searching
pod data, converting to formatted ASCII, Documentation Support
processing, Perl capabilities, Pattern Matching
Unicode as international medium for, Unicode
wrapping, Accessing Formatting Internals
text editors, scripts, entering into, How to Do It
text files, -T (file test) operator, Some File Test Operators
Text::Abbrev module, String Processing, Language Text Processing, Parsing, and Searching
Text::ParseWords module, String Processing, Language Text Processing, Parsing, and Searching
Text::Wrap module, String Processing, Language Text Processing, Parsing, and Searching
Thread method, Thread creation
thread model, Data Access, Condition variables
control, passing between threads, Condition variables
data access, Data Access
Thread module, The Thread Module, Yielding the processor, Thread creation, Thread destruction, Catching exceptions from join, The detach method, Identifying threads, Yielding the processor
detach method, shutting down threads with, The detach method
identifying threads, Identifying threads
join method, catching exceptions from, Catching exceptions from join
thread creation, Thread creation
thread destruction, Thread destruction
yielding the processor, Yielding the processor
Thread::Queue module, Queues
Thread::Semaphore module, The Thread Model, Condition variables, Semaphores
Thread::Signal module, Other standard threading modules
threads, New Tricks, Threads, The Process Model, The Thread Model, Other standard threading modules, Executing Your Code, lock, lock
locked and method attributes, using, New Tricks
locking, lock
multiple, in single interpreter, Executing Your Code
process model, The Process Model
thread model, The Thread Model, Other standard threading modules
tid method, Identifying threads
tie function, Tied Variables, tie
use or require declarations and, Tied Variables
tie modules on CPAN, Tie Modules on CPAN
Tie::Array module, Tying Arrays, Array-Tying Methods, Convenient Classes
SPLICE subroutine, using, Array-Tying Methods
Tie::Counter module, Magical Counter Variables
Tie::DBI module, Tie Modules on CPAN
Tie::DevNull module, Creative Filehandles
Tie::DevRandom module, Creative Filehandles
Tie::Hash module, Tying Hashes, Convenient Classes
Tie::Persistent module, Tie Modules on CPAN
Tie::RefHash module, Convenient Classes
Tie::Scalar module, Tying Scalars, Convenient Classes
Tie::SecureHash module, Using Closures for Private Objects, Tie Modules on CPAN
Tie::StdArray module, Tying Arrays
Tie::StdHash module, Tying Hashes
Tie::StdScalar module, Tying Scalars
Tie::SubstrHash module, Convenient Classes
Tie::Syslog module, Tie Modules on CPAN
Tie::Tee module, Creative Filehandles
Tie::VecArray module, Tie Modules on CPAN
Tie::Watch module, Tie Modules on CPAN
tied function, Tied Variables, tied
tilde, home directory expansion of, glob
time, Message Passing, Perl Functions by Category, gmtime, localtime, sleep, stat, time, utime, Data Types
file access/modification, stat, utime
Greenwich Mean (GMT), gmtime
for local timezone, localtime
Perl functions for, Perl Functions by Category
sleeping, sleep
Time::Local module, Data Types
UDP program, getting from other machines, Message Passing
time base ($^T), Special Variables in Alphabetical Order
time function, time, Data Types
Time::gmtime module, Operating System Interfaces
Time::localtime module, Operating System Interfaces
Time::tm module, Operating System Interfaces
timelocal subroutine, localtime
Timer::HiRes module, alarm
times function, times
times, portability of, Dates and Times
timing, The Perl Profiler, The Perl Profiler, Handling Timing Glitches, Handling Race Conditions, Temporary Files, Temporary Files, alarm, Benchmark, Benchmark
with alarms, alarm
comparing for subroutines' execution, The Perl Profiler, The Perl Profiler
glitches in, Handling Race Conditions
race conditions, handling, Handling Race Conditions
glitches, handling, Handling Timing Glitches, Temporary Files, Temporary Files
temporary files, Temporary Files, Temporary Files
running times of alternate code versions, comparing, Benchmark, Benchmark
timing out slow operations, Timing Out Slow Operations
titlecase, The tr/// Operator (Transliteration), Effects of Character Semantics
ucfirst, translating to, Effects of Character Semantics
u and ucfirst function, using in conversions, The tr/// Operator (Transliteration)
Tk, User Efficiency
(see also Perl/Tk)
tkRunning option (debugger), Debugger Options
toggling trace mode (debugger), Tracing
tokenization, How Perl Works
(see also lexical analysis)
tokens, Molecules, Named Unary and File Test Operators, Compiling Your Code, String Processing, Language Text Processing, Parsing, and Searching
ambiguous characters, problems with, Named Unary and File Test Operators
parsing text into list of, String Processing, Language Text Processing, Parsing, and Searching
top-level package, Name Lookups
top-of-form processing, Formats, select (output filehandle), write
top-of-page processing, Special Variables in Alphabetical Order
topicalization, Simplicities
tr/// (transliteration) operator, Pattern-Matching Operators, Pattern-Matching Operators, Pattern Modifiers, The tr/// Operator (Transliteration), Effects of Character Semantics, tr///, //
=~ and !~ binding operators, using with, Pattern-Matching Operators
characters, transliterating with, Effects of Character Semantics
modifiers for, Pattern Modifiers
tracing, stack backtrace (debugger command), Using the Debugger
trailing spaces in string comparisons, Relational Operators
translating between languages, Generating Perl in Other Languages
translation, tr///, //
transliteration escapes, processing by Perl regex compiler, When backslashes happen
trapping, eval
exceptions, eval
trapping out-of-memory errors, Special Variables in Alphabetical Order
trapping signals, Signals
trigonometry, Math::Trig module, Data Types
trinary operator, Unary and Binary Operators, Conditional Operator, Case Structures, The overload Pragma, Glossary
?: as, Conditional Operator, Case Structures
overloading, not working with, The overload Pragma
trinary operators, Operators
troff, Glossary
troubleshooting, The Perl Debugger, Common Goofs for Novices, C Traps, Shell Traps
(see also debugging)
C code, C Traps
scripts, Common Goofs for Novices
common mistakes of novices, Common Goofs for Novices
shell code, Shell Traps
true values, Singularities, Glossary
truncate function, truncate
truncating, Glossary
truncating argument list, Debugger Options
truncating arrays, Array Length
truncating numbers, int
truth conditions, The if and unless statements
if and unless statements, evaluating with, The if and unless statements
truth values, What Is Truth?
evaluating for in Perl, What Is Truth?
try block, eval
tty, Bidirectional Communication
two-dimensional arrays, Creating and Accessing a Two-Dimensional Array, Growing Your Own
creating and accessing, Creating and Accessing a Two-Dimensional Array
creating your own, Growing Your Own
tying variables, References Don't Work as Hash Keys, Tied Variables, Tying Scalars, Tying Arrays, Tying Hashes, Tying Filehandles, A Subtle Untying Trap, Tie Modules on CPAN
arrays, Tying Arrays
filehandles, Tying Filehandles
hashes, Tying Hashes
scalars, Tying Scalars
untying trap, A Subtle Untying Trap, Tie Modules on CPAN
typecasting operator (in C), C Operators Missing from Perl
typedefs (C language), Internal Data Types, Glossary
typeglob, Variable Syntax, Variable Syntax
prototype symbol (*), Variable Syntax
typeglobs, Names, Typeglobs and Filehandles, Handle References, Handle References, Handle References, Symbol Table References, Other Tricks You Can Do with Hard References, Symbol Tables, Symbol Tables, Method Invocation, Tied Variables, Filehandle-Tying Methods, Debugger Options, local, Data Types
anonymous, Handle References, Data Types
generating with Symbol module, Data Types
autovivification of, Filehandle-Tying Methods
filehandle references, creating, Handle References
IO::Handle object, Symbol Table References
local function, using with, local
printing contents of, Debugger Options
references to typeglobs vs., Handle References
subroutines, resolving to, Method Invocation
symbol table aliasing with, Symbol Tables
in symbol table hashes, Symbol Tables
variables, tying to classes via, Tied Variables
typemap, XS and XSUBs
types, Typeglobs and Filehandles (see data types)
typing variables, Scalar Values, Scalar Values
scalars, Scalar Values
subtypes, converting between, Scalar Values

U

-u (dump core) command-line switch, Switches
u escape, The s/// Operator (Substitution)
-U (unsafe) command-line switch, Switches
uc function, uc
uc operator, Effects of Character Semantics
ucfirst function, ucfirst
ucfirst operator, Effects of Character Semantics
UDP, Message Passing, Glossary
passing messages with, Message Passing
UDP packets, Sockets
$uid file statistic, stat
UID (user ID), Talking to Yourself, Special Variables in Alphabetical Order, chown, getpwuid
(see also $< and $> variables)
assumed, Talking to Yourself
passwd file entry from, getpwuid
umask function, umask, Glossary
unary operators, Operators, Unary Arithmetic Operators, Some File Test Operators, Unary and Binary Operators, Unary and Binary Operators, Terms and List Operators (Leftward), Terms and List Operators (Leftward), Ideographic Unary Operators, Named Unary and File Test Operators, Named Unary and File Test Operators, Named Unary and File Test Operators, Care with Prototypes, The overload Pragma
arithmetic, Unary Arithmetic Operators
Boolean, Some File Test Operators
class handler, invoking, The overload Pragma
functions, behaving as, Terms and List Operators (Leftward)
ideographic, Ideographic Unary Operators
list operators, distinguishing from, Named Unary and File Test Operators
named, Terms and List Operators (Leftward), Named Unary and File Test Operators, Named Unary and File Test Operators
listing of, Named Unary and File Test Operators
prototyping functions as, Care with Prototypes
undef (value), List Assignment, defined
undef function, Array Length, Time Efficiency, undef
arrays, freeing memory from, Array Length
undefined scalars, Scalar Values
undefined subroutines, calling with AUTOLOAD, Autoloading
Underscore module, Magically Banishing $_
unequal, Equality Operators (see equality operators; relational operators)
Unicode, Atoms, Molecules, Molecules, The tr/// Operator (Transliteration), Wildcard Metasymbols, Character Classes, Classic Perl Character Class Shortcuts, Unicode Properties, Defining your own character properties, Unicode Properties, Perl's Unicode properties, Standard Unicode properties, Standard Unicode properties, Standard Unicode properties, Standard Unicode properties, Unicode block properties, Unicode, Effects of Character Semantics, Effects of Character Semantics, Effects of Character Semantics, Effects of Character Semantics, Effects of Character Semantics, Caveats, chr, chr, lc, Internationalization and Locale
case translation tables, Effects of Character Semantics
converting to characters, chr
editors for, Effects of Character Semantics
information about, Unicode Properties
line separator character, Molecules
locales and, lc
paragraph separator character, Molecules
Perl properties for, Character Classes
properties, Classic Perl Character Class Shortcuts, Unicode Properties, Defining your own character properties, Perl's Unicode properties, Standard Unicode properties, Standard Unicode properties, Standard Unicode properties, Standard Unicode properties, Unicode block properties
bidirectional rendering, Standard Unicode properties
block properties, Unicode block properties
decomposition of characters, Standard Unicode properties
Perl character class shortcuts and, Classic Perl Character Class Shortcuts
Perl composites, Perl's Unicode properties
standard, Standard Unicode properties
syllabaries, classifying by vowel sounds, Standard Unicode properties
properties database, Effects of Character Semantics
smiley face, chr
summary of, accessing, Effects of Character Semantics
support for, turning on, Internationalization and Locale
titlecase, converting strings to, The tr/// Operator (Transliteration)
Unicode Standard, Version 3.0, Effects of Character Semantics
use in Perl, caveats on, Caveats
wildcard metasymbols, matching with, Wildcard Metasymbols
Unicode characters, Regular Expressions, Names, String Literals
in identifiers, Names
smiley, String Literals
uninitialized, variables, Singularities
UNIVERSAL class, UNIVERSAL: The Ultimate Ancestor Class, UNIVERSAL: The Ultimate Ancestor Class
methods, adding to, UNIVERSAL: The Ultimate Ancestor Class
UNIVERSAL module, Convenient Classes
Unix, Command Processing, Glossary
truncating kernel interpretation of #! line, Command Processing
Unix operating system, How to Do It
test command, test scripts and, How to Do It
Unix system, Decompressing and Unpacking CPAN Modules
CPAN modules, installing on, Decompressing and Unpacking CPAN Modules
Unix systems, Singularities, Filenames, Filesystems, and File Locking, Filenames, Filesystems, and File Locking, Networking and Interprocess Communication
File::Spec::Unix module, Filenames, Filesystems, and File Locking
fileglobbing, Filenames, Filesystems, and File Locking
sockets for, Networking and Interprocess Communication
unless modifier, Simple Statements
unless statements, The if and unless statements, if and unless Statements
if statements, using instead of, if and unless Statements
unlink function, unlink
unlink operator, Boolean Context
unordered lists, Hashes. (see hashes)
unpack, Endianness and Number Width
unpack function, pack, unpack, Glossary
fixed-width fields, use with, Glossary
template characters for, pack
unpacking CPAN modules, Decompressing and Unpacking CPAN Modules
unqualified, names, searching for, Name Lookups
unsafe operations, Switches
unshift function, Data Structures
unsigned integers, lists of, storing, vec
unsigned shorts, sprintf
untie function, Tying Scalars, A Subtle Untying Trap, dbmclose, untie
outstanding references, not eliminating, Tying Scalars
until modifier, Simple Statements
untying trap, A Subtle Untying Trap, Tie Modules on CPAN
up method, Semaphores
upcase function, Tricks with Parameter Lists
uppercase, converting to, String Literals, The s/// Operator (Substitution)
use, Global Declarations, Scoped Declarations
global and lexical scoping of, Scoped Declarations
use attributes pragma, Subroutine Attributes
use base declarations, Inheritance Through @ISA, Field Declarations with use fields
pseudohash implementations, requirement with, Field Declarations with use fields
use base pragma, use base
use blib pragma, use blib
use bytes pragma, Effects of Character Semantics
use charnames pragma, Effects of Character Semantics
use command, Packages
use declaration, Using Modules
modules, Using Modules
use declarations, Simplicities, Global Declarations, Pragmas, Tied Variables, Frequently Ignored Advice
(see also pragmas)
tie function and, Tied Variables
use strict, Frequently Ignored Advice
use fields declarations, Inheritance Through @ISA
use filetest pragma, Named Unary and File Test Operators
use overload pragma, The overload Pragma
use statement, How Perl Works
use subs declarations, Method Autoloading
use utf8 pragma, Wildcard Metasymbols
use warnings pragma, The Perl Debugger
user efficiency, Perl programming, User Efficiency
user ID, chown (see UID)
user interfaces, modules providing, User Interfaces
User::grent module, getgrent, Operating System Interfaces
User::pwent module, getpwuid, Operating System Interfaces, Class::Struct
Class::Struct, using to create objects and accessors, Class::Struct
username, passwd file entry from, getpwnam
users, The CPAN modules Directory, Handling Insecure Data, times, Glossary, Glossary
authenticating, Perl modules for, The CPAN modules Directory
CPU times, times
granting limited privileges to, Handling Insecure Data
groups of, Glossary, Glossary
(see also GID; groups)
users, information about, functions for getting, Perl Functions by Category
UTF-8, Atoms, Building Character
variable-length character encoding, Building Character
UTF-8 characters, Effects of Character Semantics
converting to integers, Effects of Character Semantics
utf8, Special Variables in Alphabetical Order
globally switching interfaces to, Special Variables in Alphabetical Order
utf8 (Perl version), Building Character
utf8 module, Internationalization and Locale
utf8 pragma, Effects of Character Semantics
utf8 strings, converting to/from byte strings, Building Character
utime function, utime
utmp file, getnetent (see /etc/utmp file)
UV (internal unsigned integer value), Internal Data Types

V

-v (version) command-line switch, Switches
v-strings, Special Variables in Alphabetical Order
in $^V, Special Variables in Alphabetical Order
v-strings (vector or version), V-String Literals, Glossary
-V (version) command-line switch, Switches
values, Natural and Artificial Languages, What Is Truth?, Scalar Values, List Values and Arrays, Scoped Variable Declarations, What Is a Reference?, keys, undef, Glossary
changing while copying, Glossary
hashes, sorting, keys
list, List Values and Arrays (see list values)
referencing, What Is a Reference?
scalar, Scalar Values (see scalar values)
scope, confining to, Scoped Variable Declarations
undefined, truth value of, What Is Truth?
undefining, undef
variables vs., Natural and Artificial Languages
values function, Hash-Tying Methods, values
variable, C Traps
Perl, C language vs., C Traps
variable interpolation, String Literals, Filename Globbing Operator
glob operator, using, Filename Globbing Operator
variable-length records, Formats
variable-length UTF-8 characters, Building Character
variables, Natural and Artificial Languages, Singularities, Singularities, Simplicities, Assignment Operators, Built-in Data Types, Variables, Names, Names, Hashes, Terms and List Operators (Leftward), Statements and Declarations, Lexically Scoped Variables: my, Pattern-Matching Operators, Pattern-Matching Operators, Modifying strings en passant, The tr/// Operator (Transliteration), Variable Interpolation, The qr// quote regex operator, Variable Interpolation, Scoping Issues, Format Variables, Anonymous Data, Using a Variable as a Variable Name, Other Tricks You Can Do with Hard References, Packages, Packages, Packages, Symbol Tables, Module Privacy and the Exporter, Managing Class Data, Tying Scalars, Tying Arrays, Tying Hashes, Tying Filehandles, A Subtle Untying Trap, Tie Modules on CPAN, Tie Modules on CPAN, Condition variables, Code Development Tools, Display, Customizing with Init Files, Debugger Options, Handling Insecure Data, Restricting namespace access, Universal Blunders, Frequently Ignored Advice, C Traps, Shell Traps, Programming with Style, Special Variables in Alphabetical Order, local, my, my, reset, tie, untie, Perl Language Extensions and Internals, Glossary
(see also data types)
anonymous, Anonymous Data
attributes, getting and setting, Perl Language Extensions and Internals
B::Xref module, cross-references with C, Code Development Tools
binding to packages, untie
class, Managing Class Data
condition variables, Condition variables
debugger, customizing, Customizing with Init Files
declaring, Statements and Declarations
dumping with V command, Symbol Tables
environment, Special Variables in Alphabetical Order
format, Format Variables
fully-qualified, accessing from outside package, Restricting namespace access
global, Glossary (see global)
hash, Hashes
initializing before calling subroutines, Scoping Issues
interpolating, Pattern-Matching Operators, Pattern-Matching Operators
with double quotes, Pattern-Matching Operators
into patterns, Pattern-Matching Operators
interpolation, Singularities, Variable Interpolation, The qr// quote regex operator
pattern matching, controlling with, Variable Interpolation, The qr// quote regex operator
lexical scoping, my
local, Universal Blunders, Frequently Ignored Advice
common programming errors with, Universal Blunders
my declarations, using instead of local function, Frequently Ignored Advice
localizing existing, local
modules, exporting to programs, Module Privacy and the Exporter
my, Other Tricks You Can Do with Hard References, Packages (see my declarations)
names for, Programming with Style
names in nested symbol tables, Names
our, Packages (see our declarations)
package variables, Names
package, displaying, Display
package, memory usage, Debugger Options
packages, associating with, Packages
Perl vs. C, names of, C Traps
private, my (see local variables)
repeated substitutions, performing on, Modifying strings en passant
resetting values of, reset
scoped, Lexically Scoped Variables: my
lexical scope, Lexically Scoped Variables: my
scoping, strict pragma, use of, Simplicities
shell programming, Perl vs., Shell Traps
strings of, matching against known strings, Variable Interpolation
taint and, Handling Insecure Data
translating with, The tr/// Operator (Transliteration)
tying, Tying Scalars, Tying Arrays, Tying Hashes, Tying Filehandles, A Subtle Untying Trap, Tie Modules on CPAN, tie
arrays, Tying Arrays
filehandles, Tying Filehandles
hashes, Tying Hashes
scalars, Tying Scalars
untying trap, A Subtle Untying Trap, Tie Modules on CPAN
uninitialized, Singularities
values vs., Natural and Artificial Languages
values, assignment and, Assignment Operators
watch points, placing on, Tie Modules on CPAN
variadic functions in Perl, Semantics
vars modle (obsolete), Perl Language Extensions and Internals
vec function, vec
vectors, strings as, sprintf, vec
verbosity, Debugger Options, Perl Language Extensions and Internals
debugger, setting levels of, Debugger Options
warnings, forcing in, Perl Language Extensions and Internals
verbs, Verbs
verbs, packages, handling of, Simplicities
version, Version checking, Command Processing, Location of Perl, Special Variables in Alphabetical Order
module, checking for, Version checking
of Perl, Command Processing
placing in #! line, Command Processing
of Perl ($^V), Special Variables in Alphabetical Order
of Perl, Location of Perl
specifying, Location of Perl
VERSION method, UNIVERSAL: The Ultimate Ancestor Class
version, Perl, Special Variables in Alphabetical Order
versions, Previous Perl Traps, Previous Perl Traps
Perl, Previous Perl Traps, Previous Perl Traps
changes between release 4 and 5, Previous Perl Traps, Previous Perl Traps
vi editor, Regular Expressions, Editor Support for Debugging
debugger, support for, Editor Support for Debugging
regular expressions, use of, Regular Expressions
virtual circuits (as TCP streams), Sockets
virtual machine, Perl, Executing Your Code
VMS operating system, #! and Quoting on Non-Unix Systems, Filenames, Filesystems, and File Locking
File::Spec::VMS module, Filenames, Filesystems, and File Locking
invoking Perl applications on, #! and Quoting on Non-Unix Systems
void context, Unary Arithmetic Operators, List Assignment, Using the Debugger, wantarray, Glossary
recognizing in debugger, Using the Debugger
vowel sounds, classifying syllabaries according to, Standard Unicode properties

W

-w command-line switch, Switches
w forward character=w (forward character), Regular Expressions
-w switch, Perl, Special Variables in Alphabetical Order, Diagnostic Messages
wait function, wait
wait system call, Special Variables in Alphabetical Order
waitpid function, waitpid
wantarray function, wantarray
warn function, warn
$WARNING, Special Variables in Alphabetical Order
warning messages, How to Do It, Switches, Special Variables in Alphabetical Order, warn, Diagnostic Messages
-w switch, turning on with, How to Do It
intercepting, Special Variables in Alphabetical Order
warnings, Statements and Declarations, A Subtle Untying Trap, Switches, Special Variables in Alphabetical Order, Perl Language Extensions and Internals, Warnings and Exceptions, Glossary
about undefined values, Statements and Declarations
disabling unconditionally and permanently, Switches
lexical; ${^WARNING_BITS}, Special Variables in Alphabetical Order
modules for, Warnings and Exceptions
about remaining references to tied objects, A Subtle Untying Trap
verbosity, forcing in, Perl Language Extensions and Internals
warnings module, Warnings and Exceptions
warnings pragma, Controlling Warnings
${^WARNING_BITS}, Special Variables in Alphabetical Order
warnLevel option (debugger), Debugger Options
watch expressions, Tracing, Glossary
watch points, placing on Perl variables, Tie Modules on CPAN
WeakRef module, Garbage Collection with DESTROY Methods
web, Perl modules for, World Wide Web
while loop, eof
eof function in, eof
while loops, The while and until statements
while modifier, Simple Statements
while statements, Logical Operators, Boolean Context
Boolean context, supplying, Boolean Context
whitespace, Regular Expressions, Molecules, Pick Your Own Quotes, "Here" Documents, Pattern Modifiers, Modifying strings en passant, Programming with Style, Functions, Glossary
cononicalizing in a variable, Modifying strings en passant
leading, removing in here documents, "Here" Documents
quote characters, use in, Pick Your Own Quotes
/x modifier in pattern matching, Pattern Modifiers
whitespace characters, Formats
in formats, Formats
whitespaces, Previous Perl Traps
use as variable name or delimiter for quote construct, changes in, Previous Perl Traps
wide character APIs, enabling Perl use of on target system, Switches
wide, syscalls, Special Variables in Alphabetical Order
wide-character APIs, system calls using, Building Character
${^WIDE_SYSTEM_CALLS}, Special Variables in Alphabetical Order
width, Building Character, Endianness and Number Width
character representation, Building Character
of numbers, Endianness and Number Width
wildcard metasymbols, Wildcard Metasymbols, Custom Character Classes, Custom Character Classes
character classes and, Custom Character Classes, Custom Character Classes
Win32::ChangeNotify module, Microsoft-Related Modules
Win32::Console module, Microsoft-Related Modules
Win32::Event module, Microsoft-Related Modules
Win32::EventLog module, Microsoft-Related Modules
Win32::File module, Microsoft-Related Modules
Win32::FileSecurity module, Microsoft-Related Modules
Win32::Internet module, Microsoft-Related Modules
Win32::IPC module, Microsoft-Related Modules
Win32::Mutex module, Microsoft-Related Modules
Win32::NetAdmin module, Microsoft-Related Modules
Win32::NetResource module, Microsoft-Related Modules
Win32::ODBC module, Microsoft-Related Modules
Win32::OLE module, Microsoft-Related Modules
Win32::OLE::Const module, Microsoft-Related Modules
Win32::OLE::Enum module, Microsoft-Related Modules
Win32::OLE::NLS module, Microsoft-Related Modules
Win32::OLE::Variant module, Microsoft-Related Modules
Win32::PerfLib module, Microsoft-Related Modules
Win32::Pipe module, Named Pipes
Win32::Process module, Microsoft-Related Modules
Win32::Semaphore module, Microsoft-Related Modules
Win32::Service module, Microsoft-Related Modules
Win32::Sound module, Microsoft-Related Modules
Win32::TieRegistry module, Tie Modules on CPAN, Microsoft-Related Modules
Win32API::File module, Microsoft-Related Modules
Win32API::Net module, Microsoft-Related Modules
Win32API::Registry module, Microsoft-Related Modules
word character, Regular Expressions
word lists, List Values and Arrays
words, Nailing Things Down, The m// Operator (Matching), User Interfaces, Glossary
b assertion= assertion, Nailing Things Down
capturing, The m// Operator (Matching)
lists of, doing programmable command completion on, User Interfaces
World Wide Web, Usenet Newsgroups
World Wide Web (WWW), World Wide Web (see web)
wrappers, Unix Kernel Security Bugs, Glossary
C, around set-id scripts, Unix Kernel Security Bugs
wrapping text, Accessing Formatting Internals, String Processing, Language Text Processing, Parsing, and Searching
writable file test operator, Some File Test Operators
write function, format, write
format function, declaring named sequence of picture lines, format
writing, Switches, print, printf, shmwrite, syswrite, write
data via low-level system call, print, printf, syswrite, write
scripts, Switches (see scripts)
to shared memory segment ID, shmwrite
writing to files, open
open mode and, open

X

x (repetition operator), String Operators
x (repetition) operator, Multiplicative Operators
-x (extract program) command-line switch, Command Processing, Switches
/x pattern modifier, The m// Operator (Matching), The s/// Operator (Substitution)
/x pattern modifier, Pattern Modifiers, Pattern Modifiers
-X (warning disabling) command-line switch, Switches
X wildcard metasymbol, Wildcard Metasymbols
x=, Assignment Operators
(assignment) operator, Assignment Operators
Xor logical operator, Logical Operators
xor logical operator, Bitwise Operators, Logical and, or, not, and xor
XS language, Extending Perl (Using C from Perl), External Subroutines (XS), Perl Language Extensions and Internals
code, portability of, External Subroutines (XS)
debugging tools for, Perl Language Extensions and Internals
external subroutines, wrapping, Extending Perl (Using C from Perl)
XSLoader module, Module Installation Support
XSUBs, Extending Perl (Using C from Perl), Extending Perl (Using C from Perl), XSUB Input and Output
(see also XS)
input and output, XSUB Input and Output
wrapping subroutines for Perl, Extending Perl (Using C from Perl)

Y

y/// (transliteration) operator, Pattern-Matching Operators, The tr/// Operator (Transliteration), //
yield function, Yielding the processor

Z

^Z (Control-Z) as eof, Generating Perl in Other Languages
 (string boundary), Endings: The z, , and $ Assertions
z (string boundary), Endings: The z, , and $ Assertions
zero-width assertions, Metasymbol Tables, Positions
zombie processes, Glossary
zombie processes, reaping, Reaping Zombies, Networking Servers
servers, Networking Servers
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset