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 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) 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.