Symbols | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

Index: P

• -p file test operator
• • File Test Operators (Perl tutorial)
• \P (doesn't match property): Effects of Character Semantics (Developing Perl)
• \p (matches property): Effects of Character Semantics (Developing Perl)
• -P (C preprocessor) command-line switch: Switches (Developing Perl)
• p command (debugger): Reference: p (Perl tutorial)
• pack function: pack (Developing Perl)
• • Endianness and Number Width (Developing Perl)
  • template characters for: pack (Developing Perl)
  • unpack function, Unicode characters and: Effects of Character Semantics (Developing Perl)
• pack geometry manager (Perl/Tk): Geometry Managers (Perl tutorial)
• package(): Reference: package (Perl tutorial)
• __PACKAGE__ token: Determining Current Function Name (Perl tutorial)
• • Determining the Caller's Package (Perl tutorial)
  • Global Special Constants (Perl tutorial)
• package declaration: Basic Package (Advanced Perl Developing)
• • Introduction (Perl tutorial)
  • Namespaces and Packages (Perl tutorial)
  • Scoped Declarations (Developing Perl)
  • Packages (Developing Perl)
  • package (Developing Perl)
• package variable, wrapping declaration in block scope: Managing Class Data (Developing Perl)
• packages: Introduction (Perl tutorial)
• • Program: Finding Versions and Descriptions of Installed Modules (Perl tutorial)
  • Namespaces and Packages (Perl tutorial)
  • Simplicities (Developing Perl)
  • Names (Developing Perl)
  • Names (Developing Perl)
  • Packages (Developing Perl)
  • Autoloading (Developing Perl)
  • adding methods to existing: Accessing Overridden Methods (Developing Perl)
  • binding variables to: untie (Developing Perl)
  • bless function arguments: Object Construction (Developing Perl)
  • blessing objects into: bless (Developing Perl)
  • delimiters for: Packages (Developing Perl)
  • determining current/calling: Determining the Caller's Package (Perl tutorial)
  • identifiers: Packages (Developing Perl)
  • importing semantics to: use (Developing Perl)
  • in @ISA array, inheritance through: Inheritance Through @ISA (Developing Perl)
  • methods and subroutines, resolving for: Method Invocation (Developing Perl)
  • names for: Or Leave the Quotes Out Entirely (Developing Perl)
  • • Developing with Style (Developing Perl)
  • overriding built-in functions: Overriding Built-In Functions (Perl tutorial)
  • private variables and functions: Making Variables Private to a Module (Perl tutorial)
  • quoting: Package-Quoted Classes (Developing Perl)
  • referring to indirectly: Referring to Packages Indirectly (Perl tutorial)
  • splitting for autoloading: Module Installation Support (Developing Perl)
  • symbol tables, displaying: Debugger Options (Developing Perl)
  • symbol tables for: Symbol Tables (Developing Perl)
  • tying variables to: tie (Developing Perl)
• packed sockaddr: getpeername (Developing Perl)
• packer geometry manager: Packer (Advanced Perl Developing)
• packet-oriented communication: Sockets (Perl tutorial)
• packForget() (pack geometry manager): Pack methods (Perl tutorial)
• packInfo() (pack geometry manager): Pack methods (Perl tutorial)
• packPropogate() (pack geometry manager): Pack methods (Perl tutorial)
• packSlaves() (pack geometry manager): Pack methods (Perl tutorial)
• padlists: How local and my work (Advanced Perl Developing)
• -padx, -pady options: Common Widget Configuration Options (Perl tutorial)
• • grid geometry manager: The grid Geometry Manager (Perl tutorial)
  • pack geometry manager: The pack Geometry Manager (Perl tutorial)
• pads: Names (Developing Perl)
• page numbers: Special Variables in Alphabetical Order (Developing Perl)
• pager option (debugger): Debugger Options (Developing Perl)
• pages: Special Variables in Alphabetical Order (Developing Perl)
• PalmPilot, Perl modules for: The CPAN modules Directory (Developing Perl)
• paragraph mode: Switches (Developing Perl)
• • Special Variables in Alphabetical Order (Developing Perl)
• paragraph separator character: Molecules (Developing Perl)
• paragraph tags (pod): Paragraph tags (Perl tutorial)
• paragraphs
• • counting in files: in a File 8.2. Counting Lines (or Paragraphs or Records) (Perl tutorial)
  • in pod documentation: Documenting Your Module with Pod (Perl tutorial)
  • reading files backwards by: Reading a File Backwards by Line or Paragraph (Perl tutorial)
  • reformatting: Reformatting Paragraphs (Perl tutorial)
• paragrep program (example): Testing for a Valid Pattern (Perl tutorial)
• param()
• • Reference: param (Perl tutorial)
  • The CGI.pm Module (Perl tutorial)
• parameterized HTML: Creating HTML Templates (Perl tutorial)
• parameters (see also arguments)
• • passing with typeglobs: Efficient parameter passing (Advanced Perl Developing)
  • scalar context, providing for: Singularities (Developing Perl)
  • subroutines
  • • changing in place: Tricks with Parameter Lists (Developing Perl)
    • working with: Tricks with Parameter Lists (Developing Perl)
  • SWIG and: SWIG Features (Advanced Perl Developing)
  • XS and: Default and Optional Parameters (Advanced Perl Developing)
• params() (URI::URL): Reference: params (Perl tutorial)
• parent() (HTML::Parser): Reference: parent (Perl tutorial)
• parent classes: Brief Refresher on Object-Oriented Lingo (Developing Perl)
• • • working with: Brief Refresher on Object-Oriented Lingo (Developing Perl)
  • accessing overridden methods: Accessing Overridden Methods (Perl tutorial)
  • cloning objects: Cloning Objects (Perl tutorial)
  • inheritance and: Solving the Data Inheritance Problem (Perl tutorial)
• parent processes (see processes)
• parse()
• • HTML::Parser module: Reference: parse (Perl tutorial)
  • Mail::Address module: Reference: parse (Perl tutorial)
• parse trees: The Life Cycle of a Perl Program (Developing Perl)
• • Compiling Your Code (Developing Perl)
  • • working with: The Life Cycle of a Perl Program (Developing Perl)
    • • Compiling Your Code (Developing Perl)
  • internal, keeping: Compiler Backends (Developing Perl)
  • original, reconstituting and splicing into current parse tree: The Bytecode Generator (Developing Perl)
  • reconstruction of: The Life Cycle of a Perl Program (Developing Perl)
• parse_csv subroutines: Parsing Comma-Separated Data (Perl tutorial)
• parse_file() (HTML::Parser): Reference: parse_file (Perl tutorial)
• parse_head() (LWP::UserAgent): Reference: parse_head (Perl tutorial)
• parse_query function: Query processing (Advanced Perl Developing)
• ParseDate(): Parsing Dates and Times from Strings (Perl tutorial)
• • Program: hopdelta (Perl tutorial)
• parser, template: Template Parser (Advanced Perl Developing)
• parsing: How Perl Works (Developing Perl)
• • comma-separated data: Parsing Comma-Separated Data (Perl tutorial)
  • command-line arguments: Parsing Program Arguments (Perl tutorial)
  • • Command-Line Options (Perl tutorial)
  • commas into numbers: Putting Commas in Numbers (Perl tutorial)
  • datetime from strings: Parsing Dates and Times from Strings (Perl tutorial)
  • double-quote interpolation and regular expressions: Pattern-Matching Operators (Developing Perl)
  • email addresses: Parse Email Addresses with Mail::Address (Perl tutorial)
  • filenames: Splitting a Filename into Its Component Parts (Perl tutorial)
  • HTML tags: Extracting or Removing HTML Tags (Perl tutorial)
  • in the Perl compiler: Compiling Your Code (Developing Perl)
  • input specification: Jeeves Example (Advanced Perl Developing)
  • • Advantages of This Architecture (Advanced Perl Developing)
    • example of: Sample Specification Parser (Advanced Perl Developing)
  • text, Perl modules for: The CPAN modules Directory (Developing Perl)
  • web server log file: Parsing a Web Server Log File (Perl tutorial)
• partial URLs: Introduction (Perl tutorial)
• Pass() (Mail::POP3Client): Reference: Pass (Perl tutorial)
• pass() (Net::POP3): Reference: pass (Perl tutorial)
• • Retrieving Email with Net::POP3 (Perl tutorial)
• PASS command (POP3): Retrieving Email with Net::POP3 (Perl tutorial)
• passing
• • arguments to subroutines: Passing Arguments (Perl tutorial)
  • by named parameter: Passing by Named Parameter (Perl tutorial)
  • by reference: Passing Arrays and Hashes by Reference (Perl tutorial)
  • symbol table entries: Passing References (Perl tutorial)
• passing by reference: Semantics (Developing Perl)
• • prototypes declaring function calls as: What Is a Reference? (Developing Perl)
• passing references: Passing References (Developing Perl)
• passwd command (Unix): Unix account creation and deletion routines (Perl for System Administration)
• Passwd\:\:Solaris module: Shadow Passwords (Perl for System Administration)
• password()
• • Net::Netrc module: Reference: password (Perl tutorial)
  • URI::URL module: Reference: password (Perl tutorial)
• password field (Unix): The Classic Unix Password File (Perl for System Administration)
• • BSD 4.4: Binary Database Format in BSD 4.4 (Perl for System Administration)
  • program for setting/changing: Preventing Suspicious Activities (Perl for System Administration)
  • security and: Preventing Suspicious Activities (Perl for System Administration)
  • shadow: Shadow Passwords (Perl for System Administration)
  • Unix: The Classic Unix Password File (Perl for System Administration)
  • • Unix account creation and deletion routines (Perl for System Administration)
  • Windows/2000: NT/2000 Passwords (Perl for System Administration)
• Password() (Win32::Internet): Reference: Password (Perl tutorial)
• password entries (.netrc): FTP Configuration with Net::Netrc (Perl tutorial)
• password_field() (CGI.pm): Reference: password_field (Perl tutorial)
• passwords: srand (Developing Perl)
• • crypt function and: crypt (Developing Perl)
  • passwd file: getpwent (Developing Perl)
  • Perl modules for: The CPAN modules Directory (Developing Perl)
  • randomly generating: Generating Random Numbers (Perl tutorial)
  • reading without echo: Reading Passwords (Perl tutorial)
• pasv() (Net::FTP): Reference: pasv (Perl tutorial)
• Pasv() (Win32::Internet): Reference: Pasv (Perl tutorial)
• pasv_wait() (Net::FTP): Reference: pasv_wait (Perl tutorial)
• pasv_xfer() (Net::FTP): Reference: pasv_xfer (Perl tutorial)
• pasv_xfer_unique() (Net::FTP): Reference: pasv_xfer_unique (Perl tutorial)
• patches for Perl source code: Patches (Perl tutorial)
• path()
• • Mail::Address module: Reference: path (Perl tutorial)
  • URI::URL module: Reference: path (Perl tutorial)
• PATH environment variable
• • Environment Variables (Perl tutorial)
  • How to Do It (Developing Perl)
  • Switches (Developing Perl)
  • Environment Variables (Developing Perl)
  • searching for scripts using: Command-Line Options (Perl tutorial)
  • security and: Cleaning Up Your Environment (Developing Perl)
• path for library searches, %INC: Special Variables in Alphabetical Order (Developing Perl)
• Path property (response cookies): Setting cookies (Perl tutorial)
• PATHEXT variable: Environment Variables (Perl tutorial)
• path_info() (CGI.pm): Reference: path_info (Perl tutorial)
• PATH_INFO variable: Extra Path Information (Perl tutorial)
• • CGI Environment Variables (Perl tutorial)
• paths: Introduction (Perl tutorial)
• path_translated() (CGI.pm): Reference: path_translated (Perl tutorial)
• PATH_TRANSLATED variable: Extra Path Information (Perl tutorial)
• • CGI Environment Variables (Perl tutorial)
• pattern-binding operator: Regular Expressions (Developing Perl)
• pattern space: Special Variables in Alphabetical Order (Developing Perl)
• pattern matching: Soundex Matching (Perl tutorial)
• • Introduction (Perl tutorial)
  • abbreviations: Matching Abbreviations (Perl tutorial)
  • across multiple lines: Matching Multiple Lines (Perl tutorial)
  • backtracking: Introduction (Perl tutorial)
  • copying and substituting: Copying and Substituting Simultaneously (Perl tutorial)
  • duplicate words: Detecting Duplicate Words (Perl tutorial)
  • eager: Introduction (Perl tutorial)
  • email addresses: Matching a Valid Mail Address (Perl tutorial)
  • extracting ranges of lines: Extracting a Range of Lines (Perl tutorial)
  • filenames: Globbing, or Getting a List of Filenames Matching a Pattern (Perl tutorial)
  • functions for: Perl Functions by Category (Perl tutorial)
  • fuzzy matching: Approximate Matching (Perl tutorial)
  • greedy vs. non-greedy: Introduction (Perl tutorial)
  • • Greedy and Non-Greedy Matches (Perl tutorial)
  • history.db file: Program: ggh&nbsp- Grep Netscape Global History (Perl tutorial)
  • honoring locale settings: Honoring Locale Settings in Regular Expressions (Perl tutorial)
  • logical functionality in: Expressing AND, OR, and NOT in a Single Pattern (Perl tutorial)
  • matching letters: Matching Letters (Perl tutorial)
  • matching words: Matching Words (Perl tutorial)
  • modifiers for: Introduction (Perl tutorial)
  • multiple-byte charactrs: Matching Multiple-Byte Characters (Perl tutorial)
  • Nth matches: Finding the Nth Occurrence of a Match (Perl tutorial)
  • operators for: Pattern Match Operators (Perl tutorial)
  • • Pattern-Matching Operators (Perl tutorial)
  • progressive (with /g): Finding the Nth Occurrence of a Match (Perl tutorial)
  • shell wildcards for: Matching Shell Globs as Regular Expressions (Perl tutorial)
  • tcgrep program: Program: tcgrep (Perl tutorial)
  • testing for invalid patterns: Testing for a Valid Pattern (Perl tutorial)
  • urlify program: Program: urlify (Perl tutorial)
  • useful and interesting patterns (list): Regular Expression Grabbag (Perl tutorial)
  • using /o modifier: Speeding Up Interpolated Matches (Perl tutorial)
  • where last pattern ended: Matching from Where the Last Pattern Left Off (Perl tutorial)
• pattern separators, reading data with: Reading Records with a Pattern Separator (Perl tutorial)
• patterns
• • autosplitting via -a switch: Switches (Developing Perl)
  • debugger, commands for matching: Locating Code (Developing Perl)
  • example of pattern matching: Fast Multipattern grep (Advanced Perl Developing)
  • fancy patterns: Lookaround Assertions (Developing Perl)
  • replacements, changes in Perl versions: Previous Perl Traps (Developing Perl)
• patterns (and regular expressions): Regular Expressions (Developing Perl)
• • Pattern Matching (Developing Perl)
  • m// (Developing Perl)
  • (see also m// operator)
  • alphanumeric metasymbols: Metasymbol Tables (Developing Perl)
  • assertions, defining your own: Defining Your Own Assertions (Developing Perl)
  • assertions in: The Regular Expression Bestiary (Developing Perl)
  • backreferences: Backreferences (Developing Perl)
  • • Capturing (Developing Perl)
  • capturing in: Capturing and Clustering (Developing Perl)
  • character classes: Regular Expressions (Developing Perl)
  • • Character Classes (Developing Perl)
  • characters in: The Regular Expression Bestiary (Developing Perl)
  • clustering in: Clustering (Developing Perl)
  • conditional interpolation in: Conditional interpolation (Developing Perl)
  • controlling matching: Staying in Control (Developing Perl)
  • • Perl flow control, deciding pattern execution: Letting Perl Do the Work (Developing Perl)
    • regex compiler: The Regex Compiler (Developing Perl)
  • extension syntax: Metasymbol Tables (Developing Perl)
  • extensions, lookaround assertions: Lookaround Assertions (Developing Perl)
  • finding duplicate words in paragraphs: Pattern Modifiers (Developing Perl)
  • for untainting data: Detecting and Laundering Tainted Data (Developing Perl)
  • functions for matching: Perl Functions by Category (Developing Perl)
  • generated: Generated patterns (Developing Perl)
  • greedy matching: Quantifiers (Developing Perl)
  • • The Little Engine That /Could(n't) (Developing Perl)
  • grep function and: grep (Developing Perl)
  • match-time code evaluation: Match-time code evaluation (Developing Perl)
  • match-time pattern interpolation: Match-time pattern interpolation (Developing Perl)
  • matching
  • • operators for: Regular Expressions (Developing Perl)
    • • Pattern-Matching Operators (Developing Perl)
    • special variables for: Pattern-Matching Operators (Developing Perl)
    • • The s/// Operator (Substitution) (Perl Developing)
    • substrings corresponding to subpatterns: Pattern-Matching Operators (Developing Perl)
  • matching precedence: The Little Engine That /Could(n't) (Developing Perl)
  • metacharacters and metasymbols in: Metacharacters and Metasymbols (Developing Perl)
  • metasymbols in: Specific Characters (Developing Perl)
  • minimal matching: Minimal Matching (Developing Perl)
  • modifiers, cloistering: Cloistered Pattern Modifiers (Developing Perl)
  • modifiers for: Pattern Modifiers (Developing Perl)
  • Perl code, interjecting into: Programmatic Patterns (Developing Perl)
  • positions for matching: Positions (Developing Perl)
  • developing style for: Programmatic Patterns (Developing Perl)
  • quantifiers in: The Regular Expression Bestiary (Developing Perl)
  • • Metasymbol Tables (Developing Perl)
    • Quantifiers (Developing Perl)
    • The Little Engine That /Could(n't) (Perl Developing)
  • quotes in: Pick Your Own Quotes (Developing Perl)
  • re pragma, altering default behavior of: Perl Language Extensions and Internals (Developing Perl)
  • recursive matching: Match-time pattern interpolation (Developing Perl)
  • security concerns: Code Masquerading as Data (Developing Perl)
  • split function: split (Developing Perl)
  • split function and: Pattern-Matching Operators (Developing Perl)
  • study function: study (Developing Perl)
  • substitution evaluation: Substitution evaluations (Developing Perl)
  • terminating delimiter for: Pattern-Matching Operators (Developing Perl)
  • Unicode properties, matching on: Effects of Character Semantics (Developing Perl)
• PAUSE: Creating CPAN Modules (Developing Perl)
• PauseService() (Win32::Service): Reference: PauseService (Perl tutorial)
• pausing scripts: sleep (Developing Perl)
• PDL module: Example: Matrices (Advanced Perl Developing)
• • Multiplying Matrices (Perl tutorial)
• PDL (Perl Data Language): The CPAN modules Directory (Developing Perl)
• PDUs (protocol data units): The Twenty-Minute SNMP Tutorial (Perl for System Administration)
• • advantages/disadvantages of: How Perl Can Help (Perl for System Administration)
  • • managing logins: Database Logins (Perl for System Administration)
    • monitoring from: Monitoring Server Health (Perl for System Administration)
  • DBI, using: Using the DBI Framework (Perl for System Administration)
  • disk quotas, editing: Editing Quotas with edquota Trickery (Perl for System Administration)
  • • Net\:\:DNS: Using Net::DNS (Perl for System Administration)
    • nslookup: Using nslookup (Perl for System Administration)
    • raw sockets: Working with raw network sockets (Perl for System Administration)
  • edquota command, calling: Editing Quotas with edquota Trickery (Perl for System Administration)
  • • dissecting mailboxes/messages: Dissecting a Single Message (Perl for System Administration)
    • sending: Sending Mail (Perl for System Administration)
  • filesystems, dealing with differences in: Dealing with Filesystem Differences from Perl (Perl for System Administration)
  • functions, detecting file changes: Local Filesystem Changes (Perl for System Administration)
  • host files, reading: Host Files (Perl for System Administration)
  • • modifying entries: Modifying Entry Names (Perl for System Administration)
    • developing: LDAP Developing with Perl (Perl for System Administration)
  • LDIF, reading/writing: Adding Entries with LDIF (Perl for System Administration)
  • • analyzing: Log Analysis (Perl for System Administration)
    • rotating: Log Rotation (Perl for System Administration)
    • scanning: Text Logs (Perl for System Administration)
    • using unpack(): Using unpack( ) (Perl for System Administration)
  • modules (see modules)
  • networks, pinging/sniffing: Perl Saves the Day (Perl for System Administration)
  • NIS, querying: NIS, NIS+, and WINS (Perl for System Administration)
  • ODBC, using: Using the ODBC Framework (Perl for System Administration)
  • repositories: Locating and Installing Modules (Perl for System Administration)
  • security of: It's Not Easy Being Omnipotent (Perl for System Administration)
  • SNMP, using: Using SNMP from Perl (Perl for System Administration)
  • spam, finding source of: Tracking Down Spam (Perl for System Administration)
  • SQL commands, sending: Using the ODBC Framework (Perl for System Administration)
  • SQL databases, documenting: Server Documentation (Perl for System Administration)
  • SQL Server, interacting with: Interacting with an SQL Server from Perl (Perl for System Administration)
  • SYN attacks, detecting: Perl Saves the Day (Perl for System Administration)
  • system administration, as language for: How Perl Can Help (Perl for System Administration)
  • using Finger: Finger: A Simple Directory Service (Perl for System Administration)
  • using WHOIS: The WHOIS Directory Service (Perl for System Administration)
  • using WMI: Using Window Management Instrumentation (WMI) (Perl for System Administration)
• Peek module: Reading the Source (Advanced Perl Developing)
• • Inside SVs (Advanced Perl Developing)
• PeekInput() (Win32::Console): Reference: PeekInput (Perl tutorial)
• peephole optimizer: Compilation and code generation stages (Advanced Perl Developing)
• Peer option (IO::Socket::UNIX): IO::Socket::UNIX Reference (Perl tutorial)
• peeraddr() (IO::Socket::INET): Reference: peeraddr (Perl tutorial)
• PeerAddr option (IO::Socket::INET): IO::Socket::INET Reference (Perl tutorial)
• peerhost() (IO::Socket::INET): Reference: peerhost (Perl tutorial)
• peerpath() (IO::Socket::UNIX): Reference: peerpath (Perl tutorial)
• peerport() (IO::Socket::INET): Reference: peerport (Perl tutorial)
• PeerPort option (IO::Socket::INET): IO::Socket::INET Reference (Perl tutorial)
• performance: The Pursuit of Happiness (Developing Perl)
• • CGI scripts: CGI Overview (Perl tutorial)
  • • Running CGI Scripts with mod_perl (Perl tutorial)
  • efficient attribute storage: Efficient Attribute Storage (Advanced Perl Developing)
  • eval function to improve: Using Eval for Efficiency (Advanced Perl Developing)
  • measuring: times (Developing Perl)
  • memory management: View of the Internals (Advanced Perl Developing)
  • • Memory Management Using XS (Advanced Perl Developing)
  • Perl programs, efficiency in: Efficiency (Developing Perl)
  • references and: Performance Efficiency (Advanced Perl Developing)
  • typeglob aliases and: Using Typeglob Aliases (Advanced Perl Developing)
• period (see (dot))
• Perl: The Perl Interpreter (Advanced Perl Developing)
• • The Perl Interpreter (Perl tutorial)
  • advantages and uses: Why Perl? (Advanced Perl Developing)
  • • What's Perl Good For? (Perl tutorial)
  • API for: Embedding Overview (Advanced Perl Developing)
  • architecture: Architecture (Advanced Perl Developing)
  • bugs in, reporting: The perlbug Program (Perl tutorial)
  • C, extending with XSUB input and output: XSUB Input and Output (Developing Perl)
  • C, using from: Extending Perl (Using C from Perl) (Developing Perl)
  • • creating extensions: Creating Extensions (Developing Perl)
    • external C library functions, using: Using Functions from an External C Library (Developing Perl)
    • XSUBs and XS language: XS and XSUBs (Developing Perl)
  • code generation: On Code Generation (Advanced Perl Developing)
  • command-line options: Command-Line Options (Perl tutorial)
  • command processing: Command Processing (Perl tutorial)
  • compiler: Peek into the Future (Advanced Perl Developing)
  • • The Perl Compiler (Perl tutorial)
  • CPAN (Comprehensive Perl Archive Network): CPAN (Developing Perl)
  • debugger: Pretty-Printing (Advanced Perl Developing)
  • • Reading the Source (Advanced Perl Developing)
    • The Perl Debugger (Perl tutorial)
    • Debugger Commands (Perl tutorial)
    • Customizing the Debugger (Perl tutorial)
  • documentation, resources, technical support: Resources (Advanced Perl Developing)
  • • More information (Perl tutorial)
    • Perl Resources (Perl tutorial)
    • Documentation (Perl tutorial)
    • Pod (Perl tutorial)
    • = to signify in programs: Program Structure (Perl tutorial)
    • release notes: Platform Notes (Perl tutorial)
    • utilities for: Pod Utilities (Perl tutorial)
  • embedding: Embedding Perl:The Easy Way (Advanced Perl Developing)
  • • Calling a Perl Subroutine (Advanced Perl Developing)
    • Easy Embedding API (Advanced Perl Developing)
  • embedding in C: (Developing Perl) 21.4. Embedding Perl (Using Perl from C)
  • • compiling embedded programs: Compiling Embedded Programs (Developing Perl)
    • Perl interpreter, adding to C program: Adding a Perl Interpreter to Your C Program (Developing Perl)
    • Perl stack, manipulating from C: Fiddling with the Perl Stack from C (Developing Perl)
    • Perl statement, evaluating from C: Evaluating a Perl Statement from C (Developing Perl)
    • Perl subroutine, calling from C: Calling a Perl Subroutine from C (Developing Perl)
  • example scripts: Perl examples (Perl tutorial)
  • executor: Executor (Advanced Perl Developing)
  • extensions and internals, modules for: Perl Language Extensions and Internals (Developing Perl)
  • future of: Peek into the Future (Advanced Perl Developing)
  • history of: Perl Development (Perl tutorial)
  • installing source code: Installing Perl (Perl tutorial)
  • language syntax: Language Syntax (Advanced Perl Developing)
  • location of: Location of Perl (Developing Perl)
  • models to interface or emulate other languages: The CPAN modules Directory (Developing Perl)
  • obtaining: Installing Perl (Perl tutorial)
  • developing, common practices: Common Practices (Developing Perl)
  • developing conventions: Conventions Used in this tutorial (Perl tutorial)
  • programs, life cycle of: The Life Cycle of a Perl Program (Developing Perl)
  • pseudohash implementations of: my (Developing Perl)
  • quoting packages for: Package-Quoted Classes (Developing Perl)
  • scalar-tying: Scalar-Tying Methods (Developing Perl)
  • special characters in: Variable Syntax (Developing Perl)
  • thread developing in: The Thread Model (Developing Perl)
  • translator: Translator (Advanced Perl Developing)
  • use of Unicode, caveats on: Caution, [ren2bold] Working (Developing Perl)
  • using C with: Extending Perl:A First Course (Advanced Perl Developing)
  • • Example: Fractals with Perl (Advanced Perl Developing)
  • value types: Perl Value Types (Advanced Perl Developing)
  • version number, returning: UNIVERSAL: The Ultimate Ancestor Class (Developing Perl)
• Class::Multimethods module: Accessing Overridden Methods (Developing Perl)
• perl-bin directory: Running CGI Scripts with mod_perl (Perl tutorial)
• Perl Data Language (PDL) module: Slices (Developing Perl)
• Perl, history of: History Made Practical (Developing Perl)
• Perl interpreter: How to Do It (Developing Perl)
• • The Life Cycle of a Perl Program (Developing Perl)
  • -- switch: Switches (Developing Perl)
  • -0 switch: Command Processing (Developing Perl)
  • • Switches (Developing Perl)
  • -a switch: Switches (Developing Perl)
  • • Special Variables in Alphabetical Order (Developing Perl)
  • -c switch: Switches (Developing Perl)
  • -d switch: Switches (Developing Perl)
  • • The Perl Debugger (Developing Perl)
    • The Perl Profiler (Developing Perl)
• -e switch: How to Do It (Developing Perl)
• • Switches (Developing Perl)
• -F switch: Switches (Developing Perl)
• • Switches (Developing Perl)
• -h switch: Switches (Developing Perl)
• -I switch: Command Processing (Developing Perl)
• • Switches (Developing Perl)
• -l switch: Switches (Developing Perl)
• -m switch: Switches (Developing Perl)
• -n switch: Switches (Developing Perl)
• -p switch: Switches (Developing Perl)
• -s switch: Switches (Developing Perl)
• • The Perl Debugger (Developing Perl)
• -T switch: Switches (Developing Perl)
• • Networking Servers (Developing Perl)
  • Handling Insecure Data (Developing Perl)
• -u switch: Switches (Developing Perl)
• -v switch: Switches (Developing Perl)
• -w switch: How to Do It (Developing Perl)
• • Diagnostic Messages (Developing Perl)
  • Switches (Developing Perl)
• -x switch: Command Processing (Developing Perl)
• • Switches (Developing Perl)
• switches: Switches (Developing Perl)
• sticky bit: Time Efficiency (Developing Perl)

• Perl Institute: The Perl Institute (www.perl.org) (Perl tutorial)
• Perl Journal: The Perl Journal (Perl tutorial)
• Perl library: Installing CPAN Modules into the Perl Library (Developing Perl)
• Perl modules for: The CPAN modules Directory (Developing Perl)

• • members, login names: The CPAN modules Directory (Developing Perl)

• Perl Package Manager (see PPM)
• Perl Porters: Perl Development (Perl tutorial)
• Perl Profiler (DProf): The Perl Profiler (Perl tutorial)
• Perl version: Building Character (Developing Perl)
• Perl virtual machine: Executing Your Code (Developing Perl)

• Executing Your Code (Developing Perl)

• perl_alloc function: Embedding Overview (Advanced Perl Developing)
• perlapi manpage: Evaluating a Perl Statement from C (Developing Perl)
• perlbug program: The perlbug Program (Perl tutorial)
• perlcall manpage: Fiddling with the Perl Stack from C (Developing Perl)
• perl_call_argv function: Embedding Overview (Advanced Perl Developing)

• Examples (Advanced Perl Developing)

• perl_call_va function: Embedding Overview (Advanced Perl Developing)

• Examples (Advanced Perl Developing)
• Easy Embedding API (Advanced Perl Developing)

• perlcc: Special Variables in Alphabetical Order (Developing Perl)
• perlcc command: Compiler Backends (Developing Perl)

• pbyscript resulting from: The Bytecode Generator (Developing Perl)

• $PERLDB: Special Variables in Alphabetical Order (Developing Perl)
• perlcc utility: The Perl Compiler (Perl tutorial)
• .perldb file: Customizing the Debugger (Perl tutorial)
• perl_construct function: Embedding Overview (Advanced Perl Developing)
• PERL5DB environment variable: Environment Variables (Developing Perl)

• debugger, customizing with: Customizing with Init Files (Developing Perl)

• $PERLDB ($^P) variable: Global Special Variables (Perl tutorial)
• PERLDB_OPTS environment variable

• AutoTrace option, tracing compile-phase statements: Using the Debugger (Developing Perl)
• debugger customization via: Debugger Customization (Developing Perl)

• PERLDB_OPTS variable: Customizing the Debugger (Perl tutorial)
• PERL_DEBUG_MSTATS environment variable: Environment Variables (Developing Perl)
• PERL_DEBUG_MSTATS variable: Environment Variables (Perl tutorial)
• PERL_DESTRUCT_LEVEL environment variable: Environment Variables (Developing Perl)
• PERL_DESTRUCT_LEVEL variable: Environment Variables (Perl tutorial)

• Garbage Collection with DESTROY Methods (Developing Perl)

• perldoc command: Online Documentation (Developing Perl)

• Modules (Developing Perl)
• debugger invoking: Miscellaneous Commands (Developing Perl)

• <Perl> directives (Apache): <Perl> Sections (Perl tutorial)
• perldoc utility: Documenting Your Module with Pod (Perl tutorial)

• Reference: perldoc (Perl tutorial)
• Installing the Documentation (Perl tutorial)

• perlembed manpage: Embedding Perl (Using Perl from C) (Developing Perl))

• eval_sv function, demonstrating: Evaluating a Perl Statement from C (Developing Perl)

• perl_eval_va function: Embedding Overview (Advanced Perl Developing)

• Examples (Advanced Perl Developing)
• Easy Embedding API (Advanced Perl Developing)

• perlfork documentation: Interprocess Communication (Developing Perl)
• PerlHandler directive (mod_perl): mod_perl Handlers (Perl tutorial)

• Running CGI Scripts with mod_perl (Perl tutorial)

• PerlInterpreter structure: Multiple interpreters (Advanced Perl Developing)
• PerlIO object: Perl Objects (Advanced Perl Developing)
• PERL5LIB environment variable: Load Path (Advanced Perl Developing)

• Keeping Your Own Module Directory (Perl tutorial)
• Environment Variables (Perl tutorial)
• Environment Variables (Developing Perl)

• PERLLIB variable: Environment Variables (Perl tutorial)
• perllocale manpage: lc (Developing Perl)
• PERL_MAILERS variable: Send Email with Mail::Mailer (Perl tutorial)
• perlman text viewer: GUI Example: Man Page Viewer (Advanced Perl Developing)
• perlmenu module: Managing the Screen (Perl tutorial)
• perlmodinstall manpage: Using CPAN Modules (Developing Perl)
• PERL5OPT environment variable: Environment Variables (Developing Perl)
• PerlModule directive (mod_perl): Running CGI Scripts with mod_perl (Perl tutorial)
• PERL_MODULE_EXT variable: The Perl Compiler (Perl tutorial)
• Perl Package Manager (PPM): Using the Perl Package Manager (Perl tutorial)
• PERL5OPT variable: Environment Variables (Perl tutorial)
• perl_parse function: Embedding Overview (Advanced Perl Developing)

• Examples (Advanced Perl Developing)

• $PERL_VERSION: Global Special Variables (Perl tutorial)

• Special Variables in Alphabetical Order (Developing Perl)
• Special Variables in Alphabetical Order (Developing Perl)

• perlport documentation: Interprocess Communication (Developing Perl)
• PERL5SHELL environment variable: Environment Variables (Developing Perl)
• PerlScript

• PerlScript (Perl tutorial)
• client-side: Client-Side PerlScript (Perl tutorial)
• server-side: Server-Side PerlScript (Perl tutorial)

• PERL_SCRIPT_EXT variable: The Perl Compiler (Perl tutorial)
• perl-script handler: mod_perl Handlers (Perl tutorial)

• Running CGI Scripts with mod_perl (Perl tutorial)

• PerlSendHeader directive (mod_perl): Running CGI Scripts with mod_perl (Perl tutorial)
• PERL5SHELL variable: Environment Variables (Perl tutorial)
• Perl/Tk: User Efficiency (Developing Perl)

• Perl modules for: The CPAN modules Directory (Developing Perl)

• Perl/Tk toolkit: Starting with Perl/Tk (Advanced Perl Developing)

• Introduction (Perl tutorial)
• Perl/Tk (Perl tutorial)
• callbacks: Callbacks (Perl tutorial)
• colors and fonts: Colors and Fonts (Perl tutorial)
• dialog boxes: Creating Dialog Boxes with Tk (Perl tutorial)
• event bindings: Event Bindings (Advanced Perl Developing)
• event loops: Event Loops (Advanced Perl Developing)
• geometry managers: Geometry Managers (Perl tutorial)
• menus: Creating Menus with Tk (Perl tutorial)
• ptK (portable Tk): Introduction to GUIs, Tk, and Perl/Tk (Advanced Perl Developing)
• removing DOS shell window: Removing the DOS Shell Window with Windows Perl/Tk (Perl tutorial)
• resize events: Responding to Tk Resize Events (Perl tutorial)
• scrollbars: Scrollbars (Perl tutorial)
• timers: Timers (Advanced Perl Developing)
• tkshufflepod program: Program: tkshufflepod (Perl tutorial)
• widgets: Tk Widget Reference (Advanced Perl Developing)
• • Widgets (Perl tutorial)
  • Button widget: The Button Widget (Perl tutorial)
  • Canvas widget: The Canvas Widget (Perl tutorial)
  • Checkbutton widget: The Checkbutton Widget (Perl tutorial)
  • common configuration options: Common Widget Configuration Options (Perl tutorial)
  • Entry widget: The Entry Widget (Perl tutorial)
  • Frame widget: The Frame Widget (Perl tutorial)
  • Label widget: The Label Widget (Perl tutorial)
  • Listbox widget: The Listbox Widget (Perl tutorial)
  • Menu widget: The Menu Widget (Perl tutorial)
  • Menubutton widget: The Menubutton Widget (Perl tutorial)
  • Optionmenu widget: The Optionmenu Widget (Perl tutorial)
  • Radiobutton widget: The Radiobutton Widget (Perl tutorial)
  • Scale widget: The Scale Widget (Perl tutorial)
  • Scrollbar widget: The Scrollbar Widget (Perl tutorial)
  • Text widget: The Text Widget (Perl tutorial)
  • toplevel widget: The Toplevel Widget (Perl tutorial)
• widgets methods: Widget Methods (Perl tutorial)

• perltoot document: Closures Versus Objects (Advanced Perl Developing)
• $PERL_VERSION ($]) variable: Global Special Variables (Perl tutorial)
• perlwin32 documentation: Interprocess Communication (Developing Perl)
• permissions

• sysopen (Developing Perl)
• umask (Developing Perl)
• file permission operators, interpreting: Named Unary and File Test Operators (Developing Perl)
• generating all possible: Program: permute (Perl tutorial)
• testing files for trustworthiness: Testing a File for Trustworthiness (Perl tutorial)
• users, granting limited: Handling Insecure Data (Developing Perl)

• permute program: Program: permute (Perl tutorial)
• persistence: Persistence (Advanced Perl Developing)

• Implementing Object Persistence (Advanced Perl Developing)
• Adaptor project: Implementing Object Persistence (Advanced Perl Developing)
• data structures: Transparently Persistent Data Structures (Perl tutorial)
• database data: Persistent Data (Perl tutorial)
• record-oriented: Record-Oriented Approach (Advanced Perl Developing)
• streamed data: Streamed Data (Advanced Perl Developing)
• subroutine variables: Creating Persistent Private Variables (Perl tutorial)
• transparent (orthogonal): Implementing Object Persistence (Advanced Perl Developing)
• • Design Goals (Advanced Perl Developing)

• persistent data structures, providing via tie: Tie Modules on CPAN (Developing Perl)
• persistent Perl interpreter: (Developing Perl) 21.4. Embedding Perl (Using Perl from C)
• PF_ constants: Introduction (Perl tutorial)
• .ph filename extension: Using h2ph to Translate C #include Files (Perl tutorial)
• phrase() (Mail::Address): Reference: phrase (Perl tutorial)

• Parse Email Addresses with Mail::Address (Perl tutorial)

• pi: atan2 (Developing Perl)

• Pics property (Response object): Response properties (Perl tutorial)
• picture lines: Formats (Developing Perl)

• format (Developing Perl)

• pid (see processes)
• PID (process ID): Special Variables in Alphabetical Order (Developing Perl)
• $PID ($$) variable: Global Special Variables (Perl tutorial)
• ping() (DBI): Reference: ping (Perl tutorial)
• pinging machines: Pinging a Machine (Perl tutorial)
• pipe(): Introduction (Perl tutorial)

• Communicating Between Related Processes (Perl tutorial)
• Reference: pipe (Perl tutorial)

• pipe function: pipe (Developing Perl)

• portability of: (Developing Perl) 25.5. Interprocess Communication (IPC)

• pipe# programs (examples): Communicating Between Related Processes (Perl tutorial)
• pipelines

• multistage, for input: Anonymous Pipes (Developing Perl)
• multistage, for output: Anonymous Pipes (Developing Perl)

• pipes

• closing: close (Developing Perl)
• double-ended, opening with tied filehandle: Creative Filehandles (Developing Perl)
• in interprocess communication: Pipes (Developing Perl)
• • named pipes: Named Pipes (Developing Perl)
  • process talking to itself: Talking to Yourself (Developing Perl)
• IO::Pipe module: Filehandle, Directory Handle, and Stream I/O Utilities (Developing Perl)
• open function, security risks posed by: Cleaning Up Your Environment (Developing Perl)
• read-only filehandles, opening: open (Developing Perl)

• pixmaps, widgets and: Images (Advanced Perl Developing)
• place geometry manager (Perl/Tk): The Place Geometry Manager (Perl tutorial)
• placeForget() (place geometry manager): The Place Geometry Manager (Perl tutorial)
• placeholders, DBI: Using the DBI Framework (Perl for System Administration)
• placeInfo() (place geometry manager): The Place Geometry Manager (Perl tutorial)
• places(): Overloading Operators (Perl tutorial)
• placeSlaves() (place geometry manager): The Place Geometry Manager (Perl tutorial)
• plain old documentation (see pod)
• platform independence: Persistence Issues (Advanced Perl Developing)
• platforms: Which Platforms Support Perl? (Perl tutorial)
• plotting expressions: Expression plotting (Advanced Perl Developing)
• pluralities: Pluralities (Developing Perl)
• .pm file extension: Packages (Developing Perl)
• pluralizing words: Printing Correct Plurals (Perl tutorial)
• .pm and .pl files: Packages and Files (Advanced Perl Developing)

• Introduction (Perl tutorial)
• Namespaces and Packages (Perl tutorial)

• .pm files, loading associated files with: Using Modules (Developing Perl)
• pmdesc program (example): Program: Finding Versions and Descriptions of Installed Modules (Perl tutorial)
• =pod command (pod): Reference: =pod (Perl tutorial)
• pod

• directives: Pod Directives (Developing Perl)
• embedding in Perl: Molecules (Developing Perl)

• pod documentation: On Code Generation (Advanced Perl Developing)

• Documenting Your Module with Pod (Perl tutorial)
• Documentation (Perl tutorial)
• Pod (Perl tutorial)
• = to signify in programs: Program Structure (Perl tutorial)
• sorting =head1 sections: Program: tkshufflepod (Perl tutorial)
• utilities for: Pod Utilities (Perl tutorial)

• POD modules

• Pod::Functions module: Pod::Functions (Perl tutorial)
• Pod::Html module: Pod::Html (Perl tutorial)
• Pod::Text module: Pod::Text (Perl tutorial)

• pod utilities

• pod2fm utility: Reference: pod2fm (Perl tutorial)
• pod2html utility: Documenting Your Module with Pod (Perl tutorial)
• • Reference: pod2html (Perl tutorial)
  • Pod::Html (Perl tutorial)
• pod2latex utility: Reference: pod2latex (Perl tutorial)
• pod2man utility: Reference: pod2man (Perl tutorial)
• pod2text utility: Documenting Your Module with Pod (Perl tutorial)
• • Reference: pod2text (Perl tutorial)
  • Pod::Text (Perl tutorial)

• Pod::Functions module: Documentation Support (Developing Perl)
• Pod::Html module: Documentation Support (Developing Perl)
• Pod::InputObjects module: Documentation Support (Developing Perl)
• Pod::Man module: Documentation Support (Developing Perl)
• Pod::Parser module: Documentation Support (Developing Perl)
• Pod::Select module: Documentation Support (Developing Perl)
• Pod::Text module: Documentation Support (Developing Perl)
• Pod::Text::Termcap module: Documentation Support (Developing Perl)
• Pod::Usage module: Documentation Support (Developing Perl)
• POE (Perl Object Environment): The CPAN modules Directory (Developing Perl)
• poetry in Perl: Perl Poetry (Developing Perl)
• pointer values (PVs): Scalar Values (Advanced Perl Developing)
• pointers

• Built-in Data Types (Developing Perl)
• references, unable to convert to: Scalar Values (Developing Perl)
• to strings: pack (Developing Perl)

• pointers (C language): References (Developing Perl)
• Poison Null Byte exploit: Be Careful When Reading Data (Perl for System Administration)
• poll function: Filehandle, Directory Handle, and Stream I/O Utilities (Developing Perl)
• polluting your namespace: Module Privacy and the Exporter (Developing Perl)
• polymorphism: OO: An Introduction (Advanced Perl Developing)

• The Need for Polymorphism (Advanced Perl Developing)
• Brief Refresher on Object-Oriented Lingo (Developing Perl)

• "poor man's garbage collection": Reference Counts (Advanced Perl Developing)
• pop()

• Reference: pop (Perl tutorial)
• circular lists: Implementing a Circular List (Perl tutorial)
• on multiple array elements: Processing Multiple Elements of an Array (Perl tutorial)
• Tie::IxHash module and: Retrieving from a Hash in Insertion Order (Perl tutorial)

• pop function: Data Structures (Developing Perl)

• pop (Developing Perl)

• POP method: Array-Tying Methods (Developing Perl)
• POP3 protocol, interface to: Net::POP3 (Advanced Perl Developing)

• Retrieving Email with Net::POP3 (Perl tutorial)
• Reading Email with Mail::POP3Client (Perl tutorial)

• POP3 servers: Reading Mail with POP3 (Perl tutorial)
• popen function (C language): (Developing Perl) 21.4. Embedding Perl (Using Perl from C)
• popgrep# programs (examples): Speeding Up Interpolated Matches (Perl tutorial)
• popstat() (Net::POP3): Reference: popstat (Perl tutorial)
• POPStat() (Mail::POP3Client): Reference: POPStat (Perl tutorial)
• popup_menu() (CGI.pm): Reference: popup_menu (Perl tutorial)
• popup menus

• port()

• Net::FTP module: Reference: port (Perl tutorial)
• URI::URL module: Reference: port (Perl tutorial)

• Port() (Mail::POP3Client): Reference: Port (Perl tutorial)
• portability: Persistence Issues (Advanced Perl Developing)

• Files and Filesystems (Developing Perl)

• File::Temp module, dealing with race conditions: Temporary Files (Developing Perl)
• portability of: Files and Filesystems (Developing Perl)

• Interprocess Communication (IPC) (Perl Developing)
• servers, cloning themselves with: Networking Servers (Developing Perl)
• Unicode: Unicode (Developing Perl)
• zombie processes and: Reaping Zombies (Developing Perl)

• fork syscall: Anonymous Pipes (Developing Perl)
• Perl programs: Portable Perl (Developing Perl)

• functions, information on: Perl Functions in Alphabetical Order (Developing Perl)
• of files and filesystems: Files and Filesystems (Developing Perl)
• of signals: System Interaction (Developing Perl)
• scripts using gethostent function: gethostent (Developing Perl)

• Porters: Perl Development (Perl tutorial)
• porting, information on: Interprocess Communication (Developing Perl)
• porting, efficiency of: Porter Efficiency (Developing Perl)

• name/number translations for: getservbyname (Developing Perl)
• Perl, to operating systems: CPAN (Developing Perl)

• ports and port numbers: Networking Primer (Advanced Perl Developing)

• connection attempts, logging: Program: backsniff (Perl tutorial)

• pos(): Matching from Where the Last Pattern Left Off (Perl tutorial)

• Reference: pos (Perl tutorial)
• Reference: pos (Perl tutorial)

• pos function: Progressive Matching (Developing Perl)

• Where You Left Off: The \G Assertion (Developing Perl)
• pos (Developing Perl)

• positional assertions: Where You Left Off: The \G Assertion (Developing Perl)

• ordering of matching, changing with: Alternation (Developing Perl)

• positionfrom() (Frame widget): Toplevel Methods (Perl tutorial)
• positioning text widgets: Inserting text at absolute positions (Advanced Perl Developing)
• positions: Positions (Developing Perl)

• beginnings of strings, matching: Beginnings: The \A and ^ Assertions (Developing Perl)
• ends of strings, matching: Endings: The \z, \Z, and $ Assertions (Developing Perl)
• operators switching to character positions: Effects of Character Semantics (Developing Perl)
• position just after previous match, specifying: Where You Left Off: The \G Assertion (Developing Perl)
• precedence in pattern matching: The Little Engine That /Could(n't) (Perl Developing)
• substr function, manipulating with: Positions (Developing Perl)
• word boundaries, matching: Boundaries: The \b and \B Assertions (Developing Perl)

• positive lookahead assertions: The Little Engine That /Could(n't) (Developing Perl)

• Lookaround Assertions (Developing Perl)

• POSIX classes: Character Classes (Developing Perl)
• POSIX module: POSIX (Perl tutorial)

• Operating System Interfaces (Developing Perl)
• blocking signals: Blocking Signals (Perl tutorial)
• floor() and ceil(): Rounding Floating-Point Numbers (Perl tutorial)
• getattr function: getc (Developing Perl)
• getting exported functions and variables with: Using Modules (Developing Perl)
• setsid function: Making a Daemon Server (Perl tutorial)
• signal blocking with: Blocking Signals (Developing Perl)
• strftime function: localtime (Developing Perl)
• termios interface: Using POSIX termios (Perl tutorial)
• trigonometric functions: Calculating More Trigonometric Functions (Perl tutorial)

• POSIX-style character classes: POSIX-Style Character Classes (Developing Perl)
• possible matches, specifying set of: Alternation (Developing Perl)
• post-incremented (post-decremented) variables: Unary Arithmetic Operators (Developing Perl)
• post() (Menu widget): Menu Methods (Perl tutorial)
• post() (Net::NNTP): Reference: post (Perl tutorial)

• The NNTP Protocol (Perl tutorial)

• POST method: Introduction (Perl tutorial)

• Writing a CGI Script (Perl tutorial)
• Automating Form Submission (Perl tutorial)
• Transferring the Form Data (Perl tutorial)
• HTTP::Request (Perl tutorial)

• Post Office Protocol (POP3): Retrieving Email with Net::POP3 (Perl tutorial)

• Reading Email with Mail::POP3Client (Perl tutorial)

• postcascade() (Menu widget): Menu Methods (Perl tutorial)
• -postcommand option (Menu): The Menu Widget (Perl tutorial)
• postincrement and postdecrement operators: Unary and Binary Operators (Developing Perl)
• $POSTMATCH: Special Variables in Alphabetical Order (Developing Perl)
• posting news articles: Reading and Posting Usenet News Messages (Perl tutorial)

• The NNTP Protocol (Perl tutorial)

• $POSTMATCH ($') variable: Introduction (Perl tutorial)

• Regular Expression Special Variables (Perl tutorial)

• postok() (Net::NNTP): Reference: postok (Perl tutorial)
• postscript() (Canvas): Canvas Methods (Perl tutorial)
• PostScript, converting HTML parse tree to: HTML::FormatPS (Perl tutorial)
• Postscript, Perl modules for: The CPAN modules Directory (Developing Perl)
• PPM (Perl Package Manager): Using the Perl Package Manager (Perl tutorial)

• Using CPAN Modules (Developing Perl)
• Using CPAN Modules (Developing Perl)
• Installing Modules on Win32 (Perl for System Administration)

• pragma: Effects of Character Semantics (Developing Perl)
• pragmas: Introduction (Perl tutorial)

• Simplicities (Developing Perl)
• Global Declarations (Developing Perl)
• Pragmas (Developing Perl)
• Packages (Developing Perl)
• Switches (Developing Perl)
• use (Developing Perl)
• lexically scoped: Pragmas (Developing Perl)
• modules and: Using Modules (Developing Perl)
• names, capitalization in: Names (Developing Perl)
• use charnames: String Literals (Developing Perl)

• pre-extending arrays: Time Efficiency (Developing Perl)
• pre-forking servers: Pre-Forking Servers (Perl tutorial)
• pre-incremented (pre-decremented) variables: Unary Arithmetic Operators (Developing Perl)
• preallocating memory for hashes: Presizing a Hash (Perl tutorial)
• precedence

• Operators (Perl tutorial)
• Functions (Developing Perl)
• diagnostic messages: Diagnostic Messages (Developing Perl)
• key/value pair (hashes): Hashes (Developing Perl)
• logical operators: Logical Operators (Developing Perl)
• • Logical and, or, not, and xor (Developing Perl)
  • Syntactic Snafus with Indirect Objects (Developing Perl)
• modifiers vs. commas: Scoped Variable Declarations (Developing Perl)
• operator, table of: Unary and Binary Operators (Developing Perl)
• Perl versions, changes in: Previous Perl Traps (Developing Perl)
• references and: Confusion About Precedence (Advanced Perl Developing)
• regular expression matching: The Little Engine That /Could(n't) (Perl Developing)
• unary operators, higher than binary: Named Unary and File Test Operators (Developing Perl)

• precision, controlling in output: Overloading Operators (Perl tutorial)
• predeclaring subroutines: Method Autoloading (Developing Perl)

• Perl Language Extensions and Internals (Developing Perl)

• predefined Perl variables

• Special Variables (Perl tutorial)

• prefix operators: Operators (Developing Perl)

• Unary and Binary Operators (Developing Perl)
• metacharacters working as: Metacharacters and Metasymbols (Developing Perl)

• $PREMATCH: Special Variables in Alphabetical Order (Developing Perl)
• preforker program (example): Pre-Forking Servers (Perl tutorial)
• $PREMATCH ($`) variable: Introduction (Perl tutorial)

• Regular Expression Special Variables (Perl tutorial)

• prepare() (DBI): Reference: prepare (Perl tutorial)

• Database Handles and Statement Handles (Perl tutorial)

• prepare statement (SQL): Select (Advanced Perl Developing)
• prepending, directories to @INC: Switches (Developing Perl)
• prepending elements to arrays: unshift (Developing Perl)
• preprocessing Perl: Generating Perl in Other Languages (Developing Perl)

• pretty-printing: Pretty-Printing (Advanced Perl Developing)
• prev_labeled() (Mail::Folder): Reference: prev_labeled_message (Perl tutorial)
• prev_message() (Mail::Folder): Reference: prev_message (Perl tutorial)
• prime numbers, calculating: Program: Calculating Prime Factors (Perl tutorial)
• prime_pattern program (example): Detecting Duplicate Words (Perl tutorial)
• print(): Introduction (Perl tutorial)

• Reference: print (Perl tutorial)
• filehandle keyword and

• Socket module: Client Connections (Perl tutorial)
• print function: Filehandles (Developing Perl)

• List Processing (Developing Perl)
• Time Efficiency (Developing Perl)
• Time Efficiency (Developing Perl)
• print (Developing Perl)
• implementing to tied filehandle: Filehandle-Tying Methods (Developing Perl)

• print statements, comma error in: Universal Blunders (Developing Perl)
• PrintError attribute (DBI): Database Handles and Statement Handles (Perl tutorial)
• printers, managing with ADSI: Working with Print Queues and Print Jobs via ADSI (Perl for System Administration)
• printf()

• Reference: printf (Perl tutorial)
• %c format: Converting Between ASCII Characters and Values (Perl tutorial)
• rounding floating-point numbers: Rounding Floating-Point Numbers (Perl tutorial)

• printf function: Conditional Operator (Developing Perl)

• Time Efficiency (Developing Perl)
• printf (Developing Perl)
• sprintf (Developing Perl)
• using on tied filehandle: Filehandle-Tying Methods (Developing Perl)

• print_header() (Mail::Internet): Reference: print_header (Perl tutorial)
• printing

• arrays of hashes: Access and Printing of an Array of Hashes (Developing Perl)
• data structures: Printing Data Structures (Perl tutorial)
• datetime information: Printing a Date (Perl tutorial)
• hashes: Printing a Hash (Perl tutorial)
• hashes of arrays: Access and Printing of a Hash of Arrays (Developing Perl)
• lists with commas: Printing a List with Commas (Perl tutorial)
• multidimensional arrays: Access and Printing (Developing Perl)
• • Hashes of Arrays (Developing Perl)
  • Hashes of Hashes (Developing Perl)
• multidimensional hashes: Access and Printing of a Hash of Hashes (Developing Perl)
• • Composition, Access, and Printing of More Elaborate Records (Developing Perl)
• nested data structures: Display (Developing Perl)
• simultaneously to multiple filehandles: Printing to Many Filehandles Simultaneously (Perl tutorial)
• specific lines from files: Introduction (Perl tutorial)
• typeglob contents: Debugger Options (Developing Perl)

• print_line program (example): Reading a Particular Line in a File (Perl tutorial)
• PrintRet option (debugger): Debugger Options (Developing Perl)
• priority, process: getpriority (Developing Perl)

• setpriority (Developing Perl)

• privacy: References to Anonymous Storage (Advanced Perl Developing)

• Privacy (Advanced Perl Developing)
• Brief Refresher on Object-Oriented Lingo (Developing Perl)
• Perl modules and: Module Privacy and the Exporter (Developing Perl)

• private methods: Introduction (Perl tutorial)

• ignoring inheritance with: Private Methods (Developing Perl)

• private variables: Making Variables Private to a Function (Perl tutorial)

• Making Variables Private to a Module (Perl tutorial)
• Declarations and Scope (Perl tutorial)
• Private and Local Variables (Perl tutorial)
• (see also lexical variables)

• private objects, closures, using for: Using Closures for Private Objects (Developing Perl)
• privileges: Drop Your Privileges as Soon as Possible (Perl for System Administration)

• dropping: Drop Your Privileges as Soon as Possible (Perl for System Administration)

• /proc filesystem: Using the /proc Filesystem (Perl for System Administration)

• Mac OS: MacOS Process Control (Perl for System Administration)
• Unix: Unix Process Control (Perl for System Administration)
• Windows/2000: NT/2000 Process Control (Perl for System Administration)

• procedureal developing style: Programmatic Patterns (Developing Perl)
• procedures: Verbs (Developing Perl)
• process groups: Signals (Developing Perl)

• setpgrp (Developing Perl)

• process handles: Using the Win32::IProc Module (Perl for System Administration)
• process ID (pid)

• getting process group from: getpgrp (Developing Perl)
• returning: getppid (Developing Perl)
• returning with fork: fork (Developing Perl)
• waitpid function: waitpid (Developing Perl)

• $PROCESS_ID ($$) variable: Global Special Variables (Perl tutorial)
• processes: Introduction (Perl tutorial)

• catching Ctrl-C: Catching Ctrl-C (Perl tutorial)
• checking for existence: Signaling Process Groups (Developing Perl)
• communicating between: Communicating Between Related Processes (Perl tutorial)
• controlling program input/output: Controlling Input and Output of Another Program (Perl tutorial)
• creating: Introduction (Perl tutorial)
• DLLs used by: Using the Win32::IProc Module (Perl for System Administration)
• executables used by: Using the Win32::IProc Module (Perl for System Administration)
• • Mac: MacOS Process Control (Perl for System Administration)
  • Unix: Using the Proc::ProcessTable Module (Perl for System Administration)
  • • Unix Process Control (Perl for System Administration)
  • Windows/2000: Using the Win32::Setupsup Module (Perl for System Administration)
  • • Using the Win32::Setupsup Module (Perl for System Administration)
• filtering output: Filtering Your Own Output (Perl tutorial)
• fork function: fork (Developing Perl)
• functions dealing with: Perl Functions by Category (Developing Perl)
• gathering program output: Gathering Output from a Program (Perl tutorial)
• getting group for: setpgrp (Developing Perl)
• groups: Program: lockarea (Perl tutorial)
• • Sending a Signal (Perl tutorial)
• ID (pid): open (Developing Perl)
• imitating files with named pipes: Making a Process Look Like a File with Named Pipes (Perl tutorial)
• interprocess communication: Interprocess Communication (Developing Perl)
• • between processes on same machine: Interprocess Communication (Developing Perl)
  • files: Files (Developing Perl)
  • on the Internet: Interprocess Communication (Developing Perl)
  • sockets: Sockets (Developing Perl)
  • System V IPC: System V IPC (Developing Perl)
• killing: kill (Developing Perl)
• managing: Win32::Process (Perl tutorial)
• multitasking environments, CPU access: Handling Timing Glitches (Developing Perl)
• preprocessing input: Preprocessing Input (Perl tutorial)
• priority, setting: setpriority (Developing Perl)
• process model, threads: The Process Model (Developing Perl)
• reading from/writing to programs: Reading or Writing to Another Program (Perl tutorial)
• reading STDERR from programs: Reading STDERR from a Program (Perl tutorial)
• replacing programs: Replacing the Current Program with a Different One (Perl tutorial)
• returning priority of: getpriority (Developing Perl)
• running multiple programs: Running Another Program (Perl tutorial)
• sharing variables among: Sharing Variables in Different Processes (Perl tutorial)
• signaling process groups: Signaling Process Groups (Developing Perl)
• signals: Introduction (Perl tutorial)
• • Listing Available Signals (Perl tutorial)
  • Sending a Signal (Perl tutorial)
  • Installing a Signal Handler (Perl tutorial)
  • Blocking Signals (Perl tutorial)
• standard input, output, and error in: Filehandles (Developing Perl)
• timing out operations: Timing Out an Operation (Perl tutorial)
• umask for: umask (Developing Perl)
• variables for: Special Variables in Alphabetical Order (Developing Perl)
• waiting for: wait (Developing Perl)
• windows open, interacting with: Using the Win32::Setupsup Module (Perl for System Administration)
• zombie: Introduction (Perl tutorial)
• • Avoiding Zombie Processes (Perl tutorial)
  • Reaping Zombies (Developing Perl)

• $PROCESS_ID: Special Variables in Alphabetical Order (Developing Perl)
• processing shell commands: Command Processing (Developing Perl)
• processor (see CPU)
• procmail program: Account System Wrap-Up (Perl for System Administration)
• Proc\:\:ProcessTable module: Using the Proc::ProcessTable Module (Perl for System Administration)
• product_tokens() (HTTP::Daemon): Reference: product_tokens (Perl tutorial)
• professors/students/courses example: Professors, Students, Courses (Advanced Perl Developing)
• profiler, Perl: The Perl Profiler (Developing Perl)
• profiler, Perl (DProf): The Perl Profiler (Perl tutorial)
• -prog option (perlcc): The Perl Compiler (Perl tutorial)
• profiling, Devel::DProf module: Perl Language Extensions and Internals (Developing Perl)
• program arguments, shell vs. Perl: Shell Traps (Developing Perl)
• program flow control functions: Perl Functions by Category (Perl tutorial)
• program name

• of perl executable: Special Variables in Alphabetical Order (Developing Perl)
• of perl script: Special Variables in Alphabetical Order (Developing Perl)

• program structure: Program Structure (Perl tutorial)
• $PROGRAM_NAME ($0) variable: Global Special Variables (Perl tutorial)
• developing languages, Perl modules for interfacing with or emulating: The CPAN modules Directory (Developing Perl)
• developing, Perl: Common Practices (Developing Perl)

• common mistakes by novices: Previous Perl Traps (Perl Developing)
• Common Goofs for Novices (Developing Perl)

• efficiency: Efficiency (Developing Perl)
• file-manipulating programs, writing portable: Files and Filesystems (Developing Perl)
• fluent: Fluent Perl (Developing Perl)
• portability: Portable Perl (Developing Perl)
• program generation: Program Generation (Developing Perl)

• generating Perl in other languages: Generating Perl in Other Languages (Developing Perl)

• program generators

• other languages in Perl: Generating Other Languages in Perl (Developing Perl)
• source filters: Source Filters (Developing Perl)

• developing with style: Developing with Style (Developing Perl)
• developing style, patterns: Programmatic Patterns (Developing Perl)
• developing, secure: It's Not Easy Being Omnipotent (Perl for System Administration)

• for setting/changing passwords: Preventing Suspicious Activities (Perl for System Administration)
• password-cracking: Preventing Suspicious Activities (Perl for System Administration)

• $PROGRAM_NAME: Special Variables in Alphabetical Order (Developing Perl)
• programs: Getting Started (Developing Perl)

• command-line arguments, parsing: Parsing Program Arguments (Perl tutorial)
• controlling debugger from: Using the Debugger (Developing Perl)
• controlling input/output of: Controlling Input and Output of Another Program (Perl tutorial)
• controlling with Expect: Controlling Another Program with Expect (Perl tutorial)
• core dump of: dump (Developing Perl)
• executing: system (Developing Perl)
• exiting: Getting Started (Developing Perl)
• • exit (Developing Perl)
• filtering output: Filtering Your Own Output (Perl tutorial)
• gathering output from: Gathering Output from a Program (Perl tutorial)
• preprocessing input: Preprocessing Input (Perl tutorial)
• reading from/writing to: Reading or Writing to Another Program (Perl tutorial)
• reading STDERR from: Reading STDERR from a Program (Perl tutorial)
• replacing: Replacing the Current Program with a Different One (Perl tutorial)
• running multiple: Running Another Program (Perl tutorial)
• simulating telnet from: Simulating Telnet from a Program (Perl tutorial)
• stepping through with debugger: Stepping and Running (Developing Perl)
• testing if running interactively: Testing Whether a Program Is Running Interactively (Perl tutorial)

• Perl debugger: Miscellaneous Commands (Developing Perl)
• progressive matching: Finding the Nth Occurrence of a Match (Perl tutorial)

• Where You Left Off: The \G Assertion (Developing Perl)

• projects, large, benefits of strict pragma in: Simplicities (Developing Perl)
• properties

• Initializers (Developing Perl)
• case, Unicode: Effects of Character Semantics (Developing Perl)
• document object (PerlScript): Document properties (Perl tutorial)
• types of: Magic Variables (Advanced Perl Developing)
• Unicode: Character Classes (Developing Perl)
• Unicode database of: Effects of Character Semantics (Developing Perl)
• widgets: Tk Widget Reference (Advanced Perl Developing)
• • Widget Properties (Advanced Perl Developing)

• properties, interface-/schema-defined: ADSI Basics (Perl for System Administration)
• Proto option (IO::Socket::INET): IO::Socket::INET Reference (Perl tutorial)
• protocol()

• Frame widget module: Toplevel Methods (Perl tutorial)
• HTTP::Message module: Reference: protocol (Perl tutorial)
• IO::Socket module: Reference: protocol (Perl tutorial)

• protocol data units (PDUs): The Twenty-Minute SNMP Tutorial (Perl for System Administration)
• protocols for Internet: Introduction (Perl tutorial)
• protocols, name/number translations: getprotobyname (Developing Perl)
• protocols, socket: Introduction (Perl tutorial)
• prototype(): Reference: prototype (Perl tutorial)
• prototype character: Prototypes (Developing Perl)

• $$ (current process ID): Names (Developing Perl)
• $? (exit status, last child process): Names (Developing Perl)
• $# prefix: Array Length (Developing Perl)
• $ variables: $^O variable: Portable Perl (Developing Perl)
• for scalar variable names: Arrays. (Developing Perl)
• • Variables (Developing Perl)
• in debugger: Using the Debugger (Developing Perl)
• in matching: (Developing Perl) 5.2.2. The m// Operator (Matching)
• line boundary: Endings: The \z, \Z, and $ Assertions (Developing Perl)
• metacharacter: The Regular Expression Bestiary (Developing Perl)
• • Metacharacters and Metasymbols (Developing Perl)
• scalar variable interpolation and: String Literals (Developing Perl)
• signifying scalar variables: Variable Syntax (Developing Perl)
• word boundary: Nailing Things Down (Developing Perl)
• $! variable: Logical Operators (Developing Perl)

• prototypes: Prototyping Functions (Perl tutorial)

• Introduction (Perl tutorial)
• Subroutines (Perl tutorial)
• Prototypes (Perl tutorial)
• Prototypes (Developing Perl)
• & (ampersand), omitting from subroutine names: Prototypes (Developing Perl)
• built-in functions, emulating: Prototypes (Developing Perl)
• careful use of: Care with Prototypes (Developing Perl)
• closures, giving to: Closures as function templates (Developing Perl)
• implicit pass-by-reference in: What Is a Reference? (Developing Perl)
• inlining constant functions: Inlining Constant Functions (Developing Perl)

• prototyping: Prototypes (Developing Perl)
• providers (ADSI): ADSI Basics (Perl for System Administration)
• proxy() (LWP::UserAgent): Reference: proxy (Perl tutorial)
• proxy, submitting forms through: Automating Form Submission (Perl tutorial)
• ps program (Unix): Calling an External Program (Perl for System Administration)
• pseudo-operators, overloading and: Overloadable Operators (Developing Perl)
• pseudocommands, piping: Talking to Yourself (Developing Perl)
• pseudohashes: Pseudohashes (Developing Perl)

• implementing classes with: my (Developing Perl)
• • inheritance and: Field Declarations with use fields (Developing Perl)
• simulating with overload function: Overloadable Operators (Developing Perl)
• use fields pragma, using with: Field Declarations with use fields (Developing Perl)

• pseudoliterals (see input operators)
• psgrep program (example): Program: psgrep (Perl tutorial)
• public methods: Introduction (Perl tutorial)
• pulist.exe (Windows/2000): Using the Microsoft Resource Kit Binaries (Perl for System Administration)
• punctuation characters, word boundary matching and: Boundaries: The \b and \B Assertions (Developing Perl)
• punctuation variables, English module, handling with: Perl Language Extensions and Internals (Developing Perl)
• push(): Appending One Array to Another (Perl tutorial)

• Making Hashes of Arrays (Perl tutorial)
• Reference: push (Perl tutorial)
• circular lists: Implementing a Circular List (Perl tutorial)
• Tie::IxHash module and: Retrieving from a Hash in Insertion Order (Perl tutorial)

• push function: Data Structures (Developing Perl)

• push (Developing Perl)
• pop function: Built-in Data Types (Developing Perl)

• push-pop (PP) codes: Executing Your Code (Developing Perl)
• push_content() (HTML::Parser): Reference: push_content (Perl tutorial)
• push_header() (HTTP::Headers): Reference: push_header (Perl tutorial)
• put(): Reference: put (Perl tutorial)
• Put() (Win32::Internet): Reference: Put (Perl tutorial)
• PUT requests (CGI): HTTP::Request (Perl tutorial)
• put_unique() (Net::FTP): Reference: put_unique (Perl tutorial)
• PV (internal string value): Internal Data Types (Developing Perl)
• pwd command (Unix): Time Efficiency (Developing Perl)
• pwd() (Net::FTP): Reference: pwd (Perl tutorial)
• Pwd() (Win32::Internet): Reference: Pwd (Perl tutorial)
• pwd_mkdb command (BSD 4.4): Binary Database Format in BSD 4.4 (Perl for System Administration)
• Python language: Why Perl? (Advanced Perl Developing)

• Molecules (Developing Perl)
• closures in: Python (Advanced Perl Developing)
• __getattr__ and __setattr__: Python (Advanced Perl Developing)
• modular developing in: Python (Advanced Perl Developing)
• object orientation of: Python (Advanced Perl Developing)
• references in: Python (Advanced Perl Developing)
• run-time evaluation and error handling: Python (Advanced Perl Developing)

Symbols | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z