Mastering Perl

Index

A note on the digital index

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

Symbols

# (hash), Readable Regexes, /x and (?#...), Writing in Binary

binary numbers and, Writing in Binary

escaping, Readable Regexes, /x and (?#...)

$! variable, Perl Error Basics

$& variable, References to Regular Expressions

$? variable, Perl Error Basics, Child Process Errors

child process errors and, Child Process Errors

$@ variable, Perl Error Basics

$^E variable, Perl Error Basics, Errors Specific to the Operating System

errors specific to operating systems, Errors Specific to the Operating System

$^O variable (operating system), Different Operating Systems

$_ variable, Global Matching

& (bitwise AND), Bitwise AND, &

( ) (parentheses), Noncapturing Grouping, (?:PATTERN), Global Matching

global matching and, Global Matching

noncapturing grouping in regexes, Noncapturing Grouping, (?:PATTERN)

(?!PATTERN) lookaheads, Lookahead Assertions, (?=PATTERN) and (?!PATTERN)–Negative lookahead assertions

(?#...) regular expressions, Readable Regexes, /x and (?#...)

(?:PATTERN) regular expressions, Noncapturing Grouping, (?:PATTERN)–Noncapturing Grouping, (?:PATTERN)

(?<!PATTERN) lookbehinds, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)–Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

(?<=PATTERN) lookbehinds, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)–Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

(?=PATTERN) lookaheads, Lookahead Assertions, (?=PATTERN) and (?!PATTERN)–Negative lookahead assertions

(?imsx-imsx:PATTERN) regular expressions, (?imsx-imsx:PATTERN)–(?imsx-imsx:PATTERN)

-- (double hyphen switching), Command-Line Switches, Getopt::Long

Getopt::Long module and, Getopt::Long

-DDEBUGGING_MSTATS, Benchmarking Theory

-html option (perltidy), perltidy

-I switch, Side Effects of Taint Checking

-T (taint checking) switch, Warnings Instead of Fatal Errors

warnings/fatal errors and, Warnings Instead of Fatal Errors

. (dot), References to Regular Expressions, (?imsx-imsx:PATTERN)

literal, in regular expressions, References to Regular Expressions

newlines, matching, (?imsx-imsx:PATTERN)

// (defined-or) operator, Turning on Extra Output

/o flag, References to Regular Expressions

$0 variable, Scripts with a Different Name

0b notation, Writing in Binary

32-bit values, Unary NOT, ~

8-bit values, Unary NOT, ~

<< (left shift) operators, Left << and right >> shift operators

= (equal sign) in Pod directives, Directives

>> (right shift) operators, Left << and right >> shift operators

@+ arrays, References to Regular Expressions

@- arrays, References to Regular Expressions

@ARGV array, using command-line switches, Command-Line Switches

@_ variable, Subroutines As Arguments

\ (backslash), escaping characters, Readable Regexes, /x and (?#...)

\G anchor, Global Match Anchors

\s (whitespace), Readable Regexes, /x and (?#...)

^ (carat), in regular expressions, Global Match Anchors

^ (exclusive OR) operator, Exclusive OR, ^

_ (underscore), as an identifier, The Symbol Table

| (binary OR), Binary OR, |

| (pipe), using taint checking, Tainted Data

|| (short circuit operator), Turning on Extra Output

~ (NOT) operator, Unary NOT, ~–Unary NOT, ~

A

Aas, Gisle, Readable Regexes, /x and (?#...), The perlbench Tool, pack

ActiveState, Komodo

Advanced Perl Programming, Command-Line Switches

Affrus (debugger), Affrus

aliasing, Aliasing

American Stance, Untainting Data

anchors, Global Match Anchors, Lookarounds–Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

global match, Global Match Anchors

lookarounds, Lookarounds–Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

AND (&) bitwise, Bitwise AND, &

__ANON__ pseudokey, Doing Whatever I Want

anonymous subroutines, Naming Anonymous Subroutines, Dynamic Subroutines, Subroutines As Data–Subroutines As Data

naming, Naming Anonymous Subroutines

storing as variables, Subroutines As Data–Subroutines As Data

Apache::PerlRun module, mod_perl

Apache::Pod module, Pod in Your Web Server

Apache::Registry module, mod_perl

AppConfig module, AppConfig

arguments, using subroutines as, Subroutines As Arguments–Subroutines As Arguments

ARRAY variable type, Typeglobs

arrays, Arrays–Something a Bit More Realistic

ASCII-betical, Other DBI::Profile Reports

AUTOLOAD subroutine, Autoloaded Methods, AutoSplit

automatic taint mode, Automatic Taint Mode

autosplit, AutoSplit

B

\b (word boundary), Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

%b format specifier, Writing in Binary

B::Deparse module, Unparsing Code with B::Deparse

backslash (\), escaping characters, Readable Regexes, /x and (?#...)

Barr, Graham, Subroutines As Arguments

BASH_ENV environment variable, Side Effects of Taint Checking

BEGIN blocks, Replacing Module Parts, Code in a Separate File

configuring programs, using, Code in a Separate File

begin_work method, DBM::Deep

Benchmark module, Benchmarking Time, Don’t Turn Off Your Thinking Cap, Memory Use

benchmarks, Benchmarking Perl–Further Reading, Benchmarking Time–Benchmarking Time, Memory Use–Memory Use

memory use and, Memory Use–Memory Use

time, Benchmarking Time–Benchmarking Time

binary numbers, Binary Numbers–Writing in Binary

binary OR (|), Binary OR, |

BioPerl module, Bit Vectors

bit string storage, Bit String Storage–Bit String Storage

bit vectors, Bit Vectors–Bit Vectors

bits, working with, Working with Bits–Further Reading

bitwise AND (&), Bitwise AND, &

blacklisting, Untainting Data

body elements (Pod), Body Elements

bounded integers, Bounded Integers

Brocard, Léon, Devel::ebug

Burke, Sean, The Pod Format

C

/c flag, Global Match Anchors, Summary

C library, Operating System Errors, Bit Operators

caret (^), in regular expressions, Global Match Anchors

carp function, The Best Debugger in the World

Carp module, Program Tracing–Program Tracing

case-insensitivity with regular expressions, (?imsx-imsx:PATTERN)

CDPATH environment variable, Side Effects of Taint Checking

CGI::Carp module, Doing Whatever I Want–Program Tracing

child process errors, Child Process Errors

$CHILD_ERROR, Perl Error Basics

chmod, Binary Numbers

CLEAR( ) tie method, Hashes

CLOSE( ) tie method, Filehandles

cluck (Carp module), Program Tracing

CODE variable type, Typeglobs

coding style, Good Style

comma-separated values (CSV), Profiling DBI

command-line switches, Command-Line Switches–Getopt::Long

comments (Pod), Multiline Comments

COMMIT statement (SQL), profiling database code, Switching Databases

confess (Carp module), Program Tracing

Config module, perl’s Config

Config::ApacheFile module, Other Configuration Formats

Config::InFiles module, Config::IniFiles

Config::INI module, AppConfig

Config::Scoped module, Config::Scoped

ConfigReader::Simple module, ConfigReader::Simple

configuration of programs, Configuring Perl Programs–Further Reading, Code in a Separate File, Command-Line Switches–Getopt::Long, Configuration Files–Other Configuration Formats

code in separate files, Code in a Separate File

command-line switches, Command-Line Switches–Getopt::Long

files, Configuration Files–Other Configuration Formats

consistency in coding, Good Style

constraints, Iterating Through Subroutine Lists

Conway, Damian, Readable Regexes, /x and (?#...), Wrapping Subroutines, Good Style, Wrapping Subroutines, Interactive and Noninteractive Programs

IO::Interactive modules and, Interactive and Noninteractive Programs

Cozens, Simon, Further Reading, Command-Line Switches

CPAN, Modifying and Jury-Rigging Modules

croak, The Best Debugger in the World

cron program, Turning on Extra Output

CSV (comma-separated values), Profiling DBI

=cut directive (Pod), Directives

D

-D (debugging) switch, Deciphering Regular Expressions, Using a Different Debugger with -D

-d switch, Using a Different Debugger with -D, Devel::ptkdb, Devel::ebug, Devel::DProf, Devel::LineCounter

Devel::DProf modules and, Devel::DProf

Devel::ebug module and, Devel::ebug

devel::ptkdb module and, Devel::ptkdb

data persistence, Data Persistence–Further Reading, Flat Files–YAML

flat files and, Flat Files–YAML

Data::Constraint module, Iterating Through Subroutine Lists

Data::Dump::Streamer module, Similar Modules

Data::Dumper module, Data::Dumper–Data::Dumper

databases, The General Approach, Profiling DBI–Profiling DBI, Switching Databases

code, profiling, The General Approach, Profiling DBI–Profiling DBI

switching, Switching Databases

DBD::CSV module, Profiling DBI

%DBHASH variable, They Look Like Normal Variables

DBI module, Data Persistence

dbi.prof, Making It Even Easier

DBI::Profile module, Profiling DBI–Switching Databases, Other DBI::Profile Reports–Making It Even Easier

other reports, Other DBI::Profile Reports–Making It Even Easier

DBI::ProfileDumper module, Making It Even Easier

DBI_PROFILE environment variable, setting for profiling, Profiling DBI, Making It Even Easier

DBM files, DBM Files–Summary

DBM::Deep module, DBM::Deep

dbmopen, dbmopen, Binary Numbers, They Look Like Normal Variables

de-obfuscation, De-Obfuscation–Unparsing Code with B::Deparse

debuggers, The perlbench Tool–The perlbench Tool

perlbench tools, The perlbench Tool–The perlbench Tool

debugging, Debugging Perl–Further Reading, Alternative Debuggers–Devel::ebug

alternative, Alternative Debuggers–Devel::ebug

decimal numbers, Writing in Binary

deep copy (data), Freezing Data

defined-or (//) operator, Turning on Extra Output

DELETE( ) tie method, Hashes

DESTORY method, Behind the Curtain

Devel::Cover module, Devel::Cover

Devel::DProf module, Using a Different Debugger with -D, Devel::DProf

Devel::ebug module, Devel::ebug

Devel::MyDebugger module, Using a Different Debugger with -D

Devel::Peek module, Memory Use, The vec Function

Devel::ptkdb module, Devel::ptkdb

Devel::Size module, Memory Use, Bit Vectors

Devel::SmallProf module, Finding the Culprit, Writing My Own Profiler

die, The Best Debugger in the World, eval–Propagating Objects with die

__DIE__ pseudokey, Doing Whatever I Want

diff command, Sending Patches to the Author

directives (Pod), Directives

dirname utility, Pod Translators

DNA, Writing in Binary, Storing DNA

storing, Storing DNA

writing in binary, Writing in Binary

Dominus, Mark Jason, Untainting Data, Subroutines As Arguments

dot (.), References to Regular Expressions, (?imsx-imsx:PATTERN)

literal, in regular expressions, References to Regular Expressions

newlines, matching, (?imsx-imsx:PATTERN)

double hyphen (--) switching, Command-Line Switches, Getopt::Long

Getopt::Long module, Getopt::Long

dprofpp, Devel::DProf

dualvars, Operating System Errors

dynaqmic subroutines, Dynamic Subroutines–Further Reading

E

-e argument, perl5db.pl

Eclipse, EPIC

elsif statements, storing subroutines in variables, Subroutines As Data

Email::Send::SMTP module, Replacing Module Parts

Email::Simple module, Replacing Module Parts

Email::Stuff module, Replacing Module Parts

encoding hidden source code, De-Encoding Hidden Source–De-Encoding Hidden Source

END blocks, profiling code and, The General Approach, Devel::LineCounter

__END__ token, AutoSplit

ENV environment variable, Side Effects of Taint Checking

$ENV variable, Errors Specific to the Operating System

environment variables, Environment Variables

EPIC, EPIC

equal sign (=) in Pod directives, Directives

$ERRNO, Perl Error Basics

Errno module, Operating System Errors

errno.h, Operating System Errors

errors, Warnings Instead of Fatal Errors, Detecting and Reporting Errors–Further Reading, Operating System Errors–Operating System Errors, Child Process Errors, Reporting Module Errors–Separation of Concerns, Exceptions, Recording Errors and Other Information

child process, Child Process Errors

detecting and reporting, Detecting and Reporting Errors–Further Reading

exceptions, Exceptions

fatal, Warnings Instead of Fatal Errors

module, reporting, Reporting Module Errors–Separation of Concerns

operating systems, Operating System Errors–Operating System Errors

recording, Recording Errors and Other Information

eval, Perl Error Basics, eval, Storable

$EVAL_ERROR, Perl Error Basics

exceptions, Exceptions–Fatal

exclusive OR (^) operator, Exclusive OR, ^

exec( ) function, List Forms of system and exec–Limit Special Privileges

EXISTS( ) tie method, Hashes

exit keyword, Child Process Errors

eXplain mode, (?imsx-imsx:PATTERN)

$EXTENDED_OS_ERROR, Perl Error Basics

ExtUtils::MakeMaker module, Devel::Cover, AutoSplit, An ExtUtils::MakeMaker Example

F

factorial routines, Finding the Culprit

fatal errors, Warnings Instead of Fatal Errors

Fatal module, Fatal

fatalsToBrowser function, Doing Whatever I Want

FETCH( ) tie method, Arrays, Hashes

FETCHSIZE( ) tie method, Arrays

File::Find module, Naming Anonymous Subroutines

File::Spec module, Tainted Data, Different Operating Systems

filehandle arguments, Filehandle Arguments in Older Code

filehandles, Filehandles–Filehandles

flat files, Flat Files–YAML

flock function, Binary OR, |

Foley, Richard, perl5db.pl

forking, Forking

freezing data, Freezing Data

Friedl, Jeffery, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

functions, Bad Data Can Ruin Your Day, Hiding and Ignoring Functions

interacting with operating systems and, Bad Data Can Ruin Your Day

Pod checks, hiding from, Hiding and Ignoring Functions

G

\G anchor, Summary

/g flag, Global Matching–Global Match Anchors

“Generating Sudoku”, Keeping Track of Things

Getopt modules, Command-Line Switches, Getopt Modules–Getopt::Long

Getopt::Attribute module, Command-Line Switches

Getopt::Easy module, Command-Line Switches

Getopt::Long module, Command-Line Switches, Getopt::Long–Getopt::Long, AppConfig

AppConfig module and, AppConfig

Getopt::Mixed module, Command-Line Switches

Getopt::Std module, Command-Line Switches, Getopt::Std–Getopt::Std

glob( ) function, Don’t Turn Off Your Thinking Cap

global match anchors, Global Match Anchors

global matching, Global Matching–Global Match Anchors

global variables, Typeglobs

-gnu switch (perltidy), perltidy

Goess, Kevin, Log4perl

good style, coding, Good Style

grep, References to Regular Expressions

H

hash (#), Readable Regexes, /x and (?#...), Writing in Binary

binary numbers and, Writing in Binary

escaping, Readable Regexes, /x and (?#...)

hash keys, Hash Keys

HASH variable type, Typeglobs

Hash::AsObject module, Hashes As Objects

hashes, The Symbol Table–Naming Anonymous Subroutines, Hashes As Objects, Hashes

objects and, Hashes As Objects

symbol tables and, The Symbol Table–Naming Anonymous Subroutines

hexadecimal numbers, Writing in Binary

Hoare, Tony, Benchmarking Perl

Hoffman, Paul, Hashes As Objects

Hook::LexWrap module, Wrapping Subroutines–Wrapping Subroutines, Wrapping Subroutines

HTTP::Date module, Readable Regexes, /x and (?#...)

Huckaby, Joe, DBM::Deep

I

/i flag, (?imsx-imsx:PATTERN), Global Match Anchors

I<> (italic), Body Elements

if statements, storing subroutines in variables, Subroutines As Data

IFS environment variable, Side Effects of Taint Checking

Image::Info module, pack

indirect objects for system function, List Forms of system and exec

INSERT statements (SQL), profiling database code and, Switching Databases

interactive programs, Interactive and Noninteractive Programs

interior sequences (Pod), Body Elements

Intermediate Perl, Who Should Read This Book, Dynamic Subroutines

IO::Handle module, IO::Handle::untaint

IO::Interactive module, Interactive and Noninteractive Programs

IO::Socket::INET module, Replacing Module Parts

J

JAPH (Just another Perl hacker), Backing Up

JavaScript Object Notation (JSON), YAML

JSON (JavaScript Object Notation), YAML

Just another Perl hacker (JAPH), Backing Up

K

keys (hash), Hash Keys

keys operator, The Symbol Table

Komodo, Komodo

Kulp, David, Benchmarking Time

L

-l switch (perldoc), Pod Translators, The main Thing

$L::glob variable, Don’t Turn Off Your Thinking Cap

Late Night Software, Affrus

Learning Perl, Introduction: Becoming a Master, References to Regular Expressions, Dynamic Subroutines

anonymous subroutines and, Dynamic Subroutines

left shift (<<) operators, Left << and right >> shift operators

Leroy, Jean-Louis, Benchmarking Time

Lester, Andy, Pod in Your Web Server, Pod Coverage

lexical variables, Package and Lexical Variables–Getting the Package Version

lib directives, Special Environment Variables

lib module, Side Effects of Taint Checking

__LINE__ compiler directive, die with a Reference

Lingua::* module, Profiling DBI

List::Util module, Subroutines As Data, Subroutines As Arguments

literal dot (.), References to Regular Expressions

local patches, Local Patches

local support, Untainting Data

Local::Error module, Propagating Objects with die

log4j, Log4perl

Log4perl, Log4perl–Other Log::Log4perl Features, Configuring Log4perl

configuring, Configuring Log4perl

Log::Dispatch module, Recording Errors and Other Information

Log::Log4perl module, Recording Errors and Other Information

logging, Logging–Further Reading

lookaheads, Lookahead Assertions, (?=PATTERN) and (?!PATTERN)–Negative lookahead assertions

lookarounds, Lookarounds–Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

lookbehinds, Lookarounds, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)–Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

M

-M switch, Using a Different Debugger with -D, Who’s Calling?, My Method

-m switch (perldoc), Pod Translators

Mac::Carbon module, Errors Specific to the Operating System

Mac::Errors module, Errors Specific to the Operating System

Mac::Glue module, Errors Specific to the Operating System

MacPerl, Errors Specific to the Operating System

mail command, List Forms of system and exec

main, as a C subroutine and Perl package, The main Thing

Makefile, An ExtUtils::MakeMaker Example

Maki, Eric, Keeping Track of Things

map( ) function, Don’t Turn Off Your Thinking Cap

masks, Bitwise AND, &

Mastering Regular Expressions, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

maybe_regex method, References As Arguments

Memoize module, Finding the Culprit

memory management, Memory Use

memory use, benchmarking programs, Memory Use–Memory Use

metacharacters (shell), using system and exec function, List Forms of system and exec

method lists, Method Lists

missing input, Detecting and Reporting Errors

mkdir, Binary Numbers

ModPerl::PerlRum module, mod_perl

ModPerl::Registry module, mod_perl

Module::Build module, Devel::Cover

Module::Release module, Distributing the Programs

modules, Safely Changing Modules, Modifying and Jury-Rigging Modules–Further Reading, Taking over a Module, Replacing Module Parts–Replacing Module Parts, Subclassing–Other Examples, Wrapping Subroutines–Wrapping Subroutines, Getopt Modules–Getopt::Long, Reporting Module Errors–Separation of Concerns, Modules As Programs–Further Reading, Testing the Program–Adding to the Script, Distributing the Programs

changing, Safely Changing Modules

distributing, Distributing the Programs

errors, reporting, Reporting Module Errors–Separation of Concerns

Getopt, Getopt Modules–Getopt::Long

programs, as, Modules As Programs–Further Reading

replacing parts of, Replacing Module Parts–Replacing Module Parts

subclassing, Subclassing–Other Examples

taking over, Taking over a Module

testing, Testing the Program–Adding to the Script

wrapping subroutines and, Wrapping Subroutines–Wrapping Subroutines

mod_perl, mod_perl

multiline comments (Pod), Multiline Comments

multiline matching modes, (?imsx-imsx:PATTERN)

multiple-character switches, Command-Line Switches

MySQL, Data Persistence

N

named subroutines, Creating and Replacing Named Subroutines–Creating and Replacing Named Subroutines

Nandor, Chris, Devel::DProf

negative lookarounds, Lookarounds, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

Net::FTP module, Benchmarking Time

Net::SMTP module, Replacing Module Parts

New C Primer Plus, Bit Operators

NEXTKEY( ) tie method, Hashes

noncapturing grouping in regular expressions, Noncapturing Grouping, (?:PATTERN)–Noncapturing Grouping, (?:PATTERN)

noninteractive programs, Interactive and Noninteractive Programs

NOT (~) operator, Unary NOT, ~–Unary NOT, ~

nroff, Pod Translators

O

obfuscation of code, De-Obfuscation–Unparsing Code with B::Deparse

Object::Iterate module, Subroutines As Arguments

objects, Hashes As Objects, Propagating Objects with die

propagating with die, Propagating Objects with die

older code, handing filehandles arguments and, Filehandle Arguments in Older Code

operating systems, Bad Data Can Ruin Your Day, Different Operating Systems, Operating System Errors–Operating System Errors, Errors Specific to the Operating System–Errors Specific to the Operating System

errors, Operating System Errors–Operating System Errors

errors specific to, Errors Specific to the Operating System–Errors Specific to the Operating System

interacting with functions and, Bad Data Can Ruin Your Day

running programs on, Different Operating Systems

OR (|), binary, Binary OR, |

Oracle, Data Persistence

OS/2, Errors Specific to the Operating System

$OS_ERROR, Perl Error Basics

P

pack( ) function, pack

__PACKAGE__ compiler directive, die with a Reference

package main, Backing Up

package variables, Package and Lexical Variables–Getting the Package Version

package versions, Getting the Package Version

parentheses (( )), Noncapturing Grouping, (?:PATTERN), Global Matching

global matching and, Global Matching

noncapturing grouping in regexes, Noncapturing Grouping, (?:PATTERN)

patches, Sending Patches to the Author

PATH setting, Taint Checking

PAUSE (Perl Authors Upload Server), Taking over a Module

Perl Authors Upload Server (PAUSE), Taking over a Module

Perl Best Practices, Readable Regexes, /x and (?#...), Good Style

Perl Power Tools, Benchmarking Time, Pod Translators

Perl Review, Keeping Track of Things

perl5db.pl, Debugging Perl, perl5db.pl, Alternative Debuggers–Devel::ebug

PERL5LIB environment variable, Side Effects of Taint Checking, Safely Changing Modules

PERL5OPT environment variable, Special Environment Variables

Perl::Critic module, Perl::Critic–Creating My Own Perl::Critic Policy

perlbench tool, Benchmarking Theory, The perlbench Tool–The perlbench Tool

perldebguts documentation, Deciphering Regular Expressions, Further Reading, Memory Use

benchmarking and, Memory Use

perldebug documentation, perl5db.pl

perldoc, Pod Translators

perlfunc documentation, Bad Data Can Ruin Your Day

perlopentuf documentation, Bad Data Can Ruin Your Day

perlpodspec documentation, The Pod Format

perlre documentation, Advanced Regular Expressions, Further Reading

regular expressions, Advanced Regular Expressions

perlretut documentation, Further Reading

perlstyle documentation, Good Style

perlsub documentation, Further Reading

perltidy program, perltidy–perltidy

perlvar documentation, Perl Error Basics

PERL_DPROF_OUT_FILE_NAME environment variable, Devel::DProf

persistent logging, Persistent Logging

pipe (|), using taint checking, Tainted Data

pipelines, processing, Processing Pipelines

Plain Old Documentation, Working with Pod (see Pod)

Pod (Plain Old Documentation), Working with Pod–Further Reading, Translating Pod–Pod in Your Web Server, Testing Pod–Hiding and Ignoring Functions

testing, Testing Pod–Hiding and Ignoring Functions

translating, Translating Pod–Pod in Your Web Server

Pod::Checker module, Checking Pod

Pod::Parser module, Translating Pod

Pod::Perldoc module, Pod Translators

Pod::Perldoc::ToToc module, Pod::Perldoc::ToToc–Pod::Perldoc::ToToc

Pod::Simple module, Pod::Simple–Pod::Simple

Pod::TOC module, Pod::Simple

pointers, Typeglobs

POP( ) tie method, Arrays

Portable Network Graphics (PNG), pack

pos( ) operator, Global Matching

positive lookarounds, Lookarounds, Lookbehind Assertions, (?<!PATTERN) and (?<=PATTERN)

PostgreSQL, Data Persistence

precedence in regular expressions, Noncapturing Grouping, (?:PATTERN)

print statements, The Best Debugger in the World–Wrapping Subroutines, Turning on Extra Output

configuring programs and, Turning on Extra Output

debugging tool, using as, The Best Debugger in the World–Wrapping Subroutines

PRINT( ) tie method, Filehandles

printf function, Operating System Errors, Writing in Binary

%b format specifier and, Writing in Binary

problem-solving, My Philosophy of Problem-Solving

profiling, Profiling Perl–Further Reading, The General Approach, Profiling DBI–Switching Databases, Devel::DProf

approach to, The General Approach

DBI, Profiling DBI–Switching Databases

Devel::DProf module and, Devel::DProf

Prussian Stance, Untainting Data

PUSH( ) tie method, Arrays

Q

qr( ) quoting operator, Summary

qr// (quoting operator), References to Regular Expressions, (?imsx-imsx:PATTERN), Global Match Anchors

case-insensitivity and, (?imsx-imsx:PATTERN)

quoting operator (qr//), References to Regular Expressions, (?imsx-imsx:PATTERN), Global Match Anchors

case-insensitivity and, (?imsx-imsx:PATTERN)

R

readable regexes, Readable Regexes, /x and (?#...)

READLINE( ) tie method, Filehandles

RealPlayer, Errors Specific to the Operating System

recursive algorithms, Finding the Culprit

references, References As Arguments, Memory Use, Symbolic References, die with a Reference

arguments, References As Arguments

dieing with, die with a Reference

symbolic, Symbolic References

regexes, Advanced Regular Expressions (see regular expressions)

Regexp::Common module, Final Thoughts

Regexp::English module, Final Thoughts

regular expressions, Advanced Regular Expressions–Further Reading, References to Regular Expressions–References As Arguments, Deciphering Regular Expressions–Final Thoughts

advanced, Advanced Regular Expressions–Further Reading

deciphering, Deciphering Regular Expressions–Final Thoughts

references to, References to Regular Expressions–References As Arguments

REPL (Read-Evaluate-Print), Subroutines As Data

require statement, configuring programs and, Code in a Separate File

reset method, At the User Level

reudce function, Subroutines As Arguments

right shift (>>) operators, Left << and right >> shift operators

Rolsky, Dave, Recording Errors and Other Information

ROT-13, De-Encoding Hidden Source

ROT-255, De-Encoding Hidden Source

S

-s switch, The -s Switch

SCALAR variable type, Typeglobs

Scalar::Util module, Tainted Data

scalars, Scalars–Self-Destructing Values

Schilli, Michael, Recording Errors and Other Information, Log4perl

Schwartz, Randal, Introduction: Becoming a Master

Schwartzian Transform, Don’t Turn Off Your Thinking Cap, Don’t Turn Off Your Thinking Cap

scope, using lexical variables and, Package and Lexical Variables

sea level (benchmark), Benchmarking Theory

secure programming techniques, Secure Programming Techniques–Further Reading

self-destructing values, Self-Destructing Values

servers (web), using Pod, Pod in Your Web Server

shallow copy (data), Freezing Data

shift (<< >>) operators, Left << and right >> shift operators

short circuit operator (||), Turning on Extra Output

sleep program, Benchmarking Time

split, Positive lookahead assertions

sprintf function, Configuring Log4perl, pack, Writing in Binary

%b format specifier and, Writing in Binary

SQLite, Switching Databases

STDERR, Recording Errors and Other Information

STDOUT, checking interactive/noninteractive programs, Interactive and Noninteractive Programs

Stonehenge Consulting Services, Introduction: Becoming a Master

Storable module, Storable–Freezing Data

store function (Storable module), Storable

STORE( ) tie method, Arrays, Hashes

STORESIZE( ) tie method, Arrays

strict, Before You Waste Too Much Time, Symbolic References

symbolic references and, Symbolic References

strings (bit storage), Bit String Storage–Bit String Storage

style, coding, Good Style

subclassing, Subclassing–Other Examples

subroutines, Wrapping Subroutines–Wrapping Subroutines, Naming Anonymous Subroutines, Dynamic Subroutines–Further Reading, Subroutines As Data–Subroutines As Data, Creating and Replacing Named Subroutines–Creating and Replacing Named Subroutines, Iterating Through Subroutine Lists, Subroutines As Arguments–Subroutines As Arguments, Autoloaded Methods, Wrapping Subroutines–Wrapping Subroutines

arguments, as, Subroutines As Arguments–Subroutines As Arguments

as data, Subroutines As Data–Subroutines As Data

autoloaded methods and, Autoloaded Methods

dynamic, Dynamic Subroutines–Further Reading

iterating through, Iterating Through Subroutine Lists

named, creating and replacing, Creating and Replacing Named Subroutines–Creating and Replacing Named Subroutines

naming anonymous, Naming Anonymous Subroutines

wrapping, Wrapping Subroutines–Wrapping Subroutines, Wrapping Subroutines–Wrapping Subroutines

symbol tables, Symbol Tables and Typeglobs–Further Reading

symbolic references, Symbolic References

syslogd, Recording Errors and Other Information

sysopen function, Binary OR, |

sysopen( ) function, sysopen

system function, Left << and right >> shift operators

system( ) function, List Forms of system and exec–Limit Special Privileges

T

-T (taint checking) switch, Taint Checking–Warnings Instead of Fatal Errors

-t file test, Interactive and Noninteractive Programs

-t switch, Warnings Instead of Fatal Errors

-T switch, Devel::DProf, Pod Translators

dprofpp, Devel::DProf

perldoc, Pod Translators

taint checking, Taint Checking–Side Effects of Taint Checking, Side Effects of Taint Checking, Untainting Data–Choosing Untainted Data with Tainted Data

side effect of, Side Effects of Taint Checking

untainting data, Untainting Data–Choosing Untainted Data with Tainted Data

Template module, Adding to the Script

Template toolkit, Reporting Module Errors

Test::Builder module, References As Arguments

Test::Harness module, Devel::Cover

Test::More module, References As Arguments

Test::Output module, Testing the Program

Test::Pod::Coverage module, Pod Coverage

Text::Template::Simple module, Errors Specific to the Operating System

thaw( ) function, Freezing Data

three-argument open, Three-Argument open

tie function, They Look Like Normal Variables

Tie:: functions, Hiding and Ignoring Functions, Behind the Curtain

Tie::Array module, Behind the Curtain

Tie::Array::PackedC module, Bit Vectors

Tie::Cycle module, At the User Level, Tie::Cycle–Tie::Cycle

Tie::Handle module, Behind the Curtain

Tie::Hash module, Behind the Curtain

Tie::Scalar module, Behind the Curtain

tied variables, The Magic of Tied Variables–Further Reading

tied( ) function, They Look Like Normal Variables

TIESCALAR method, Behind the Curtain

time function, Benchmarking Time

timethese function, Comparing Code

translators (Pod), Translating Pod–Pod in Your Web Server

Tregar, Sam, Making It Even Easier

typeglobs, Symbol Tables and Typeglobs–Further Reading, Aliasing

aliasing, Aliasing

U

-U switch, Warnings Instead of Fatal Errors

underscore (_), as an identifier, The Symbol Table

unreachable external resources, Detecting and Reporting Errors

untainting data, Untainting Data–Choosing Untainted Data with Tainted Data, IO::Handle::untaint

IO::Handle module, IO::Handle::untaint

V

variables, using tied, They Look Like Normal Variables–Further Reading

vec( ) function, The vec Function–The vec Function, Storing DNA

storing DNA, Storing DNA

VMS, Errors Specific to the Operating System

W

-w (warnings) switch, My Method

wait( ) function, Perl Error Basics

Wall, Larry, Before You Waste Too Much Time, Sending Patches to the Author

Wardley, Andy, Reporting Module Errors

__WARN__ pseudokey, Doing Whatever I Want

warn statement, The Best Debugger in the World

warnings, Warnings Instead of Fatal Errors, Before You Waste Too Much Time

web servers, using Pod, Pod in Your Web Server

whitelisting, Untainting Data

whitespace in code, perltidy

Win32::GetLastErro( ), Errors Specific to the Operating System

Win32::Registry module, Other Configuration Formats

Windows, Errors Specific to the Operating System

X

/x flag, Readable Regexes, /x and (?#...), Global Match Anchors

global match anchors and, Global Match Anchors

XOR (^) exclusive operator, Exclusive OR, ^

Y

YAML (YAML Ain’t Markup Language), YAML

YAPE::Regex::Explain module, Deciphering Regular Expressions