Index

Symbols

$: variable, Filled Fields
$_
default for file tests, The -x File Tests
default for stat(), lstat(), The stat Function
foreach statement and, The foreach Statement
implicit assignment to when reading, Input from STDIN
regular expression matching default, Simple Uses of Regular Expressions
selecting other than with =~ operator, Selecting a Different Target (the =~ Operator)
split() default, The split Function
tr() default target, Transliteration
unlink() default, Removing a File
%ENV variable@percentENV], Using system and exec
+= operator
defined, Binary Assignment Operators
example of, Chapter 4
-A operator, The -x File Tests
-B operator, The -x File Tests
-C operator, The -x File Tests
-d operator, The -x File Tests
-e operator, The -x File Tests
-f operator, The -x File Tests
-i command option, for inplace editing, Variable-Length ( Text) Databases
-M operator, The -x File Tests
example of, Ensuring a Modest Amount of Security
-r operator, The -x File Tests
-s operator, The -x File Tests
-t operator, The -x File Tests
-T operator, The -x File Tests
-w operator, The -x File Tests
-x operator, The -x File Tests
-z operator, The -x File Tests
8.3, Using Pathnames and Filenames
&& operator as control structure, &&, ||, and ?: as Control Structures
**= operator, Binary Assignment Operators
@*, in formats, Multiline Fields
@_, Arguments
introduced, Making It a Bit More Modular
scope of, Arguments
! (logical not) operator, Making It a Bit More Modular
!= operator, Operators for Strings
!/usr/bin/perl line, Basic Concepts
, (comma) operator, Other Operators
$1 as regular expression memory access, Special Read-Only Variables
$a variable, as special in sort comparison routine, Advanced Sorting
$& (match string), Special Read-Only Variables
$b variable, as special in sort comparison routine, Advanced Sorting
$` (before-match string), Special Read-Only Variables
$^ variable, Changing the Top-of-Page Format Name
$^I variable, Variable-Length ( Text) Databases
$^T variable, The -x File Tests
$= variable, Changing the Position on the Page
$#fred (index of last element of @fred), Array Element Access
$- variable, Changing the Position on the Page
$% (special variable), example of, Listing the Secret Words
$' (after-match string), Special Read-Only Variables
$/ variable, Input from STDIN
$~ variable, Changing the Format Name
$_[0], distinct from $_, Arguments
.. operator, as list constructor operator, Literal Representation
.= operator, Binary Assignment Operators
== operator, Operators for Strings
=> operator (CGI), Fancier Calling Sequences , Fancier Calling Sequences
=~ operator
defined, Selecting a Different Target (the =~ Operator)
example of, Making It Fair for the Rest
substitution and, Substitutions
tr() and, Transliteration
-= operator, Numeric Fields
-- operator, Autoincrement and Autodecrement
< operator, Operators for Strings
< operator, Operators for Strings
<= operator, Operators for Strings
\>= operator, Operators for Strings
+ (plus sign)
open() and, Fixed-Length Random-Access Databases
in regular expressions, Multipliers
++ operator
defined, Autoincrement and Autodecrement
++ operator
example of, Using system and exec
?: operator, as control structure, &&, ||, and ?: as Control Structures
\> operator, Operators for Strings
\>= operator, Operators for Strings
!/usr/bin/perl line, Basic Concepts
1, in regular expressions, Parentheses as memory
| (vertical bar)
open() and, Warning Someone When Things Go Astray, Using Processes as Filehandles
|| (logical-or) operator
as control structure, &&, ||, and ?: as Control Structures
die() and, A Slight Diversion: die
example of, Advanced Sorting, Chapter 8
introduced, Making It a Bit More Modular
1, and $1, Special Read-Only Variables

A

Abba, Transliteration
AbortSystemShutdown module, Win32 Extensions
access time, changing, Modifying Timestamps
Active Data Objects, Data-Access Objects
Active Message Library, Using Automation Objects
ActiveState, ActiveState Perl for Win32
ActiveState Tool Corporation, History of Perl
ActiveX Data Objects, Win32 Database Interfaces
AddConnectio, Reading a Directory Handle
addition, operator for, Operators for Numbers
address labels, and formats, examples of, Invoking a Format
AdminMisc module, Win32 Extensions
ADO (ActiveX Data Objects), Win32 Database Interfaces
alternation, in regular expressions, Alternation
anchoring, in regular expressions, Anchoring Patterns
angle brackets (), as globbing delimiter, Globbing
appending to a file, Opening and Closing a Filehandle
archaeology, Extracting and Replacing a Substring
arguments, to subroutines, Arguments
@ARGV, as command-line arguments, Input from the Diamond Operator
array assignment operator, Assignment
array context, readdir() and, Reading a Directory Handle
array elements
accessing, More than One Secret Word
numbering of, Array Element Access
referencing, Array Element Access
array expression, as subscript, Array Element Access
array literals, defined, Literal Representation
array operators, Array Operators and Functions
array slice, Array Element Access
array variables
and foreach statement, The foreach Statement
assigned scalar values, Assignment
automatically growing, Array Element Access
default value of, Variables
defined, Variables
in array literals, Assignment
in scalar context, Assignment
interpolated into strings, Variable Interpolation of Arrays
arrays
defined, What Is a List or Array?
empty, Literal Representation
introduced, More than One Secret Word
referencing elements, Array Element Access
size boundaries, What Is a List or Array?
Artistic License, Availability
assigning to a substr() operator, Extracting and Replacing a Substring
assigning to an array, More than One Secret Word
assignment operator, Scalar Operators and Functions
assignment, binary, Binary Assignment Operators
associative arrays
variables, Hash Variables
associativity, Operator Precedence and Associativity
asterisk (*)
as prefix, Symbol Table Manipulation With *FRED
in pack format string, Packing and Unpacking Binary Data
in regular expressions, Multipliers
Astro, pronouncing Windex, Finding a Substring
at sign (@)
as array name prefix, More than One Secret Word
as format field delimiter, Text Fields
as prefix for array variables, Variables
attrib command (see chmod command)
autodecrement operator, Autoincrement and Autodecrement
autoincrement
example of, The for Statement
operator, Autoincrement and Autodecrement

B

B, as anchor in regular expressions, Anchoring Patterns
, example of, Using Variable Interpolation
backquotes (`)
as command invocation, Using Backquotes
backslash, Using Pathnames and Filenames
backslash ()
as escape character, Single-Quoted Strings
before dollar in regular expression, Anchoring Patterns
escapes, Double-Quoted Strings
in regular expressions, Single-Character Patterns
as memory access, Parentheses as memory
backtracking, in regular expressions, Multipliers
backup files, and inplace editing, Variable-Length ( Text) Databases
basename command, emulating, Chapter 13
big-endian, Packing and Unpacking Binary Data
binary assignment operator, Binary Assignment Operators
binary data, treated, using strings, Strings
binmode(), Fixed-Length Random-Access Databases
blocks
as body of subroutine, Making It a Bit More Modular, Defining a User Function
defined, Statement Blocks
introduced, Adding Choices
labeled, Labeled Blocks
looping, The last Statement
naked, The last Statement
break (in C), and last operator, The last Statement
BuildNumber module, Win32 Extensions
built-in variables, Many, Many Predefined Variables
bytes in memory, interpreting, Packing and Unpacking Binary Data

C

c, as complement option of tr, Transliteration
cacls.exe program, Modifying Permissions
Camel Book, Support, Packing and Unpacking Binary Data, Variable-Length ( Text) Databases, Many, Many More Functions
canonical name, from gethostbyname(), Getting Network Information
caret (^)
as anchor in regular expressions, Anchoring Patterns
as filled-field in formats, Filled Fields
case
ignoring
example of, Handling Varying Input Formats
in substitution, Substitutions
in variable names, Scalar Variables
cd command, Moving Around the Directory Tree, Moving Around the Directory Tree
CGI Programming, CGI Programming
CGI.pm module, The CGI.pm Module
ChangeNotify module, Win32 Extensions
changing directories, Moving Around the Directory Tree
character classes, in regular expressions, Single-Character Patterns
character ranges, in regular expressions, Single-Character Patterns
chdir() operator
defined, Moving Around the Directory Tree
example of, Chapter 12
Chili’s, Acknowledgments for First Edition
chmod command, and the chmod() operator, Modifying Permissions
chmod() operator, Modifying Permissions
chomp()
examples of, Using Filehandles
chomp() operator
defined, The chomp Function
examples of, Moving the Secret Word List into a Separate File, The Final Programs
introduced, Asking Questions and Remembering the Result
chop() operator
defined, The chop( ) and chomp( ) Functions
examples of, <STDIN> as a Scalar Value, Chapter 2
chr() operator, Packing and Unpacking Binary Data
circle, circumference of, Exercises
clients, networking, Networking Clients , A Webget Client
Clipboard module, Win32 Extensions
close()
defined, Opening and Closing a Filehandle
close() operator
and process-filehandles, Using Processes as Filehandles
examples of, Moving the Secret Word List into a Separate File
closedir() operator
defined, Opening and Closing a Directory Handle
example of, Chapter 12
CLSID, Creating Automation Objects
cmp operator
defined, Advanced Sorting
COBOL, What Is a Format?
Coke, Double-Quoted Strings
colon (:)
as label suffix, Labeled Blocks
matching with split(), The split Function
column headers, in format, What Is a Format?
columns, labeling, Listing the Secret Words
comma (,)
as array literal character, Literal Representation
comma (,) operator, Other Operators
command line, The Command Line
command-line arguments, Variable-Length ( Text) Databases
and the diamond operator, Input from the Diamond Operator
comments, in Perl programs, Basic Concepts
comparison operators
numbers and strings, Operators for Strings
comparison routine, in sorting, Advanced Sorting
compiled language, Perl as a, Basic Concepts
concatenation, Operators for Strings
Console module, Win32 Extensions
constant part, What Is a Format?
context, scalar and array, Scalar and List Context
continue block, The next Statement
control expression
and while statements, The while/until Statement
of if statement, The if/unless Statement
Control-D, as end of file, <STDIN> as an Array
copy pass, Variable-Length ( Text) Databases
counting characters, Transliteration
CPAN (Comprehensive Perl Archive Network), CPAN: Beyond the Standard Library
Create(), Opening and Reading Registry Values
CreateObject, Using Automation Objects
createObject(), Creating Automation Objects, Creating Automation Objects
creating processes, Using system and exec
curly braces ({})
in double-quoted strings, Interpolation of Scalars into Strings
in regular expressions, Multipliers
required in if statements, The if/unless Statement
currently selected filehandle, Using select to Change the Filehandle

D

d, as delete option of tr, Transliteration
d, in regular expressions, Single-Character Patterns
dangling else, and impossibility of, The if/unless Statement
dash (-), in regular expression ranges, Single-Character Patterns
database interface modules, Database Interfaces
database management, using the DBM library, DBM Databases and DBM Hashes
databases
fixed-length records in, Fixed-Length Random-Access Databases
human-readable, Variable-Length ( Text) Databases
random-access, Fixed-Length Random-Access Databases
daytime server, A Simple Client , A Simple Client
DBM array, DBM Databases and DBM Hashes
DBM files, Maintaining a Last-Good-Guess Database
DBM library, DBM Databases and DBM Hashes
dbmclose() operator
defined, Opening and Closing DBM Hashes
example of, The Final Programs
dbmopen() operator
defined, Opening and Closing DBM Hashes
examples of, Maintaining a Last-Good-Guess Database, The Final Programs
debugger, The Debugger
decimal points, in floating-point numbers, Float Literals
default filehandle, Using Filehandles
default values, implemented with || operator, Making It a Bit More Modular
defensive programming, Advanced Sorting
defining a format, Defining a Format
delete operator, The delete Function
delete() operator, example of, Using a DBM Hash
DeleteKey(), More Registry Operations
deleting characters, Transliteration
deleting Registry keys, More Registry Operations
delimiters, for tr, Transliteration
diamond operator, Input from the Diamond Operator, Variable-Length ( Text) Databases
diamond operator ()
defined, Input from the Diamond Operator, Variable-Length ( Text) Databases
examples of, Simple Uses of Regular Expressions, Chapter 8 , Chapter 10 , Chapter 15 , Chapter 17
die()
defined, A Slight Diversion: die
die() operator
examples of, Chapter 12
using, Many Secret Word Files in the Current Directory
directories, renaming files into, Renaming a File
directory handles
creating, Opening and Closing a Directory Handle
defined, Directory Handles
division, operators for, Operators for Numbers
Documentation, Documentation
documentation, Documentation
dollar sign ($)
as scalar variable prefix, Scalar Variables
removing significance in strings, Interpolation of Scalars into Strings
DomainName module, Win32 Extensions
dot (.)
as current directory, Chapter 12
example of, Chapter 8
in regular expressions, Single-Character Patterns
double-quote interpolation (see variable interpolation.)
double-quoted strings
and backslash escape, Double-Quoted Strings
and hash elements, The keys Function
and variable interpolation, Interpolation of Scalars into Strings
defined, Double-Quoted Strings
example of, Asking Questions and Remembering the Result

E

-e command-line option, and inplace editing, Variable-Length ( Text) Databases
e, as option to substitute operator, The eval Operator (and s///e)
e-mail, example of handling, The last Statement
each() operator
defined, The each Function
examples of, Using a DBM Hash
echo command, and globbing, Globbing
editors, and updating databases, Variable-Length ( Text) Databases
elements of array, What Is a List or Array?
else keyword, The if/unless Statement
elsif keyword
defined, The if/unless Statement
example of, Advanced Sorting, Chapter 4
introduced, More than One Secret Word
embedding Perl, Embeddible, Extensible
empty array, Literal Representation
empty list, Literal Representation
and clearing out a hash, The values Function
as default value for array variable, Variables
end of file
detecting, introduced, Moving the Secret Word List into a Separate File
with Control-D, <STDIN> as an Array
environment variables, controlling through %ENV, Using system and exec
eq operator
defined, Operators for Strings
example of, Adding Choices, The Final Programs
equal sign (=)
as array assignment operator, Assignment
as assignment operator, Scalar Operators and Functions
Error module, Win32 Extensions
eval(), The eval Operator (and s///e)
eval() operator, What Is a Format?
EventLog module, Win32 Extensions
examples, where to get on-line, Exercises
execute bits, Modifying Permissions
exit status, die() and, A Slight Diversion: die
exit value, Using Processes as Filehandles
exit() operator, Using Processes as Filehandles
ExpandEnvironmentStrings module, Win32 Extensions
experts, and reading introductory sections, Making It Fair for the Rest
exponential notation, in floating-point numbers, Float Literals
exponentiation operator (**), Operators for Numbers
expressions
in a subroutine body, Return Values
in array literals, Literal Representation
extension modules
Win32, list of, Win32 Extensions, Win32 Extensions
extension modules, definition of, Library Terminology

F

false
and regular expressions, Simple Uses of Regular Expressions
defined, The if/unless Statement
FAQ, Perl, Support
field definition line, introduced, Listing the Secret Words
field value line, introduced, Listing the Secret Words
fieldlines of format, Defining a Format
File module, Modifying Permissions, Win32 Extensions
filehandle
default, defined, Using Filehandles
filehandles
and formats, Invoking a Format
defined, What Is a Filehandle?
indirect, Globbing
introduced, Moving the Secret Word List into a Separate File
print() and, Warning Someone When Things Go Astray
as processes, Using Processes as Filehandles
read() and, Fixed-Length Random-Access Databases
reading from, Using Filehandles
seek() and, Fixed-Length Random-Access Databases
as uppercase, Moving the Secret Word List into a Separate File
filename glob, Many Secret Word Files in the Current Directory
filenames, Using Pathnames and Filenames, Using Pathnames and Filenames
files
age, example of, Ensuring a Modest Amount of Security
appending to, Opening and Closing a Filehandle
information about, with stat(), The stat Function
modifying permissions of, Modifying Permissions
modifying timestamps of, Modifying Timestamps
opening, Opening and Closing a Filehandle
removing, Removing a File
renaming, Making Those Old Word Lists More Noticeable, Renaming a File
testing for existence, The -x File Tests
FileSecurity module, Modifying Permissions, Win32 Extensions
File::Basename, Using Pathnames and Filenames
filled fields, in formats, Filled Fields
finding a substring, Finding a Substring
finding a substring in reverse, Finding a Substring
findstr command, Simple Uses of Regular Expressions, Simple Uses of Regular Expressions
ignoring case, Ignoring Case
floating-point literals, Float Literals
floating-point numbers, All Numbers Use the Same Format Internally
footnotes, meaning of, Conventions
for statement
defined, The for Statement
example of, Labeled Blocks, Chapter 4
foreach statement
defined, The foreach Statement
example of, The Final Programs, Reading a Directory Handle, Chapter 4 , Chapter 5 , Chapter 12
examples of, Using a DBM Hash
introduced, Maintaining a Last-Good-Guess Database
foreach(), example of, Chapter 6
format definition
example of, Listing the Secret Words
location in source file, Defining a Format
format fieldholders, Defining a Format
format fieldlines, Defining a Format
format keyword
defined, Defining a Format
example of, The Final Programs
introduced, Listing the Secret Words
format name
changing, Changing the Format Name
format names, selecting, Defining a Format
format template, Defining a Format
FormatMessage module, Win32 Extensions
formats
changing top-of-page format name, Changing the Top-of-Page Format Name
constant part, What Is a Format?
defined, What Is a Format?
defining, Defining a Format
defining text fields, Text Fields
invoking, Invoking a Format
multi-line fieldholder
defined, Multiline Fields
top-of-page, The Top-of-Page Format
variable part, What Is a Format?
whitespace within, Defining a Format
formatted output, printf() and, Using printf for Formatted Output
formfeed, and top-of-page format, The Top-of-Page Format
FsType function, The stat Function
FsType module, Win32 Extensions
FTP, obtaining exercises via, FTP
FTPMAIL, FTPMAIL
FTPMAIL, obtaining exercises via, FTPMAIL
function pointers, Function Pointers

G

g
as global replace option, Substitutions
modifier of regexp match, Other Operators
GetCwd function, Moving Around the Directory Tree
GetCwd module, Win32 Extensions
GetFileAttributes method, Modifying Permissions
gethostbyname(), Getting Network Information
GetLastError module, Win32 Extensions
GetNextAvailDrive module, Win32 Extensions
getopt, and the Perl standard library, Input from the Diamond Operator
GetOSVersion module, Win32 Extensions
getservbyname(), Networking Clients
getservbyport(), Networking Clients
GetShortPathName function, Using Pathnames and Filenames
GetShortPathName module, Win32 Extensions
GetTickCount module, Win32 Extensions
GetValues method, Opening and Reading Registry Values
glob, Many Secret Word Files in the Current Directory
global replace
example of, Chapter 10
in substitute operator, Substitutions
global variables, and subroutines, Defining a User Function
globbing
and variable interpolation, Globbing
compared with regular expressions, Globbing
defined, Globbing
example of, with unlink(), Removing a File
GNU Public License, Availability
goto
unnecessary in Perl, Labeled Blocks
greediness
in regular expression patterns, Multipliers
in regular expressions, Multipliers
grep function, grep and map
gt operator, Operators for Strings
gzip utility, Standard Perl Distribution

H

hash
introduced, Giving Each Person a Different Secret Word
hash keys, Giving Each Person a Different Secret Word
hash operators, Hash Functions
hashes
creating new elements of, Hash Variables
defined, What Is a Hash?
example of assignment to, Giving Each Person a Different Secret Word
literal representation of, Literal Representation of a Hash
order in, What Is a Hash?
removing elements from with delete, The delete Function
sorting (sort-of), Advanced Sorting
stepping through with the each() operator, The each Function
Hello, world (program example), The “Hello, world” Program
help
documentation, Documentation
technical support, Support, Support
here strings, Strings
hex(), Integer Literals, Conversion Between Numbers and Strings
hexadecimal numbers
defined, Integer Literals
hives, Registry, The Registry Structure
HKEY_LOCAL_MACHINE subtree, The Registry Structure
human-readable databases, Variable-Length ( Text) Databases

I

i
as ignore-case option of substitute operator, Substitutions
-i command-line option, and inplace editing, Variable-Length ( Text) Databases
i<
as ignore-case flag in matching, Ignoring Case
if modifier, Expression Modifiers
if statement
defined, The if/unless Statement
example of, Making It a Bit More Modular, The Final Programs, The if/unless Statement, The keys Function
introduced, Adding Choices
not counting as looping block, The next Statement
ignoring case
example of, Handling Varying Input Formats
in substitution, Substitutions
with i flag, Ignoring Case
in-proc servers, Introduction to OLE Automation
indentation, in Perl programs, Basic Concepts
index() operator
defined, Finding a Substring
indirect filehandles, Globbing
infinite loops, The redo Statement
InitiateSystemShutdown module, Win32 Extensions
inplace editing, Variable-Length ( Text) Databases
int(), The -x File Tests
integer literals, Integer Literals
integers, All Numbers Use the Same Format Internally
Internet module, Win32 Extensions
interpreted language, Perl as a, Basic Concepts
interpreted languages, History of Perl
interpreting bytes in memory, Packing and Unpacking Binary Data
Introduction to OLE Automation, Introduction to OLE Automation
invoking a format, Invoking a Format
invoking a subroutine, Invoking a User Function
IO::Socket module, Networking Clients
IPC module, Win32 Extensions
ISAP, ActiveState Perl for Win32
ISAPI extensions, PerlIS and PerlScript
IsWin95 module, Win32 Extensions
IsWinNT module, Win32 Extensions

J

join()
defined, The join Function
example of, Getting Network Information

K

keys(), Many Secret Word Files in the Current Directory
defined, The keys Function
introduced, Maintaining a Last-Good-Guess Database
scalar context and, The keys Function
keys, of hashes, What Is a Hash?
keys, Registry, The Registry Structure
kit’n'caboodle, Advanced Sorting
kludge, Labeled Blocks

L

labels, Labeled Blocks
language extension modules, For Developers: Language Extensions and Platform Development Support
last access time, changing, Modifying Timestamps
last modification time, changing, Modifying Timestamps
last operator
defined, The last Statement
example of, Chapter 9
last(), example of, Expression Modifiers
le operator, Operators for Strings
left angle brackets (<), as format field characters, Text Fields
left associativity, Operator Precedence and Associativity
left square bracket ([), in double-quoted strings, Variable Interpolation of Arrays
left-right pairs
as delimiters, Using a Different Delimiter
length(), example of, Fixed-Length Random-Access Databases
libraries, definition of, Library Terminology
libwin32 package, Standard Perl Distribution
link(), File and Directory Manipulation
list, What Is a List or Array?
(see also array.)
introduced, More than One Secret Word
list constructor operator (..), Literal Representation
list expressions, and foreach statement, The foreach Statement
list reference (in Perl 5.0), Assignment
listing the /etc directory, example of, Reading a Directory Handle
lists
nested, Assignment
as subroutine return values, Return Values
literal lists, slices of, Array Element Access
literals, array, Literal Representation
literals, of hashes, Literal Representation of a Hash
little-endian, Packing and Unpacking Binary Data
local()
example of, Numeric Fields, Chapter 8
loops and, Private Variables in Functions
local servers, Introduction to OLE Automation
local variables
and foreach statement, The foreach Statement
creating, with local(), Private Variables in Functions
in subroutines, example of, Arguments
logical comparison operators, Operators for Numbers
logical not (!) operator, Making It a Bit More Modular
LoginName function, Getting User and Machine Information
LoginName module, Win32 Extensions
LookupAccountName module, Win32 Extensions
LookupAccountSID module, Win32 Extensions
looping blocks, The last Statement
loops
endless, The while/until Statement
exiting early, with last, The last Statement
infinite, The redo Statement
local() and, Private Variables in Functions
nested, exiting from, Labeled Blocks
lowercase, example of converting to, Making It Fair for the Rest
lpr command, example of, Using Processes as Filehandles
lt operator, Operators for Strings
lvalue, Assignment

M

m, as match operator, Using a Different Delimiter
mailing lists, Perl, Support
main routine, unneeded in Perl, Basic Concepts
map operator, grep and map
MAPI, Using Automation Objects
match operator
defined, Simple Uses of Regular Expressions
example of, Handling Varying Input Formats
matching
choosing a delimiter besides slash, Using a Different Delimiter
mathematics modules, Mathematics
Max Headroom, Modifying Timestamps
McMenamin’s, Acknowledgments for First Edition
memory, interpeting bytes in, Packing and Unpacking Binary Data
methods, Introduction to OLE Automation
microbrew, Acknowledgments for First Edition
mkdir command, mkdir() and, Making and Removing Directories
modes, and making directories, Making and Removing Directories
modification time
changing, Modifying Timestamps
example of, Ensuring a Modest Amount of Security
modules, definition of, Library Terminology
modules, list of, Standard Modules , CPAN: Beyond the Standard Library
Win32 extensions, Win32 Extensions, Win32 Extensions
modulus operator (%), Operators for Numbers
multi-line fieldholder, in formats, Multiline Fields
multiplication, operator for, Operators for Numbers
Mutex module, Win32 Extensions
mv command, rename() and, Renaming a File

N

, in single-quoted strings, Single-Quoted Strings
naked blocks, The last Statement
name spaces, Variables
naming subroutine arguments, using local variables, Private Variables in Functions
ne operator
defined, Operators for Strings
example of, Guessing the Secret Word
nested loops, exiting from, Labeled Blocks
nested subroutine invocation, Invoking a User Function
net use, Reading a Directory Handle
net view, Exercises
NetAdmin module, Getting User and Machine Information, Win32 Extensions
NetResource module, Reading a Directory Handle, Win32 Extensions
netstat, Using Processes as Filehandles
networking, Networking Clients , A Webget Client
newline
and non-matching by dot, Single-Character Patterns
newlines
in format value, and @* field, Multiline Fields
newlines, removing, <STDIN> as a Scalar Value
newsgroup, Perl, Support
next operator
defined, The next Statement
NodeName function, Getting User and Machine Information
NodeName module, Win32 Extensions
numbers
and automatic conversion to strings, Conversion Between Numbers and Strings
defined, What Is Scalar Data?
numeric fields (in formats), Numeric Fields
numeric operators, Operators for Numbers
numeric order, example of sorting by, Advanced Sorting

O

obscure biblical reference, Transliteration
oct(), Integer Literals, Conversion Between Numbers and Strings
octal numbers, defined, Integer Literals
OCX controls, Introduction to OLE Automation
ODBC module, Win32 Database Interfaces, Win32 Extensions
OLE module, Creating Automation Objects, Creating Automation Objects, Chapter 19 , Win32 Extensions
OLEDB, Data-Access Objects
open()
commands and, example of, The Final Programs
example of, Invoking a Format, Chapter 10
introduced, Moving the Secret Word List into a Separate File
vertical bar in, Warning Someone When Things Go Astray, Using Processes as Filehandles
Open(), Opening and Reading Registry Values
open()
defined, Opening and Closing a Filehandle
plus sign and, Fixed-Length Random-Access Databases
opendir(), Opening and Closing a Directory Handle, Reading a Directory Handle
example of, Chapter 12
opening
DBM database, Opening and Closing DBM Hashes
files, Opening and Closing a Filehandle
Registry values, Opening and Reading Registry Values, Opening and Reading Registry Values
operands, defined, Scalar Operators
operators
addition, Operators for Numbers
assignment, Scalar Operators and Functions
associativity, Operator Precedence and Associativity
autodecrement, Autoincrement and Autodecrement
autoincrement, Autoincrement and Autodecrement
defined, Scalar Operators
division, Operators for Numbers
for hashes, Hash Functions
logical comparison, Operators for Numbers
multiplication, Operators for Numbers
precedence of, Operator Precedence and Associativity
for scalar variables, Scalar Operators and Functions
for strings, Operators for Strings, Operators for Strings
subtraction, Operators for Numbers
undef and, The Undefined Value
ord() operator, Packing and Unpacking Binary Data

P

-p command-line option, and inplace editing, Variable-Length ( Text) Databases
pack()
defined, Packing and Unpacking Binary Data
example of, Fixed-Length Random-Access Databases
pack format string, Packing and Unpacking Binary Data
packages, Library Terminology , Packages
page length
changing, in formats, Changing the Page Length
default, for top-of-page format, The Top-of-Page Format
page position, changing, in formats, Changing the Position on the Page
parameters, introduced, Making It a Bit More Modular
parentheses
array literals and, Literal Representation
as memory in regular expressions, Precedence
chdir() and, Moving Around the Directory Tree
forcing array context with, Assignment
keys() and, The keys Function
memory in regular expressions, Parentheses as memory
precedence and, Operator Precedence and Associativity
print() and, Using print for Normal Output
in regular expressions, Precedence
values() and, The values Function
path delimiter, Using Pathnames and Filenames
PATH environment variable, managing, Using system and exec
pathnames, Double-Quoted Strings, Using Pathnames and Filenames, Using Pathnames and Filenames
percent sign (%)
as associative array prefix, Giving Each Person a Different Secret Word, Hash Variables
as modulus operator, Operators for Numbers
Perl
embedding, Embeddible, Extensible
history of, History of Perl, History of Perl
standard distribution of, Standard Perl Distribution
technical support, Support, Support
Perl compiler, The Perl Compiler
Perl for Win32, ActiveState Perl for Win32
Perl standard library, Input from the Diamond Operator
perldoc command, Documentation
PerlIIS extension, PerlIS and PerlScript
PerlIS, ActiveState Perl for Win32
PerlScript, ActiveState Perl for Win32, PerlIS and PerlScript
Perl: The Motion Picture, Packing and Unpacking Binary Data
permissions, Maintaining a Last-Good-Guess Database, Modifying Permissions
modifying, Modifying Permissions
permission bits, in dbmopen(), Opening and Closing DBM Hashes
pi
computing with, Chapter 2
obscure reference to, Packing and Unpacking Binary Data
pipe (see vertical bar)
Pipe module, Win32 Extensions
plus sign (+)
open() and, Fixed-Length Random-Access Databases
in regular expressions, Multipliers
.plx extension, Basic Concepts
POD, Documentation
pod, The CGI.pm Module
pointers, Function Pointers
pop()
defined, The push and pop Functions
example of, Chapter 4
popen library function, emulating, Using Processes as Filehandles
port numbers, Networking Clients
pound sign (#)
comment character, Basic Concepts
format field characters, Numeric Fields
powers of ten, example of, with substr(), Extracting and Replacing a Substring
Practical Extraction and Report Language, What Is a Format?
pragmas, definition of, Library Terminology
precedence, Operator Precedence and Associativity
in regular expressions, Precedence
parentheses and, Operator Precedence and Associativity
predefined variables, Many, Many Predefined Variables
print(), Fixed-Length Random-Access Databases
$_ and, The foreach Statement
array literals and, Literal Representation
defined, Output with print, Using print for Normal Output
example of, The “Hello, world” Program, The Final Programs
filehandle keyword and, Warning Someone When Things Go Astray
return value of, Using print for Normal Output
writes to same filehandle and, The Top-of-Page Format
printf()
defined, Using printf for Formatted Output
example of, Exercises, Chapter 4 , Chapter 6
process exit value, Using Processes as Filehandles
process launching, Summary of Process Operations
Process module, Win32::Process, Win32::Process, Win32 Extensions
processes
creating, Using system and exec
as filehandles, Using Processes as Filehandles
Windows NT and, Win32::Process, Win32::Process
products, finding, Labeled Blocks
ProgID, Creating Automation Objects, Using Automation Objects
Programming Perl, (see Camel Book.)
prompt, example of, Asking Questions and Remembering the Result
properties, Introduction to OLE Automation
push(), The push and pop Functions
pwd command, Moving Around the Directory Tree

Q

question mark (?), in regular expressions, Multipliers
qw() operator, More than One Secret Word, Passing Parameters via CGI

R

rand(), Exercises
example of, Chapter 3
random access, seek() and, Fixed-Length Random-Access Databases
ranges of characters, Single-Character Patterns
read(), Fixed-Length Random-Access Databases
readdir(), Reading a Directory Handle
reading data from a command, Using Processes as Filehandles
reading from a file, Using Filehandles
reading from standard input, Input from STDIN
reading Registry values, Opening and Reading Registry Values, Opening and Reading Registry Values
redo operator, The redo Statement
regedit.exe, regedt32.exe utilities, The Registry
Registry module, Chapter 16 , Win32 Extensions
Registry package, The Registry, The Registry Structure
Registry, Windows NT, The Registry, More Registry Operations
regular expression
grouping patterns of, Grouping Patterns
regular expressions
alternation in, Alternation
anchoring in, Anchoring Patterns
and variable interpolation, Using Variable Interpolation
backtracking in, Multipliers
character classes in, Single-Character Patterns
compared with globbing, Globbing
defined, Concepts About Regular Expressions
example of, Making It Fair for the Rest, Making It a Bit More Modular, The last Statement
extended syntax, Additional Regular Expression Features
introduced, Handling Varying Input Formats
non-special characters of, Single-Character Patterns
precedence in, Precedence
split() and, The split Function
removing a file, Removing a File
removing characters, Transliteration
removing the last character, The chop( ) and chomp( ) Functions
rename command (Windows NT), Renaming a File
rename(), Making Those Old Word Lists More Noticeable
defined, Renaming a File
example of, Chapter 13
renaming files, Renaming a File
examples of, Making Those Old Word Lists More Noticeable
report generating, example of, Listing the Secret Words
reports, writing, What Is a Format?
result, Scalar Operators
return status, backwards for system(), Using system and exec
return values
from subroutine, example of, The Final Programs
introduced, Making It a Bit More Modular
of tr, Transliteration
print() and, Using print for Normal Output
read() and, Fixed-Length Random-Access Databases
of select(), Using select to Change the Filehandle
subroutines, Return Values
reverse()
defined, The reverse Function
example of, Chapter 3 , Chapter 6
right angle brackets (\>), as format field characters, Text Fields
right associativity, Operator Precedence and Associativity
rindex() operator
defined, Finding a Substring
example of, Chapter 15
rm command, unlink() and, Removing a File
rmdir command, and rmdir(), Making and Removing Directories

S

s operator
example of, The Final Programs, Globbing
making basename of file and, Chapter 13
substitute operator, Substitutions
s option, tr(), Transliteration
s, in regular expressions, Single-Character Patterns
scalar assignment, used as a value, Scalar Operators and Functions
scalar context
and readdir(), Reading a Directory Handle
defined, Scalar and List Context
introduced, Assignment
scalar data, What Is Scalar Data?
scalar values, assigned to array variables, Assignment
scalar variables
defined, Scalar Variables
introduced, Asking Questions and Remembering the Result
operators for, Scalar Operators and Functions
scientific notation, in floating-point numbers, Float Literals
Scooby Doo, pronouncing Windex, Finding a Substring
secret words, guessing, Guessing the Secret Word
security, Security Matters
seek(), Fixed-Length Random-Access Databases
select()
defined, Using select to Change the Filehandle
return value of, Using select to Change the Filehandle
Semaphore module, Win32 Extensions
semicolon (;), as statement terminator, The “Hello, world” Program
sequence, in regular expressions, Sequence
Service module, Win32 Extensions
SetCwd module, Win32 Extensions
SetFileAttributes method, Modifying Permissions
setting Registry values, Setting Registry Values, More Registry Operations
SetValue(), Setting Registry Values
SetValueEx(), Setting Registry Values
shebang line, Basic Concepts
shell, avoiding for new processes, Using system and exec
shift(), The shift and unshift Functions
ShortCut module, Win32 Extensions
single-quoted strings, Single-Quoted Strings
skiing, A Stroll Through Perl
slash, Using Pathnames and Filenames
slash (/)
and changing regular expressions, Using a Different Delimiter
as regular expression delimiter, Simple Uses of Regular Expressions
choosing alternate to, in substitution, Substitutions
slices
and variable interpolation in strings, Variable Interpolation of Arrays
of array, Array Element Access
on literal lists, Array Element Access
Socket module, Networking Clients
sockets, Networking Clients
sort()
controlling sort order of, Advanced Sorting
defined, The sort Function
example of, Chapter 12 , Chapter 15
introduced, Maintaining a Last-Good-Guess Database
sort comparison routines, Advanced Sorting
using array lookups, Advanced Sorting
sort()
example of, Chapter 12
sorting
advanced, Advanced Sorting
example of numeric, Advanced Sorting
Sound module, Win32 Extensions
space
between array values when interpolated, Variable Interpolation of Arrays
in regular expressions, Single-Character Patterns
spaceship () operator
defined, Advanced Sorting
spaceship operator, Advanced Sorting
spaceship operator ()
example of, Chapter 17
Spawn module, Win32 Extensions
split() operator
defined, The split Function
example of, Invoking a Format
spotted owls, Removing a File
sprintf() operator
compared with pack(), Packing and Unpacking Binary Data
defined, Formatting Data with sprintf( )
example of, Numeric Fields
Sprite, Double-Quoted Strings
square brackets ([]), in regular expressions, Single-Character Patterns
standard distribution, Perl, Standard Perl Distribution
standard error
of command in backquotes, Using Backquotes
standard input
example of using, <STDIN> as a Scalar Value
of command in backquotes, Using Backquotes
reading from, Input from STDIN
Standard Modules, Standard Modules
standard output
example of using, Output with print
stat(), The stat Function
statement block, Statement Blocks
(see also block.)
introduced, Adding Choices
STDERR
defined, What Is a Filehandle?
introduced, Moving the Secret Word List into a Separate File
, The Undefined Value
in array context, <STDIN> as an Array
example of, Chapter 6
defined, Input from STDIN , What Is a Filehandle?
example of, The Final Programs, Input from STDIN , The last Statement
introduced, Asking Questions and Remembering the Result
introduced, Moving the Secret Word List into a Separate File
as scalar value, <STDIN> as a Scalar Value
as target of a match, Selecting a Different Target (the =~ Operator)
and undef return value, The Undefined Value
STDOUT
defined, What Is a Filehandle?
introduced, Moving the Secret Word List into a Separate File
string concatenation, Operators for Strings
string operators, Operators for Strings, Operators for Strings
strings
and automatic conversion to numbers, Conversion Between Numbers and Strings
counting characters in, Transliteration
defined, What Is Scalar Data?, Strings
deleting characters from, Transliteration
length of, Strings
literal representation of, Strings
pathnames in, Double-Quoted Strings
removing last character, The chop( ) and chomp( ) Functions
sub keyword
defined, Defining a User Function
example of, The Final Programs, Chapter 8
introduced, Making It a Bit More Modular
subkeys (see keys, registry)
subroutine definitions
example of, Chapter 8
location of in file, Making It a Bit More Modular
location of in text, Defining a User Function
re-defining, Defining a User Function
subroutines
and scope of variables, Defining a User Function
arguments, Arguments
defined, Defining a User Function
introduced, Making It a Bit More Modular
invoking, Invoking a User Function
lack of locals, Defining a User Function
nested invocation of, Invoking a User Function
return values of, Return Values
subscrips
with array elements, Array Element Access
subscript reference, introduced, More than One Secret Word
subscripts
and array expressions, Array Element Access
substitute operator
defined, Simple Uses of Regular Expressions, Substitutions
introduced, Making It Fair for the Rest
substr() operator
defined, Extracting and Replacing a Substring
example of, Chapter 15
variable as first argument, Extracting and Replacing a Substring
substrings
finding, Finding a Substring
subtraction, operator for, Operators for Numbers
subtrees, Registry, The Registry Structure
symlink(), File and Directory Manipulation
system() operator
and PATH, Using system and exec
defined, Using system and exec
list of arguments to, Using system and exec

T

Tab, Double-Quoted Strings
tar utility, Standard Perl Distribution
TCP, Perl and, Networking Clients , A Webget Client
technical support, Support, Support
temperature, Exercises
template of format, Defining a Format
text editors, and updating databases, Variable-Length ( Text) Databases
text fields (in formats), Text Fields
tilde (~), in formats, Filled Fields
time
manipulation of, Maintaining a Last-Good-Guess Database
UNIX internal format, Modifying Timestamps
time operator
example of, The Final Programs, Modifying Timestamps
time operator, example of, Maintaining a Last-Good-Guess Database
timestamps, modifying, Modifying Timestamps
_TOP, as suffix for top-of-page format, The Top-of-Page Format
top-of-page format
changing name, Changing the Top-of-Page Format Name
defined, The Top-of-Page Format
example of, Listing the Secret Words
tr operator
defined, Transliteration
example of, Making It Fair for the Rest, The Final Programs
translate operator, introduced, Making It Fair for the Rest
transliteration, Transliteration
true
and regular expressions, Simple Uses of Regular Expressions
defined, The if/unless Statement

U

UNC path, Using Pathnames and Filenames
undef
and, Input from STDIN
and array element access, Array Element Access
and associative array elements, Hash Variables
as default value for $^I, Variable-Length ( Text) Databases
as initial value of local variables, Private Variables in Functions
as return value from globbing, Globbing
as return value from pop(), The push and pop Functions
as return value from readdir(), Reading a Directory Handle
defined, The Undefined Value
resulting from split(), The split Function
to control dbmopen(), Opening and Closing DBM Hashes
when assigning lists, Assignment
underscore (_), in variable names, Scalar Variables
unless modifier, Expression Modifiers
unless statement (see if statement.)
example of, A Slight Diversion: die
unlink() operator
defined, Removing a File
example of, Chapter 13
unpack()
example of, Fixed-Length Random-Access Databases
unpack() operator
and return values from gethostbyname(), Getting Network Information
defined, Packing and Unpacking Binary Data
example of, Getting Network Information
unshift(), The shift and unshift Functions
until modifier, Expression Modifiers
until statement (see while statement.)
uppercase
for filehandles, Moving the Secret Word List into a Separate File
use statement, Passing Parameters via CGI , Creating Automation Objects
user function (see subroutine.)
utime() operator, Modifying Timestamps

V

values() operator, The values Function
variable interpolation
and array variables, Variable Interpolation of Arrays
and double-quoted strings, Double-Quoted Strings
and globbing, Globbing
and regular expressions, Using Variable Interpolation
and the substitute operator, Substitutions
defined, Interpolation of Scalars into Strings
used with system(), Using system and exec
variable names, defined, Making It Fair for the Rest
variable part of format, What Is a Format?
variables
and subroutines, Defining a User Function
array, Variables
associative array, Hash Variables
default value of, The Undefined Value
predefined, Many, Many Predefined Variables
scalar, Scalar Variables
VARIANT, Variants
Variant, Variants
vertical bar (|)
as format field characters, Text Fields
in regular expressions, Alternation
open() and, Warning Someone When Things Go Astray, Using Processes as Filehandles
Very Bad Programming Style, example of, Array Element Access
Visual Basic, Translating Samples from Visual Basic
von Neumann, John, Foreword to the First Edition of Learning Perl
vowels, matching, Single-Character Patterns

W

w, in regular expressions, Single-Character Patterns
Wall, Larry, Foreword to the First Edition of Learning Perl, Support, &&, ||, and ?: as Control Structures
Webget client (example), A Webget Client , A Webget Client
while modifier, Expression Modifiers
while statement
and last operator, The last Statement
and next operator, The next Statement
and redo operator, The redo Statement
defined, The while/until Statement
example of, Making It a Bit More Modular, Many Secret Word Files in the Current Directory, The keys Function, The each Function, Input from STDIN , Chapter 4
introduced, Guessing the Secret Word
whitespace
defined, Basic Concepts
in formats, Defining a Format
in pack format string, Packing and Unpacking Binary Data
in Perl programs, Basic Concepts
in regular expressions, Single-Character Patterns
Win32 Extensions, Win32 Extensions
Win32::AbortSystemShutdown module, Win32 Extensions
Win32::AdminMisc module, Win32 Extensions
Win32::BuildNumber module, Win32 Extensions
Win32::ChangeNotify module, Win32 Extensions
Win32::Clipboard module, Win32 Extensions
Win32::Console module, Win32 Extensions
Win32::DomainName module, Win32 Extensions
Win32::Error module, Win32 Extensions
Win32::EventLog module, Win32 Extensions
Win32::ExpandEnvironmentStrings module, Win32 Extensions
Win32::File module, Modifying Permissions, Win32 Extensions
Win32::FileSecurity module, Modifying Permissions, Win32 Extensions
Win32::FormatMessage module, Win32 Extensions
Win32::FsType function, The stat Function
Win32::FsType module, Win32 Extensions
Win32::GetCwd function, Moving Around the Directory Tree
Win32::GetCwd module, Win32 Extensions
Win32::GetLastError module, Win32 Extensions
Win32::GetNextAvailDrive module, Win32 Extensions
Win32::GetOSVersion module, Win32 Extensions
Win32::GetShortPathName function, Using Pathnames and Filenames
Win32::GetShortPathName module, Win32 Extensions
Win32::GetTickCount module, Win32 Extensions
Win32::InitiateSystemShutdown module, Win32 Extensions
Win32::Internet module, Win32 Extensions
Win32::IPC module, Win32 Extensions
Win32::IsWin95 module, Win32 Extensions
Win32::IsWinNT module, Win32 Extensions
Win32::LoginName function, Getting User and Machine Information
Win32::LoginName module, Win32 Extensions
Win32::LookupAccountName module, Win32 Extensions
Win32::LookupAccountSID module, Win32 Extensions
Win32::Mutex module, Win32 Extensions
Win32::NetAdmin module, Getting User and Machine Information, Win32 Extensions
Win32::NetResource module, Reading a Directory Handle, Win32 Extensions
Win32::NodeName function, Getting User and Machine Information
Win32::NodeName module, Win32 Extensions
Win32::ODBC module, Win32 Database Interfaces, Win32 Extensions
Win32::OLE module, Creating Automation Objects, Creating Automation Objects, Chapter 19 , Win32 Extensions
Win32::Pipe module, Win32 Extensions
Win32::Process, Win32::Process
Win32::Process module, Win32::Process, Win32::Process, Win32 Extensions
Win32::Registry module, Chapter 16 , Win32 Extensions
Win32::Registry package, The Registry, The Registry Structure
Win32::Semaphore module, Win32 Extensions
Win32::Service module, Win32 Extensions
Win32::SetCwd module, Win32 Extensions
Win32::Shortcut module, Win32 Extensions
Win32::Sound module, Win32 Extensions
Win32::Spawn module, Win32 Extensions
Windows 95
Windows NT versus, Windows NT and Windows 95
Windows NT
processes on, Win32::Process, Win32::Process
Registry, The Registry, More Registry Operations
Windows 95 versus, Windows NT and Windows 95
WinZip utility, Standard Perl Distribution
word boundary
and regular expressions, Anchoring Patterns
in regular expressions
example of, Handling Varying Input Formats
word characters, in regular expressions, Single-Character Patterns
words, and filled fields in formats, Filled Fields
World Wide Web, CGI Programming
World Wide Web, modules for, The World Wide Web
write operator
defined, Invoking a Format
introduced, Listing the Secret Words
write() operator
example of, The Final Programs, Invoking a Format

X

x operator
example of, Chapter 2
x, as string repetition operator, Operators for Strings
..................Content has been hidden....................

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