operating system modules performance security manpages documentation Perl manpages perldoc command man command documentation books on Perl home page, Perl newsgroups comp.lang.perl newsgroups World Wide Web bug reports debugging bug reports documentation bug reports declarations \n (newline) exiting programs programs exiting languages natural vs. artificial natural languages artificial languages nouns values variables vs. variables values vs. interpreters variables names for names variables scope variables scalars arrays data types strings numbers $ (dollar sign) signifying scalar variables @ (at sign) for array names hashes handles typeglob Perl special characters in % (percent sign) signifying variable type & (ampersand) for subroutine names subroutines * (asterisk) typeglob typeglob prototype symbol (*) scalars singularities singularities = (equal sign) = (assignment) operator Unix systems quoting mechanisms double quotes variables interpolation interpolation of variables backslash (\), interpreting with double quotes \\ (backslash) double quotes, interpreting with single quotes suppressing interpolation backquotes (`) references scalars references objects references to, in scalars subroutines references to, in scalars uninitialized, variables Boolean values variables uninitialized null values ("" or 0) true values false values parameters scalar context, providing for operators scalar context, supplying to parameters strings quoted quotes strings, use in double quotes strings, use in operators quotes, syntactical similarity to pluralities arrays lists scalars list of arrays hashes names hashes, storing in numbers arrays, storing in subarrays and subhashes references to, in arrays subscripts, arrays elements in arrays $ (dollar sign) for scalar variable names stacks unordered lists hashes hashes scalars unordered set of hashes associative arrays hashes key/value pairs hashes key/value pairs in % (percent sign) for hash names percent (%) sign % = (equal sign) => (corresponds to) operator , (comma) key/value pairs and comma (,) , list context hashes in keys(thinsp;&) sort(thinsp;&) keys, lists of {thinsp&;} (braces) hash key, enclosing in keys, hashes braces {thinsp&;}, enclosing in curly braces {thinsp&;} $ (dollar sign) dollar sign ($) $ lists converting to scalars (thinsp&;) (parentheses) , (comma) as separator parentheses (thinsp&;) (thinsp&;) scalars lists, converting to multidimensional arrays arrays multidimensional nested data structures data structures complex, representing as scalars complex data structures representing as scalars scalars complex data structures, representing as encapsulation objects attributes objects, hashes of topicalization packages modules declarations packages global names prefixing with module name namespaces for packages verbs, packages, handling of nouns packages, handling of use declarations declarations use declarations modules CPAN, collection of CPAN (Comprehensive Pearl Archive Network) Comprehensive Pearl Archive Network CPAN pragmas strict module projects, large, benefits of strict pragma in scope variables strict pragma and variables scoping, strict pragma, use of verbs procedures commands names for names commands functions names functions operators verbs as subroutines user-defined user-defined subroutines user-defined subroutines subroutines & (ampersand) Perl version 5, changes in use programs, Perl student gade averages, calculating and printing executing Perl program Perl interpreter interpreters, Perl command line calling perl interpreter from Macintosh operating system command-line interface in versions Perl interpreter -e switch operating systems perl interpreter, starting on one-liners text editors, scripts, entering into shebang notation #! scripts, Perl perl interpreter, associating with # (sharp) #! (shebang) notation PATH environment variable chmod function Unix operating system test command, test scripts and test command (Unix) Perl interpreter -w switch -w switch, turning on warning messages with warning messages -w switch, turning on with filehandles running executing input filehandles output filehandles glue language, Perl as filehandles creating STDIN STDOUT open function shells I/O streams, setting up processes standard input, output, and error in line reading operator < (left angle bracket) < (less than) operator > (right angle bracket) > (greater than) operator angle brackets <; > empty angle operator (<>) output filehandles;STDOUT print function newlines removing chop function chomp function operators mathematics operators in Perl unary operators binary operators trinary operators prefix operators infix operators arithmetic operators binary arithmetic operators addition multiplication arithmetic operators order of evaluation operators precedence of strings operators operators string operators concatenation (.) operator concatenating strings . (dot) (concatenation) operator multiplicative operators binary repetition (x) operator x operator repetition (x) operator multiplication strings, repeat operator repetition (x) operator x (repetition operator) double-quoted strings interpolation and concatenation interpolation double-quoted strings assignment operators operators assignment operators = (equal sign) == (equal to) operator storage locations lvalues for lvalues operators and assignment operators values, returning variables values, assignment and autoincrement (++) operator autodecrement (--) operator unary operators arithmetic + (plus) ++ (autoincrement) operator - (hyphen) -- (autodecrement) operator incrementing variables decrementing variables pre-incremented (pre-decremented) variables post-incremented (post-decremented) variables void context logical operators short-circuit operators logical operators operators logical operators if statements logical operators and BASIC programming language logical operators borrowed from precedence logical operators & (ampersand) && (logical and) operator and (&&) logical operator || (OR logical operator) OR logical operator Or operator Xor logical operator conditional code execution executing code, conditionally $! variable if statements while statements comparison operators relational operators relational operators strings comparison operators numbers comparison operators for = (equal sign) == (equal to) operator ! (bang) != (not equal to) operator < (left angle bracket) < (less than) operator > (right angle bracket) > (grater than) operator < (left angle bracket) <= (less than or equal) operator < (left angle bracket) <=> (comparison) operator comparison operators cmp operator redundancy in Perl sort subroutines comparison operators in files test operators test operators (files) attributes files, test operators for -e (exists) file test -r (readable by effective uid/gid) file test readable file test operator -w (writable by effective uid/gid) file test writable file test operator -d (directory) file test directories file test operator -f (plain) file test regular files, testing for -T (text) file test text files, -T (file test) operator binary files as regular files irregular files Boolean operators unary operators Boolean control structures control structures truth, defining Boolean definition of truth truth values evaluating for in Perl false value false value scalars truth, evaluating in strings truth values of numbers truth values of references truth value of values undefined, truth value of truth conditions if and unless statements, evaluating with if statements blocks blocks statements {} (braces) for statement blocks else statements eleseif statements unless statements iterative statements loops while loops iterative statements while loops loops while loops iterative statements until statements $ variables $line blank lines, truth value of newlines blank lines, truth values and eof function shift operator loops for loops iterative statements for loops for loops iterative statements foreach statement loops foreach loops foreach loops list context foreach statements, providing loops next and last operators next operator last operator patterns (and regular expressions) regexps patterns regexes patterns REs patterns search programs grep function findstr function awk sed vi editor regular expressions, use of emacs editor regular expressions, use of patterns (and regular expressions) matching operators for substitution operator s operator substitution operator split function separators split operator, defining links HTTP, searching for HTTP (Hypertext Transfer Protocol) links, searching for = (equal sign) =~ (pattern binding) operator pattern-binding operator find command grep command findstr function binding operator (=~) $ variables $_ variable character classes patterns (and regular expressions) character classes + (plus) quantifier quantifiers whitespace word character digits s for whitespace=\s (for whitespace) w forward character=\w (forward character) d for digit=\d (for digit) numbers d for digit=\d (for digit) Unicode characters ideographs . (dot) character wildcard quantifiers {} (braces) quantifier curly braces {} maximum and minimum item matches, specifying period . (dot) . (dot) quantifiers, use in * (asterisk) quantifier ? (question mark) quantifier greedy matching patterns (and regular expressions) greedy matching negation of character class ^ (caret) assertion $ variables $_ variable minimal matching patterns (and regular expressions) minimal matching anchors boundary assertions b word boundary=\b (word boundary) words b assertion=\b assertion strings boundary assertions ^ (caret) line boundary $ (dollar sign) word boundary patterns (and regular expressions) backreferences backreferences () (parentheses) for backreferences interpolation backreference variables list context LISTs LISTs===>lists filters, source code keys function sort function map function reverse function print function characters bytes internationalization ASCII Unicode UTF-8 free-form languages tokens identifiers whitespace space newline Fortran Python ; (semicolon) Perl statements, terminating with Unicode paragraph separator character Unicode line separator character paragraph separator character line separator character greedy matching tokens # (sharp) for comments comments definition pod embedding in Perl plain old documentation pod blocks data types built-in built-in data types variables data types pointers scalars arrays hashes negative subscripts in Perl subscripting negative key/value pairs, hashes hashes key/value pairs terms in Perl syntax, Perl assignment operator lvalue rvalue temporary values stacks expression evaluation push function pop function variables names variables $ (dollar sign) for scalar variable names scalars names arrays arrays names for names hashes hashes names for @ (at sign) for array names slices of arrays or hashes % (percent sign) for hash names lvalues subroutines names for & (ampersand) for subroutine names names namespaces symbol tables lexical scopes packages pads scope text lexical scope and subnamespaces, for variables subroutines names for & (ampersand) for subroutine names * (asterisk) for typeglob names typeglobs names labels and filehandles filehandles names for labels names for reserved words names capitalization conventions capitalization modules user-defined, capitalization in names pragmas names, capitalization in _ (underscore) digits in names numbers digits in names identifiers Unicode characters in identifiers $ (dollar sign) $$ (current process ID) $ (dollar sign) $? (exit status, last child process) $ variables ${^ (internal variable names) internal variable names, Perl names identifiers vs. identifiers names vs. fully-qualified names symbol tables in fully qualified names : (colon) :: in fully qualified names variables names in nested symbol tables variables package variables package variables symbol tables packages scope lexically scoped variables lexical scopes variables attached to my declarations names lookups of unqualified, names, searching for our declarations aliases symbol table entries strict pragma eval compilation units strings as compilation units package variables lexical scopes package variables, searching for top-level package main package searching rules for name searches files lexically scoped variables and indirection references references and scalar values scalar values data types scalars scalars values scalar scalar values literals numeric numeric literals literals string string literals undefined scalars typing variables scalars numbers typing in Perl floating-point numbers typing variables subtypes, converting between strings numbers, converting to numbers strings, converting to casting strings and references casting to other pointer types pointers references, unable to convert to numeric literals exponential notation scalar values numeric literals , (comma) large numbers and _ (underscore) large numbers and numbers large, underscore and strings converting to numbers 0x, 0b, and 0 prefixes, handling of oct function octal characters hexadecimal characters numbers octal octal characters numbers hexadecimal hexadecimal characters characters octal octal characters characters hexadecimal hexadecimal characters string literals interpolation scalar values scalar values string literals " (double quotes) ' (single quotes) escape sequences for control characters control characters quotation marks strings and identifiers single quotes (') in interpolation scalar values characters into double-quoted strings strings double-quoted character interpolation in backspace character alert (bell) ESC character ESC in octal DEL in hexadecimal Control-C Unicode characters smiley named character pragmas use charnames capitalization escape sequences for uppercase, converting to lowercase, converting to \ (backslash) \Q notation for backslashing nonalphanumeric characters ending escape sequences for character modification newlines in string literals string literals newlines in variable interpolation interpolation variables in double-quoted strings $ (dollar sign) scalar variable interpolation and @ (at sign) inside strings, escaping with backslash {} (braces);identifiers in quotation marks in braces identifiers enclosing in braces ` (backtick) quotation marks quoting operators operators quoting operators patterns (and regular expressions) quotes in / (slash) delimiters, replacing as \ (backslash) quoted strings, avoiding overuse in ' (single quotes) as delimiters, variable interpolation and whitespace quote characters, use in # (sharp) quoting character, whitespace and barewords quotation marks leaving out reserved words barewords, possible conflict with capitalization barewords, problems with qw operator bare identifiers identifiers bare, barewords vs. packages names for : (colon) :: for package identifiers values arrays arrays variables array arrays variables of interpolation array variables scalar values interpolating array values character classes confusing with array subscripts regular expressions character classes, confusing with array subscripts {} (braces) search patterns, clarifying with use here documents line-oriented quoting < (left angle bracket) << for here documents quoting, line oriented quotation marks line-oriented quoting identifiers line-oriented quoting scalar values here documents here documents indentation of whitespace leading, removing in here documents string literals v-strings (vector or version) v-strings (vector or version) . (dot) separating integers in v-strings scalar values v-string literals line number number line __LINE__ token filenames names file __LINE__ token __FILE__ token Control-D key Control-Z key __END__ token scripts end marker for Control-D character Control-Z character __DATA__ token context context list context, scalar context list context scalar context context scalar and list context operations contexts, evaluation in my declarations context rules and our declarations context rules and overloaded functions lists LISTs scalar context subtypes of string context numeric context context Boolean context Boolean context unlink operator scalar context Boolean values and conditional context Boolean context while statements Boolean context, supplying context void context void context scalar context void context context interpolative (double-quoted) context interpolative context double-quote context substitution (s///) operator s/// (substitution) operator quotation marks interpolative context ` (backtick) operator qx// (quoted execution) operator m// (match) operator qr// (quote regex) operator values list list values lists list values arrays and arrays lists and () (parentheses) for list values , (comma) delimiting list values lists LISTs arrays list values vs. list values arrays vs. list interpolation interpolation list null list lists null () (parentheses) null lists, representing , (comma) delimiting list values qw (quote words) word lists () (parentheses) as quote characters assigning to lists lists assignment undef (value) void context scalar context list assignment in while statements list assignment in extending arrays length of arrays arrays length of arrays last element of $ (dollar sign) $# prefix shortening arrays truncating arrays null list assigning to arrays undef function arrays, freeing memory from hashes hashes key/value pairs , (comma) key/value pairs and key/value pairs, hashes initializing hash variables = (equal sign) => (corresponds to) operator list context hash variables, using in precedence key/value pair (hashes) hashes key/value pair precedence variables hash scalar context hash variables, evaluating in keys function hashes keys, finding number in $SUBSCRIPT_SEPARATOR $ variables $; (SUBSCRIPT_SEPARATOR) awk converting to/from Perl types data types typeglobs * (asterisk) for typeglob names names typeglobs data types typeglobs filehandles typeglobs for local filehandles filehandles localizing aliases symbol table entries symbol table entries aliasing input operators pseudoliterals input operators literals pseudoliterals input operators command input operator backtick operator grave accents backticks ` (backtick) operator $ variables $? ($CHILD_ERROR) backtick operator and qx// (quoted execution) operator qx// (quoted execution) operator ` (backtick) operator quoted execution operator ` (backtick) operator < (left angle bracket) for line input > (right angle bracket) for line input operator angle operator angle operator line input operators angle operator filehandles angle operator and $ variables $_ ($ARG) variable angle operator and while loops angle operator and $_ readline function list context angle operator in null filehandle ;angle operator and @ARGV array scalar variables in angle brackets filename globbing operator glob operator globbing filenames fileglob operator glob operator < (left angle bracket) for filename globbing > (right angle bracket) for filename globbing glob function $ variables $_ ($ARG) ;glob function with variable interpolation glob operator, using interpolation glob operator, using for unary operators named named unary operators operators operators precedence of associativity, operators operators associativity of terms relationships among, expressing with operators unary operators binary operators mathematics operators functions operators and arity precedence operator, table of unary operators binary operators trinary operator ternary operators trinary operator prefix operators postincrement and postdecrement operators list operators arity highest to lowest, listing of () (parentheses) grouping operator for expressions C language operators, precedence relationships operators precedence of C precedence, retaining in Perl scalar values operators fo overloading operators overloading terms precedence of list operators () (parentheses) variables quote operators {} (braces) precedence of [] (brackets) precedence of unary operators functions, behaving as + (plus sign) + unary operator function calls chdir function precedence and | (vertical bar) || logical OR operator precedence, chdir vs. * (asterisk) (multiplicative) operator unary operators named rand function do {} operator eval {} operator infix dereference operator arrow operator arrow (->) operator - (hyphen) -> (arrow) operator references hard hard references objects blessing classes package autoincrement (++) operator autodecrement (--) operator + (plus) ++ (autoincrement) operator - (hyphen) -- (autodecrement) operator magical autoincrement autoincrement (++) operator magical * (asterisk) ** (exponentiation)operator exponentiation (**) operator unary operators ideographic ideographic unary operators ! (bang) logical negation operator logical negation (!) operator not (!) operator negation logical (!) operator - (hyphen) arithmetic negation operator minus (-) operator negation arithmetic (-)operator arithmetic operators ~ (tilde) bitwise negation operator bitwise negation (~) operator negation bitwise (~) operator + (plus) ;unary operator \ (backslash) reference operator binding operators = (equal sign) =~ (pattern binding) operator ! (bang) !~ (binding) operator multiplicative operators division multiplicative operators * (asterisk) multiplicative operator / (slash) division operator % (percent sign) modulus operator modulus (%) operator x (repetition) operator binary repetition (x) operator lists replicating with x operator repetition (x) operator initializing arrays and hash slices arrays initializing with x operator hashes initializing with x operator additive operators subtraction additive operators + (plus) additive operator - (hyphen) subtractive operator . (dot) (concatenation) operator concatenation (.) operator strings concatenating bit-shift operators shift operators bytes bit-shift operators left-shift (<<) operator < (left angle bracket) << (left-shift) operator right-shift (>>) operator > (right angle bracket) >> (right-shift) operator shift operators unary operators named named unary operators functions named unary operators named unary operators listing of unary operators named listing of precedence unary operators, higher than binary list operators unary operators, distinguishing from unary operators list operators, distinguishing from + (plus) - (hyphen) * (asterisk) / (slash) . (dot) ?(question mark) % (percent sign) & (ampersand) tokens ambiguous characters, problems with file test operators -r (readable by effective uid/gid) file test -w (writable by effective uid/gid) file test -x (executable by effective uid/gid) file test -o (effective UID) file test -R (readable by real uid/gid file test -W (writeable by real uid/gid) file test -X (executable by real uid/gid) file test -O (real UID) file test -e (exists) file test -z (zero size) file test -s file test operator -f (plain) file test -d (directory) file test -l (symbolic link) file test -p (named pipe) file test -S file test operator -b (block special) file test operator -c (character special) file test -t (tty) file test -u (setuid) file test -g (setgid) file test -k (sticky) file test writable file test operator readable file test operator permissions file permission operators, interpreting use filetest pragma -T (text file) test operator -B (binary file) test operator -M (modification age) file test operator -A (access age) file test operator -C file test operator time file age files ages for $^T ($BASETIME) timing script running scripts running time of relational operators greater than (>) operator greater than or equal (>=) operator less than (<) operator less than or equal (<=) operator > (right angle bracket) greater than operator > (right angle bracket) >= (greater than or equal) operator < (left angle bracket) less than operator < (left angle bracket) <= (less than or equal) operator asssociativity operators relational operators nonassociation of strings comparing comparing strings trailing spaces in string comparisons locales declarations, string comparisons and equality operators equal to (=) operator not equal to (!=) operator < (left angle bracket) <=> (comparison)operator !(bang) != (not equal to) operator = (equal sign) == (equal to) operator inequality equality operators[semi] relational operators unequal equality operators[semi] relational operators comparison operators spaceship operator (<=>) binary operators bitwise operators bitwise operators and (&) bitwise operator & (ampersand) & (bitwise and) operator | (vertical bar) bitwise or operator ^ (caret) bitwise xor operator exclusive or (xor) operator or operator | (bitwise) xor logical operator numbers bitwise operators, working with strings bitwise operators, working with logical AND (&&) operator logical OR (||) operator & (ampersand) && (AND) operator and (&&) logical operator | (vertical bar) || (OR) operator short-circuit operators C language C-style logical operators logical operators OR (||) operator or operator range (.. and ...) operator . (dot) .. (range) operator list context range (..) operator in scalar context range (..) operator in $. ($INPUT_LINE_NUMBER) . (dot) ... (range operator) strings range operator, working with magical autoincrement operator conditional (?:) operator ? (question mark) ?: (conditional) operator trinary operator ?: as scalar context conditional operator in list context conditional operator in printf function sortas="@parentheses">() conditional operator, use with () (parentheses) conditional operator, use with assignment to conditional operator assignment operators = (equal sign) = (assignment) operator * (asterisk) **= (exponentiation assignment) operator + (plus sign) += (assignment) operator - (hyphen) -= (assignment) operator . (dot) .= (assignment) operator * (asterisk) *= (multiplication assignment) operator / (slash) /=; (assignment) operator % (percent sign) %= (modulus assignment) operator x= (assignment) operator & &= (assignment) operator | (vertical bar) |= (assignment) operator ^ (caret) ^= (assignment) operator < (left angle bracket) <<= (assignment) operator > (right angle bracket) >>= (assignment) operator & (ampersand) &&= (assignment) operator | (vertical bar) ||= (assignment) operator lvalues assignment operators and list context list assignment in scalar context list assignment in , (comma) operator , (comma) operator => operator scalar context comma operator in list context comma operator in =; (equal sign) =;> (corresponds to) operator list operators logical operators precedence logical operators and (&&) logical operator or operator xor logical operator exclusive or (xor) operator bitwise operators address-of operator (in C) operators C language, missing in Perl C language operators missing in Perl & (ampersand) address-of operator (in C) references Perl, C pointers vs. * (asterisk) ;dereference operator (in C) dereference-address operator (*), C language typecasting operator (in C) statements declarations warnings about undefined values variables declaring declarations variables my declarations our declarations [semi] (semicolon) statements simple ; (semicolon) simple statements, ending in blocks modifiers statements, simple if modifier unless modifier while modifier until modifier for modifier foreach modifier do SUBROUTINE do BLOCK do loop controls blocks {} (braces) ;for statement blocks BLOCK BLOCK blocks scopes statements compound scopes blocks expressions EXPR and LIST EXPRs scalar context expressions in EXPRs LISTs list context expressions in LISTs labels conditional statements without braces, writing statements if and unless statements loops loops conditional statements if statements\; unless statements if statements unless statements if statements, using instead of scope variables in if statements loops labels with loops capitalization label names while loops until loops loops using while loops using until continue block blocks continue block next operator scope variables in while loops for modifier loops using for expressions multiple, in loops initialization expressions conditions, expressions in loops re-initialization expressions, loops expressions loops, separating with commas (,) loops iteration through scope variables in three-part for loops infinite loops loops infinite exiting infinite loop terminating infinite loop stopping infinite loop quitting infinite loop endless loop infinite loops loops last operator last operator foreach loops variables control, in foreach loop control variables $ variables $_ ($ARG) ;forearch statement and for as an alias of foreach hashes printing out in sorted order aliasing in foreach loops scope loop variable in foreach my function continue block iteration loops labels with loops loops labels for operators, for loop control commands for loop control last operator next operator redo operator labels return operators functions return operators in continue block continue block loops last operator break statement last operator next operator blocks loops loops blocks statements redo operator continuation lines Getopts::* modules statements loop-control operators vs. loops control operators for blocks bare bare blocks exiting once-through blocks next operator exiting once-through blocks with eval {} loop controls and sub {} loop controls and do {} loop controls and exiting if or unless blocks {} (braces) bare blocks, creating with next used in a do while do BLOCK iterating last operator used in a do while do BLOCK terminating case structure if statements in case structure switch statement case statement bare blocks case structures, doing with last operator foreach loops aliasing capability, using aliases for/foreach loops, creating with conditional (?:) operator ? (question mark) ?: (conditional) operator trinary operator ?: as hashes cascading conditionals, using instead of goto function labels with goto statement EXPRs goto operator, use with & (ampersand) for subroutine names subroutines substituting with goto AUTOLOAD subroutines global declarations declarations global statements global declarations and compilers global declarations and no declarations use declarations declarations subroutines subroutines declaring definitions subroutines declarations vs. or operator list operators, use with OR (||) operator list operators and logical operators or operator use with list operators definitions subroutines loading from other files subroutines definitions, loading from other files require operator pragmas use require importing declarations scoped scope declarations and lexically scoped declarations dynamic scoping use global and lexical scoping of declarations packages default package package declaration my function declarations variables variables declaring dynamic scoping local variables global variables variables my my function package variables global variables scope modifiers scope operators my function our function local function lexicals lexical scope names scope, confining to values scope, confining to scalar context lvalues in list context lvalues in lvalues modifiers and precedence modifiers vs. commas dynamic scoping lexical scope variables scoped lexical scope scopes lexical scope scopes static scopes; lexical static scoping lexical scope scopes file scopes block my function our function local function files scopes closures global variables declaring variables declaring global declarations global variables lexically scoped our declarations global variables, lexically scoped scopes dynamic dynamic scoping local operator, using on global variables local operator global variables, using on global variables local operator, using on my declarations local vs. symbol tables local operator, making temporary changes with pragmas use declarations pragmas no declarations pragmas lexical scope pragmas and pragmas lexically scoped warnings pragma -w switch, perl $ variables $^W strict pragma global variables controlling use with strict pragma barewords strict pragma, checking use of symbolic dereferences checking with strict pragma patterns (and regular expressions) matching patterns regular expressions patterns databases Perl connections to text processing, Perl capabilities matching patterns patterns regex patterns m// (match) operator match operator m// operator s/// (substitution) operator substitution operator s/// operator operators matching and substitution characters in patterns patterns (and regular expressions) characters in literals metacharacters characters metacharacters \ (backslash) to escape metacharacters * (asterisk) metacharacter | (vertical bar) metacharacter () (parentheses) metacharacter [] (brackets) [ metacharacter {} (braces) { metacharacter ^ (caret) metacharacter $ (dollar sign) metacharacter + (plus sign) metacharacter ? (question mark) metacharacter . (dot) metacharacter \ (backslash) metacharacter zero-width assertions assertions (in patterns) \b word boundary assertion \t tab character assertion patterns (and regular expressions) assertions in metacharacters structural structural metacharacters in regular expressions | (vertical bar) for alternation alternation bar | grouping operator () (parentheses) grouping operator patterns (and regular expressions) quantifiers in quantifiers (in matching) zero-width assertions quantifiers and modifiers statements quantifiers vs. operators pattern-matching patterns (and regular expressions) matching operators for interpolation double quotes ("), using variables interpolating with double quotes " (double quotes) quotation marks double (") m// (match operator) double quote interpolation, providing s/// (substitution operator) double-quote interpolation, providing substitution (s///) operator parsing double-quote interpolation and regular expressions " (double quotes) qq//; print function patterns (and regular expressions) terminating delimiter for variables interpolating into patterns interpolation variables into patterns tr/// (transliteration) operator = (equal sign) =~ (pattern binding) operator using with pattern matching operators ! (bang) !~ (binding) operator using with pattern matching operators binding operators pattern-matching operators, using with y/// (transliteration) operator split function patterns (and regular expressions) split function and qr// (quote regex) operator m// (match) operator =~ (binding) operator, using with s/// (substitution) operator =~ and !~ binding operators, using with tr/// (transliteration) operator =~ and !~ binding operators, using with scalars pattern-matching operators, applying to lvalues pattern-matching operators, use on delimiters pattern-matching operators and $ variables $` $ variables $& $ variables $' patterns (and regular expressions) matching substrings corresponding to subpatterns patterns (and regular expressions) matching special variables for scopes pattern-matching operations dynamic scoping pattern variables patterns (and regular expressions) modifiers for modifiers for patterns operators pattern-matching modifiers for m// (match) operator modifiers for s/// (substitution) operator modifiers for qr// (quote regex) operator modifiers for tr/// (transliteration) operator modifiers for flags modifiers options modifiers case sensitivity /i modifier (case insensitive) /i pattern modifier /s pattern modifier /m pattern modifier /x pattern modifier /o pattern modifier case matching, /i operator strings containing newlines, matches against newlines strings containing, matches against . (dot) character wildcard /o pattern modifier single quotes (') pattern recompilation and recompiling patterns, limiting with /o modifier /x pattern modifier whitespace /x modifier in pattern matching # (sharp) for comments /x pattern modifier, using with comments extending with /x pattern modifier patterns (and regular expressions) finding duplicate words in paragraphs m// (matching) operator / (slash) // m// operator Boolean context m// (match) operator in scalar context m// (match) operator in backreferences list context m// (match) operator in m// (match) operator modifiers for modifiers for patterns m// (match) operator /i pattern modifier /m pattern modifier ^ (caret) in matching $ (dollar sign) in matching /s pattern modifier /x pattern modifier /o pattern modifier /g pattern modifier /cg pattern modifier global matching /g modifier list context m//g, listing all matches found hashes key/value pairs capturing from string with m//g operator capturing in patterns words, alphanumeric words capturing scalar context /g pattern modifier, use in \G positional assertion assertions (in patterns) \G positional assertion /g (global) pattern modifier ? (question mark) ?? operator m?? operator m?? (match) operator s/// (substitution) operator replacement, matched substrings s/// (substitution) operator searching for substrings substrings searching for and replacing with s/// operator strings searching for and replacing substrings (s/// operator) patterns (and regular expressions) matching special variables for double quotes (") replacement string, use with " (double quotes) in replacement string dynamic scoping pattern variables \u escape uppercase, converting to capitalization uppercase, converting to (\u escape) double-quote context scalar variables, expanding in scalar variables in double-quote context Control-A /g (global) pattern modifier modifiers pattern with s/// (substitution) operator s/// (substitution) operator pattern modifiers used with /i pattern modifier /m pattern modifier /s pattern modifier /x pattern modifier /o pattern modifier /g pattern modifier /e pattern modifier global search and replace search and replace, global numbers hexadecimal, converting to hexadecimal converting numbers to converting numbers to/from hexadecimal strings modifying arrays s/// (substitution) operator and loops s/// (substitution) operator, using on arrays aliases in for/foreach loops searching and replacing elements in arrays for loops searching and replacing elements in arrays foreach loops searching and replacing elements in arrays variables repeated substitutions, performing on whitespace cononicalizing in a variable loops using in (global substitutions) tr/// (transliteration) operator y/// (transliteration) operator sed binding operators tr/// (substitution) operator, use with characters replacing in strings rot13 encryption character sets ordering and ranges of characters in ranges character sets, specifying in modifiers patterns with tr/// (transliteration) operator /c pattern modifier /d pattern modifier deleting found but unreplaced characters /s pattern modifier duplicate replaced characters, eliminating /d modifier eval function translating with variables variables translating with case sensitivity capitalization changing titlecase \u and ucfirst function, using in conversions Unicode titlecase, converting strings to patterns (and regular expressions) metacharacters and metasymbols in metacharacters in patterns metasymbols in patterns * (asterisk) metacharacter | (vertical bar) metacharacter () (parentheses) metacharacter [] (brackets) [ metacharacter {} (braces) { metacharacter ^ (caret) metacharacter $ (dollar sign) metacharacter + (plus sign) metacharacter ? (question mark) metacharacter . (dot) metacharacter prefix operators metacharacters working as \ (backslash) to escape metacharacters metacharacters escaping with backslash (\) structural metasymbols ellipses (...) assertions (in patterns) zero-width assertions \ (backslash) \... metasymbol | (vertical bar) ...|... alternation alternation match one or the other (...|...) () (parentheses) (...) grouping grouping operator [] (brackets) [...] character class quantifiers (in matching) patterns (and regular expressions) quantifiers in * (asterisk) quantifier + (plus sign) quantifier ? (question mark) quantifier {} (braces) quantifier minimal matching maximal matching * (asterisk) *? quantifier + (plus sign) +? quantifier ? (question mark) ?? quantifier quantifiers in matching minimal and maximal metasymbols extension syntax for patterns (and regular expressions) extension syntax patterns (and regular expressions) alphanumeric metasymbols metasymbols alphanumeric, in patterns character classes metasymbols used within [] (brackets) character classes case escape sequences for processing during variable interpolation pass aliases for characters characters aliases for patterns (and regular expressions) metasymbols in metasymbols in patterns control characters metasymbols in patterns octal numbers characters, specifying with \NNN metasymbol hexadecimal numbers character numbers, specifying as named character, metasymbol for symbols metasymbols, generic wildcards wildcard metasymbols . (dot) character wildcard characters wildcard matches for \C wildcard metasymbol \X wildcard metasymbol character classes wildcard metasymbols and newlines dot (.) metacharacter, matching quantifiers in matches dot (.) metacharacter, using with Unicode wildcard metasymbols, matching with use utf8 pragma combining character sequence, matching with \X patterns (and regular expressions) character classes character classes classes, Perl Unicode Perl properties for properties Unicode POSIX classes character classes custom [] (brackets) character classes ranges characters - (hyphen) in character ranges ^ (caret) inverting character class character class, inverting wildcard metasymbols character classes and negation character classes \b (backspace assertion in character classes) backspace \b assertion in character classes character metasymbols in character classes wildcard metasymbols character classes and alternation character classes and quantifiers in matching character classes and assertions (in patterns) character classes and character classes Perl shortcuts for negation character classes locales Perl character class shortcuts and byte meanings, character class shortcuts Unicode properties Perl character class shortcuts and character classes Unicode properties Unicode properties Unicode information about Unicode properties Perl composites composite Unicode properties Unicode properties standard standard Unicode properties categories, characters characters decomposition of compatibility decomposition, characters canonical decomposition, characters decomposing characters into simpler ones Unicode properties decomposition of characters Unicode properties bidirectional rendering bidirectional rendering, Unicode properties vowel sounds, classifying syllabaries according to Unicode properties syllabaries, classifying by vowel sounds Unicode properties block properties block properties, Unicode scripts languages, checking for languages checking characters for characters properties defining your own characters properties under Unicode - (hyphen) character set subtraction subtracting, from character sets ! (bang) complemented character sets, using for character classes Perl classic character classes POSIX-style POSIX-style character classes negation POSIX character classes locales use locale pragma with POSIX character classes quantifiers in matching patterns (and regular expressions) quantifiers in * (asterisk) in quantifiers + (plus sign) in quantifiers ? (question mark) in quantifiers quantifiers minimal and maximal minimal matching maximal matching greedy matching length, matching leftmost longest matching quantifiers greedy greedy matching anchors positions patterns (and regular expressions) positions for matching zero-width assertions assertions (in patterns) positional substr function manipulating string positions with positions substr function, manipulating with \A (string boundary) ^ (caret) ;line boundary beginnings of strings, matching positions beginnings of strings, matching assertions (in patterns) positional \A and ^ assertions (string boundary) strings boundary assertions lines boundary assertions \Z (string boundary) \z (string boundary) $ (dollar sign) line boundary end of string, matching positions ends of strings, matching assertions (in matching) positional \z, \Z, and $ assertions \b (word boundary assertion) \B (non word boundary) positions word boundaries, matching assertions (in matching) \b and \B (word and non word boundary) boundaries, words (matching) punctuation characters word boundary matching and backspace \b assertion in character class pos function failed matches, searching past position of /c modifier failed matches, searching past \G positional assertion pos function progressive matching positional assertions positions position just after previous match, specifying loops \G assertion, using in patterns (and regular expressions) capturing in capturing in patterns patterns (and regular expressions) backreferences backreferences patterns ;backreference () (parentheses) for backreferences backreferences accessing with numbered variables groupings nesting of backreferences creating with parentheses () (parentheses) for backreferences $ variables @& $ variables @+ $ variables @' $ variables @` @ (at sign) @+ array of ending positions @ (at sign) @- array patterns (and regular expressions) clustering in clustering in patterns () (parentheses) (?:PATTERN) notation, clustering without capturing capturing in patterns suppressing in clustering clustering in patterns without capturing, reasons for alternation interior, limiting scope of () (parentheses) (?:PATTERN) notation, clustering without capturing split function cloisters modifiers pattern cloistered patterns (and regular expressions) modifiers cloistering subtracting pattern modifiers from cloisters alternation in patterns | (pipe symbol) for pattern alternation possible matches, specifying set of positional assertions ordering of matching, changing with patterns (and regular expressions) controlling matching patterns (and regular expressions) controlling matching Perl flow control, deciding pattern execution logical operators Perl, doing alternation | (vertical bar) || (logical or) operator or operator comments discarding before processing loops comments and blank lines, discarding before processing variables interpolation pattern matching, controlling with interpolating variables pattern matching, controlling with /o modifier recompilation, suppressing with variables strings of, matching against known strings \ (backslash) interpretation by regex parser " (double quotes) translation escape processing transliteration escapes, processing by Perl regex compiler double quotes (") translation escape processing ' (single quotes) suppressing transliteration escape processing single quotes (') suppressing variable interpolation and translation escape processing grep program case case-sensitive matching, switching off qr// (quote regex) operator compilers regex compiler patterns (and regular expressions) controlling matching regex compiler backtracking NFA (nondeterministic finite-state automaton) nondeterministic finite-state automaton (NFA) precedence regular expression matching patterns (and regular expressions) matching precedence order precedence backtracking in pattern matching positions precedence in pattern matching alternation precedence, pattern matching sequential matches assertions precedence, pattern matching positive lookahead assertions negative lookahead assertions patterns (and regular expressions) quantifiers in atoms quantifiers atoms and greedy matching patterns (and regular expressions) greedy matching matching patterns atoms precedence, pattern matching () (parentheses);grouping operator grouping operator [] (brackets) to match characters \b assertion for backspace BACKSPACE character /b for characters patterns - (hyphen) ^ (caret) matching special characters characters special character classes self-matching characters lookaround lookbehind lookahead ? (question mark) regex extensions (?!) ? (question mark) regex extensions (?=) ? (question mark) regex extensions (?<=) ? (question mark) regex extensions (?<!) patterns (and regular expressions) extensions lookaround assertions patterns fancy patterns assertions lookaround assertions positive lookahead assertions negative lookahead assertions contractions in words, avoiding confusion with single quotes single quotes (') contractions in words, avoiding confusion with ? (question mark) regex extensions (?>) nonbacktracking subpatterns backtracking nonbacktracking subpatterns programming style, patterns patterns (and regular expressions) programming style for procedureal programming style imperative programming style declarative approach, regular expression programming expressions Perl, supplying in replacement strings patterns (and regular expressions) Perl code, interjecting into patterns (and regular expressions) generated generated patterns substitution evaluations /e modifier substitution evaluation patterns (and regular expressions) substitution evaluation replacement strings /e modifier, building with patterns (and regular expressions) match-time code evaluation code subpatterns in regular expressions patterns (and regular expressions) match-time pattern interpolation interpolation match-time pattern interpolation match-time pattern interpolation backreferences deriving patterns from matched substrings recursive matching patterns (and regular expressions) recursive matching patterns (and regular expressions) conditional interpolation in conditionals, interpolation into patterns interpolation conditionals into patterns patterns (and regular expressions) assertions, defining your own assertions defining your own overloaded string constants, translating text with tags (HTML and XML), transforming text to subroutines user-defined functions subroutines functions subroutines subroutines functions routines subroutines methods subroutines vs. anonymous subroutines declaring subroutines without defining sub keyword declarations subroutines with definitions closures creating subroutines names of names subroutines importing subroutines from another module subroutines importing from another module calling subroutines indirectly subroutines calling indirectly & (ampersand) for subroutine names references to subroutines capitalization subroutine names names subroutines capitalization in defining subroutines subroutines defining subroutines data, passing into and out of lists scalars, subroutine return and parameter values scalars parameter and return lists, subroutines variadic functions in Perl @ (at sign) @_ array arrays @_ arrays @ (at sign) @_ arrays passing by reference references passing by return value, subroutine subroutines return values scalar context subroutines, calling and evaluating in list context subroutines, calling and evaluating in subroutines parameter lists, working with parameters subroutines working with passing by value, copying @_ values to my list arrays @_ arrays copying values to my list names parameters, not requiring upcase function parameters subroutines changing in place errors subroutines subroutines errors, indicating exceptions raising to indicate subroutine errors recursion of subroutines subroutines scoping issues scope subroutines lexical variables accessing from functions static variables variables static C/C++ languages static variables lexical variables persistence across function calls BEGIN blocks initializing variables before calling subroutines INIT blocks initializing variables before calling subroutine initializing variables before calling subroutines variables initializing before calling subroutines references passing passing references subroutines passing references in arrays passing by reference into or out of functions sets intersection intersection of sets hashes passing by reference into or out of functions functions references, using for both input and output prototyping prototypes star asterisk & (ampersand) for subroutine names omitting in prototypes prototypes & (ampersand), omitting from subroutine names built-in functions subroutines, prototyping to emulate prototypes built-in functions, emulating characters prototype @ (at sign) prototype character % (percent sign) prototype character & (ampersand) prototype character sub keyword $ (dollar sign); prototype character * (asterisk) prototype character filehandles passing prototypes inlining constant functions constants inlining constant functions inlining constant functions subroutines redefining, inlining and inlining constant functions preventing inlining prototypes careful use of subroutines prototyping, careful use of unary operators prototyping functions as attributes attributes subroutines use attributes pragma locked attribute (subroutines) method attribute (subroutines) lvalues lvalue attribute, subroutines names attributes, subroutines attributes subroutines names, syntax for lvalues lvalue attribute, subroutines formats reports, generating charts, generating formats declaring declaring formats filehandles formats associated with, default names of names formats associated with filehandles output record formats, declaring justification picture lines @ (at sign) in picture lines ^ (caret) in picture lines # (sharp) in formats numbers justifying by decimal point decimal points, lining up locales decimal points in formats whitespace characters in formats $ variables $: ($FORMAT_LINE_BREAK_CHARACTERS) variable-length records records, variable-length ~ (tilde) to suppress blank lines formats top-of-form processing top-of-form processing filehandles ending with _TOP lexical variables formats lexical variables in $ variables $- ($FORMAT_LINES_LEFT) variables format $ variables $~ ($FORMAT_NAME) $ variables $^ ($FORMAT_TOP_NAME) $ variables $% ($FORMAT_PAGE_NUMBER) $ variables $= ($FORMAT_LINES_PER_PAGE) $ variables $| ($OUTPUT_AUTOFLUSH) $ variables $^L ($FORMAT_LINEFEED) select function for format variables formats variables select function for format variables English module FileHandle module numbers commas, inserting into | (vertical bar) for centering centering > (right angle bracket) for right justification < for left justification right justification left justification more than sign > fmt (Unix utility) formats fmt (Unix utility) formats footers footers $ variables $^ ($FORMAT_TOP_NAME) $ variables $- ($FORMAT_LINES_LEFT) headers, format names $ variables $^A ($ACCUMULATOR) formats accessing formatting internals formline operator wrapping text FileHandle module text wrapping typeglobs eval function variables references references data structures flat, linear in Perl indirection pointers (C language) references indirection references defining symbolic references hard references referents symbol tables symbolic references naming entries in scalars hard references as anonymous referents values referencing dereferencing dereferencing references implicit referencing or dereferencing filehandles implicit referencing in passing by reference prototypes declaring function calls as bless function reference as argument for lock function reference as argument for prototypes implicit pass-by-reference in references to data structures data structures references to arrays references to hashes references to references creating hard references \ (backslash) reference operator references creating with backslash operator references to anonymous data variables anonymous arrays anonymous, references to [] (brackets) ;array composer anonymous array composer hashes anonymous, references to {} (braces) ;hash composer anonymous hash composer anonymous subroutine composer sub declaration subroutines anonymous references to constructors objects constructors constructors subroutines returning references bless operator references to objects handles references to filehandles references to references to filehandles typeglobs filehandle references, creating typeglobs references to typeglobs vs. typeglobs anonymous filehandles anonymous references to symbol tables symbol tables references to typeglobs IO\:\:Handle object hard references using dereferencing variables dereferencing blocks - (hyphen) -> (arrow) operator arrow (-> ) operator dereferencing dereferencing operator for arrow operator - (hyphen) ->(arrow) operator object methods encapsulation methods references to objects pseudohashes list context backslash operator, supplying ref operator references stringifying stringifying references bless operator objects stringifying stringifying objects typeglobs variables my my declarations strings printing values in hard references using closures closures my declarations closures and callbacks functions generation of methods references to objects methods, references to objects methods, references to closures closures as function templates function templates, closures as prototypes closures, giving to closures nested subroutines, emulating with nested subroutines subroutines nested symbolic references references symbolic strict pragma lexical variables symbolic references and " (double quotes) references braces, brackets and quoting in {} (braces) quotation marks " (double quotes) and ' (single quotes) under Symbols hashes references as keys strings references and references stringifying stringifying references tying variables references weak weak references caching memory garbage collection garbage collection deallocating memory circular references references circular, and memory data structures stacks queues shift function unshift function push function pop function hashes flat lookup tables, providing access to complex data structures creating in Perl lists nested nested lists arrays nested nested arrays multidimensional arrays arrays multidimensional tables multidimensional arrays two-dimensional arrays creating and accessing arrays nested two-dimensional arrays, creating and accessing references in multidimsional arrays two-dimensional arrays creating your own assignment elements, two-dimsional arrays appending elements to arrays accessing multidimensional arrays printing multidimensional arrays references stringifying stringifying references dereferencing array elements slices of multidimensional arrays accessing slices of multidimensional arrays loops extracting slices, multidimensional arrays anonymous arrays two-dimensional array slice Perl Data Language (PDL) module troubleshooting, multidimensional arrays references stringifying stringifying references data organization in Perl hashes Perl data organization in lists ordered, data records in arrays references to hashes key/value pairs, hashes organizing and accessing data in arrays hashes of hashes of arrays data structures hashes of arrays printing multidimensional arrays anonymous arrays hash of, creating hashes of arrays generating hashes of arrays access and printing of accessing hashes of arrays printing hashes of arrays indexing arrays sorting arrays in hashes of arrays of hashes hashes of arrays data structures arrays of hashes anonymous hashes array of, creating arrays of hashes generating hashes of arrays generating appending members to existing hash arrays of hashes accessing and printing printing arrays of hashes accessing array of hashes multidimensional hashes hashes multidimensional data structures multidimensional hashes printing multidimensional arrays anonymous hashes adding to multidimensional hashes hashes multidimensional generation of multidimensional hashes generation of multidimensional hashes accessing and printing hashes multidimensional accessing and printing printing multidimensional hashes accessing multidimensional hashes each function sorting hashes data structures hashes of functions functions hashes of commands hashes of functions, storing in references to functions storing in data structures dereferencing hash values as functions records of various data structures data structures records of elaborate references to hashes multidimensional hashes records of various data structures composing, accessing, and printing accessing records of elaborate data structures printing multidimensional hashes hashes of complex records records of various data structures generating hash of loading data structures data structures saving Data::Dumper saving, data structures data structures stringifying stringifying data structures packages abstraction namespace packages modules pragmas .pm file extension files Perl module, housing in single use command CPAN (Comprehensive Perl Archive Network) modules CPAN, storing in CPAN classes object classes object-oriented programming modules classes vs. classes modules vs. inheritance class object-oriented programming references in Perl, emulating references object-oriented programming and declarations package symbol tables current package, determining use of package declaration main package variables packages, associating with global variables package variables as scopes package declarations variables my my declarations variables our our declarations scopes my variables blocks package declarations, span of packages identifiers labels packages and identifiers, package : (colon) :: for package identifiers single quotes (') as package delimiters packages delimiters for symbol tables for packages identifiers, package in package symbol table names packages _ (underscore) in variable names signal handlers defining as strings eval function packages and symbol tables packages symbol tables for hashes symbol tables names symbol tables symbol tables containing references to other symbol tables references in symbol tables to other symbol tables typeglobs in symbol table hashes hashes symbol tables typeglobs in key/value pairs, hashes symbol tables dereferencing typeglobs hashes symbol tables key/value pairs in variables dumping with V command aliases symbol table key, assignment to typeglob importing symbols from one package to another references to subroutines retrieving from or passing to subroutines references to retrieving from or passing to scalars constants scalars constants constants constants constant pragma anonymous subroutines giving names at run time subroutines constant typeglobs symbol table aliasing with references to symbol table entries AUTOLOAD subroutine functions autoloading subroutines autoloading packages modules modules packages undefined subroutines, calling with AUTOLOAD definitions subroutines loading with AUTOLOAD goto function closures assigning to glob to define subroutine AutoSplit module AutoLoader module SelfLoader module autosplitting modules splitting into separate files .al filename extensions files modules, autoloading DynaLoader module modules exporting CPAN (Comprehensive Perl Archive Network) documentation, standard modules perldoc command man command object-oriented modules classes definitions of object-oriented modules as definitions classes (object-oriented modules as) import function symbols importing into current package names modules @INC array %INC hash : (colon) :: in module names, translating to system directory separators operating systems module names, translating to directory names identifiers Perl modules lib pragma BEGIN blocks modifications to @INC array, handling with hashes %INC for modules key/value pairs, hashes modules, %INC hash pathnames module installed on Windows system capitalization module names names modules capitalization in use declaration modules require function pragmas modules and no declaration .pm files loading associated files with POSIX module getting exported functions and variables with modules creating object-oriented modules method calls, allowing exporting symbols symbols exporting from modules Exporter module module privacy and modules creating privacy and the Exporter privacy Perl modules and namespace modules and contract between module and user variables modules, exporting to programs functions modules, exporting to programs polluting your namespace importing symbols Exporter module; exporting symbols exporting symbols inheritance modules, from Exporter class symbols leaving off export list or deleting from import list exporting symbols without using import method from Exporter import function export_to_level method modules creating version checking version module, checking for modules creating symbol exportation, preventing symbols, exporting prevention of export_fail method errors failed symbol exports tags, symbol sets, Exporter built-in functions overriding modules built-in functions, overriding overriding functions functions overriding subs pragma overriding built-in functions with CORE pseudopackage CORE::GLOBAL pseudopackage objects object-oriented programming OOP object-oriented programming data structures objects objects instances classes methods instance methods class methods constructors inheritance base classes parent classes subclasses superclasses derived classes polymorphism encapsulation privacy interfaces objects Perl object system references for objects referents objects as classes packages as methods subroutines as subroutines methods invoking executing methods abstraction in object-oriented programming object-oriented programming abstraction in indirection between class use and implementation invocant class methods package names as invocants for instance methods object references as invocants for references to objects invocants for instance methods methods invoking explicitly or implicitly explicit method invocations implicit method invocation methods subroutines vs. subroutines methods vs. packages methods and subroutines, resolving for typeglobs subroutines, resolving to methods invoking using arrow operator - (hyphen) -> (arrow) operator method invocation with arrow (-> ) operator methods invoking using indirect objects indirect object syntax indirect object slot indirect object syntax ambiguities in precedence logical operators logical operators precedence of & && (logical and) operator and (&&) logical operator precedence, and operator vs. && or operator precedence, or vs. || & (ampersand) && (logical and) operator | (vertical bar) || (logical or) operator quoting packages packages quoting classes quoting packages for subroutines classes with same names names classes, distinguishing from subroutines constructors objects constructors references objects as bless function packages bless function arguments anonymous hashes data structue for objects data structures for objects hashes anonymous references to references blessing ref function reftype function classes objects, giving to constructors bless function and bless function constructors, using with objects constructors inheritable constructors inheritable inheritance constructors class methods constructors as methods invoking subroutine calls vs. subroutines calling, method invocations vs. constructors class names or objects, working with objects constructors initializers constructors initializers initializing objects properties attributes accessor methods member data instance variables constructors naming names constructors base classes constructors and class inheritance inheritance class classes inheritance among @ISA array empty subclass test inheritance class single or multiple single inheritance multiple inheritance subroutines method resolution, steps for methods searching for class inheritance debugging Perl, using C compiler -DDEBUGGING option @ISA array inheritance through objects inheritance, through @ISA array inheritance through @ISA array packages in @ISA array, inheritance through methods searching for inheritance through @ISA array use base declarations classes @ISA array, including with base pragma use fields declarations modules class system and classes base base classes overriding base class methods base classes overriding methods of methods overriding SUPER pseudoclass classes inheritance among overridden methods, accessing accessing overridden methods derived classes methods as wrappers around base class methods SUPER pseudoclass CORE pseudopackage built-in methods overridden, calling via CORE pseudopackage mulitple inheritance, SUPER pseudopackage, working with Class::Multimethods module methods adding to an existing class packages adding methods to existing classes inheritance among UNIVERSAL class and UNIVERSAL class methods in UNIVERSAL class isa method can method multiple inheritance methods, invoking all overridden base class overridden methods, base class, invoking all base class overridden methods, invoking all VERSION method classes version number, returning UNIVERSAL class methods, adding to methods UINVERSAL class adding to AUTOLOAD subroutine AUTOLOAD method methods autoloading subroutines autoloading functions autoloading classes inheritance among method autoloading multiple inheritance AUTOLOAD subroutine and predeclaring subroutines subroutines declaring in package for AUTOLOAD management use subs declarations classes inheritance among private methods, avoiding with private methods, ignoring inheritance with methods private methods, ignoring inheritance with lexical variables file-scoped, storing anonymous subroutine in modules classes, storing in for privacy objects instance destructors destructors memory management, destructors and nested destruction objects storing within other objects vs. inheritance destructors garbage collection with objects instance destructors garbage collection with garbage collection with DESTROY methods references weakening or breaking WeakRef module container classes holding pointers to self-referential data structures data structures self-referential, container classes holding pointers to circular references breaking PERL_DESTRUCT_LEVEL variable environment variables PERL_DESTRUCT_LEVEL interpreters object destruction at shutdown objects instance data, managing instance data managing methods Perl classes inheritance of hashes anonymous data structure for objects accessor methods creating instance variables separate functions, writing for each attributes subclass, overriding superclass ancestor subclasses attributes, overriding superclass ancestors Struct::Class module objects instance data, managing use fields pragma field declarations with field declarations with use fields pragma declarations fields with use fields pragma arrays anonymous, objects implemented as arrays anonymous, objects implemented as use fields pragma, overcoming problems with pseudohashes use fields pragma, using with key mapping, pseudohashes mapping keys, pseudohashes accessor methods pseudohashes and pseudohashes implementing classes with inheritance and inheritance classes and objects pseudohash implementation and use base declarations pseudohash implementations, requirement with objects instance data, managing generating classes with Class::Struct instance data managing generating classes with Class::Struct classes generating with Class::Struct module structs emulating declarations structs objects instance data, managing generating accessors with autoloading autoloading generating accessors with accessor methods generating with autoloading instance data managing generating accesors with autoloading accessor methods generating with closures closures generating accessor methods with objects instance data, managing generating accesors with closures instance data managing generating accessors with closures objects instance data, managing private objects, using closures for closures private objects, using for private objects, closures, using for instance data managing using closures for private objects encapsulation objects in closures access checks, setting in constructor constructors access checks, setting in Tie::SecureHash module hashes restricted, implementing inheritance restricted access and Class::Contract module objects instance data, managing new features, Perl 5.6 instance data managing new features, Perl 5.6 lvalues methods, declaring to indicate return of declarations methods lvalues, indicating return of methods declarations lvalues, indicating return of attributes lvalue, subroutines subroutines lvalue attribute threads locked and method attributes, using locked attribute method attribute attributes locked and method, using with threads objects class data, managing classes data, managing for state common, sharing by class objects variables class attributes class, storing state for package variable, storing class data in methods class data, working like accessors accessor methods class data methods, working like debugging debug level, setting through class or instances package variable wrapping declaration in block scope inheritance class accessors classes data, managing for storing references to class data in object itself state inheritance with class data accessor methods overloading operators overloading references to objects overloading and Math::BigInt module integers Math::BigInt module overloading overload pragma use overload pragma handlers overload unary operators class handler, invoking binary operators class handler, invoking trinary operator overloading, not working with overload handlers handlers overload arithmetic overloaded objects and subtraction overloaded objects addition overloaded plus (+) operator operators overloadable overloading overloadable operators pseudo-operators, overloading and operators overloadable conversion operators " (double quotes) conversion operator, stringification 0+ (numification) operator conversion operators stringification stringification conversion operators numification (nonnumeric variable converted to number) numbers converting nonnumeric variables to conversion operators Boolean context, interpreting object in Boolean context bool conversion operator handlers overloading as_string handler arithmetic operators overloading operators overloadable arithmetic operators autogeneration, overloading overloading autogeneration of overloading, autogeneration of . (dot) (concatenation) operator autogeneration via stringification handler concatenation (.) operator autogeneration via stringification handler logical operators overloading operators overloadable logical negation operator ! (bang) ! (logical negation) operator overloading negation operator (!), overloading short-circuit operators overloading and operators overloadable bitwise operators bitwise operators overloading assignment operators overloading operators overloadable assignment operators autogeneration, overloading autoincrement and autodecrement magical autodecrement and autoincrement autodecrement (--) operator magical autoincrement (++) operator magical comparision operators overloading operators overloadable comparison operators sorting overloading and overloading sorting and mathematical functions, overloading overlaoding mathematical functions iterative operator, overloading operators overloadable iterative operator operators overloadable dereference operators dereference operators, overloading pseudohashes simulating with overload function overloading circular references, avoiding references circular in overloading circular references overloading, avoiding in operators overloadable circular references, problems with overloading copy constructor (=) copy constructor assignment operators overloading copy constructor mutators, copying and handlers overload missing overloading nonmethod and fallback nomethod overloading key fallback overloading key autogeneration, overloading preventing constants overloading overloading constants import method overloading constants q// (pattern match) operator concatenation (.) operator string constants, overloading functions for overloading overloading functions for StrVal (overload::StrVal) Overloaded (overload::Overloaded) Method (overload::Method) overloading inheritance and inheritance overloading and overloading at run time debugging overloading overloading diagnostics binding variables to packages tie function untie function variables tying tying variables funny characters characters funny characters preceding variable names hashes tying databases tying hash variables to dbmopen function dbmclose function typeglobs variables, tying to classes via tied function objects tied variables, underlying bless function tie vs. constructors tied variable classes classes implementing tie tie function use or require declarations and use declarations tie function and require declarations tie function and dbmopen function use declarations with methods called by tied variables names methods, tied variables capitalization method names, tied variables tying variables scalars variables tying scalars scalars tying untie function outstanding references, not eliminating Tie::Scalar module Tie::StdScalar module scalars tying methods for methods tying scalars classes scalar-tying references to tied scalar variables Carp module flock function assignment of tied variables garbage collection objects associated with tied variables scalars tying magical counter variables magical counter variables counters, magical counter variables Tie::Counter module scalars tying preventing unlocalized use of $_ variables no declarations Underscore module arrays tying variables tying arrays tying variables arrays methods classes implementing tied arrays Tie::Array module Tie::StdArray module methods array-tying arrays tying methods for bounded array, creating references to tied arrays accessing elements, tied arrays assignment tied array element POP method Tie::Array module SPLICE subroutine, using splicing tied arrays arrays tying notational convenience notational convenience, tied arrays functions interpolating interpolation functions variables tying hashes tying variables hashes hashes tying classes implementing tied hashes methods classes implementing tied hashes key/value pairs, hashes deleting Tie::Hash module Tie::StdHash module methods hash-tying hashes tying methods for cat command (Unix) clearing hashes exists function invoking on hash keys function values function each function scalar context keys function, calling in variables tying filehandles filehandles tying tying variables filehandles classes implementing tied filehandles methods classes implementing tied filehandles syswrite function reversing print and printf statements (tied filehandles) filehandle-tying filehandles tying methods for typeglobs autovivification of autovivification typeglobs print function implementing to tied filehandle READLINE method angle operator reading filehandle from GETC method closing tied filehandles SEEK method tell function using on tied filehandle printf function using on tied filehandle sprintf function read function sysread function syswrite function eof function tied filehandle, using on file descriptors returning for tied filehandles fileno file descriptors overloading stringifying stringifying operator overloading debugging turning on in tied filehandle filehandles tying creative filehandles pipes double-ended, opening with tied filehandle double-ended pipe, opening with tied filehandle Tie::DevNull module Tie::DevRandom module Tie::Tee module tee program, Unix null device, Unix random numbers producing as handles or scalars variables tying untying trap untying trap tying variables untying trap untie function objects tied variables, underlying breaking reference to references to tied variable objects, breaking warnings about remaining references to tied objects modules tie modules on CPAN tie modules on CPAN CPAN (Comprehensive Perl Archive Network) tie modules on MLDBM module DBM file storing complex data values in storing complex data values in DBM file relational databases hashes, tying to Tie::DBI module Tie::Persistent module persistent data structures, providing via tie data structures persistent, providing via tie encapsulation namespace-based namespace encapsulation based on Tie::SecureHash module syslog, filehandle tying to filehandles syslog tying output to Tie::Syslog module bit vector, providing array interface to Tie::VecArray module variables watch points, placing on watch points, placing on Perl variables Tie::Watch module registry (Microsoft Windows), manipulating Microsoft Windows registry, manipulating Win32::TieRegistry module Unicode character sets Unicode internationalization textual data, with Unicode text Unicode as international medium for bytes characters vs. characters bytes vs. data byte-oriented vs. character-oriented octets bytes width character representation octal numbers characters, representing UTF-8 variable-length character encoding characters converting between fixed 8-bit and variable-length UTF-8 variable-length UTF-8 characters fixed 8-bit chracters utf8 (Perl version) IP addresses UTF-8 representation of gethostbyaddr function converting characters back into bytes wide-character APIs, system calls using Microsoft Windows system calls using wide-character APIs interfaces byte vs. character semantics in -C (native wide characters) command-line switch $ variables ${^WIDE_SYSTEM_CALLS} utf8 strings, converting to/from byte strings code mixing character semantics with byte semantics character semantics, effects of use bytes pragma built-in operators character semantics, operating on utf8 pragma functions byte-oriented wrappers for length function byte-oriented wrapper for Unicode editors for literals UTF-8, enabling use in ASCII characters converting to Unicode use charnames pragma named characters, inserting identifiers Unicode alphanumeric characters, containing canonicalization characters, information on regular expressions characters, matching instead of bytes Tengwar script \C, matching single byte in C language character classes matching against character properties in Unicode \w matching ideograph with ideographs matching with \w \p (matches property) \P (doesn't match property) character classes predefined, availability of patterns (and regular expressions) Unicode properties, matching on combining character sequence, \X, matching with \X matching extended Unicode sequence with tr/// (transliteration) operator characters, transliterating with case translation operators, using Unicode tables titlecase ucfirst, translating to uc operator ucfirst operator Unicode case translation tables properties case, Unicode operators positions or lengths, switching to character positions positions operators switching to character positions integers converting to UTF-8 characters UTF-8 characters converting to integers converting between integers and UTF-8 characters pack function unpack function, Unicode characters and chr function ord function scalar reverse function Unicode properties database properties Unicode database of Unicode summary of, accessing Unicode Unicode Standard, Version 3.0 Perl use of Unicode, caveats on Unicode use in Perl, caveats on IPC (interprocess communication) processes interprocess communication invoking executing signals processes interprocess communication on the Internet sockets protocols and System V IPC syscalls processes interprocess communication between processes on same machine IPC (interprocess communication) between processes on same machine porting information on perlport documentation Microsoft Windows porting information (perlwin32) perlwin32 documentation perlfork documentation signals IPC (interprocess communication) signals %SIG hash hashes %SIG, references to signal handlers references to signal handlers (user-defined) kill function signals sources of keyboard sequences, generating signals with Control-C or Control-Z, generating signals with kernels generating signals hard references %SIG array functions signal-handling handlers for signals quit signals, handler for interrupt signals, handler for intercept signals, handler for Control-C signals, handler for core dumps, signals triggering in C library signals core dumps, triggering in C library C language library, signals triggering core dumps in die function quit signal handling and signals trapping with sigtrap pragma sigtrap pragma trapping signals sigtrap pragma IGNORE pseudosignal DEFAULT pseudosignal operating systems signals and default behaviors of names signals kill function Config module operating system mapping between signal names and numbers scopes signal handling local signal handler assignment process groups signals signaling process groups processes signaling process groups groups processes identifiers process group ID setprgp function existence of a process processes checking for existence kill function Microsoft systems and Microsoft Windows signal number 0 on signals zombie processes, reaping reaping zombie processes processes zombie zombie processes, reaping kernels autoreaping zombies on fork function zombie processes and sigaction function kernels signal reliability on System V IPC syscalls reliable signals, not supporting operating systems signal reliability on syscalls signal interruption of signals timing out slow operations syscalls restarting timing out slow operations ALRM signal flock function alarms and signals blocking blocking signals POSIX module signal blocking with sigprocmask syscall files in interprocess communication processes interprocess communication files files in interprocess communication locking mechanisms locking files race conditions file locking and flock function operating systems flock support on locking files shared and exclusive locks shared file locks exclusive file locks blocking, shared locks filehandles file locks on locking files dissolving locks by closing files exclusive file locks obtaining sysopen function semaphore file, use in file locking DBM files locking locking files DBM files GDMB files (GNU DBM), locking files in interprocess communication passing filehandles filehandles passing in IPC fork function child processes, inheriting parent filehandles STDIN, STDOUT, and STDERR filehandles passing filehandles to new programs through STDIN, STDOUT, and STDERR filehandles filehandles passing in IPC through standard filehandles file descriptors filehandles, passing with exec function filehandles, leaving open across calls fcntl syscall filehandle close-on exec flag, manipulating file descriptors passing through environment variable or command-line option open function converting file descriptor to filehandle operating systems fork operator, support for interprocess communication pipes pipes in interprocess communication input pipes output pipes input pipes output pipes anonymous pipes open function pipes, opening with child processes starting writeable pipelines multistage, for output shells pipe commands with special characters, handling shells avoiding with multi-argument piped open output pipes STDOUT as pipe to another program child processes readable, starting pipelines multistage, for input input pipes multistage pipelines ` (backtick) open function close function fork syscall pipes in interprocess communication process talking to itself open function forking open fork function fork-open pseudocommands, piping | (vertical bar) |- piping pseudocommand | (vertical bar) -| piping pseudocommand shells bypassing with -| piping pseudocommand setgid function setuid function UID (user ID) assumed gid (group ID) assumed output pipes filtering filtering output with forking open in interprocess communication bidirectional communication bidirectional communication, pipes input pipes bidirectional output pipes bidirectional Open2, Open3 library modules input pipes tridirectional output pipes tridirectional buffering bi-directional pipes, problems with tty IO::Pty module Expect module function call pipe, low-level for bi-directional communication socketpair syscall named pipes FIFOs pipes in interprocess communication named pipes mkfifo function Win32::Pipe module Microsoft Windows Win32::Pipe module -p file test operator file test operators -p, checking for FIFO sysopen function System V IPC processes interprocess communication System V IPC semaphore files System V IPC messages System V IPC shared memory, System V IPC memory shared, System V IPC mmap syscall shared memory, System V IPC controlled access to memory shared, System V IPC controlled access to IPC::Shareable module semaphore files shared memory ShMem package destructors shared memory and semaphore processes interprocess communication sockets sockets in interprocess communication NFS (network filesystems) limitations of sockets TCP and datagrams UDP packets TCP over Internet-domain sockets virtual circuits (as TCP streams) IP (Internet Protocol) DNS (domain name server) sockets Unix-domain sockets functions socket-related in Perl sockets functions (Perl), dealing with Socket module IO::Socket module -T (taint checking) switch operating systems sockets, support for Internet services, CPAN modules for networking modules sockets in interprocess communication networking clients networking clients Internet TCP clients/servers TCP clients/servers clients, TCP servers, TCP IO::Socket::INET module Socket module networking client, connecting to server shutdown syscall closing server connections (half-close) sockets in interprocess communication networking servers servers, networking networking servers getpeername function clients, networking getting name of servers, networking forking clones to handle incoming connections select syscall multiplexing I/O between clients fork function servers, cloning themselves with zombie processes, reaping servers reaping zombie processes servers STDIN, STDOUT, and STDERR reassigning to client connection perl interpreter program -T switch -T (taint checking) switch taint checking CRLF in Internet programs line terminators, Internet programs sockets in interprocess communication message passing messages passing with UDP UDP passing messages with time UDP program, getting from other machines threads multithreading threads process model processes process model, threads logical separation, parent and child processes copy-on-write semantics Microsoft Windows fork operation, cloning interpreter objects forks cloned interpreter on Windows interpreters threads ithreads threads thread model multiprocessing thread model kernels threads and modules thread safety and semaphores thread safety and operating systems threading libraries scheduling and preemption policies, threads signals threads, delivering to Perl thread programming in Thread::Semaphore module Thread module methods Thread class class methods Thread class object methods Thread objects functions Thread module Thread module thread creation Thread method async function new method closures threads Thread module thread destruction exit function threads and destroying threads join method join method join method catching exceptions from Thread module join method, catching exceptions from exceptions threads, catching eval method threads, catching exceptions with Thread module detach method, shutting down threads with detach method destroying threads detach method exceptions in detached child threads Thread module identifying threads identifiers thread IDs tid method self method, thread accessing own thread object equal method comparing thread objects list method current thread objects in process Thread module yielding the processor yield function CPU, yielding (threads) processor CPU thread model data access data access threads global variables threads, accessing in lexical variables threads, accessing in package variables threads, no protection in data access threads synchronizing with lock synchronization data access in threads lock function data access control in threads references locking blocking calls, lock, threads recursivity locks data access threads unlocking data access threads deadlock deadlock in threads subroutines locking for threads locking subroutines data access threads locking subroutines subroutines locking for threads locked attribute locked attribute, subroutines attributes locked, subroutines methods object methods locking object methods locking locking methods data access threads locking methods data access threads condition variables condition variables variables condition variables CPU condition variables allowing threads to relinquish Thread::Semaphore module thread model control, passing between threads modules thread modules Thread::Queue module queues, Thread::Queue module enqueue method scope in threads Thread::Semaphore module semaphores Thread::Semaphore module down method up method Thread::Signal module signals Thread::Signal module core dumps Thread::Signal module, preventing with compiling compiling life cycle of Perl programs Perl programs, life cycle of life cycle, Perl programs life cycle, Perl programs compilation phase compiling life cycle, Perl programs compile phase parse trees BEGIN blocks CHECK blocks INIT blocks END blocks Perl interpreter life cycle, Perl programs code generation phase compiling life cycle, Perl programs code generation phase code generation bytecode executable image file parse trees reconstruction of life cycle, Perl programs parse tree reconstruction compiling life cycle, Perl programs parse tree reconstruction life cycle, Perl programs execution phase execution Perl programs run phase compiling compiling your code run phase vs. run time compile phase vs. compile time lexer lexical analysis lexical analysis in the Perl compiler parsing in the Perl compiler optimizing in the Perl compiler tokens opcodes parse trees executing code interpreter, Perl virtual machine, Perl Perl virtual machine opcodes push-pop (PP) codes stacks Perl virtuall machine operand stack save stack localized values, saving scopes scope stack context stack jumpenv stack return stack mark stack recursive lexical pad stacks lexical variables recursive lexical pad stack C language C stack, storing C variables on interpreter, Perl Perl virtual machine threads multiple, in single interpreter interpreter, Perl multiple, running mod_perl module ithreads Perl API to Apache web server mod_perl extension interpreter, Perl embedding in applications parse trees internal, keeping compiler, Perl backends for backends, compiler C language accesing Perl from enclosing framework code generators modules backend backends, compiler modules debugging backend modules for modules backend, calling backends, compiler modules, calling O module perlcc command code generators code generators bytecode generator B::Bytecode module perlcc command pbyscript resulting from Byteloader module source code filter for parse trees original, reconstituting and splicing into current parse tree code generators C Code generators C language C code generators B::C and B::CC modules source code development tools for O module B::Lint module lint (C program verifier) B::Xref module variables B::Xref module, cross-references with C subroutines B::Xref module, cross-references with C formats B::Xref module, cross-references with C B::Deparse module binary files decompiling with B::Deparse module compilers, Perl interpreters, interaction with interpreter, Perl compiler, interaction with subroutines named, compiler/interpreter interaction BEGIN blocks order of running INIT blocks order of running CHECK blocks order of running END blocks order of running BEGIN blocks altering compiler parsing of file END blocks skipping END block exit value of program, modifying INIT blocks order of running compilation order of execution code, order of commands processing commands processing interpreters; Perl interpreter executing Perl programs interpreters for commands operating systems command interpreters for processing shell commands switches, command-line scripts Perl, searching for and compiling switches, command-line -e switches interpreter, Perl invoking with #! (shebang) line # (sharp) #! (shebang) notation operating systems invoking interpreters with #! line standard input scripts, passing by Perl interpreter -x switch -x (extract program) command-line switch Unix truncating kernel interpretation of #! line -I (include path) command-line switch, Perl interpreter -I switch -0 command-line switch Perl interpreter -0 switch - (hyphen) -*- for emacs emacs -*- sequences env program, starting Perl with version of Perl placing in #! line shells Bourne shell (sh) /bin/sh operating systems #! technique, simulating on non-Unix systems # (sharp) #! (shebang) notation simulating on non-Unix systems Macintosh operating system invoking Perl application on MS-DOS operating system, invoking Perl applications on dosish.h file OS/2 operating system invoking Perl applications on VMS operating system invoking Perl applications on Microsoft Windows ActiveState Perl distribution, installing ActiveState Perl distribution installing on Windows systems quotation marks on non-Unix systems interpreters for commands quoting on Unix systems Microsoft Windows Windows NT, quoting on Macintosh operating system quoting on control characters non-ASCII on Macintosh command processing location of Perl Perl location of version of Perl specifying switches, command-line options switches, command-line flags switches, command-line Perl interpreter switches - (hyphen) -- command-line switch Perl interpreter -- switch Perl interpreter -0 switch -0 switch, perl $ variables $/ ($INPUT_RECORD_SEPARATOR) record delimiter $/ variable octal numbers specifying $/ as paragraph mode slurping files Perl, setting value for Perl interpreter -a switch -a (autosplit) command-line switch autosplit mode -F (pattern to split on)command-line switch Perl interpreter -F switch field separator, specifying different Perl interpreter -c switch -c (check syntax) command-line switch scripts checking syntax of syntax, checking wide character APIs, enabling Perl use of on target system Perl interpreter -d switch -d (debug) command-line switch -d (debug) command-line switch debugging scripts debugging scripts debugging debugging Perl interpreter -D switch -D (debugging) command-line switch $ variables $^D ($DEBUGGING) configuration, Perl, for debugging Perl interpreter -e switch -e (execute) command-line switch scripts building with -e switch writing scripts scripts Perl interpreter -F switch -F (pattern to split on) command-line switch patterns autosplitting via -a switch shells quotes, passing through Perl interpreter -h switch -h (help) command-line switch Perl interpreter -i switch -i (in-place editing) command-line switch angle operator inplace editing ($^I, $INPLACE_EDIT) input files, locating end with eof backup files Perl interpreter -I switch -I (include path) command-line switch directories prepending to @INC @INC array;prepending directories to prepending, directories to @INC Perl interpreter -l switch -l (automatic line ending) command-line switch automatic, line-end processing line-end processing, automatic $ variables $\ ($OUPUT_RECORD_SEPARATOR) Perl interpreter -m switch -m (use module)command-line switch -M (use module) command-line switch Perl interpreter -M switch pragmas Perl interpreter -n switch -n (loop) command-line switch Perl interpreter -p switch -p (print while looping) command-line switch Perl interpreter -P switch -P (C preprocessor) command-line switch C preprocessor Perl interpreter -s switch -s (switch) command-line switch Perl interpreter -S switch -S (search for script) command-line switch PATH environment variable searching for scripts scripts searching for Perl interpreter -T switch -T (taint checking) command-line switch taint checking Perl interpreter -u switch -u (dump core) command-line switch core files files core scripts dumping core files Perl interpreter -U switch -U (unsafe) command-line switch unsafe operations Perl interpreter -v switch -v (version) command-line switch Perl interpreter -V switch -V (version) command-line switch Perl interpreter -w switch warning messages -w command-line switch Perl interpreter -x switch -x (extract program) command-line switch message script embedded in scripts embedding in messages Perl interpreter -X switch -X (warning disabling) command-line switch warnings disabling unconditionally and permanently environment variables shells environment variables, using with subshells, environment variables, using with HOME variable chdir command, calling without argument natural languages environment variables controlling Perl handling of LOGDIR variable PATH environment variable libraries Perl library files, searching for PERL5LIB environment variable switches, command-line default, taking switches as PERL5OPT environment variable PERL5DB environment variable debugging debugger code, command for loading Microsoft Windows shell, setting alternative for Perl use PERL5SHELL environment variable shells alternative for Perl, Windows systems COMSPEC environment variable malloc function PERL_DEBUG_MSTATS environment variable, using with memory statistics on, displaying PERL_DEBUG_MSTATS environment variable debugging global destruction of objects other references, controlling PERL_DESTRUCT_LEVEL environment variable destructors controlling objects destruction of (global), controlling references destruction of, controlling environment variables modules, Perl use of debugging -s (switch) command-line switch Perl interpreter -s switch Perl interpreter -d switch -d (debug) command-line switch troubleshooting debugging use warnings pragma breakpoints setting for debugger commands history, debugger and history, command numbers command command history, debugger and \ (backslash) for multiline commands source code window around breakpoint, examining = (equal sign) ==> current line marker tracing, stack backtrace (debugger command) stacks backtracing with T command $ (dollar sign) in debugger @ (at sign) in debugger . (dot) in debugger command void context recognizing in debugger scalar context recognizing in debugger list context recognizing in debugger debugging controlling from programs programs controlling debugger from compile time, controlling debugger during PERLDB_OPTS environment variable AutoTrace option, tracing compile-phase statements breakpoints setting on load debugging Perl debugger commands commands debugger [semi] (semicolon) in debugger commands \ (backslash) entering continued commands in debugger programs stepping through with debugger commands debugger stepping and running stepping through code subroutine calls executing without stepping through . (dot) in debugger command return value currently executing subroutine, displaying in debugger commands debugger breakpoints breakpoints setting with debugger commands breakpoints deleting deleting breakpoints breakpoints listing all actions (debugger) listing all tracing stack backtrace, debugger T command commands debugger tracing toggling trace mode (debugger) watch expressions breakpoints watch expressions, causing commands debugger for display commands debugger for display printing nested data structures nested data structures, printed list context evaluating expressions in (debugger) variables package, displaying commands debugger locating code code extracting and displaying with debugger listing code - (hyphen) in debugger commands filenames viewing different program or eval statement patterns debugger, commands for matching m// (matching) operator / (slash) debugger command m?? (match) operator subroutines debugger command for pattern match listings commands debugger actions and actions (debugger) command execution, specifying from debugger deleting all debugger actions < (left angle bracket) in debugger commands > (right angle bracket) in debugger commands { (braces) in debugger commands ! (bang) in debugger commands ! (bang) !! debugger command shells debugger commands and | (vertical bar) debugger command | (vertical bar) || debugger command commands debugger quitting debugger quitting Perl debugger exiting Perl debugger commands debugger restarting debugger = (equal sign) debugger command aliases debugger command for man command commands debugger documentation, viewing documentation default system viewer, calling perldoc command debugger invoking commands debugger options, manipulating customization debugger debugging debugger customization PERLDB_OPTS environment variable debugger customization via editors, support for debugging customization debugger editor support for Term::ReadKey module Term::ReadLine module emacs editor support for debugger vi editor debugger, support for customization debugger init files, using initialization debugger, customizing with init files PERL5DB environment variable debugger, customizing with variables debugger, customizing functions debugger, calling internal customization debugger debugger options debugging debugger, customizing options shells spawning, characters for commands recalling, debugger option recallCommand option (debugger) pager option (debugger) tkRunning option (debugger) signal level option (debugger) warnLevel option (debugger) dieLevel option (debugger) verbosity debugger, setting levels of AutoTrace option (debugger) LineInfo option (debugger) inhibit_exit option (debugger) exiting debugger PrintRet option (debugger) ornaments option (debugger) screen appearance of command line command line screen appearance of frame option (debugger) messages printing on entry and exit from subroutines maxTraceLen option (debugger) truncating argument list arrayDepth option (debugger) hashDepth option (debugger) output array and hash, changing style (debugger) arrays output style, changing in debugger hashes output style, changing in debugger printing typeglob contents typeglobs printing contents of symbol tables displaying for packages packages symbol tables displaying addresses reused, displaying contents of reused addresses, displaying contents of strings display, changing in debugger quotation marks strings changing style of string display variables package, memory usage debugging debugger, unattended execution execution unattended, debugger terminal, setting for debugging I/O Term::Rendezvous module input debugger, setting output debugger, setting ReadLine module, disabling support to debugger noninteractive mode, putting debugger in environment variables PERLDB_OPTS, setting debugger options with debugging debugger support, Perl functions debugger customization customization debugger functions for perl interpreter program -d switch -d switch, perl DProf Devel::Dprof module Devel::Dprof module profiling subroutine execution with Devel::Dprof module efficiency profiling speed efficiency profiler, Perl timing comparing for subroutines' execution dbprofpp program Devel::SmallProf module guts bytecode compilation C language Perl extensions and embedding Perl perl interpreter program lexical analysis tokenization lexical analysis parsing compilation phase, processing Perl program opcodes -c (check syntax) command-line switch BEGIN blocks CHECK blocks use statement data types internal, Perl and C SV (internal scalar value) AV (internal array value) IV (internal integer value) integers IV (internal integer values) HV (internal hash value) UV (internal unsigned integer value) NV (internal double value) PV (internal string value) RV (internal reference value) GV (internal glob value) typedefs (C language) arrays AV (array value) typedef in C, corresponding to scalars SV (scalar value) in C hashes HV (hash value) typedef in C integers IV typedef in C C language Perl, extending with Perl C, using from extending Perl XSUBs XS XSUBs wrapping subroutines for Perl dynamic linking C source code from Perl subroutines external (XSUBs) XS language external subroutines, wrapping XS language functions, mapping between C and Perl extending Perl XSUBs and XS language, wrapping Perl in Perl C, using from XSUBs and XS language C language Perl, extending with XSUBs and XS language XSUBs XS xsubpp compiler SWIG SWIG system XSUBs, automatically generating h2xs utility functions Perl, wrapping around C C language Perl functions, wrapping around static linking dynamic linking typemap extending Perl extensions, creating Perl C, using from creating extensions C language Perl, extending with creating extensions h2xs utility Makefile.PL modules testing test.pl MANIFEST file Exporter DynaLoader bootstrapping modules blib input XSUBs output XSUBs XSUBs input and output extending Perl XSUB input and output Perl C, extending with XSUB input and output C language Perl, using from XSUB input and output modules testing test.pl extending Perl using functions from external C libraby C language Perl, extending with external C library, using functions from Perl C, using from external C library functions, using math library, C language libraries math library, C embedding Perl Perl embedding in C C language Perl, using from IPC::Open2 IPC::Open3 interpreter, Perl accessing from C popen function (C language) interpreter, Perl persistent persistent Perl interpreter Apache web server mod_perl module perlembed manpage embedding Perl compiling embedded programs compiling embedded Perl program (in C) Perl embedding in C compiling embedded programs C language Perl, using from compiling embedded Perl programs %Config hash ExtUtils::Embed module interpreter, Perl adding to C program embedding Perl adding Perl interpreter to C program C language Perl, using from adding Perl interpreter Perl embedding in C Perl interpreter, adding to C program subroutines Perl, calling from C Perl embedding in C Perl subroutine, calling from C C language Perl, using from Perl subroutine, calling from statements Perl, evaluating from C Perl embedding in C Perl statement, evaluating from C C language Perl, using from Perl statement, evaluating embedding Perl evaluating Perl statement from C eval_sv and eval_pv functions perlapi manpage scalars Perl, converting to C types perlembed manpage eval_sv function, demonstrating Perl embedding in C Perl stack, manipulating from C C language Perl, running from Perl stack, manipulating embedding Perl Perl stack, manipulating from C stacks Perl, manipulating from C data types converting between C and Perl converting data types between C and Perl perlcall manpage integers exponentiation exponentiation of integers CPAN (Comprehensive Perl Archive Network) Perl CPAN (Comprehensive Perl Archive Network) CPAN (Comprehensive Perl Archive Network) subdirectories doc directory (CPAN), official Perl manpages manpages CPAN doc subdirectory, containing modules CPAN directory for ports Perl, to operating systems operating systems Perl ports to scripts Perl, CPAN directory of src directory (CPAN) source code CPAN, for Perl distribution modules CPAN CPAN (Comprehensive Perl Archive Network) modules directory bundles modules CPAN categories of CPAN (Comprehensive Perl Archive Network) modules categories of modules Java, Perl modules for pod Perl modules for source filters core modules, Perl language extensions, Perl modules for compiler, Perl modules related to development support, modules for operating systems Perl modules for PalmPilot, Perl modules for serial ports, Perl modules for hardware drivers, Perl modules for interacting with networking modules implementing network protocols Internet protocols, Perl modules for modems, Perl modules for household appliances, Perl modules for math, Perl modules for statistics, Perl modules for algorithms Perl modules for data structures dates Perl modules for times, Perl modules for object-oriented programming Perl modules for PDL (Perl Data Language) POE (Perl Object Environment) DBI (Database Interface) Perl modules for DBD (Database drivers) Perl modules for databases Perl modules for operating databases see also DBI Curses, Perl modules for command-line editing Perl modules for Perl/Tk Perl modules for Tk Perl/Tk Gtk, Perl modules for Gnome, Perl modules for Sx, Perl modules for Qt, Perl modules for GUIs Perl modules for programming languages Perl modules for interfacing with or emulating Perl models to interface or emulate other languages files Perl modules for directories Perl modules for text Perl modules for hyphenating text, Perl module for wrapping text Perl module for parsing text, Perl modules for stemming text, Perl modules for searching text Perl modules for Postscript, Perl modules for fonts Perl modules for XML, Perl modules for RTF Perl modules for option processing, Perl modules for command-line switches see also option processing command-line flags see also option processing configuration files, Perl modules for internationalization Perl modules for locale Perl modules for localization locale authentication, Perl modules for authorization, Perl modules for security Perl modules for encryption Perl modules for passwords Perl modules for message digests, Perl modules for users authenticating, Perl modules for web Perl modules for HTML Perl modules for HTTP Perl modules for CGI Perl modules for MIME, Perl modules for Apache web server Perl modules for servers Perl modules for daemons Perl modules for zipping, Perl modules for tarring, Perl modules for file conversions, Perl modules for graphs, Perl modules for GIFs, Perl modules for VRML, Perl modules for Gimp Perl modules for mail Perl modules for email mail Usenet Perl modules for netnews Usenet IO::modules logfiles, Perl modules for files Perl modules for networking services, Perl module for interacting with Expect Microsoft Windows Perl modules for ASP Perl modules for OSBC Perl modules for OLE, Perl modules for Windows Microsoft Windows astronomy, Perl modules for biology, Perl modules for chemistry, Perl modules for credit cards, Perl modules for mortgages, Perl modules for audio, Perl modules for video, Perl modules for MIDI, Perl modules for weather, Perl modules for games, Perl modules for tarballs (.tar.gz files) tar files Makefile.PL CPAN (Comprehensive Perl Archive Network) modules installing and building PPM (Perl Package Manager) modules CPAN making available to programs perlmodinstall manpage installation modules, CPAN CPAN module installing modules with ActiveState Perl distribution PPM (Perl Package Manager) PPM (Perl Package Manager) modules CPAN decompressing and unpacking CPAN (Comprehensive Perl Archive Network) modules decompressing and unpacking decompressing CPAN modules unpacking CPAN modules Unix system CPAN modules, installing on Microsoft Windows CPAN modules, installing on building CPAN modules CPAN (Comprehensive Perl Archive Network) modules building modules CPAN building Perl library libraries Perl, installing modules into modules CPAN installing into Perl library CPAN (Comprehensive Perl Archive Network) modules installing into Perl library installation modules, CPAN into Perl library MakeMaker ExtUtils::MakeMaker MakeMaker Makefile.PL PAUSE modules CPAN creating CPAN (Comprehensive Perl Archive Network) modules creating h2xs MakeMaker ExtUtils::MakeMaker MakeMaker modules testing testing modules testing modules internal testing testing modules external testing security taint taint mode, using source code foreign code, executing security handling insecure data data insecure, handling security insecure data, handling setuid program setgid program users granting limited privileges to permissions users, granting limited taint taint mode programs needing to run with perl interpreter program -T switch -T switch, perl taint taint mode automatic enabling of identifiers effective user or group IDs, differing from real set-id programs taint taint mode enabling explicitly with -T switch daemons taint mode, importance of enabling for servers taint mode, importance of enabling for CGI scripts taint mode, necessity of running under scripts CGI, taint mode and taint taint checks environment variables taint checking checking, taint debugging taint variables taint and arrays taint in hashes taint in insecure dependency errors errors insecure data exceptions insecure data indirect objects explicit path, passing in slot testing for tainted data data insecure, handling detecting and laundering tainted data security insecure data, handling detecting and laundering tainted data taint tainted data, detecting and laundering patterns (and regular expressions) for untainting data environment cleaning up security insecure data, handling environment, cleaning up data insecure, handling environment, cleaning up PATH environment variable security and shells environment variables as security hazards open function for pipes, security risks posed by pipes open function, security risks posed by filenames external data in, security risks of newlines in filenames, security risks of ; (semicolon) in filenames, security risks of data insecure, handling command and file access under reduced privileges security insecure data, handling command and file access under reduced privileges commands accessing under reduced privileges files accessing under reduced privileges identifiers effective UID or GID, setting back to real set-id program dangerous operations, UID and GID setting to real ` (backtick) security and shells avoiding use of forking pipe open, avoiding shell in security timing glitches, handling timing glitches, handling multiprocessing processer access, unpredictability of CPU access in multitasking environment processes multitasking environments, CPU access Unix security bugs debugging Unix security bugs security timing glitches, handling Unix kernel security bugs timing glitches, handling Unix kernel security bugs # (sharp) #! (shebang) notation security problems caused by set-id programs Unix kernel bugs, security problems with kernels Unix, set-id script bug in symbolic links security risks in Unix wrappers C, around set-id scripts C language wrapper programs timing glitches in race conditions, handling race conditions handling security timing glitches, handling race conditions file tests race conditions with overwriting existing files, race conditions and sysopen command file overwriting, controlling filehandles use instead of filenames, security benefits of stat function filehandles, calling on temporary files, security risks with security timing glitches, handling temporary files timing glitches, handling temporary files identifiers PIDs, guessing functions temporary filenames, generating names temporary files, generating File::Temp module, dealing with race conditions fcntl function security risks associated with scripts insecure security insecure code, handling code insecure, handling taint taint checking code quarantining suspicious code Safe module safe compartments for insecure code security insecure code, handling safe compartments for code insecure, handling safe compartments for Safe module insecure code, handling with chroot syscall namespaces access, restricting with Safe module variables fully-qualified, accessing from outside package reval method, running suspicious code with eval method restricted (reval) Safe module insecure code, handling restricting operator access operators access, restricting with Safe module code insecure, handling safe examples CGI scripts input, evaluating (Safe module) security code masquerading as data data insecure, handling code masquerading as data code insecure, handling code masquerading as data shells security pitfalls with use, avoiding system function list argument form, avoiding shell with exec function list argument form, avoiding shell with open function piped list argument form, avoiding shell with patterns (and regular expressions) security concerns denial-of-service problems (patterns and regular expressions), security concerns core dumps denial-of-service problems with pattern matching alarm function pattern match, timing out BSD::Resource module, per-process resource limits, setting programming, Perl Perl programming, common practices programming, Perl common mistakes of novices novice programmers, common mistakes of troubleshooting scripts common mistakes of novices scripts Perl common mistakes of novices FAQ, Perl online , (comma) error in print statements print statements comma error in = == (equal to) operator ! (bang) != (not equal to) operator ne operator eq operator comparing strings strings operators [semi] (semicolon) errors, omitting trailing here documents semicolon (;), omitting trailing {} braces backreferences m// (match) operator s// (substitution) operator match (m//) operator substitute (s//) operator local function common programming errors with variables local common programming errors with do loops loops () (parentheses) $ variables $^ ($FORMAT_TOP_NAME) list context operations behaving differently in scalar context operations behaving differently in barewords avoiding, reasons for use declarations use strict angle operator functions default arguments, avoiding errors with my declarations local, using instead of local variables my declarations, using for variables local my declarations, using instead of local function local function my declaration, using instead of C language programming, differences from Perl troubleshooting C code if statements C language, differences from Perl break command (in C) continue command (in C) last command do {} while construct, not taking next command do {} while construct, not taking switch statement Perl vs. C programming variables Perl vs. C, names of comments Perl vs. C syntax for addresses C language, Perl vs. variable Perl, C language vs. syscalls Perl, C language vs. signal handlers %SIG, Perl vs. C language shells programming, Perl vs. troubleshooting shell code variables shell programming, Perl vs. foreach loops loop variable, Perl vs. shell programming ` (backtick) operator shell programming, Perl vs. substitution, shells versus Perl scripts interpretation, shells vs. Perl program arguments, shell vs. Perl environment variables shells vs. Perl programming, Perl common mistakes by novices Perl traps, previous versions versions Perl changes between release 4 and 5 @ (at sign) changes in use, Perl versions barewords Perl versions, changes in subroutines barewords, confusing with identifiers starting with underscore (_), changes in Perl versions _ (underscore) Perl versions, changes in use : (colon) :: for package identifiers patterns replacements, changes in Perl versions splice function Perl versions, changes in precedence Perl versions, changes in assignment operators precedence, Perl versions, differences in formats argument lists for, evaluating in list context goto function Perl versions, changes in whitespaces use as variable name or delimiter for quote construct, changes in caller function Perl versions, changes in return value m//g operator Perl versions, changes in subroutines sorting, reverse disallowed as name for reverse, disallowing as sort subroutine name taintperl program strings double-quoted changes in Perl versions negative array subscripts, counting from end of array arrays negative subscripts, counting from end of array , (comma) operator in scalar context scalar context comma operator in arrays tied, delete function and delete function tied arrays, not returning deleted value for foreach loops Perl versions, changes in programming, Perl efficiency performance Perl programs, efficiency in scripts Perl performance of efficiency performance speed performance optimizing performance and hashes instead of linear searches searching linear, versus hashes subscripting foreach loops goto function printf function print function $ variables $& ($MATCH) $ variables $' ($POSTMATCH) $ variables $` ($PREMATCH) eval function strings eval function and eval function loops and loops eval function within next operator next if construct quantifiers length of strings subroutines performance and getc function substr function last operator switch statement print function strings concatenating concatenation (.) operator . (dot) ;concatenation operator split function arrays performance and pre-extending arrays undef function eof function /etc/passwd file /etc/group file syscalls performance and system function performance and pwd command (Unix) metacharacters sticky bit perl interpreter program sticky bit memory efficiency of code effienciency of porting, efficiency of user efficiency, Perl programming GUI, using PerlTk Perl/Tk Tk Perl/Tk error messages user efficiency, improving with scripts Perl programming with style programming, Perl programming with style style, programming with {} (braces) whitespace () (parentheses) last function loops labels with loops grep function map function ` (backtick);operator _ (underscore) in variable names names variable variables names for packages names for modules names for names modules/packages capitalization package/module names functions names for methods names for and operator or operator error messages STDERR filehandle code reusing reusing code programming, Perl fluent scripts Perl idiomatic Perl, using idioms, Perl programming, Perl program generation generators, Perl programs programming, Perl program generators other languages in Perl generators, Perl programs other languages in Perl programming, Perl program generation generating Perl in other languages generators, Perl programs in other languages preprocessing Perl #line directive __FILE__; setting __LINE__; setting __END__; use of Control-D as eof ^D (Control-D) as eof Control-Z as eof ^Z (Control-Z) as eof languages translating converting between languages translating between languages source code filters for filters source code programming, Perl program generators source filters generators, Perl programs source filters programming, Perl portability portability, Perl programs operating systems Perl program portability $ (dollar sign) $ variables $^O variable %Config hash functions Perl, varying across platforms newlines Perl program portability and carriage returns newlines CRLF newlines \n newlines sockets newlines, sending across operating systems newlines, variations in width of numbers numbers width of integers computer storage, order of floating-point numbers computer storage, order of big-endian little-endian 32-bit systems 64-bit systems number width pack unpack portability of files and filesystems files path components, separators for filesystems, portability File::Spec module File::Basename module programming, Perl file-manipulating programs, writing portable AutoSplit, portability of operating systems GUIs, relying on files portably opening %ENV hash portability of environment variables portability of signals portability of portability of signals filenames globbing globbing filenames portability of $!, portability of IPC (interprocess communication) portability and system function portability of exec function portability of fork function portability of pipe function portability of backticks portability of open function portability of mail sending, portability and System V IPC portability of modules CPAN mail, sending XS language code, portability of external subroutines portability of subroutines external portability of modules CPAN portability of CPAN module portability of DBM modules, portability of dates, portability of times, portability of character sets, portability of internationalization pod format documentation,embedded in Perl programs pod pod translators comments multiline directives (pod) commands in pod pod directives pod translators pod modules history of Perl Perl, history of complementation negation creation time modification time, file poetry in Perl variables special special variables _(underscore) global filehandle backreferences numbered variables $ variables $1 et al $ variables $[ (index of first array variable) characters $[ variable arrays first element of strings first character of $ variables $# obsolete variable for numeric output $ variables $* $ variables $a and $b (sort variables) sort variables $ variables $^A ($ACCUMULATOR) $ACCUMULATOR $ variables $_ ($ARG) $ARG pattern space @ (at sign) @_ array subroutines arguments parameters arguments formal arguments arguments formal ARGV filehandle $ARGV variable @ARGV array ARGVOUT filehandle $ variables $^T ($BASETIME) $BASETIME basetime ($^T) time base ($^T) $ variables $? ($CHILD_ERROR) $CHILD_ERROR errors $? variable for exit status status of exiting process wait system call -c (check syntax) command-line switch $ variables $^C ($COMPILING) perlcc compiler DATA filehandle __END__ token __DATA__ token $ variables $^D ($DEBUGGING) $DEBUGGING debugging flags effective GID (group ID) GID (group ID), effective $ variables $) ($EFFECTIVE_GROUP_ID) $EFFECTIVE_GROUP_ID $ variables $> ($EFFECTIVE_USER_ID) $EFFECTIVE_USER_ID real UID $< variable effective UID ($EFFECTIVE_USER_ID) $< and $> variables UID (user ID) $< and $> variables %ENV hash environment variables variables environment errors $@ variable for $ variables $@ ($EVAL_ERROR) $EVAL_ERROR processes variables for $ variables $^S ($EXCEPTIONS_BEING_CAUGHT) $EXCEPTIONS_BEING_CAUGHT $ variables $^X ($EXECUTABLE_NAME) $EXECUTABLE_NAME program name of perl executable @EXPORT array @EXPORT_OK array %EXPORT_TAGS hash $ variables $^E ($EXTENDED_OS_ERROR) $EXTENDED_OS_ERROR @F array -a switch, perl perl interpreter program -a switch -w switch, Perl %FIELDS hash form feed $ variables $^L ($FORMAT_FORMFEED) $FORMAT_FORMFEED $ variables $- ($FORMAT_LINES_LEFT) $FORMAT_LINES_LEFT $ variables $= ($FORMAT_LINES_PER_PAGE) $FORMAT_LINES_PER_PAGE $ variables $: ($FORMAT_LINE_BREAK_CHARACTERS) $FORMAT_LINE_BREAK_CHARACTERS continuation lines strings breaking $: variable $ variables $~ ($FORMAT_NAME) $FORMAT_NAME format pages page numbers numbers for pages $ variables $% ($FORMAT_PAGE_NUMBER) $FORMAT_PAGE_NUMBER $ variables $^ ($FORMAT_TOP_NAME) $FORMAT_TOP_NAME top-of-page processing filehandles ending with _TOP $ variables $^H hints, compiler compiler hints %INC hash require operator filenames %INC hash of @INC array path for library searches, %INC search path %INC $ variables $^I ($INPLACE_EDIT) $INPLACE_EDIT inplace edits with $^I $ variables $. ($INPUT_LINE_NUMBER) $INPUT_LINE_NUMBER line numbers of input file $ variables $/ ($INPUT_RECORD_SEPARATOR) $INPUT_RECORD_SEPARATOR paragraph mode RS (awk variable) $INPUT_RECORD_SEPARATOR record mode @ISA array @+ array of ending positions length of matched string LENGTH (awk variable) @+ @ (at sign) @- array of starting positions starting position of matched string RSTART (awk variable) @- $ variables $+ ($LAST_PAREN_MATCH) $LAST_PAREN_MATCH $ variables $, ($LIST_SEPARATOR) $LIST_SEPARATOR $ variables $^M trapping out-of-memory errors malloc errors memory running out of errors out-of-memory errors out of memory errors $ variables $& ($MATCH) $MATCH $ variables $] ($PERL_VERSION) $PERL_VERSION version, Perl $ variables $^O ($OSNAME) $OSNAME $OSNAME $^O variable operating system name $ variables $! ($OS_ERROR) $OS_ERROR errors $! variable for errno $OS_ERROR $ variables $| ($OUTPUT_AUTOFLUSH) $OUTPUT_AUTOFLUSH commands buffering flushing buffers autoflushing buffers records input, separator for $/ variable input record separator $/ variable records output, separator for $\ variable output record separator $\ variable output field separator $, variable $ variables $, ($OUTPUT_FIELD_SEPARATOR) $OUTPUT_FIELD_SEPARATOR $ variables $\ ($OUTPUT_RECORD_SEPARATOR) $OUTPUT_RECORD_SEPARATOR $ variables $^P ($PERLDB) $PERLDB $ variables $^V ($PERL_VERSION) $PERL_VERSION version of Perl ($^V) revision version v-strings in $^V $ variables $' ($POSTMATCH) $POSTMATCH $ variables $` ($PREMATCH) $PREMATCH $ variables $$ ($PROCESS_ID) $PROCESS_ID PID (process ID) $ variables $0 ($PROGRAM_NAME) $PROGRAM_NAME names program $0 variable scripts names of $0 variable program name of perl script GID (group ID) $( variable[semi] $) variable real GID $( variable effective GID $) variable $ variables $( ($REAL_GROUP_ID) $REAL_GROUP_ID $ variables $) ($EFFECTIVE_GROUP_ID) $EFFECTIVE_GROUP_ID $ variables $< ($REAL_USER_ID) $REAL_USER_ID %SIG hash signals %SIG hash warning messages intercepting exceptions intercepting STDERR filehandle STDIN filehandle STDOUT filehandle $ variables $[semi] ($SUBSCRIPT_SEPARATOR) $SUBSCRIPT_SEPARATOR subscript separator $[semi] variable arrays subscript separator $[semi] variable $ variables $^F ($SYSTEM_FD_MAX) $SYSTEM_FD_MAX close-on-exec flag $ variables $^W ($WARNING) $WARNING lexical warnings ${^WARNING_BITS} warnings lexical; ${^WARNING_BITS} $ variables ${^WARNING_BITS} ${^WARNING_BITS} utf8 globally switching interfaces to wide, syscalls $ variables ${^WIDE_SYSTEM_CALLS} ${^WIDE_SYSTEM_CALLS} functions functions under specific function name lists as function arguments lists flattening () (parentheses) in functions whitespace precedence order of function precedence switches -w switch C language library functions functions C library documentation C library functions functions in list or scalar context scalar context functions in list context functions in bytes characters vs. characters bytes vs. functions by category categories of functions scalars functions for manipulating regular expressions functions dealing with patterns (and regular expressions) functions for matching numbers functions dealing with arrays processing, functions for lists processing, functions for hashes processing, functions for input functions dealing with output functions dealing with data fixed-length, functions for records functions dealing with files functions dealing with filehandles functions dealing with directories functions dealing with flow of program control, functions for scope functions dealing with miscellaneous functions processes functions dealing with groups processes functions dealing with modules functions dealing with classes functions dealing with objects functions dealing with sockets low-level access, functions for System V IPC functions dealing with users, information about, functions for getting groups users functions dealing with login names functions dealing with networking network information, functions for retrieving time Perl functions for functions returning tainted data taint functions returning tainted data exceptions functions raising lport manpage, function portability information portability functions, information on abs (absolute value) function accept function sockets accepting connections from clients alarm function SIGALRM signal timing with alarms syscall function itimer routines Timer::HiRes module arctangents atan function tan function tangent pi bind function naming, socket sockets attaching address to addresses socket names as binmode function files read in binary mode binary mode on filehandles disciplines filehandles, setting up with binmode bless function objects blessing packages blessing objects into caller function subroutine call stack stacks subroutines, current calls DB package caller function chdir function directories changing working home directory files permissions permissions, file chmod function File::chmod module chomp function characters deleting deleting characters stripping deleting characters newlines chomp function, deleting with chop function chop function chomp function lists chopping substr function chop function and chown function files ownership and group, changing ownership, file UID (user ID) GID (group ID) user ID UID group ID GID converting ASCII value to character converting Unicode value to character chr function characters getting from ASCII values characters getting from Unicode values ASCII converting to characters Unicode converting to characters Unicode smiley face chroot function directories root, redefining root directory, redefining / (slash) root directory close function files closing sockets closing pipes closing open function $. and line counter $. variable $ variables $. ($INPUT_LINE_NUMBER) resetting with close function $ variables $? ($CHILD_ERROR) close function and closedir function directories closing connect function sockets connecting cos function (cosines) crypt function encryption passwords crypt function and decryption encryption DBM files dbmclose and dbmopen functions untie function hashes binding DBM files to binding DBM file to hash locking files DBM files associative arrays hashes arrays associative hashes real values, testing for with defined function defined function undef (value) testing if defined deleting hash elements delete function hashes deleting values from %ENV hash deleting from DBM files deleting from die function exceptions die function and eval function die function and do BLOCK operator do FILE operator files do FILE operator subroutines do SUBROUTINE operator do SUBROUTINE operator dump function core dumps dump function for programs core dump of each function hashes returning key/value pairs key/value pairs, hashes returning with each function eof function while loop eof function in files end-of-file eval function try block exceptions trapping trapping exceptions files renaming, program for exec function scripts terminating with exec execvp function (in C) metacharacters in exec arguments execv function (in C) exists function arrays exists function and hashes exists function and autovivification exit function programs exiting subroutines aborting with exit die function exit function versus exp function fcntl function 0 but true -w exemption 0 but true fileno function file descriptors open function fileno function and select function STDIN filehandle STDOUT filehandle STDERR filehandle $^F variable $^F variable input STDIN filehandle output STDOUT filehandle errors STDERR filehandle flock function locking files flock function fork function locks, inheriting across calls to fork function process ID (pid) returning with fork child processes ID, returning processes fork function parent processes processes buffering unflushed buffers in Perl versions exit function format function declaration picture lines names format format names write function format function, declaring named sequence of picture lines symbol tables format name identifiers in formline function $ variables $^A ($ACCUMULATOR) formline function output output format output accumulator format function output accumulator " (double quotes) in formline arguments quotation marks in formline arguments getc function characters single-character input STDIN filehandle reading single characters from input single-character, buffered and unbuffered buffering single-character input and cbreak option Term::ReadKey modlue POSIX module getattr function getgrent function setgrent function endgrent function /etc/group file groups users members, login names names login login names login names getgrent function User::grent module getgrgid function GID (group ID) looking up files by login names getgrgid function, returning getgrnam function group name groups users group name names group names login names getgrnam function, returning gethostbyaddr function addresses network, translating to names names getting from network addresses hostnames getting from network addresses networking network addresses, translating into names Socket module inet_ntoa function inet_ntoa function IP addresses using v-string notation for gethostbyname function hostnames translating to addresses names hostnames, translating to network addresses addresses network, getting from hostnames gethostent function /etc/hosts file sethostent function endhostent function portability scripts using gethostent function Net::hostent module getlogin function getpwuid function /etc/utmp file login names getlogin function for getnetbyaddr function addresses network, translating to names networking network addresses translating to names names network addresses, getting from Net::netent module getnetbyname function hostnames translating to addresses names translating to network addresses addresses getting from hostnames getnetent function /etc/networks file networks file /etc/networks file utmp file /etc/utmp file hosts file /etc/hosts file IP addresses network names and getpeername function sockets getting packed sockaddr address packed sockaddr getpgrp function process ID (pid) getting process group from process group getppid function process ID (pid) returning init program getpriority function processes returning priority of groups process returning priority of priority, process getprotobyname function protocols, name/number translations names protocols, translating to/from numbers getprotobynumber function numbers protocol Net::proto module getprotoent function setprotoent function endprotoent function /etc/protocols file getpwent function setpwent function endpwent function /etc/passwd file passwords passwd file getpwnam function names users username, passwd file entry from shadow, password entries getpwuid function UID (user ID) passwd file entry from identifiers UID; GID User::pwent module getservbyname function ports name/number translations for numbers port, getting name for names ports, getting from number service port name/number translations getservbyport function names protocols, getting from port numbers numbers ports, getting protocol names from getservent function setservent function endservent function /etc/services file getsockname function addresses packed socket sockets functions for getsockopt function glob function filenames expansions of tilde, home directory expansion of expansion, filename gmtime function Greenwich Mean Time (GMT) time Greenwich Mean (GMT) converting time goto function labels with goto statement subroutines substituting with goto grep function searching grep function for $ variables $_ ($ARG) grep function and patterns (and regular expressions) grep function and hex function numbers hexadecimal hexadecimal numbers converting hexadecimal numbers to decimal import function modules exporting names to other modules index function strings index function searching for substrings int function numbers truncating with int truncating numbers integers ioctl function input ioctl function output ioctl function syscalls ioctl and fcntl returns converting list values to strings join function strings joining keys function hashes keys, returning list of sorting keys and values, hashes values hashes, sorting kill function terminating processes processes killing stopping terminating ending terminating signals killing processes with System V IPC killing proces groups groups process killing loops last operator last operator blocks loops and lc function strings capitalization of capitalization capitalization lc and lcfirst functions perllocale manpage locales Unicode and Unicode locales and lcfirst function length function characters length in scalars characters, length of link function filenames linking with hard links hard links, filenames listen function sockets listen function for local function local declaration variables localizing existing local variables global variables localizing arrays elements, giving temporary values to hashes elements, giving temporary values to typeglobs local function, using with filehandles local, creating localtime function time for local timezone converting time timelocal subroutine subroutines timelocal date function localtime function POSIX module strftime function locking threads locking threads log function logarithm lstat function lstat function stat function symbolic links lstat function and patterns (and regular expressions) m// operator[semi] m?? operator match (m//) operator m// (match) operator / (slash) // operator==>match operator $ variables $_ ($ARG) map function and map function lists map function and mkdir function directories creating messages functions for msgctl function System V IPC messages, syscalls for msgget function msgrcv function msgsnd function my declarations variables private local variables private variables local variables scope private variables lexical variables lexical variables variables lexical scoping subroutines lexically scoped data types TYPE declarations in Perl classes pseudohash implementations of pseudohashes implementing classes with attributes class new method constructors new method loops next operator next operator no declaration oct function octal numbers numbers octal strings hexadecimal hexadecimal numbers strings octal octal numbers strings binary binary numbers converting octal numbers to decimal stat file permissions as octal open function files open function filehandles open function indirect filehandles autovivification of filehandles references to filehandles filenames mode, separating from > (right angle bracket) in filenames < (left angle bracket) in filenames + (plus) in filenames | (vertical bar) in filenames open function modes in three-argument form modes, opening files in input files, open mode for output files, open mode for writing to files open mode and reading files open mode and pipes read-only filehandles, opening filehandles piped, explicitly closing shells pipe commands with shell metacharacters, passing to metacharacters shell, in pipe commands open function piped (two-argument form) forks open command, two-argument form open function fork-open forks fork open & (ampersand) in filenames filenames & (ampersand) in filehandles duplicating, reasons for & &= in filenames forks processes ID (pid) identifiers processes (pid) pid processes sysopen function binmode files text/binary distinction binary files disciplines stacks disciplines opendir function directories opendir function ord function characters getting ASCII values of ASCII values for characters converting characters to ASCII values our function our declarations global variables declaring package variables declaring global declarations our declarations attributes variable interpolation and converting list values to strings pack function binary pack function strings list values, converting to formats pack/unpack templates, strings templates, characters for pack/unpack characters in formats formats characters in pack function template characters for unpack function template characters for pointers to strings integers formats formats integers ints longs long longs floating-point numbers C language structs structs formatting package declaration declarations package symbol tables packages pipe function pop function deleting array elements arrays pop function and pos function m// (match) operator pos function and match (m//) operator pos function and offsets for m// successes writing data via low-level system call print function STDOUT filehandle printing to strings printing select function writing data via low-level system call printf function push function appending elements to arrays arrays appending elements to quotemeta function metacharacters escaping with quotemeta \ (backslash) quotemeta function for rand function random numbers numbers random floating-point numbers rand function, returning read function bytes reading filehandles reading bytes of data from offsets read function and readdir function directories reading entries from readlink function symbolic links getting filenames from filenames getting from symbolic links links symbolic links qx// (quote construct) operator recv function sockets receiving messages on messages receiving on sockets redo operator loops redo operator and ref function references checking for rename function names for files==>filenames files changing name of filenames changing name of require operator reset function loops reset function and match (??) operator, reset function and m?? operator reset function and variables resetting values of return function subroutines return function reverse function lists returning elements in reverse order hashes inverting inverting arrays and hashes rewinddir function directories rewinddir function rindex function strings rindex function searching for substrings rmdir function removing deleting erasing deleting directories deleting deleting directories scalar pseudofunction list context forcing scalar context instead scalar context forcing seek function filehandles positioning file pointer for offsets seek function seekdir function directories seekdir function select function filehandles selecting for output output selecting filehandles for top-of-form processing select function output checking file descriptors for input checking file descriptors for ready file descriptors file descriptors bitmasks sleep function select function instead of semctl function semaphores functions for System V IPC functions for semaphores semget function identifiers semaphores semop function send function sockets sending messages on messages sending on sockets setpgrp function processes getting group for pid (process ID) getting process group process group setpriority function priority, process processes priority, setting setsockopt function sockets setting options shift function deleting array elements arrays deleting elements of shmctl function System V IPC shared memory, functions for shared memory, System V IPC functions for shmget function memory shared memory segment ID identifiers shared memory segments shmread function reading shared memory segment ID shmwrite function writing to shared memory segment ID shutdown function sockets shutting down connection connections shutting down sockets closing one side >shutdown sin function (sine) sleep function time sleeping scripts pausing pausing scripts sockets opening with socket function opening sockets socketpair function sorting sort function comparison operators sort function and lists sorting sorting lists cmp operator < (left angle bracket) <=> (comparison) operator splice function arrays deleting elements of arrays replacing/removing elements replacing array elements deleting array elements converting strings to list values patterns (and regular expressions) split function split function strings splitting into substrings sprintf function formats for strings strings formats for printf function converting decimal numbers to binary digits or octals converting decimal numbers to octal or hexadecimal integers formats for shorts unsigned shorts vectors, strings as sqrt function (square root) srand function seed, random number random numbers numbers random security cryptography passwords stat function files getting statistics of time file access/modification modification time, file files access and modification times access time, file $dev file statistic $ino file statistic $mode file statistic $nlink file statistic $uid file statistic $gid file statistic $rdev file statistic $size file statistic $atime file statistic $mtime file statistic $ctime file statistic $blksize file statistic $blocks file statistic study function patterns (and regular expressions) study function strings study function and sub declaration declaring subroutines subroutines declaring substr function strings extracting substrings extracting substrings symlink function files symbolically linking filenames linking symbolically symbolic links syscall function lists syscall function with system calls sysopen function opening files via low-level system call files opening via low-level system call permissions files permissions sysread function files reading via low-level system call reading data via low-level system call bytes reading system function programs executing scripts executing executing other programs from Perl syswrite function files writing via low-level system call writing data via low-level system call tell function files returning current position for seek function tell function telldir function tie function classes package binding variables to packages variables tying packages tying variables to tied function time function time times function users CPU times CPU time performance measuring tr/// (transliteration) operator translation truncate function files truncating uc function capitalization characters case of capitalization ucfirst function initial caps capitalization umask function processes umask for permissions files permissions undef function values undefining unlink function files deleting deleting files directories deleting deleting directories unpack function strings converting to list values converting strings to list values checksums percent sign (%) % (percent sign) % (percent sign) for checksums adding additional array elements unshift function prepending elements to arrays arrays prepending elements to untie function classes package binding variables to packages variables binding to packages packages binding variables to pragmas packages importing semantics to semantics importing semantics into package utime function time file access/modification modification time, file files access and modification times access time, file values function hashes returning values of vec function vectors, strings as strings vec function and integers strings as vectors of unsigned integers, lists of, storing wait function processes waiting for child processes processes waitpid function process ID (pid) waitpid function wantarray function context void void context warn function warning messages errors warn function, producing error messages writing data via low-level system call write function top-of-form processing y/// (transliteration) operator translation tr/// (transliteration) operator autouse pragma use base pragma @ISA array use base pragma and use blib pragma blib pragma security, of file test operators modules standard capitalization in module names data types modules for modules standard for data types Class::Struct module integers standard modules for arithmetic with Math::BigFloat module floating-point numbers Math::BigFloat module Math::BigInt module Math::Complex module Math::Trig module trigonometry, Math::Trig module overloading overload module operators overloading symbol tables Symbol module typeglobs anonymous generating with Symbol module time Time::Local module time function localtime function gmtime function modules standard text, manipulating with text Perl modules for Search::Dict module Text::Abbrev module abbreviations, text Text::ParseWords module tokens parsing text into list of arrays parsing text into Text::Wrap module wrapping text command line modules for processing modules standard command-line processing Getopt::Long module option processing Perl modules for Getopt::Std module switches, command-line single character, processing with clustering files modules for cross-platform access methods modules standard files, cross-platform methods of access Cwd module directories current working, getting pathname of File::Basename module basename, files File::CheckTree module directories file test checks on trees File::Compare module comparing files File::Copy module copying filenames or filehandles File::DosGlob module Microsoft Windows fileglobbing, File::DosGlob module globbing filenames File::Find module find function traversing file trees like Unix systems fileglobbing File::Glob module File::Path module directories creating or removing portably File::Spec module object-oriented programming portable filename operations File::Spec::Functions module File::Spec::Mac module Macintosh operating system File::Spec::Mac module OS2 operating system File::Spec::OS2 module File::Spec::OS2 module File::Spec::Unix module Unix systems File::Spec::Unix module File::Spec::VMS module VMS operating system File::Spec::VMS module File::Spec::VMS module File::Spec::Win32 module Microsoft Windows File::Spec::Win32 module File::stat module stat function lstat function IPC (interprocess communication) modules for modules standard object-oriented file, directory, and IPC access object-oriented programming modules for file, directory, and IPC access directories DirHandle module handles directories FileHandle module IO module IO::Dir module directories IO::Dir module IO::File module filehandles object methods for, using IO::Handle module IO::Pipe module pipes IO::Pipe module IO::Poll module poll function IO::Seekable module seekable I/O objects IO::Select module select function SelectSaver module filehandles SelectSaver module internationalization modules for locales modules for modules standard internationalization and locales bytes module charnames module I18N::Collate module locale module utf8 module Unicode support for, turning on operating systems interfaces to, manipulating modules standard operating system interfaces, manipulating Fcntl module C language fcntl.h definitions, loading as Perl constants constants Perl, loading fcntl.h definitions as POSIX module shell module signal handling sigtrap module Sys::Hostname module hostnames Sys::Hostname module Sys::Syslog module C language syslog functions, using in Perl Time::gmtime module Time::localtime module localtime function Time::tm module User::grent module User::pwent module modules standard networking and interprocess communication networking modules for IPC (interprocess communication) modules for IO::Socket module sockets modules for IO::Socket::INET module IO::Socket::UNIX module Unix systems sockets for IPC::Msg module messages IPC::Msg module IPC::Open2 module IPC::Open3 module IPC::Semaphore module semaphores IPC::Semaphore module IPC::SysV module System V IPC IPC::SysV module constants System V IPC, defining for Net::hostent module gethost* functions, overriding built-in Net::netent module getnet* functions, overriding built-in Net::Ping module hosts (remote), checking for reachability Net::protoent module getproto* functions, overriding built-in Net::servent module getserv* functions, overriding built-in Socket module web, Perl modules for World Wide Web (WWW) web CGI module HTML CGI module, generation of CGI::Apache module Apache web server CGI::Apache module CGI::Carp module errors writing to httpd or other CGI errors logs CGI::Cookie module HTTP cookies, setting and getting cookies (HTTP), setting and getting CGI::Fast module Fast CGI protocol, using CGI::Pretty module HTML code, producing nicely formatted CGI::Push module server-push CGI scripting DBM files modules for modules standard DBM file management libraries, loading AnyDBM_File module DB_File module GDBM_File module NDBM_File module SDBM_File module user interfaces, modules providing modules standard user interfaces, providing Term::Cap module Term::Complete module words lists of, doing programmable command completion on Term::ReadLine module readline packages modules standard security, dealing with security modules for authentication, Perl modules for encryption modules for Opcode module ops module Safe module Perl extensions and internals, modules for extending Perl extensions, creating modules standard Perl language extensions and externals attributes attributes module subroutines atrributes, getting and setting variables attributes, getting and setting attrs module (obsolete) base module inheritance base class, establishing at compile time classes inheritance among base module Data::Dumper module serializing Perl data structures DB module debugging DB module Devel::DProf module profiling, Devel::DProf module XS language debugging tools for Devel::Peek module debugging Devel::Peek module for XS programs diagnostics module verbosity warnings, forcing in warnings verbosity, forcing in Dumpvalue module data screen dump, providing English module punctuation variables, English module, handling with Env module environment variables Env module Errno module Fatal module exceptions raising on failure fields module less module re module patterns (and regular expressions) re pragma, altering default behavior of strict module subs module predeclaring subroutines vars modle (obsolete) global variables predeclaring, vars module modules standard base classes and convenience base classes Tie::Array module arrays tying Tie::Array module handles tied, base class definitons for Tie::Hash module hashes tying Tie::Hash module, providing base class definitions Tie::RefHash module references hash keys, providing as keys, hash providing references as Tie::Scalar module scalars tying base class definitions, providing Tie::SubstrHash module UNIVERSAL module base classes UNIVERSAL module, providing for all classes modules standard warnings and exceptions warnings modules for exceptions modules for Carp module warnings module lexical warnings modules standard documentation support documentation modules for Pod::Checker module Pod::Functions module functions built-in, listing by type built-in functions listing by type Pod::Html module HTML pod files, converting to Pod::InputObjects module Pod::Man module manpages Pod::Man module Pod::Parser module base classes for pod filters and translators Pod::Select module Pod::Text module text pod data, converting to formatted ASCII Pod::Text::Termcap module Pod::Usage module modules standard module installation support installation modules supporting AutoLoader module subroutines autoloading AutoSplit module packages splitting for autoloading autouse module blib pragma libraries uninstalled extensions from MakeMaker Config module CPAN module Devel::SelfStubber module stubs for modules, generating SelfLoader module Devel::SelfStubber module, using with DynaLoader module libraries C/C++, loading as Perl extensions Exporter module modules importing ExtUtils::Command module ExtUtils::Embed module embedding Perl ExtUtils::Install module ExtUtils::Installed module installed modules, inventory of ExtUtils::Liblist module libraries ExtUtils::Liblist module ExtUtils::MakeMaker module Makefile creating for Perl extensions ExtUtils::Manifest module MANIFEST file ExtUtils::Mkbootstrap module bootstrapping modules ExtUtils::Mksymlists module ExtUtils::MM_Cygwin module ExtUtils::MM_OS2 module ExtUtils::MM_Unix module ExtUtils::MM_VMS module ExtUtils::MM_Win32 module ExtUtils::Packlist module ExtUtils::testlib module FindBin module lib module @INC array SelfLoader module XSLoader module libraries C/C++, loading as Perl extensions modules standard development support Benchmark module comparing running time of alternate code versions scripts Perl test scripts Test module Test::Harness module modules standard Perl compiler and code generator code generation compilers, Perl modules related to B module B::Asmdata module B::Assemble module B::Bblock module B::Bytecode module backends, compiler B::C module B::CC module B::Debug module B::Deparse module B::Disassembler module B::Lint module B::Showlex module lexical variables in functions or files, showing B::Stash module B::Terse module B::Xref module ByteLoader module O module backends, compiler generic interface to ActiveState Perl distribution Microsoft-only modules Microsoft Windows modules for Win32::ChangeNotify module Win32::Console module Win32::Event module Win32::EventLog module Win32::File module Win32::FileSecurity module security Win32::FileSecurity module Win32::IPC module Win32::Internet module Win32::Mutex module Win32::NetAdmin module networking Win32 network modules Win32::NetResource module Win32::ODBC module Win32::OLE module Win32::OLE::Const module Win32::OLE::Enum module Win32::OLE::NLS module Win32::OLE::Variant module Win32::PerfLib module Win32::Process module Win32::Semaphore module semaphores Win32::Semaphore module Win32::Service module Win32::Sound module Win32::TieRegistry module registry (Microsoft Windows), manipulating Win32API::File module files Win32API::File module Win32API::Net module Win32API::Registry module Benchmark module comparing running times of alternate code versions timing running times of alternate code versions, comparing Carp module errors Carp module CGI module managing HTML forms with CGI::Carp module errors CGI::Carp module, handling of Class::Struct module Net::hostent module Class::Struct, using to create objects and accesors User::pwent module Class::Struct, using to create objects and accessors CPAN module CPAN (Comprehensive Perl Archive Network) CPAN module as automated interface to Cwd module current working directory for process, determining Data::Dumper module DBM files complex data values, storing in MLDBM module Data::Dumper module, using with DB_File module Data::Dumper module, using with stringification modules for marshalling modules diagnostic messages error messages[semi] warning messages precedence diagnostic messages warning messages error messages -w switch, perl perl interpreter program -w switch errors bugs accessor methods arguments actual address-of operator (in C) algorithms aliases alternation anonymous architecture arguments arguments parameters $ARGV variable arithmetic operators arrays arrays lists list context array context list context ASCII American Standard Code for Information Interchange ASCII assertions (in patterns) assignment operators associativity of operators asynchronous events atoms attributes autogeneration, overloading autoincrement (++) operator autoloading autosplit mode (with -a switch) autovivification AV (internal array value) awk backreferences backtracking backward compatibility barewords base classes big-endian binary binary operators binding bits bit-shift operators (<<, >>) bless function blocks buffering block Boolean scalar context Boolean values and breakpoints broadcasting BSD (Berkeley Standard Distribution) buckets hashes buckets buffering built-in bundles bytes bytecode C language C language preprocessor preprocessor (C language) calling by reference passing by reference calling by value passing by value callbacks canonicalization capturing in patterns characters character classes characters properties circumfix operator classes class methods methods clients clustering in patterns cloisters closures code generators code subpatterns in regular expressions collating sequence shells commands in buffering commands commands buffering autoflushing buffers names commands command-line arguments @ARGV array comments compilation units compile phase compile time compilers constructors concatenating strings connections networking connections (between client and server) constructors context numeric context Boolean context scalar context void context strings context of continuation lines core dumps CPAN (Comprehensive Perl Archive Network) cracker security cracking current package packages current package STDOUT filehandle output currently selected channel CV (internal code value) statements dangling dangling statements data structures data types objects datagrams DBM files databases Data Base Management DBM files declarations decrementing variables default values defined function definitions delimiters dereferencing derived classes classes derived derived classes descriptors file descriptors destructors destructors hardware devices devices (hardware) directives (pod) pod directives directories handles handles directories dweomer dwimmer dynamic scoping scopes dynamic elements in arrays embedding Perl empty subclass test derived classes empty subclass test values changing while copying encapsulation environment environment variables EOF (end-of-file) here documents end-of-file files end-of-file (EOF) errno errno dollar sign, $! under Symbols; $OS_ERROR errors number (errno) exceptions fatal errors exec function files executable executable files programs executing subroutines executing execute bit bits execute bits exporting symbols expressions extending Perl extensions, creating false values quotation marks false values fatal errors exceptions fatal errors, causing die function fatal errors, causing field separator, specifying different split function variable-width fields, extracting with unpack function fixed-width fields, use with FIFOs files filesystems file descriptors file tests filehandles filenames filesystems filters flags flags modifiers; switches floating-point numbers numbers floating-point floating-point numbers flushing buffers FMTEYEWTK (Far More Than Everything You Ever Wanted to Know) fork function formal arguments arguments formal $ARGV variable formats freeware functions characters funny characters preceding variable names funny characters garbage collection of globals identifiers GID (group ID) GID (group ID) globbing filenames global (variables) variables global global glue language, Perl as greedy matching grep utility groups users users groups of users groups of GID; groups GV (internal glob value) hacker handlers hard references references hard references hard hard references hashes key/value pairs hashes, key/value pairs header files header files modules C language header files here documents hexadecimal home directory hosts hubris HV (internal hash value) identifiers impatience import method index function indirect filehandles filehandles indirect indirect objects objects indirect indirect objects indirection indirection hard references; symbolic references infix operators inheritance instances instance data integers numbers integers integers interfaces interpolation, variable interpreter, Perl invocant I/O (input/output) IO (internal I/O object) IO (internal I/O object) indirect objects IP (Internet Protocol) is-a iteration iteration loops loops iteration through IV (internal integer values) integers IV (internal integer value) JAPH (Just Another Perl Hacker) hashes keys keywords reserved words labels statements labels for labels laziness < (left angle bracket) << (left-shift) operator leftmost longest matching lexer lexical analysis lexical scopes lexical variables libraries LIFO (Last In, First Out) lines buffering line line numbers links lists list context list operators literals little-endian bytes storage locations big-endian; little-endian storage locations for bytes big endian; little endian local logical operators lookahead lookbehind loops loops control statements in loops labels for labels loops and lvalues storage locations lvalues for storage locations lvalues for lvalues magic Makefile man command man command perldoc manpages memory metacharacters metasymbols multidimensional arrays arrays multidimensional multiple inheritance named pipes pipes named namespaces NFS (network filesystems) networking network filesystems NFS lists null null values offsets one-liners programs one-liners open source software operating systems operators operators overloadable overloading packages polymorphism ports precedence preprocessing Perl prototypes pumpkins and pumpkings scalars scopes semaphores sh (Bourne shell) shells slurping files subscripting s/// (substitution) operator substrings superuser root user switch statement symbolic debugging symbolic debugging debugging debugging symbolic symbolic references synchronization syntactic sugar syntax syscalls taint checking TCP terms trinary operator troff true values truncating casting data types lexical variables typed typedefs (C language) UDP umask function Unix v-strings (vector or version) warnings watch expressions whitespace words wrappers zombie processes